first commit for java

Author: bhagat-hrishi

.gitignore

@@ -0,0 +1 @@
+*.class

Array/CommandLine.java

@@ -0,0 +1,13 @@
+public class CommandLine {
+    public static void main(String[] args) {
+        for(int i=0;i<args.length;i++)
+        {
+            System.out.println(args[i]);
+        }
+
+    }
+}
+//space act as delemiter in cmd line argument
+//Run by "java CommandLine 1 2 3 4"
+//I command line argument itself contain space then we should enclose in double quote 
+//Run by java CommandLine 1 "hrishi bhagat"

Array/InstanceVariable.java

@@ -0,0 +1,12 @@
+public class InstanceVariable {
+    
+    boolean b;
+    public static void main(String[] args) {
+        InstanceVariable obj=new InstanceVariable();
+        //instance variable initalized with default value by jvm
+        //for accessing instane variable from static area we required Object reference
+        //but from non static area we can access direclty
+        System.out.println(obj.b);
+
+    }
+}

Array/LocalVaraible.java

@@ -0,0 +1,14 @@
+public class LocalVaraible {
+    public static void main(String[] args) {
+        int a;
+        int b;
+        //if you declare local variable and not using the this is fine and no error
+        //Error in below statement
+        System.out.println(b);//you declare local variable and you are using it
+
+        //Only applicable modifier for local variable is final 
+        //if you are using any other then you get error
+        
+        strictfp a=0;//error
+    }
+}

Array/MainMethod.java

@@ -0,0 +1,23 @@
+class Parent
+{
+    // cheking of main method done by JVM and not by compiler
+    // we can change "order of modifier" for main method observe below
+
+    strictfp static final public synchronized void main(String... hrishi)// instead of args we can use any valid  identifier
+    {
+        // we can add  "final,synchronize,strictfp"   modifier to main method
+        System.out.println("\n\nI am string main\n\n");
+    }
+
+    // Overloading of main possible but JVM call String argument main method
+    public static void main(int[] args) {
+        System.out.println("I am int main method");
+    }
+}
+
+public class MainMethod extends Parent
+{
+    //Inheritance concept applicable for main method
+    //if child class does not contain main method then parent class main method executed
+    //this is child class which not contain main method in such cases parent class main method is executed
+}

Array/MainMethod2.java

@@ -0,0 +1,14 @@
+class IAmParent
+{
+    public static void main(String[] args) {
+        System.out.println("Parent main method");
+    }
+}
+//So This seems overriding concept applicable for main method but this is
+//"method hiding " and not overriding
+//compile and run by "java IamParent" and "java MainMethod2"
+public class MainMethod2 {
+    public static void main(String[] args) {
+        System.out.println("Child main method");
+    }
+}

Array/StaticVariable.java

@@ -0,0 +1,9 @@
+public class StaticVariable {
+    static String s;
+    public static void main(String[] args) {
+        
+        //initialize by default value
+        //all variable share same copy of static variable
+        System.out.println(s);
+    }
+}

Array/Var_arg.java

@@ -0,0 +1,50 @@
+class Var_arg
+{
+    //This introduced in "1.5" version
+    public static void m1(int ... x)
+    {
+        int sum=0;
+        for(int i:x)
+        {
+            sum+=i;
+        }
+        System.out.println("Sum of elements: "+sum);
+        System.out.println("I am var_arg");
+    }
+    
+    /**
+      In general var-arg method will get least priority that is if no other method
+      matched then only var-arg method will get the chance this is exactly same as
+      default case inside a switch.
+     */
+    //Original no arg is prefere with var-arg method
+    public static void m1()
+    {
+        System.out.println("I am original no argument");
+    }
+    
+    //we can mix general parameter with var-arg parameter but var-arg in this case should presnt at rightmost side
+    //this is error  public static void general_and_var_arg(float ... f , String s)
+    public static void general_and_var_arg(String s,float ... f)
+    {
+        System.out.println("general_and_var_arg");
+    }
+    //As internally var-arg method are implemented as 1D Array
+    // public static void m1(int [] a)//this is error 
+    // {
+
+    // }
+
+    //As var-arg method is internlly uses 1d array then we can declare main method as below
+    public static void main(String ... args)//use of var-arg 
+    {
+        m1(90);//with 1 arg
+        System.out.println("_______________________\n");
+        m1();//with no arg
+        System.out.println("_______________________\n");
+        m1(3,4,4,5,5,6,6);//with 7 arg
+        System.out.println("_______________________\n");
+  
+        general_and_var_arg("Hrishi");
+    }
+}

Array/Var_arg2.java

@@ -0,0 +1,22 @@
+public class Var_arg2 {
+    
+    //we can call this method by passing group of elements
+    static void m1(int ... x)
+    {
+            System.out.println("I am m1");
+    }
+    //we can call this method by passing group of "1D" Arrays
+    static void m2(int[] ...x)
+    {
+            System.out.println("I am m2");
+    }
+    
+    public static void main(String[] args) {
+        
+        m1(2,3,4,5,6);
+
+        int []arr1={1,2,4,5,6,7};
+        int []arr2={3,4,5,6,7,8,2};
+        m2(arr1,arr2);//passing arrays to function
+    }
+}

Array/anonymus.java

@@ -0,0 +1,26 @@
+class anonymus
+{
+
+    public static int sum(int[] x)
+    {
+        int total=0;
+        for(int x1:x)
+        {
+        total=total+x1;
+        }
+        return total;
+    }
+    public static void main(String [] args)
+    {
+        //decalaration  
+        new int[]{10,20,30,40};//valid
+        new int[][]{{10,20},{30,40}};//valid
+
+        
+        //At the time of anonymous array creation we can't specify the size otherwise we will get compile time error.
+        new int[3]{10,20,30,40};//C.E:';' expected(invalid)
+
+        //use of anonymus array
+        System.out.println(sum(new int[]{10,20,30,40}));//100
+    }
+}

Array/array1.java

@@ -0,0 +1,27 @@
+class array1
+{
+    public static void main(String [] args)
+    {
+        //1:At the time of array creation compulsory we should specify the size
+        // int [] a=new int[];//C.E:array dimension missing
+
+        //2:It is legal to have an array with size zero in java.
+        int[] b=new int[0];
+        System.out.println(b.length);//0
+
+        //3:If we are taking array size with -ve int value then we will get runtime exception
+        int[] c=new int[-3];//R.E:NegativeArraySizeException
+
+
+        //4:Only allowed data type for array decleration are (byte,short,char,int) and other are NOT allowed
+        int[] d=new int['a'];//(valid)
+        byte bite=10;
+        int[] a2=new int[bite];//(valid)
+        /*long used*/int[] a3=new int[10l];//C.E:possible loss of precision//(invalid)
+        /*double used*/int[] a4=new int[10.5];//C.E:possible loss of precision//(invalid)
+
+
+        
+    
+    }
+}

Array/array2.java

@@ -0,0 +1,33 @@
+class array2
+{
+    public static void main(String[] args)
+    {
+        //at time of creation each element is intitialized with default value
+        int [] a=new int[4];
+        boolean []b=new boolean[2];
+        for(int tmp:a)
+            System.out.println(tmp);
+        System.out.println("-------------------------------------------------------");
+        for(boolean tmp:b)
+            System.out.println(tmp);
+        System.out.println("-------------------------------------------------------");
+        //Whenever we are trying to print any object reference internally toString() method
+        float [][] f=new float[3][2];
+        System.out.println(a);
+        System.out.println(f);
+        System.out.println(f[0]);
+        System.out.println(f[0][0]);
+        System.out.println("-------------------------------------------------------");
+
+        //length is final variable applicable for array which give size of array and length() method is used for String
+        int [] x=new int[3];
+        System.out.println("length: "+x.length);//3
+
+        //In multidimensional arrays length variable represents only base size but not total size. <----------------------------------------------
+        int[][] tmp=new int[6][3];
+    System.out.println(tmp.length);//6
+
+    
+    }
+
+}

Array/array3.java

@@ -0,0 +1,21 @@
+import java.util.*;
+class array3
+{
+    public static void main(String [] args)
+    {
+        //for primitive array as array element any type is allowed which can be promoted to declared type
+        //For the int type arrays the allowed array element types are byte, short, char, int
+        //For float type arrays the allowed element types are byte, short, char, int, long, float.
+        float [] f=new float[2];
+        f[0]='a';
+        f[1]=90;
+        System.out.println(f[0]+"    "+f[1]);
+
+
+        //case of interface type arrays as array elements we can provide its implemented class objects.
+        Runnable [] a=new Runnable[1];  
+        Thread t=new Thread();
+        a[0]=t;
+
+    }
+}

Array/java_function_can_also_contain_dollor_underscore.java

@@ -0,0 +1,12 @@
+class java_function_can_also_contain_dollor_underscore
+{
+    public  static void _$m132()
+    {
+        System.out.println("this is funtion");
+    }
+    public static void main(String [] args)
+    {   
+        _$m132();
+        
+    }
+}

Collections/AllCursors.java

@@ -0,0 +1,44 @@
+import java.util.Enumeration;
+import java.util.Iterator;
+import java.util.ListIterator;
+import java.util.Vector;
+
+public class AllCursors {
+    public static void main(String[] args) {
+        Vector v=new Vector<Integer>();
+        for(int i=0;i<10;i++)
+        {
+            v.add(i+1);
+        }
+        //for Enumeration
+        Enumeration<Integer> e=v.elements();
+        System.out.println("\nBy enumration");
+        while(e.hasMoreElements())//method of enumeration
+        {
+            //return type of nextElement method is Object so we need to do typecasting
+            System.out.print((Integer)e.nextElement()+ "  ");//method of enumeration
+        }
+
+        //for Iterator
+        Iterator<Integer> it=v.iterator();
+        System.out.println("\nBy Iterator");
+        while(it.hasNext())
+        {
+            //return type of next function is Object so we need to typecast
+            Integer i=(Integer)it.next();
+            if(i%2==0)
+                System.out.print(i+ "  ");
+            else
+                it.remove();
+        }
+
+        //by ListIterator
+        System.out.println("\nListIterator");
+        ListIterator lst=v.listIterator();
+        while(lst.hasNext())//listiterator is child interface of iterator so it has hasNext method
+        {
+            System.out.println("Element: "+lst.next()+"  "+lst.nextIndex());
+        }
+       
+    }
+}