OOP CONCEPT

Author: Vinay Patel

OOP/OOP 1 _ Introduction & Concepts - Classes, Objects, Constructors, Keywords/Main.java

@@ -0,0 +1,100 @@
+package OOP_KUNAL;
+
+import java.util.Arrays;
+
+public class Main {
+ public static void main(String[] args) {
+
+ int[] numbers = new int[5];
+ String[] names = new String[5];
+
+ Student[] students = new Student[5];
+
+ // just declaring
+ // Student vinay;
+ // System.out.println(Arrays.toString(students)); // Output is null
+
+ // vinay = new Student();
+ // here new keyword use it --> Dynamically allocate the memory and return a ref
+ // to it.
+
+ Student vinay = new Student(197, "VP", 90);
+
+ // System.out.println(vinay); // give random value
+
+ // vinay.rno =197;
+ // vinay.name="Vinay Patel";
+ // vinay.marks = 88.54f;
+
+ // vinay.changeName("Patel");
+ // vinay.greeting();
+
+ System.out.println(vinay.rno); // by default 0
+ System.out.println(vinay.name); // by default null
+ System.out.println(vinay.marks); // by default 0.0
+
+ // constructure is defined that what is happen when you creating object.
+ System.out.println();
+ Student random = new Student(vinay);
+ System.out.println(random.name);
+ System.out.println(random.marks);
+ System.out.println(random.rno);
+
+ }
+
+}
+// create a class
+
+// Inside the object variable is known as instance variable.
+class Student {
+ int rno;
+ String name;
+ float marks = 90;
+
+ // we need a way to add the value of the above properties object by objects.
+
+ // we need one word to access every object.
+
+ void greeting() {
+ System.out.println("Hello ! my name is " + name);
+ }
+
+ void changeName(String newName) {
+ // name = newName;
+ this.name = newName;
+ }
+
+ Student(Student other) {
+ this.name = other.name;
+ this.rno = other.rno;
+ this.marks = other.marks;
+ }
+
+ Student() {
+ // vinay.rno =197;
+ // vinay.name="Vinay Patel";
+ // vinay.marks = 88.54f;
+ this.rno = 197;
+ this.name = "Vinay Patel";
+ this.marks = 88.54f;
+ // replacing name with referance vaibale.(Simple meaning of this keyword)
+ }
+
+ // this keyword is simple means that is referance to the object.
+
+ // here below aprit is object of student class and this is automatically take
+ // name (Arput.rno,Arpit.name)
+
+ // Student arpit = new Student(17,"Arpit")
+ Student(int roll, String name, float marks) {
+ this.rno = roll;
+ this.name = name;
+ this.marks = marks;
+ }
+ // Student(){
+
+ // }
+}
+
+// premetive data type like int ,float are stored in stack memory only for more
+// effeciency

OOP/OOP 1 _ Introduction & Concepts - Classes, Objects, Constructors, Keywords/WrapperExample.java

@@ -0,0 +1,81 @@
+// premetive data types should be also created using new keyword is known as wrapper class.
+
+// In java only pass by value .
+
+package OOP_KUNAL;
+
+import javax.print.DocFlavor.STRING;
+
+public class WrapperExample {
+ public static void main(String[] args) {
+ // int a = 10;
+ // int b=20;
+ // Integer num = new Integer(45);
+
+ // Integer num = 45; //here num is like object
+ // num.compare(a, a) // different method is available.
+
+ Integer a = 10;
+ Integer b=20;
+
+
+
+ swap(a, b); // not swap
+ System.out.println(a+" "+b);
+
+ final A vinay = new A("Vinay");
+ vinay.name = "other name";
+
+ // when a non primitive is final,you cannot reassign it.
+ // vinay = new A("new object");
+ A obj;
+ for (int i = 0; i < 100000000; i++) {
+ obj = new A("Random name");
+ }
+ }
+ static void swap(int a,int b){
+ int temp = a;
+ a = b;
+ b = temp;
+ 
+ }
+ // below still not swap
+ // because intenal implementation of Integr is the using final .
+ static void swap(Integer a,Integer b){
+ Integer temp = a;
+ a = b;
+ b = temp;
+ 
+ }
+
+}
+
+
+class A{
+ // final int num;
+ // final variable always initialize while declaring.
+
+
+ // If not premitive data type then it will be change..
+
+ // final Student vinay = new Student(){
+ // vinay.name = "new name";
+ // vinay = other object ( we can not do it)
+ // }
+
+ // In above example we can change the name;
+
+
+ final int num = 10;
+ String name;
+
+ public A(String name){
+ // System.out.println("Object is created");
+ this.name = name;
+ }
+ 
+ @Override
+ protected void finalize() throws Throwable {
+ System.out.println("Object is destroyed");
+ }
+}

OOP/OOP 2 _ Packages, Static, Singleton Class, In-built Methods/Main.java

@@ -0,0 +1,7 @@
+public class Main {
+ Singleton obj1 = Singleton.getInstance();
+ Singleton obj2 = Singleton.getInstance();
+ Singleton obj3 = Singleton.getInstance();
+
+ // all 3 ref(All 3 object which we declare above obj1,obj2,obj3) variables are pointing to just one object
+}

OOP/OOP 2 _ Packages, Static, Singleton Class, In-built Methods/Singleton.java

@@ -0,0 +1,21 @@
+// You only want one instance of that class. 
+// Only one object you want to allow.
+
+public class Singleton {
+ // In this class we creat only one object.
+
+ // You should not allow anyone to creat constructor.
+ 
+ private Singleton(){
+
+ }
+ private static Singleton instance;
+
+ public static Singleton getInstance(){
+ // check whether 1 obj only is created or not
+ if(instance == null){
+ instance = new Singleton();
+ }
+ return instance;
+ }
+}

OOP/OOP 2 _ Packages, Static, Singleton Class, In-built Methods/staticExample/Human.java

@@ -0,0 +1,40 @@
+// Which propeties are not directly linked with object is known as static.
+
+// common to all object of the class is known as static.
+
+// It is accessed by class name as well as this keyword.
+
+// common to all the object is known as static
+
+// whenever you deal with static varibale whether you decaring or changeing or accesing--> then do not do it with reference varable (Object) it work but... convence is not ... RIGHT APPROACH IS use CLASS NAME ..
+
+// static variable is not depednet on the object. It will work even if you do not creat object. --> Best example of this line is main method in java. where entire code is runing...
+
+
+// static variable or methods or block.. anthing are run on the compile time.
+
+package staticExample;
+
+public class Human {
+
+ int age;
+ String name;
+ int salary;
+ boolean married;
+
+ // long population; // static
+ static long population; // static
+
+
+ public Human(int age, String name, int salary, boolean married) {
+ this.age = age;
+ this.name = name;
+ this.salary = salary;
+ this.married = married;
+
+
+ // this.population += 1;
+ Human.population += 1;
+ }
+
+}

OOP/OOP 2 _ Packages, Static, Singleton Class, In-built Methods/staticExample/InnerClasses.java

@@ -0,0 +1,36 @@
+package staticExample;
+
+// outside classes can not be static.
+
+// static public class InnerClasses {
+// class Test{
+
+// }
+// }
+
+public class InnerClasses {
+
+ // Without static it will give error.
+
+ // class Test {
+ // String name;
+
+ // public Test(String name) {
+ // this.name = name;
+ // }
+ // }
+ static class Test {
+ String name;
+
+ public Test(String name) {
+ this.name = name;
+ }
+ }
+
+ public static void main(String[] args) {
+ Test a = new Test("Vinay");
+ Test b = new Test("Patel");
+
+ System.out.println(a);
+ }
+}

OOP/OOP 2 _ Packages, Static, Singleton Class, In-built Methods/staticExample/Main.java

@@ -0,0 +1,43 @@
+// Inside the static method you can not use any method without static .
+
+package staticExample;
+
+import java.util.GregorianCalendar;
+
+import javax.crypto.spec.GCMParameterSpec;
+
+public class Main {
+ public static void main(String[] args) {
+ // Human vinay = new Human(22, "Vinay Patel", 50000, false);
+ // Human sonu = new Human(22, "Sonu Patel", 60000, true);
+ // Human Airpt = new Human(22, "Sonu Patel", 60000, true);
+
+ // System.out.println(vinay.population);
+ // System.out.println(sonu.population);
+ // System.out.println(Airpt.population);
+ 
+ // System.out.println(Human.population);
+ // System.out.println(Human.population);
+ // System.out.println(Human.population);
+
+ // greeting(); //This is non-static 
+
+ // fun();
+
+ // this is not dependent on objects.
+ static void fun(){
+ // greeting(); //You cant use this because it requires on instance(object).
+ // but the function you are using it in does not instance.
+
+ // we can use it like below
+ Main obj = new Main();
+ obj.greeting();
+ }
+ }
+ // we know that something which is not static, belongs to an object.
+ void greeting(){
+ // fun(); // we can use it.
+ System.out.println("HEYY");
+ }
+ 
+}

OOP/OOP 2 _ Packages, Static, Singleton Class, In-built Methods/staticExample/Packages.txt

@@ -0,0 +1,5 @@
+Packages are nothing but like a folder.
+
+we have different Packages that will use different code or logic we can use it using import.
+
+We can import the things from other Packages and we have use it.

OOP/OOP 2 _ Packages, Static, Singleton Class, In-built Methods/staticExample/StaticBlock.java

@@ -0,0 +1,25 @@
+package staticExample;
+
+// this is a demo to show initialisation of static variabkes
+
+public class StaticBlock {
+ static int a=4;
+ static int b;
+
+ // will inly run once,when the first obj is created i.e when the class is loaded for the first time.
+ 
+ static{
+ System.out.println("I am in static block");
+ b = a*5;
+ }
+ public static void main(String[] args) {
+ StaticBlock obj = new StaticBlock();
+ System.out.println (StaticBlock.a+" "+StaticBlock.b);
+ 
+ StaticBlock.b += 3;
+ StaticBlock obj2 = new StaticBlock();
+ System.out.println (StaticBlock.a+" "+StaticBlock.b);
+ 
+
+ }
+}