├── array.java
├── notes
    ├── Arrays.pptx
    ├── intro-2.pptx
    ├── java intro.pptx
    ├── Java Type Casting.pptx
    ├── String Handling.pptx
    ├── Control statements.pptx
    ├── JP COURSE FILE-converted.pdf
    └── operators,expressions,control stmts.pptx
├── basics
    ├── variables
    │   ├── StaticVar.java
    │   ├── CricketerImpl.java
    │   ├── Cricketer.java
    │   └── InstanceVar.java
    ├── HelloWorld.java
    ├── controlstatements
    │   ├── EnhancedFor.java
    │   ├── Ifstmt.java
    │   ├── WhileExam.java
    │   ├── NestedIf.java
    │   └── SwitchCase.java
    ├── NarrowCastExample.java
    ├── datatype
    │   ├── TypeConv.java
    │   ├── NarrowCastExample.java
    │   └── Datatype.java
    ├── TypCast.java
    ├── StudentImpl.java
    ├── Strings.java
    ├── FactImpl.java
    ├── ArmstrongImpl.java
    ├── ArithmeticOp.java
    ├── Primitive.java
    └── InputMethods.java
├── Wrapper.java
├── Strings
    ├── StringExam.java
    └── Stringcomp.java
├── Arrays
    ├── ComArraym.java
    ├── Typcast.java
    ├── ComArray.java
    ├── IterateArray.java
    ├── MultiDimArray.java
    ├── enhanced_for_loop.java
    └── ConsoleExam.java
├── .gitignore
├── Factorial.java
├── StudentImpl.java
├── Armstrong.java
├── README.md
└── .vscode
    └── launch.json


/array.java:
--------------------------------------------------------------------------------
1 | public array{
2 |   public static void main(String[] ar){
3 |     }
4 | }
5 | 


--------------------------------------------------------------------------------
/notes/Arrays.pptx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Sreekar2610/OOP-using-Java/HEAD/notes/Arrays.pptx


--------------------------------------------------------------------------------
/notes/intro-2.pptx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Sreekar2610/OOP-using-Java/HEAD/notes/intro-2.pptx


--------------------------------------------------------------------------------
/notes/java intro.pptx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Sreekar2610/OOP-using-Java/HEAD/notes/java intro.pptx


--------------------------------------------------------------------------------
/basics/variables/StaticVar.java:
--------------------------------------------------------------------------------
1 | package basics.variables;
2 | 
3 | public class StaticVar {
4 |     
5 | }
6 | 


--------------------------------------------------------------------------------
/notes/Java Type Casting.pptx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Sreekar2610/OOP-using-Java/HEAD/notes/Java Type Casting.pptx


--------------------------------------------------------------------------------
/notes/String Handling.pptx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Sreekar2610/OOP-using-Java/HEAD/notes/String Handling.pptx


--------------------------------------------------------------------------------
/notes/Control statements.pptx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Sreekar2610/OOP-using-Java/HEAD/notes/Control statements.pptx


--------------------------------------------------------------------------------
/notes/JP COURSE FILE-converted.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Sreekar2610/OOP-using-Java/HEAD/notes/JP COURSE FILE-converted.pdf


--------------------------------------------------------------------------------
/notes/operators,expressions,control stmts.pptx:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Sreekar2610/OOP-using-Java/HEAD/notes/operators,expressions,control stmts.pptx


--------------------------------------------------------------------------------
/basics/HelloWorld.java:
--------------------------------------------------------------------------------
1 | package basics;
2 | class HelloWorld{
3 |     public static void main(String[] args){
4 |         System.out.println("Hello there welcome to java");
5 |     }
6 | }


--------------------------------------------------------------------------------
/basics/controlstatements/EnhancedFor.java:
--------------------------------------------------------------------------------
1 | class EnhancedFor{
2 | 	public static void main(String[] ar){
3 | 		int[] marks={10,20,30,40,50};
4 | 		for(int i:marks){
5 | 			System.out.println("marks are"+i);
6 | 		}
7 | }
8 | }


--------------------------------------------------------------------------------
/Wrapper.java:
--------------------------------------------------------------------------------
1 | class Wrapper
2 | {  
3 |     public static void main(String[] p)
4 |     {    System.out.println("Welcome "+p[0]);
5 |          int a= Integer.parseInt(p[1]);
6 |          int b= Integer.parseInt(p[2]);
7 |          System.out.println(a+b);
8 |      }
9 | }


--------------------------------------------------------------------------------
/basics/NarrowCastExample.java:
--------------------------------------------------------------------------------
 1 | package basics;
 2 | 
 3 | public class NarrowCastExample {
 4 |     public static void main(String[] args) {
 5 |         int marks=70;
 6 |         double dmarks=(double)marks;
 7 |         System.out.println(marks);
 8 |         System.out.println(dmarks);
 9 |     }
10 | }
11 | 


--------------------------------------------------------------------------------
/basics/datatype/TypeConv.java:
--------------------------------------------------------------------------------
 1 | package basics.datatype;
 2 | 
 3 | public class TypeConv {
 4 |     public static void main(String[] args) {
 5 |         int rno=81;
 6 |         double rnn=rno;
 7 |         System.out.println(rno);// Automatic casting: int to double
 8 |         System.out.println(rnn);
 9 |     }
10 | }
11 | 


--------------------------------------------------------------------------------
/basics/datatype/NarrowCastExample.java:
--------------------------------------------------------------------------------
 1 | package basics.datatype;
 2 | 
 3 | public class NarrowCastExample {
 4 |     public static void main(String[] args) {
 5 |         int marks=70;
 6 |         double dmarks=(double)marks;
 7 |         System.out.println(marks);
 8 |         System.out.println(dmarks);
 9 |     }
10 | }
11 | 


--------------------------------------------------------------------------------
/Strings/StringExam.java:
--------------------------------------------------------------------------------
 1 | class StringExam{
 2 | 	public static void main(String[] args){
 3 | 		String str="tonight";
 4 | 		System.out.println(str.indexOf('u'));
 5 | 		System.out.println(str.indexOf('t',3));
 6 | 		String subString="ton";
 7 | 		System.out.println(str.indexOf(subString));
 8 | 		System.out.println(str.indexOf(subString,7));
 9 | 	}
10 | }


--------------------------------------------------------------------------------
/Arrays/ComArraym.java:
--------------------------------------------------------------------------------
 1 | class ComArraym{
 2 | 	/*
 3 | 	min array element
 4 | 	*/
 5 | 	static void min(int arr[]){
 6 | 		int min=arr[0];
 7 | 		for(int i=1;i<arr.length;i++)
 8 | 			if(min>arr[i])
 9 | 				min=arr[i];
10 | 		System.out.println(min);
11 | 		
12 | 	}
13 | 	public static void main(String[] args){
14 | 		int a[]={33,3,4,5};
15 | 		min(a);
16 | 	}
17 | }


--------------------------------------------------------------------------------
/Arrays/Typcast.java:
--------------------------------------------------------------------------------
 1 | class TypCast{
 2 | 	public static void main(String[] args) {
 3 | 		int marks=80;
 4 | 		long lmv=marks;
 5 | 		System.out.println("integer value"+marks);
 6 | 		System.out.println("long value"+lmv);
 7 | 
 8 | 		float  d=129.345;
 9 | 		double inm=(double)d;
10 | 		System.out.println("double value"+d);
11 | 		System.out.println("integer value"+inm);
12 | 	}
13 | }


--------------------------------------------------------------------------------
/Strings/Stringcomp.java:
--------------------------------------------------------------------------------
 1 | import java.util.Scanner;
 2 | class Stringcomp{
 3 | 	public static void main(String[] ar){
 4 | 		Scanner sc=new Scanner(System.in);
 5 | 		System.out.println("enter your name:");
 6 | 		String nam=sc.nextLine();
 7 | 		if(nam.equals("java")){
 8 | 			System.out.println("good choice");
 9 | 		}
10 | 		else{
11 | 			System.out.println("you have entered"+nam);
12 | 		}
13 | 	}
14 | }
15 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
 1 | # Compiled class file
 2 | *.class
 3 | 
 4 | # Log file
 5 | *.log
 6 | 
 7 | # BlueJ files
 8 | *.ctxt
 9 | 
10 | # Mobile Tools for Java (J2ME)
11 | .mtj.tmp/
12 | 
13 | # Package Files #
14 | *.jar
15 | *.war
16 | *.nar
17 | *.ear
18 | *.zip
19 | *.tar.gz
20 | *.rar
21 | 
22 | # virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
23 | hs_err_pid*
24 | replay_pid*
25 | 


--------------------------------------------------------------------------------
/Arrays/ComArray.java:
--------------------------------------------------------------------------------
 1 | public class ComArray{
 2 | 	int[] arr3={4,7,3,9,2};
 3 | 		public static void main(String[] args) {
 4 | 			/*common array element*/
 5 | 			int[] arr1={4,7,3,9,2};
 6 | 			int[] arr2={3,2,12,9,40,32,4};
 7 | 			for(int i=0;i<arr1.length;i++){
 8 | 				for(int j=0;j<arr2.length;j++){
 9 | 					if(arr1[i]==arr2[j]){
10 | 						System.out.println(arr1[i]);
11 | 					}
12 | 				}
13 | 			}
14 | 		}
15 | }


--------------------------------------------------------------------------------
/Factorial.java:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | public class Factorial{
 3 |     public static void main(String[] args){
 4 |         int f=1;
 5 |         Scanner sc= new Scanner(System.in);
 6 |         System.out.println("Enter the number to find the factorial");
 7 |         int n=sc.nextInt();
 8 |         for(int i=1;i<=n;i++){
 9 |             f=f*i;
10 |         }
11 |         System.out.println("Fcatorial of "+n+" is "+f);
12 |     }
13 | }


--------------------------------------------------------------------------------
/basics/TypCast.java:
--------------------------------------------------------------------------------
 1 | class TypCast{
 2 | 	public static void main(String[] args) {
 3 | 		int marks=80;
 4 | 		long lmv=marks;
 5 | 		System.out.println("integer value"+marks);
 6 | 		System.out.println("long value"+lmv);
 7 | 
 8 | 		/*float  d=129.345;
 9 | 		double inm=(double)d;*/
10 | 		double d=129.345;
11 | 		int inm=(int)d;
12 | 
13 | 		System.out.println("double value"+d);
14 | 		System.out.println("integer value"+inm);
15 | 	}
16 | }


--------------------------------------------------------------------------------
/Arrays/IterateArray.java:
--------------------------------------------------------------------------------
 1 | class IterateArray{
 2 | 		public static void main(String[] ar){
 3 | 			int[] arr={1,2,4,5,6,7};
 4 | 			ComArray co=new ComArray();
 5 | 			for(int l:co.arr3){
 6 | 				System.out.println(l);
 7 | 			}
 8 | 			
 9 | 			ComArray.main(null);
10 | 			System.out.println("elements are");
11 | 			//array.length property tells the total elements in array
12 | 			for(int i=0;i<arr.length;i++){
13 | 
14 | 				System.out.println(arr[i]);
15 | 			}
16 | 		}
17 | }


--------------------------------------------------------------------------------
/basics/StudentImpl.java:
--------------------------------------------------------------------------------
 1 | package basics;
 2 | 
 3 | public class StudentImpl {
 4 |     public static void main(String[] args){
 5 |         Student s = new Student("james","1232");
 6 |         s.display();
 7 |     }
 8 | }
 9 |  class Student{
10 |     String nam,rn;
11 |     Student(String name,String rno){
12 |         nam=name;
13 |         rn=rno;
14 |     }
15 |     public void display(){
16 |         System.out.printf("Welcome %s rno is %s \n",nam,rn);
17 | 
18 |     }
19 | }


--------------------------------------------------------------------------------
/basics/variables/CricketerImpl.java:
--------------------------------------------------------------------------------
 1 | package basics.variables;
 2 | /**
 3 |  * local variables
 4 |  * Cricketer class 
 5 |  */
 6 | public class CricketerImpl {
 7 |     public static void main(String[] ar){
 8 |         Cricketer c1=new Cricketer();
 9 |         Cricketer c2=new Cricketer("MS Dhoni","India", 32);
10 |         System.out.println(c2);
11 |         c1.name="Sachin";
12 |         c1.team="India";
13 |         c1.age=55;
14 |         System.out.println(c1);
15 |     }
16 | }
17 | 


--------------------------------------------------------------------------------
/basics/variables/Cricketer.java:
--------------------------------------------------------------------------------
 1 | package basics.variables;
 2 | /**
 3 |  * Local variables
 4 |  */
 5 | public class Cricketer {
 6 |     String name;
 7 |     String team;
 8 |     int age;
 9 |     Cricketer(){
10 |         name="";
11 |         team="";
12 |         age=0;
13 |     }
14 |     Cricketer(String n, String t, int a){
15 |         name=n;
16 |         team=t;
17 |         age=a;
18 |     }
19 |     public String toString(){
20 |         return "this is"+name+"of"+team;
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/basics/Strings.java:
--------------------------------------------------------------------------------
 1 | public class Strings {
 2 |     public static void main(String[] args) {
 3 | 
 4 |         int Myinteger = 97;
 5 | 
 6 |         String text = "Hello";
 7 |         String blank = " ";
 8 |         String name = "Yethishwar";
 9 |         String greeting = text + blank + name;
10 | 
11 |         System.out.println(greeting);
12 |         System.out.println("Hello" + " " + name); // Concatenation
13 | 
14 |         System.out.println("Thi is Integer value:" + " " + Myinteger);
15 | 
16 |     }
17 | }


--------------------------------------------------------------------------------
/StudentImpl.java:
--------------------------------------------------------------------------------
 1 | 
 2 | public class StudentImpl {
 3 |     public static void main(String[] args){
 4 |         Student s = new Student("james","1232");
 5 | 	//Factorial f=new Factorial();
 6 | 	Factorial.main(null);
 7 |         s.display();
 8 |     }
 9 | }
10 |  class Student{
11 |     String nam,rn;
12 |     Student(String name,String rno){
13 |         nam=name;
14 |         rn=rno;
15 |     }
16 |     public void display(){
17 |         System.out.printf("Welcome %s rno is %s \n",nam,rn);
18 | 
19 |     }
20 | }


--------------------------------------------------------------------------------
/basics/FactImpl.java:
--------------------------------------------------------------------------------
 1 | package basics;
 2 | import java.io.*;
 3 | 
 4 | public class FactImpl {
 5 |     public static void main(String[] args) throws IOException{
 6 |         int f=1;
 7 |         BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
 8 |         System.out.println("enter the number to find the factorial");
 9 |         int n=Integer.parseInt(br.readLine());
10 |         for(int i=1;i<=n;i++){
11 |             f=f*i;
12 |         }
13 |         System.out.println("factorial of "+n+" is "+f);
14 |     }
15 | }
16 | 
17 | 


--------------------------------------------------------------------------------
/basics/datatype/Datatype.java:
--------------------------------------------------------------------------------
 1 | package basics.datatype;
 2 | 
 3 | public class Datatype {
 4 |     public static void main(String[] pp){
 5 |         int a=90;
 6 |         String s="hi";
 7 |         /**
 8 |          * getClass()- used to retrieve the runtime class of the object
 9 |          * getSimpleName()--it retrieves the simple name of the class without the package
10 |          */
11 |         System.out.println("datatype of s is "+s.getClass().getSimpleName());
12 |         System.out.println("datatype of a is "+Integer.TYPE);
13 |     }
14 | }
15 | 


--------------------------------------------------------------------------------
/basics/controlstatements/Ifstmt.java:
--------------------------------------------------------------------------------
 1 | package basics.controlstatements;
 2 | import java.util.*;
 3 | public class Ifstmt {
 4 |     public static void main(String[] ar){
 5 |             Scanner sc=new Scanner(System.in);
 6 |             System.out.println("enter the age");
 7 |             int age=sc.nextInt();
 8 |             if(age>=18){
 9 |                 System.out.println("You are allowed to vote");
10 |             }
11 |             else{
12 |                 System.out.println("You are not eligible");
13 |             }
14 |             sc.close();
15 |     }
16 |     
17 | }
18 | 


--------------------------------------------------------------------------------
/Arrays/MultiDimArray.java:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | /** two dimensional array program**/
 3 | class MultiDimArray{
 4 | 	public static void main(String[] ar){
 5 | 		int marks[][]=new int[10][2];
 6 | 		Scanner sc=new Scanner(System.in);
 7 | 		System.out.println("enter roll number and marks");
 8 | 		for(int i=0;i<marks.length;i++){
 9 | 				System.out.println("rollno");
10 | 				marks[i][0]=sc.nextInt();
11 | 				System.out.println("marks");
12 | 				marks[i][1]=sc.nextInt();
13 | 			
14 | 		}
15 | 		for(int j=0;j<marks.length;j++){
16 | 		System.out.println("roll no "+marks[j][0]+" marks"+marks[j][1]);
17 | 	}
18 | 	}
19 | }
20 | 


--------------------------------------------------------------------------------
/Armstrong.java:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | public class Armstrong{
 3 |     public static void main(String[] args){
 4 |         int sum=0,n,orn;
 5 |         Scanner sc= new Scanner(System.in);
 6 |         n= sc.nextInt();
 7 |         orn=n;
 8 |         while(orn!=0){
 9 |             int rem=orn%10;
10 |             sum+=rem*rem*rem;
11 |             orn/=10;
12 |         }
13 |         if(sum==n){
14 |             System.out.println("It is an Armstrong Number.");
15 |         }
16 |         else{
17 |             System.out.println("It is not an Armstrong Number.");
18 |         }
19 |         sc.close();
20 |     }
21 | }


--------------------------------------------------------------------------------
/basics/ArmstrongImpl.java:
--------------------------------------------------------------------------------
 1 | package basics;
 2 | import java.util.*;
 3 | public class ArmstrongImpl {
 4 |     //armstrong number logic
 5 |     public static void main(String[] ar){
 6 |         int sum=0,n,orn;
 7 |         Scanner sc=new Scanner(System.in);
 8 |         System.out.println("enter the number:");
 9 |         n=sc.nextInt();
10 |         orn=n;
11 |         while(orn!=0){
12 |              int rem=orn%10;
13 |              sum+=rem*rem*rem;
14 |              orn/=10;
15 | 
16 |         }
17 |         if(sum==n){
18 |             System.out.println("armstrong number");
19 |         }else{
20 |             System.out.println("not armstrong number");
21 |         }
22 |         sc.close();
23 |     }
24 |     
25 | }
26 | 


--------------------------------------------------------------------------------
/basics/ArithmeticOp.java:
--------------------------------------------------------------------------------
 1 | package basics;
 2 | import java.util.*;
 3 | class ArithmeticOp{
 4 |     public static void main(String[] args){
 5 |         Scanner sc=new Scanner(System.in);
 6 |         System.out.println("enter the two integers");
 7 |         int a=sc.nextInt();
 8 |         int b=sc.nextInt();
 9 |         sc.close();
10 |         Arith a1=new Arith(a,b);
11 |         a1.add();
12 |         a1.sub();
13 |     }
14 | }
15 | class Arith{
16 |     int n1,n2;
17 |     Arith(int a,int b){
18 |         this.n1=a;
19 |         this.n2=b;
20 |     }
21 |     void add(){
22 |         System.out.println("addition result:"+(n1+n2));
23 |     }
24 |     void sub(){
25 |          System.out.println("subtraction result:"+(n1-n2));
26 |     }
27 | }


--------------------------------------------------------------------------------
/Arrays/enhanced_for_loop.java:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | 
 3 | public class enhanced_for_loop {
 4 |     public static void main(String[] args) {
 5 |         Scanner sc = new Scanner(System.in);
 6 |         int i = 0;
 7 |         System.out.println("Enter the limit:");
 8 |         int n = sc.nextInt();
 9 |         System.out.println("Enter the marks:");
10 |         int marks [] = new int [n];
11 |         while (i < n) {
12 |             marks [i] = sc.nextInt();
13 |             i++; //incrementing index value           
14 |         }
15 |         System.out.println("The marks are:");
16 | 
17 |         //implementing enhanced for loop
18 |         for(int nn:marks){
19 |             System.out.println(nn);
20 |         }
21 |         sc.close();
22 | 
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/basics/controlstatements/WhileExam.java:
--------------------------------------------------------------------------------
 1 | package basics.controlstatements;
 2 | import java.util.*;
 3 | /**
 4 |  * Java program to accept input and store in arrays
 5 |  */
 6 | public class WhileExam {
 7 |     public static void main(String[] p){
 8 |         Scanner sc=new Scanner(System.in);
 9 |         int i=0;
10 |         System.out.println("enter the limit");
11 |         int n=sc.nextInt();
12 |         System.out.println("enter the marks");
13 |         int marks[]=new int[n];
14 |         while(i<n){
15 |             marks[i]=sc.nextInt();
16 |             i++;
17 |         }
18 |         System.out.println("the marks are");
19 | 
20 |         for(int nn : marks){
21 |             System.out.println(nn);
22 |         }
23 |         sc.close();
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/basics/controlstatements/NestedIf.java:
--------------------------------------------------------------------------------
 1 | package basics.controlstatements;
 2 | 
 3 | public class NestedIf {
 4 |     public static void main(String[] args){
 5 |         java.util.Scanner sc=new java.util.Scanner(System.in);
 6 |         System.out.println("enter your favorite iconic character:");
 7 |         String act=sc.nextLine();
 8 |         if(act.equals("Iron Man")){
 9 |             System.out.println("Great choice");
10 |             System.out.println("enter"+act+"real name");
11 |             String reall=sc.nextLine();
12 |             if(reall.equalsIgnoreCase("tony stark")){
13 |                 System.out.println("Cool actor");
14 |             }
15 |         }else{
16 |             System.out.println(act);
17 |         }
18 |         sc.close();
19 |         
20 |     }
21 | }
22 | 


--------------------------------------------------------------------------------
/Arrays/ConsoleExam.java:
--------------------------------------------------------------------------------
 1 | import java.io.Console;
 2 | /**
 3 | System.console() returns null if your application is not run in a terminal (though you can handle this in your application
 4 | secure password entry (hard to do cross-platform)
 5 | synchronisation (multiple threads can prompt for input and Console will queue them up nicely, whereas if you used System.in/out then all of the prompts would appear simultaneously).
 6 | 
 7 | */
 8 | class ConsoleExam{
 9 | 	public static void main(String[] args) {
10 | 		System.out.println("using console");
11 | 		Console con=System.console();
12 | 		if(con!=null){
13 | 			con.printf("enter your name");
14 | 			String name=con.readLine();
15 | 			con.printf("Hello,%s!%n",name);
16 | 		}else{
17 | 			System.out.println("console not available");
18 | 		}
19 | 	}
20 | }


--------------------------------------------------------------------------------
/basics/variables/InstanceVar.java:
--------------------------------------------------------------------------------
 1 | package basics.variables;
 2 | /**
 3 |  * Call By Reference
 4 |  * When you pass an object to a method, changes to the object inside a method do affect
 5 |  * the object used as an argument.
 6 |  */
 7 | public class InstanceVar {
 8 |     int a,b,c;
 9 |     InstanceVar(int i,int j){
10 |         a=i;
11 |         b=j;
12 |     }
13 |     int addition(InstanceVar inv){
14 |         c=inv.a+inv.b;
15 |         return c;
16 |     }
17 |     public static void main(String ar[]){
18 |         InstanceVar inv1=new InstanceVar(3, 2);
19 |         System.out.println("Before Call"+inv1.a+" "+inv1.b);
20 |         
21 |         int c=inv1.addition(inv1);
22 |         System.out.println("result is"+c);
23 |         inv1.a=4;
24 |         inv1.b=2;
25 |         int res=inv1.addition(inv1);
26 |         System.out.println("After Call"+inv1.a+" "+inv1.b);
27 |         System.out.println("result is"+res);
28 |     }
29 |     
30 | }
31 | 


--------------------------------------------------------------------------------
/basics/Primitive.java:
--------------------------------------------------------------------------------
 1 | public class Primitive {
 2 |     public static void main(String[] args) {
 3 | 
 4 |         // Primitive data types
 5 | 
 6 |         int Mynumber = 97; // ranging from -2,147,483,648 to 2,147,483,647.
 7 |         short Myshort = 830; // ranging from -32,768 to 32,767.
 8 |         long Mylong = 97723323; // ranging from -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807.
 9 | 
10 |         double Mydouble = 7.121121;
11 |         float Myfloat = 3.45f;
12 | 
13 |         char Mychar = 'Y';
14 |         boolean Myboolean = true;
15 | 
16 |         byte Mybyte = 127;
17 | 
18 |         System.out.println(Mynumber);
19 |         System.out.println(Myshort);
20 |         System.out.println(Mylong);
21 |         System.out.println(Mydouble);
22 |         System.out.println(Myfloat);
23 |         System.out.println(Mychar);
24 |         System.out.println(Myboolean);
25 |         System.out.println(Mybyte);
26 |     }
27 | }


--------------------------------------------------------------------------------
/basics/controlstatements/SwitchCase.java:
--------------------------------------------------------------------------------
 1 | package basics.controlstatements;
 2 | import java.util.*;
 3 | public class SwitchCase {
 4 |     public static void main(String[] args) {
 5 |         int a=4,b=2;
 6 |         Scanner sc=new Scanner(System.in);
 7 |         System.out.println("******");
 8 |         System.out.println("*ARITHMETIC OPERATIONS***");
 9 |         System.out.println("1. Add");
10 |         System.out.println("2. Sub");
11 |         System.out.println("3. Mul");
12 |         System.out.println("4. Div");
13 |         System.out.println("enter your choice");
14 |         int ch=sc.nextInt();
15 |         switch(ch){
16 |             case 1-> System.out.println("addition result is"+(a+b));
17 |             case 2-> System.out.println("subtraction result is"+(a-b));
18 |             case 3-> System.out.println("multiplication result is"+(a*b));
19 |             case 4-> System.out.println("division result is"+(a/b));
20 |             default -> System.out.println("give proper option");
21 |         }
22 |         sc.close();
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # Java Programming
 2 | This repository is focused on Core to Advanced Java Programming.It covers the OOP concepts, packages,Collections framework, Java Swings.
 3 | ## Contributing
 4 | 
 5 | Contributions are always welcome!
 6 | 
 7 | - Create a personal fork of the project on Github.This will create a copy of this repository in your account.
 8 | 
 9 | - Clone the fork on your local machine. Your remote repo on Github is called origin.
10 |  
11 |  ```
12 |  git clone "url u just copied"
13 |  ```
14 | 
15 | - Make necessary changes and commit using
16 | ``` 
17 |     git  add filename
18 | ```
19 | ```
20 |     git commit -m "msg"
21 | ```
22 | - Push your changes to github forked repository.
23 | ```
24 | git push -u origin your-branch-name
25 | ```
26 | - Submit your changes for a review
27 | ```
28 | If you go to your repository on GitHub, you'll see a Compare & pull request button. Click on that button.
29 | ```
30 | - Open a pull request
31 | -Soon I'll be merging all your changes into the main branch of this project. You will get a notification email once the changes have been merged.
32 | 


--------------------------------------------------------------------------------
/basics/InputMethods.java:
--------------------------------------------------------------------------------
 1 | import java.util.Scanner;
 2 | 
 3 | public class InputMethods {
 4 |     public static void main(String[] args) {
 5 |         Scanner scanner = new Scanner(System.in);
 6 | 
 7 |         // Basic Input methods
 8 |         System.out.println("Enter your name: ");
 9 |         String name = scanner.next();
10 |         scanner.nextLine();
11 |         System.out.println("Enter your college name: ");
12 |         String college = scanner.nextLine(); // Read the whole line
13 |         System.out.println("Enter your Roll number: ");
14 |         int rollNumber = scanner.nextInt();
15 |         System.out.println("Enter your 1st Year marks Percentage: ");
16 |         float marks = scanner.nextFloat(); // variable declaration
17 |         scanner.close();
18 | 
19 |         System.out.println("--------- Your Details ---------\n");
20 |         System.out.println("Name :" + name);
21 |         System.out.println("\nCollege : " + college);
22 |         System.out.println("\nRoll No : " + rollNumber);
23 |         System.out.println("\nPercentage : " + marks);
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/.vscode/launch.json:
--------------------------------------------------------------------------------
  1 | {
  2 |     "configurations": [
  3 |         {
  4 |             "type": "java",
  5 |             "name": "WhileExam",
  6 |             "request": "launch",
  7 |             "mainClass": "basics.controlstatements.WhileExam",
  8 |             "projectName": "OOP-using-Java_b9476530"
  9 |         },
 10 |         {
 11 |             "type": "java",
 12 |             "name": "SwitchCase",
 13 |             "request": "launch",
 14 |             "mainClass": "basics.controlstatements.SwitchCase",
 15 |             "projectName": "OOP-using-Java_b9476530"
 16 |         },
 17 |         {
 18 |             "type": "java",
 19 |             "name": "Datatype",
 20 |             "request": "launch",
 21 |             "mainClass": "basics.datatype.Datatype",
 22 |             "projectName": "OOP-using-Java_b9476530"
 23 |         },
 24 |         {
 25 |             "type": "java",
 26 |             "name": "CricketerImpl",
 27 |             "request": "launch",
 28 |             "mainClass": "basics.variables.CricketerImpl",
 29 |             "projectName": "OOP-using-Java_b9476530"
 30 |         },
 31 |         {
 32 |             "type": "java",
 33 |             "name": "InstanceVar",
 34 |             "request": "launch",
 35 |             "mainClass": "basics.variables.InstanceVar",
 36 |             "projectName": "OOP-using-Java_b9476530"
 37 |         },
 38 |         {
 39 |             "type": "java",
 40 |             "name": "NestedIf",
 41 |             "request": "launch",
 42 |             "mainClass": "basics.controlstatements.NestedIf",
 43 |             "projectName": "OOP-using-Java_b9476530"
 44 |         },
 45 |         {
 46 |             "type": "java",
 47 |             "name": "Ifstmt",
 48 |             "request": "launch",
 49 |             "mainClass": "basics.controlstatements.Ifstmt",
 50 |             "projectName": "OOP-using-Java_b9476530"
 51 |         },
 52 |         {
 53 |             "type": "java",
 54 |             "name": "NarrowCastExample",
 55 |             "request": "launch",
 56 |             "mainClass": "basics.NarrowCastExample",
 57 |             "projectName": "OOP-using-Java_b9476530"
 58 |         },
 59 |         {
 60 |             "type": "java",
 61 |             "name": "TypeConv",
 62 |             "request": "launch",
 63 |             "mainClass": "basics.TypeConv",
 64 |             "projectName": "OOP-using-Java_b9476530"
 65 |         },
 66 |         {
 67 |             "type": "java",
 68 |             "name": "ArmstrongImpl",
 69 |             "request": "launch",
 70 |             "mainClass": "basics.ArmstrongImpl",
 71 |             "projectName": "OOP-using-Java_b9476530"
 72 |         },
 73 |         {
 74 |             "type": "java",
 75 |             "name": "FactImpl",
 76 |             "request": "launch",
 77 |             "mainClass": "basics.FactImpl",
 78 |             "projectName": "OOP-using-Java_b9476530"
 79 |         },
 80 |         {
 81 |             "type": "java",
 82 |             "name": "StudentImpl",
 83 |             "request": "launch",
 84 |             "mainClass": "basics.StudentImpl",
 85 |             "projectName": "OOP-using-Java_b9476530"
 86 |         },
 87 |         {
 88 |             "type": "java",
 89 |             "name": "ArithmeticOp",
 90 |             "request": "launch",
 91 |             "mainClass": "basics.ArithmeticOp",
 92 |             "projectName": "OOP-using-Java_b9476530"
 93 |         },
 94 |         {
 95 |             "name": "gcc.exe - Build and debug active file",
 96 |             "type": "cppdbg",
 97 |             "request": "launch",
 98 |             "program": "${fileDirname}\\${fileBasenameNoExtension}.exe",
 99 |             "args": [],
100 |             "stopAtEntry": false,
101 |             "cwd": "${fileDirname}",
102 |             "environment": [],
103 |             "externalConsole": true,
104 |             "MIMode": "gdb",
105 |             "miDebuggerPath": "E:\\CodeBlocks\\MinGW\\bin\\gdb.exe",
106 |             "setupCommands": [
107 |                 {
108 |                     "description": "Enable pretty-printing for gdb",
109 |                     "text": "-enable-pretty-printing",
110 |                     "ignoreFailures": true
111 |                 }
112 |             ],
113 |             "preLaunchTask": "C/C++: gcc.exe build active file"
114 |         },
115 |         {
116 |             "name": "gcc build & run active file",
117 |             "type": "cppdbg",
118 |             "request": "launch",
119 |             "program": "${fileDirname}\\${fileBasenameNoExtension}.exe",
120 |             "args": [],
121 |             "stopAtEntry": false,
122 |             "cwd": "${fileDirname}",
123 |             "environment": [],
124 |             "externalConsole": false,
125 |             "MIMode": "gdb",
126 |             "miDebuggerPath": "E:\\CodeBlocks\\MinGW\\bin\\gdb.exe",
127 |             "setupCommands": [
128 |                 {
129 |                     "description": "Enable pretty-printing for gdb",
130 |                     "text": "-enable-pretty-printing",
131 |                     "ignoreFailures": true
132 |                 }
133 |             ],
134 |             "preLaunchTask": "gcc build & run active file"
135 |         }
136 |     ]
137 | }


--------------------------------------------------------------------------------