Migrate development environment from Windows to macOS and continue project updates

Someshdiwan · Someshdiwan · commit 3b3405ed4164 · 2025-06-11T12:42:27.000+05:30
- Shifted primary development environment from Windows to macOS to ensure better performance, stability, and streamlined workflow for Java development.
- Removed OS-specific metadata and ensured platform-agnostic project compatibility.
- Normalized line endings to LF for cross-platform consistency.
- Verified and adjusted file paths, permissions, and encoding settings to suit macOS environment.
- Cleaned up unnecessary Windows-generated files and updated Git configuration accordingly.
- Future commits and development will now be
managed entirely from macOS.

This migration ensures a cleaner, more consistent
setup moving forward and prepares the project for
scalable development across Unix-based systems.

Future development will continue on macOS for a
smoother, Unix-based experience.

Signed-off-by: Someshdiwan &lt;Someshdiwan369@gmail.com&gt;
diff --git a/Section5OperatorExpression/1. Fundamentals/1. Fundamentals.iml b/Section5OperatorExpression/1. Fundamentals/1. Fundamentals.iml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="jdk" jdkName="23" jdkType="JavaSDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>
diff --git a/Section5OperatorExpression/1. Fundamentals/Operators/1.5 Boolean Logic/1.5 Boolean Logic.iml b/Section5OperatorExpression/1. Fundamentals/Operators/1.5 Boolean Logic/1.5 Boolean Logic.iml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="jdk" jdkName="23" jdkType="JavaSDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>
diff --git a/Section5OperatorExpression/1. Fundamentals/Operators/1.5 Boolean Logic/src/BooleanLogic.java b/Section5OperatorExpression/1. Fundamentals/Operators/1.5 Boolean Logic/src/BooleanLogic.java
@@ -0,0 +1,9 @@
+public class BooleanLogic {
+   public static void main(String[] args) {
+      boolean value1, value2; //Declare two boolean variables.
+      value1 = true; //Initialize one as true.
+      value2 = !value1; //Initialize the other one as NOT the first one.
+      //(NOT value1 OR value1) OR (value1 AND NOT value2)
+      boolean result = (!value1 || value1) || (value1 && !value2);
+   }
+}
diff --git a/Section5OperatorExpression/1. Fundamentals/Operators/1.6 Boolean Calculator/1.6 Boolean Calculator.iml b/Section5OperatorExpression/1. Fundamentals/Operators/1.6 Boolean Calculator/1.6 Boolean Calculator.iml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="jdk" jdkName="23" jdkType="JavaSDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>
diff --git a/Section5OperatorExpression/1. Fundamentals/Operators/1.6 Boolean Calculator/src/BooleanCalculator.java b/Section5OperatorExpression/1. Fundamentals/Operators/1.6 Boolean Calculator/src/BooleanCalculator.java
@@ -0,0 +1,8 @@
+public class BooleanCalculator
+{
+   public static void main(String[] args)
+   {
+      int a = 3, b = -4, c = 1;
+      boolean t = true, f = false;
+   }
+}
diff --git a/Section5OperatorExpression/1. Fundamentals/Operators/Boolean Operators/Boolean Operators.iml b/Section5OperatorExpression/1. Fundamentals/Operators/Boolean Operators/Boolean Operators.iml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="jdk" jdkName="23" jdkType="JavaSDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>
diff --git a/Section5OperatorExpression/1. Fundamentals/Operators/Boolean Operators/src/BooleanOperators.java b/Section5OperatorExpression/1. Fundamentals/Operators/Boolean Operators/src/BooleanOperators.java
@@ -0,0 +1,15 @@
+public class BooleanOperators
+{
+   public static void main(String[] args)
+   {
+      boolean statement1 = true, statement2 = false;
+      System.out.print("Not true is ");
+      System.out.println(!statement1);
+      System.out.print("True and false is ");
+      System.out.println(statement1 && statement2);
+      System.out.print("True or false is ");
+      System.out.println(statement1 || statement2);
+      System.out.print("Not (True and not false) is ");
+      System.out.println(!(statement1 && !statement2));
+   }
+}
diff --git a/Section5OperatorExpression/1. Fundamentals/Operators/Comparison Operators/Comparison Operators.iml b/Section5OperatorExpression/1. Fundamentals/Operators/Comparison Operators/Comparison Operators.iml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="jdk" jdkName="23" jdkType="JavaSDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>
diff --git a/Section5OperatorExpression/1. Fundamentals/Operators/Comparison Operators/src/ComparisonOperators.java b/Section5OperatorExpression/1. Fundamentals/Operators/Comparison Operators/src/ComparisonOperators.java
@@ -0,0 +1,15 @@
+public class ComparisonOperators
+{
+   public static void main(String[] args)
+   {
+      int number1 = 1, number2 = 2;
+      boolean value1 = number1 < number2;
+      System.out.println("Is number1 less than number2? " + value1);
+      boolean value2 = number1 >= number2;
+      System.out.println("Is number1 greater than or equal to number2? " + value2);
+      boolean value3 = 2*number1 == number2;
+      System.out.println("Is two times number1 equal to number2? " + value3);
+      boolean value4 = !(number1 != number2);
+      System.out.println("Is number1 not different from number2? " + value4);
+   }
+}
diff --git a/Section5OperatorExpression/1. Fundamentals/Operators/Operators.iml b/Section5OperatorExpression/1. Fundamentals/Operators/Operators.iml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="jdk" jdkName="23" jdkType="JavaSDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>
diff --git a/Section5OperatorExpression/1. Fundamentals/Operators/Shortcut Operators/Shortcut Operators.iml b/Section5OperatorExpression/1. Fundamentals/Operators/Shortcut Operators/Shortcut Operators.iml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="jdk" jdkName="23" jdkType="JavaSDK" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>
diff --git a/Section5OperatorExpression/1. Fundamentals/Operators/Shortcut Operators/src/ShortcutOperators.java b/Section5OperatorExpression/1. Fundamentals/Operators/Shortcut Operators/src/ShortcutOperators.java
@@ -0,0 +1,15 @@
+public class ShortcutOperators
+{
+   public static void main(String[] args)
+   {
+      int x = 1, y = 3, z = -2;
+      x++; //x is incremented by 1
+      System.out.println("x is now " + x);
+      z--; //z is decremented by 1
+      System.out.println("z is now " + z);
+      y += x; //y increases by the current value of x
+      System.out.println("y is now " + y);
+      z *= x-y; //z gets multiplied by the difference between x and y
+      System.out.println("z is finally " + z);
+   }
+}
diff --git a/Section5OperatorExpression/1. Fundamentals/src/Hello.java b/Section5OperatorExpression/1. Fundamentals/src/Hello.java
@@ -0,0 +1,5 @@
+public class Hello {
+    public static void main(String[] args) {
+        System.out.println("Hello");
+    }
+}
diff --git a/Section5OperatorExpression/Txt and Images/literals.txt b/Section5OperatorExpression/Txt and Images/literals.txt
@@ -0,0 +1,47 @@
+Literals: Java Literals are syntactic representations of boolean, character, numeric, or string data.
+Example: 4 is an integer literal.
+
+Identifiers: Identifiers are the names of variables, methods, classes, packages and interfaces
+
+Octal values are denoted in Java by a leading zero. Normal decimal numbers cannot have a leading zero.
+Thus, the seemingly valid value 09 will produce an error from the compiler, since 9 is outside of octal’s 0 to 7 range.
+
+You signify a hexadecimal constant with a leading zero-x, (0x or 0X).
+The range of a hexadecimal digit is 0 to 15, so A through F (or a through f ) are substituted for 10 through 15.
+
+When a literal value is assigned to a byte or short variable, no error is generated if the literal value is within the
+range of the target type. An integer literal can always be assigned to a long variable. However, to specify a long
+literal, you will need to explicitly tell the compiler that the literal value is of type long. You do this by appending
+an upper- or lowercase L to the literal.
+
+Beginning with JDK 7, you can also specify integer literals using binary. To do so, prefix the value with 0b or 0B.
+For example, this specifies the decimal value 10 using a binary literal: int x = 0b1010;
+
+int x = 123_456_789;
+the value given to x will be 123,456,789. The underscores will be ignored.
+
+Floating-point literals in Java default to double precision.
+To specify a float literal, you must append an F or f to the constant.
+
+Hexadecimal floating-point literals are also supported, but they are rarely used.
+They must be in a form similar to scientific notation, but a P or p, rather than an E or e, is used.
+For example, 0x12.2P2 is a valid floating-point literal. The value following the P, called the binary exponent,
+indicates the power-of-two by which the number is multiplied. Therefore, 0x12.2P2 represents 72.5.
+
+double num = 9_423_497_862.0;
+the value given to num will be 9,423,497,862.0
+double num = 9_423_497.1_0_9;
+In this case, the fractional part is .109
+
+Boolean literals are simple. There are only two logical values that a boolean value can have, true and false.
+The values of true and false do not convert into any numerical representation.
+The true literal in Java does not equal 1, nor does the false literal equal 0.
+
+As you may know, in some other languages, including C/C++, strings are implemented as arrays of characters.
+However, this is not the case in Java. Strings are actually object types.
+Because Java implements strings as objects, Java includes extensive string-handling capabilities that are both powerful
+and easy to use.
+
+The remainder a % b is defined such that (a / b) * b + a % b is always equal to a :
+System.out.println(-15 % 2);    // -1
+System.out.println(15 % -2);    // 1
diff --git a/Section5OperatorExpression/Txt and Images/notes.txt b/Section5OperatorExpression/Txt and Images/notes.txt
@@ -0,0 +1,30 @@
+Terminal: echo $PATH	# This is where it looks for the applications that we want to open.
+
+Class name always starts with a capital letter.
+
+To understand code and see control flow, debug the code after putting breakpoint.
+We can also change the values in debugger window to see what will happen at a particular value.
+
+Input:
+class Scanner to scan something i.e. Input something
+
+command & click on class name to open class file. ex: cmd & click on 'Scanner'
+
+javac -d . cmd.java
+The -d switch specifies the destination where to put the generated class file.
+
+OBJECT CLASS :
+Object class is present in java.lang package.Every class in Java is directly or indirectly derived from the Object class.
+If a Class does not extend any other class then it is direct child class of Object and if extends other class then it is
+an indirectly derived. Therefore the Object class methods are available to all Java classes. Hence Object class acts as
+a root of inheritance hierarchy in any Java Program.
+
+There are methods in Object class:
+toString(), hashCode(), equals(Object obj), getClass(), finalize(), clone(), etc.
+
+NUMBER CLASS :
+Most of the time, while working with numbers in java, we use primitive data types. But, Java also provides various
+numeric wrapper sub classes under the abstract class Number present in java.lang package.There are mainly six subclasses
+under Number class.These sub-classes define some useful methods which are used frequently while dealing with numbers.
+Byte, Integer, Double, Short, Float, Long
+NOTE : Primitive Wrapper Classes are Immutable in Java.
diff --git a/Section5OperatorExpression/Txt and Images/type_conversion&casting.txt b/Section5OperatorExpression/Txt and Images/type_conversion&casting.txt
@@ -0,0 +1,73 @@
+Type Conversion and Casting:
+
+Java’s Automatic Conversions
+When one type of data is assigned to another type of variable, an automatic type conversion will take place if the
+following two conditions are met:
+• The two types are compatible.
+• The destination type is larger than the source type.
+Java also performs an automatic type conversion when storing a literal integer constant into variables of type
+byte, short, long, or char.
+
+Casting Incompatible Types
+Although the automatic type conversions are helpful, they will not fulfill all needs. For example, what if you want to
+assign an int value to a byte variable? This conversion will not be performed automatically, because a byte is smaller
+than an int. This kind of conversion is sometimes called a narrowing conversion, since you are explicitly making the
+value narrower so that it will fit into the target type.
+
+For example, the following fragment casts an int to a byte. If the integer’s value is larger than the range of a byte,
+it will be reduced modulo (the remainder of an integer division by the) byte’s range.
+int a;
+byte b;
+b = (byte) a;
+
+A different type of conversion will occur when a floating-point value is assigned to an integer type: truncation.
+
+Automatic Type Promotion in Expressions:
+
+int a = 257;
+byte b = (byte)a;
+When the value 257 is cast into a byte variable, the result is the remainder of the division of 257 by 256
+(the range of a byte), which is 1 in this case.
+
+
+       byte a = 40;
+       byte b = 50;
+       byte c = 100;
+       int d = a * b / c;
+The result of the intermediate term a * b easily exceeds the range of either of its byte operands.
+To handle this kind of problem, Java automatically promotes each byte, short, or char operand to int when evaluating
+an expression. This means that the subexpression a*b is performed using integers—not bytes.
+ byte b = 50;
+       b = b * 2; // Error! Cannot assign an int to a byte!
+The code is attempting to store 50 * 2, a perfectly valid byte value, back into a byte variable. However, because the
+operands were automatically promoted to int when the expression was evaluated, the result has also been promoted to int.
+
+The Type Promotion Rules:
+
+Java defines several type promotion rules that apply to expressions.
+They are as follows: First, all byte, short, and char values are promoted to int, as just described.
+Then, if one operand is a long, the whole expression is promoted to long. If one operand is a float,
+the entire expression is promoted to float. If any of the operands are double, the result is double.
+
+class Promote {
+       public static void main(String args[]) {
+         byte b = 42;
+         char c = 'a';
+         short s = 1024;
+         int i = 50000;
+         float f = 5.67f;
+         double d = .1234;
+         double result = (f * b) + (i / c) - (d * s);
+         System.out.println((f * b) + " + " + (i / c) + " - " + (d * s));
+         System.out.println("result = " + result);
+    }
+}
+Let’s look closely at the type promotions that occur in this line from the program:
+
+     double result = (f * b) + (i / c) - (d * s);
+
+In the first subexpression, f * b, b is promoted to a float and the result of the subexpression is float.
+Next, in the subexpression i/c, c is promoted to int, and the result is of type int. Then, in d * s, the value of s is
+promoted to double, and the type of the subexpression is double. Finally, these three intermediate values, float, int,
+and double, are considered. The outcome of float plus an int is a float. Then the resultant float minus the last double
+is promoted to double, which is the type for the final result of the expression.
diff --git a/Section5OperatorExpression/src/Basics.java b/Section5OperatorExpression/src/Basics.java
@@ -0,0 +1,18 @@
+public class Basics {
+    public static void main(String[] args) {
+//        int a = 10;
+//        if (a == 10) {
+//            System.out.println("Hello World");
+//        }
+//        int count = 1;
+//        while(count != 5) {
+//            System.out.println(count);
+//            count++;
+//        }
+
+        // for loop
+        for(int count = 1; count != 5; count++) {
+            System.out.println(count);
+        }
+    }
+}
diff --git a/Section5OperatorExpression/src/Inputs.java b/Section5OperatorExpression/src/Inputs.java
@@ -0,0 +1,16 @@
+import java.util.Scanner;
+
+public class Inputs {
+    public static void main(String[] args) {
+        Scanner input = new Scanner(System.in);
+//        System.out.print("Please enter some input: ");
+//        int rollno = input.nextInt();
+//        System.out.println("Your roll number is " + rollno);
+
+//        String name = input.next();
+//        System.out.println(name);
+
+//        float marks = input.nextFloat();
+//        System.out.println(marks);
+    }
+}
diff --git a/Section5OperatorExpression/src/Main.java b/Section5OperatorExpression/src/Main.java
@@ -0,0 +1,8 @@
+import java.util.Scanner;
+
+public class Main {
+    public static void main(String[] args) {
+        Scanner input = new Scanner(System.in);
+        System.out.println(input.nextLine());
+    }
+}
diff --git a/Section5OperatorExpression/src/Prime.java b/Section5OperatorExpression/src/Prime.java
@@ -0,0 +1,26 @@
+import java.util.Scanner;
+
+public class Prime {
+    public static void main(String[] args) {
+        Scanner in = new Scanner(System.in);
+        System.out.print("Please enter a number: ");
+        int n = in.nextInt();
+        if(n <= 1) {
+            System.out.println("Neither prime nor composite");
+            return;
+        }
+        int c = 2;
+        while (c * c <= n) {
+            if (n % c == 0) {
+                System.out.println("Not Prime");
+                return;
+            }
+            c = c + 1;
+            // c++;
+        }
+        if (c * c > n) {
+            System.out.println("Prime");
+        }
+        
+    }
+}
diff --git a/Section5OperatorExpression/src/Primitives.java b/Section5OperatorExpression/src/Primitives.java
diff --git a/Section5OperatorExpression/src/Sum.java b/Section5OperatorExpression/src/Sum.java
diff --git a/Section5OperatorExpression/src/Temperature.java b/Section5OperatorExpression/src/Temperature.java
diff --git a/Section5OperatorExpression/src/Ticket.java b/Section5OperatorExpression/src/Ticket.java
diff --git a/Section5OperatorExpression/src/TypeCasting.java b/Section5OperatorExpression/src/TypeCasting.java
