Add files via upload

Author: nano-bot01

ConstVsStatic.java

@@ -0,0 +1,79 @@
+package Java_Technical_Training;
+
+/*
+ * static block vs init block
+ * static block vs init block vs constructor
+ * if static is used in both parent and child class, the static block of parent class will run first
+ */
+
+class Q {
+    static int a; // ! Eager Binding, Eager Loading
+    int b; // ! instance variable, during object creation, lazy loading
+
+    Q() {
+        a = 20;
+        System.out.println("priority 4: This is constructor ");
+        b = 20;
+    }
+
+    {
+        a = 10;
+        System.out.println("priority 3: This is init block " + a);
+
+    }
+    // init is pre constructor call
+    // initialize instance variable, same work as constructor
+    // ! it ruins the readiablity of code
+
+    static {
+        a = 30;
+        System.out.println("priority 1: Static Block will execute during class loading : " + a);
+        // used to initialize static variables
+        // pre logic or preprocessing before initilization
+    }
+    static {
+        a = 40;
+        System.out.println("priority 2: This is second static block " + a);
+    }
+
+    static void show() {
+        System.out.println("A is : " + a);
+    }
+}
+
+class Parents {
+    static int x;
+    static {
+        x = 10;
+        System.out.println("this is static from parents class : " + x);
+    }
+    static {
+        System.out.println("this is second static block from parents class");
+    }
+    {
+        System.out.println("I am the parent init block");
+    }// inti block
+
+    Parents() {
+        System.out.println("I am parents class default constructor");
+    }// constructor
+
+}
+
+class Child extends Parents {
+    static int y;
+
+    static {
+        y = 0 + 10;
+        System.out.println("this is static from child class  " + y);
+    }
+}
+
+public class ConstVsStatic {
+    public static void main(String[] args) {
+        // Q.show();
+        // Q obj = new Q();
+        Child obj2 = new Child();
+
+    }
+}

MethodOverloadingAndTypePromotion.java

@@ -0,0 +1,96 @@
+package Java_Technical_Training;
+
+/* 
+ * Method overloading and type promotion 
+ * 
+ * 
+ * type promotion 
+ * 
+ * byte -> short -> int -> long -> double
+ *                         long ->float-> double
+ *                  int -> float -> double
+ *                  int  -> double
+ */
+
+class TypePromotion {
+    void show(byte x) {
+        System.out.println(x + " : Byte ----");
+    }
+
+    void show(short x) {
+        System.out.println(x + " : Short ----");
+    }
+
+    void show(String x) {
+        System.out.println(x + " : String ----");
+    }
+
+    void show(int x) {
+        System.out.println(x + " : Int ----");
+    }
+
+    void show(char x) {
+        System.out.println(x + " : Char ----");
+    }
+
+    void show(float x) {
+        System.out.println(x + " : float ----");
+    }
+
+    void show(int... x) {
+        System.out.println(x + " : Var args ----");
+    }
+
+    // ! first chance given to primitive type, than it goes for var args then it
+    // ! goes for Wrapper classes, then it shows error
+
+    void show(Integer x) {
+        System.out.println(x + " : Integer class ----");
+    }
+
+}
+
+class Shopping {
+    void search(double amount) {
+        System.out.println("Product is available");
+    }
+
+    void search(String name) {
+        System.out.println("Product is available");
+
+    }
+
+    void search(String name, double amount) {
+        System.out.println("Product is unavailable");
+
+    }
+
+    void search(double amount, String name) {
+        System.out.println("Product is unavailable");
+
+    }
+
+}
+
+public class MethodOverloadingAndTypePromotion {
+    public static void main(String[] args) {
+        Shopping obj = new Shopping();
+        obj.search("Apple");
+        obj.search(80000.0);
+        obj.search("Watch", 75000.0);
+        obj.search(7500000.0, "Car");
+
+        TypePromotion obj2 = new TypePromotion();
+        obj2.show('A');
+        obj2.show("ankit");
+        obj2.show(34);
+        obj2.show('A' + 10);// will converted to int
+        obj2.show(34.5f);
+        obj2.show(343443L);
+        obj2.show(343443454L);
+        obj2.show();
+        obj2.show(10, 59);
+        obj2.show(4543);
+
+    }
+}

StaticOverriding.java

@@ -0,0 +1,71 @@
+package Java_Technical_Training;
+
+/*
+ * can we override static method : no, as it is bind with class not objects
+ * 
+ * static - keyword, they are loaded once, bind with class name
+ * static methods can be called without class objects
+ * static is also present for objects
+ * 
+ * 
+    
+ }
+ */
+
+class StaticExample {
+    int count; // instance variable
+    static int counter; // class variable
+
+    StaticExample() {
+        count++; // ! instance variable, object bind ( runtime binding)
+        counter++; // ! class variable, class bind, static bind
+        System.out.println("Intance var count is : " + count + " Static var counter is : " + counter);
+    }
+
+    static void show() {
+        System.out.println("I am  the show : ");
+    }
+}
+
+class ParentClass {
+    void disp() {
+        System.out.println("I am the parent class display ");
+    }
+}
+
+class ChildClass extends ParentClass {
+    void disp() {
+        System.out.println("I am the child class display ");
+    }
+
+    static void print() {
+        System.out.println("I am static method of child class ");
+    }
+}
+/*
+ * overriding :
+ * same signature as per parents is essential
+ * inheritance must be present
+ * depends on object creation
+ */
+
+public class StaticOverriding {
+    public static void main(String[] args) {
+        StaticExample obj1 = new StaticExample();
+        StaticExample obj2 = new StaticExample();
+        StaticExample obj3 = new StaticExample();
+        StaticExample obj4 = new StaticExample();
+        StaticExample.show();
+
+        // overriding
+        ChildClass obj5 = new ChildClass();
+        obj5.disp();
+        obj5.print();
+        ChildClass.print();
+
+        ParentClass obj6 = new ChildClass();
+        obj6.disp(); //
+        // obj6.print();
+
+    }
+}

StaticVsInstance.java

@@ -0,0 +1,43 @@
+package Java_Technical_Training;
+
+class Demo {
+    int a; // lazy loading, during object creation
+    static int b; // class member (eager loading, during class loading)
+
+    static {
+        b = 1;
+        System.out.println("this is static : b == " + b);
+    }
+
+    static void show() {
+        // a = 1000; // ! Cannot make a static reference to the non-static field
+        System.out.println(" Show : " + b);
+    }// static methods
+
+    Demo() {
+        b++;
+        System.out.println("This is constructor here a is : " + a + " and b is : " + b);
+    }
+
+    void print() {
+        System.out.println(" This is print : " + b);
+        // we can also use static variables in instance variable
+        // we can access eager variables in lazy varables and methods but its opposite
+        // is not true;
+    }
+}
+
+public class StaticVsInstance {
+    public static void main(String[] args) {
+        Demo.show();// only static values can be used
+        Demo ob = new Demo();
+        ob.print();
+
+        Demo ob2 = new Demo();
+        Demo ob3 = new Demo();
+        Demo ob4 = new Demo();
+        // a is creating in heap 4 times as it is an instance varaible, but b is created
+        // once.
+
+    }
+}