21/03

Author: nano-bot01

training/InterfaceDemo.java

@@ -0,0 +1,62 @@
+package Java_Technical_Training;
+
+/*
+ *  What is interface, why do we need it??
+ *      it is a keyword in java, used to create standards or interfaces.
+ *      it provides 100 % abstraction
+ *      
+ */
+
+interface DBOperation {
+    // ! 100 % abstract and public class
+
+    int MAX_CONNECTIONS = 10;
+    // ? public static final int MAX_CONNECTIONS = 10;
+    // MAX_CONNECTIONS=20; // ? can't update this variable
+
+    void add();
+
+    void remove();
+
+    void update();
+
+    void read();
+}
+
+class OracleDB implements DBOperation {
+
+    @Override
+    public void add() {
+        // MAX_CONNECTIONS = 20;
+        System.out.println("This is add operation ");
+    }
+
+    @Override
+    public void read() {
+        System.out.println("This is read operation ");
+
+    }
+
+    @Override
+    public void update() {
+        System.out.println("This is update operation ");
+    }
+
+    @Override
+    public void remove() {
+        System.out.println("This is remove operation ");
+
+    }
+
+}
+
+public class InterfaceDemo {
+    public static void main(String[] args) {
+        OracleDB obj = new OracleDB();
+        obj.add();
+        obj.read();
+        obj.update();
+        obj.remove();
+    }
+
+}

training/InterfaceUseWays.java

@@ -0,0 +1,123 @@
+package Java_Technical_Training;
+
+/*
+ * Steps : 
+ *      1. create interface
+ *      2. create class for implementation
+ *      3. create objects 
+ *      4. use object 
+ */
+
+@FunctionalInterface // tell it is SAM
+interface calc {
+    int compute(int x, int y);
+}
+
+// ! first way : create class, interface and do implemention using overriding
+// ! second way : anonymous class(super implementation)
+// ! third way : lambda expression (from java 8 version )
+// ? short hand style, SAM interface implementation : single abstract method
+// interface
+
+// class mycalc implements calc {
+
+// @Override
+// public int compute(int x, int y) {
+// return x + y;
+// }
+
+// }
+class Rparent {
+
+    void show() {
+        System.out.println("I am the R show parents");
+    }
+}
+
+// ! default keyword use
+interface intt {
+    void show();
+
+    default void print() {
+        System.out.println("1.  Print inside interface intt");
+    }
+
+    static void disp() {
+        System.out.println("Static method inside interface intt");
+    }
+}
+
+interface intt2 {
+    default void print() {
+        System.out.println("2.  Print inside interface intt2");
+    }
+}
+
+interface intt3 extends intt, intt2 {
+    default void print() {
+        intt.super.print();
+        intt2.super.print();
+        System.out.println("3.  This is print inside interface intt3");
+    }
+}
+
+public class InterfaceUseWays {
+    public static void main(String[] args) {
+        // calc obj = new mycalc();
+        // int res = obj.compuete(45, 54);
+        // System.out.println(res);
+
+        // ! Anonymous class
+        // during object creation we create a class
+
+        calc obj = new calc() {
+            public int compute(int x, int y) {
+                return x * y;
+            }
+        };
+        int r = obj.compute(54, 45);
+        System.out.println("The result is : " + r);
+
+        // ? third way
+        // ! lambda function
+        calc obj2 = (int a, int b) -> a + b;
+        System.out.println("The result by lambda is : " + obj2.compute(54, 45));
+
+        // ? bytecode genrated by lamda, merges the bytecodes, hence it is an advantage
+        // ? of using lambda function
+
+        // ! Anonymous class
+        Rparent t = new Rparent() {
+            void show() {
+                System.out.println("R child show...");
+                this.print();
+            }
+
+            void print() {
+                System.out.println("R child print...");
+            }
+        };
+        t.show();
+        // t.print();
+
+        // ! Anonymous class
+        intt i = new intt() {
+            public void show() {
+                print();
+                System.out.println("This is show of interface intt");
+            }
+        };
+        i.show();
+        intt.disp();
+        System.out.println();
+
+        // ! Anonymous class
+        intt3 ii = new intt3() {
+            public void show() {
+                print();
+                System.out.println("This is show of interface intt3");
+            }
+        };
+        ii.print();
+    }
+}