class || obj || this || new .notes added

Author: MehraDevesh2022

oops/01-Inrtoduction/Class.text

@@ -0,0 +1,66 @@
+A class is a template for an object, and an object is an instance of a class.
+A class creates a new data type that can be used to create objects.
+
+When you declare an object of a class, you are creating an instance of that class.
+Thus, a class is a logical construct. An object has physical reality. (That is, an object occupies space in memory.)
+
+Objects are characterized by three essential properties: state, identity, and behavior.
+The state of an object is a value from its data type. The identity of an object distinguishes one object from another.
+It is useful to think of an object’s identity as the place where its value is stored in memory.
+The behavior of an object is the effect of data-type operations.
+
+
+In object-oriented programming, the dot operator is used to link the name of an object with the name of an instance variable or method of that object. 
+It is also commonly referred to as the dot notation or dot syntax.
+
+
+
+
+The 'new' keyword dynamically allocates(that is, allocates at run time)memory for an object & returns a reference to it.
+This reference is, more or less, the address in memory of the object allocated by new.
+This reference is then stored in the variable.
+Thus, in Java, all class objects must be dynamically allocated.
+
+
+
+
+Box mybox; // declare reference to object
+     mybox = new Box(); // allocate a Box object
+The first line declares mybox as a reference to an object of type Box. At this point, mybox does not yet refer to an
+actual object. The next line allocates an object and assigns a reference to it to mybox. After the second line executes,
+you can use mybox as if it were a Box object. But in reality, mybox simply holds, in essence, the memory address of the
+actual Box object.
+The key to Java’s safety is that you cannot manipulate references as you can actual pointers.
+Thus, you cannot cause an object reference to point to an arbitrary memory location or manipulate it like an integer.
+
+A Closer Look at new:
+classname class-var = new classname ( );
+Here, class-var is a variable of the class type being created. The classname is the name of the class that is being
+instantiated. The class name followed by parentheses specifies the constructor for the class. A constructor defines
+what occurs when an object of a class is created.
+
+You might be wondering why you do not need to use new for such things as integers or characters.
+The answer is that Java’s primitive types are not implemented as objects.
+Rather, they are implemented as “normal” variables.
+This is done in the interest of efficiency.
+
+It is important to understand that new allocates memory for an object during run time.
+
+Box b1 = new Box();
+Box b2 = b1;
+b1 and b2 will both refer to the same object. The assignment of b1 to b2 did not allocate any memory or copy any part
+of the original object. It simply makes b2 refer to the same object as does b1. Thus, any changes made to the object
+through b2 will affect the object to which b1 is referring, since they are the same object.
+When you assign one object reference variable to another object reference variable, you are not creating a copy of the
+object, you are only making a copy of the reference.
+
+int square(int i){
+    return i * i;
+}
+A parameter is a variable defined by a method that receives a value when the method is called. For example,
+in square( int i), i is a parameter. An argument is a value that is passed to a method when it is invoked.
+For example, square(100) passes 100 as an argument. Inside square( ), the parameter i receives that value.
+
+NOTE:
+Bus bus = new Bus();
+lhs(reference i.e. bus) is looked by compiler & rhs (object i.e. new Bus()) is looked by jvm

oops/01-Inrtoduction/Class01$Student.class

@@ -0,0 +1,93 @@
+import java.util.*;
+
+public class Class01 {
+    public static void main(String[] args) {
+
+        // data of 5 students: {roll no, name, marks}
+        int[] rno = new int[5];
+        String[] name = new String[5];
+        float[] marks = new float[5];
+
+        // instaed of this just make Student class own data type or you can say templet
+        // for student
+        Student[] students = new Student[5]; // student type array whre student has all propties name , rno , marks for
+                                             // state and function for state change
+
+        // just declaring
+        // Student devesh; // memory created at stack not in heap
+        // devesh = new Student(); //memory created at heap using new Keyword
+
+        // ! we can use access inatnce variables and functionusing . dot operator
+        // devesh.changeName("Shoe lover");
+        // devesh.greeting();
+
+        Student devesh = new Student(15, "devesh", 85.4f);
+
+        System.out.println(devesh.rno);
+        System.out.println(devesh.name);
+        System.out.println(devesh.marks);
+
+        // this is how we can use other student data with new student
+        Student random = new Student(devesh); // (Student other) will acess in calss
+        System.out.println(random.name);
+        System.out.println(random.rno);
+        System.out.println(random.marks);
+
+        // call one constructor to other
+        Student one = new Student();
+        System.out.println(one.name);
+        System.out.println(one.rno);
+        System.out.println(one.marks);
+
+        // ! out put for this =>
+        // default person
+        // 13
+        // 100.0
+        Student two = one; // two is pointing to the same obejct as like one
+
+    }
+
+    // create a class
+    // for every single student
+    public static class Student {
+        int rno;
+        String name;
+        float marks = 90;
+
+        // this keyword => this keyword refering to intsance of Student class or you can
+        // say its behave like refernce variable of object that is created using Student
+        // class. in our case devesh is a student and thsi referes to devesh
+        void greeting() {
+            System.out.println("Hello! My name is " + this.name);
+        }
+
+        void changeName(String name) {
+            this.name = name;
+        }
+
+        // Student arpit = new Student(17, "Arpit", 89.7f);
+        // here, this will be replaced with arpit
+        Student(int rno, String name, float marks) {
+            this.rno = rno;
+            this.name = name;
+            this.marks = marks;
+
+        }
+
+        // this how we can use other object data with new object. other is object passed
+        // witj constructor while called
+        Student(Student other) {
+            this.name = other.name;
+            this.rno = other.rno;
+            this.marks = other.marks;
+        }
+
+        // default constructor
+        // this is how you call a constructor from another constructor
+        Student() {
+            // internally: new Student (13, "default person", 100.0f);
+            // here this is pointing a constructor who takes three paramtere as args
+            this(13, "default person", 100.0f); // these are the deafult value passed from here
+        }
+    }
+}