• It is a high level programming language which is based on deep concept of Object-Oriented Programming.
• Java is a platform because it has its own runtime environment that is JVM (Java Virtual Machine).
• The features of OOP are : Class, Object, Inheritance, Polymorphism, Encapsulation, Abstraction
• The features of OOPs are such that the real world problems can be solved by using programming language with less complexity.

James Gosling and his team started JAVA. In Sun Micro Systems, the JAVA was evolved in the year 1991. The first name of JAVA was OAK.
After 4 years that is in 1995 the first version of JAVA was developed. The name of the version was JAVA alpha Beta version. In 1996 the next version was developed, JDK 1.0.

• ! Ques might come
  Version | Release Date | Code Name

• Oracle in 2010 acquitted Sun Microsystems company, so currently license of JAVA is in hands of Oracle

• JAVA is platform independent

• The program written once can run anywhere.

• 

• Java is portable since we can move .class file from one platform to another.

• .class file contains bytecode.

• To execute Java code, you need to compile it. The Java compiler (javac) takes the source code (.java files) and produces bytecode, which is a platform-independent intermediate representation of the code.

• Security :
  - JVM : Its basic role is to verify byte code before running it. This makes sure that the program is not making any unsafe operation. There are various unsafe operations that a program can perform, for e.g. A program might branch to an incorrect location that contains data rather than instructions.
  - Security Manager : Security Manager Layer is present in JVM, it's makes sure that untrusted code does not manage to access some APIs and features of the platform.
  - No Pointers : Java does not support pointers as C and C++ supports, therefore some arbitrary location can not be addressed. Some arbitrary address can be accessed via pointers, which might be
  - Java has 4 access modifiers, public, protected, private and default, so if we want to hide some code we can use access modifiers.
  

• Exception Handling :

  • If a program has some error, it will not get compiled. Exception Handling catches the results which are unexpected and reports the error to the program until the rectification of the error by the programmer. This concept will not allow code to run making java more secure
• Own Memory Management :

  • The memory management mechanism is unique and owned by java, there is no need for manual intervention for garbage collection and everything is handled automatically. There is no headache to free the memory, it drastically reduces the programmer overhead.

• Size is fixed
• e.g. : int
  It is further Divided into Boolean and Numeric

• Size might change on runtime
• e.g. Array, String, Class, Structure ... etc.

package com.hitarth.classLectures;

public class asd {
    public static void main(String[] args) {
        char letter1 = '9';
        System.out.println(letter1); // → 9

        char letter2 = 65; // ASCII / Unicode
        System.out.println(letter2); // → A

		int number = 'A';
		System.out.println(number); // -> 65 // ASCII value of A = 65

    }
}
Copy

• They are declared within a method or a constructor or a block.
• The scope of local variable is inside a method or a constructor or a block
• The variables get allocated in the memory when they get executed
• After an exit the variables get destroyed outside the block.
• Local Variables don't have any default values.
• They are stored in stack memory.
• Access specifiers can't be used with local variables.

package com.hitarth.packages;

public class random {
}

class A {
    int a = 10;
    static int b = 20;

    void add() {
        int c = 30, d; // int c, d => local variable
        d = a + b + c;
        System.out.println(d);
    }
}
Copy

• declared inside a class but outside a constructor or a method or a block.
• The scope of an instance variable is inside all method, blocks or a constructor within a class.
• Variables get memory allocated when an object is created
• When an object gets deleted or destroyed, the variable releases the memory.
• Instance variable is stored in heap memory.
• They have default values. Default value of int is zero, for bool it is false, for char is NULL.
• Access specifiers can be used with instance variable.

• They are declared within a class by using static keyword but outside a method or a constructor or a block.
• the scope of static variable is inside all method or constructor or block.
• these variable get allocated in memory when we run a program and .class file is loaded
• when .class file is unloaded the variables get deleted.
• static variables are stored in static memory
• the default value of static variable is similar to an instance variable.
• access specifiers can be used with static variables.

package com.hitarth.packages;

class abc {
    int a = 10;
    static int b =20;
}

public class random {

    public static void main(String[] args) {
        abc ob1 = new abc();
        System.out.println(ob1.a); // → 10
        System.out.println(ob1.b); // → 20
        ob1.a = 1000;
        ob1.b = 2000;
        System.out.println(ob1.a); // → 1000
        System.out.println(ob1.b); // → 2000

        abc ob2 = new abc();
        System.out.println(ob2.a); // → 10
        System.out.println(ob2.b); // → 2000
    }
}
Copy

• Addition, Subtraction, Multiplication, Division, Modulus %, increment ++, decrement --

• equal to ==, not equal to !=, >, <, >=, <=,

• operations are performed on individual bits
• converts decimal to binary and perform the required operation
• learn about && in java
• bitwise right shift >>, bitwise left shift <<, zero fill right shift >>>

and &&, or ||, not !

package com.hitarth.packages;


public class random {


    public static void main(String[] args) {
        int x = 10, y = -10;
        System.out.println(x << 2); // → 40
        System.out.println(x >> 2); // → 2
        System.out.println(x >>> 2); // → 2
        System.out.println(y << 2); // → -40
        System.out.println(y >> 2); // → -3
        System.out.println(y >>> 2); // → 1073741821

    }
}
Copy

In Java, keywords are reserved words that have a specific meaning and cannot be used as identifiers (e.g., variable names, class names, method names).

1. abstract
2. assert
3. boolean
4. break
5. byte
6. case
7. catch
8. char
9. class
10. const (not used, reserved for future use)
11. continue
12. default
13. do
14. double
15. else
16. enum (introduced in Java 5)
17. extends
18. final
19. finally
20. float
21. for
22. if
23. goto (not used, reserved for future use)
24. implements
25. import
26. instanceof
27. int
28. interface
29. long
30. native
31. new
32. package
33. private
34. protected
35. public
36. return
37. short
38. static
39. strictfp
40. super
41. switch
42. synchronized
43. this
44. throw
45. throws
46. transient
47. try
48. void
49. volatile
50. while

In Java, identifiers are used to name classes, methods, variables, and other program elements. Here are the rules for defining identifiers in Java:

1. Must Begin with a Letter, Currency Character, or an Underscore:
   • Identifiers must start with a letter, currency character ($), or underscore (_).
2. Can Be Followed by Letters, Digits, Currency Characters, or Underscores:
   • After the initial character, the identifier can consist of letters, digits, currency characters, or underscores.
   • integer values can't be used at the first place.
3. No Spaces or Special Characters:
   • Spaces and special characters (except for currency characters and underscores) are not allowed within an identifier.
4. Cannot be a Reserved Keyword:
   • Identifiers cannot be a reserved keyword. Java has a set of reserved words that have predefined meanings in the language and cannot be used as identifiers.
5. Case-Sensitive:
   • Java is case-sensitive, so myVariable and myvariable would be considered different identifiers.
6. Length is Not Limited:
   • The length of an identifier is not limited, but it's a good practice to keep identifiers reasonably short and meaningful.

three words are given : my java demo

It is a process of wrapping data and method together into a single unit.
In OOP we have to build objects, and objects are developed by means of classes. Defining classes in OOP is termed as encapsulation.

Telusko YT > Inheritance
Inheritance in JAVA is a mechanism in which one object acquires all the properties and behavior of a parent object.

It is a process of hiding some data or method, so that it is not easily accessible to others.

https://www.geeksforgeeks.org/difference-between-compile-time-and-run-time-polymorphism-in-java/
Function having same name, but it performs different operations.
For example : If we use print operation then, method for printing an image and document will be different.

• It is of two types : Compile Time Polymorphism and Runtime Polymorphism :
  • Compile Time : Method Overloading
  • Runtime : Method Overriding (Class extend karke parent class ke method ko @Override use karke uska method ko override karna (@Override use karna is not necessary))

package com.hitarth.IIITL2024;
// factorial by recusrion
public class FactorialByRecursion {
    public static void main(String[] args) {
        int num = 5;
        System.out.println("Factorial of " + num + " is: " + factorial(num));
    }

    static int factorial(int num) {
        if (num == 0 || num == 1)
            return 1;
        else
            return num * factorial(num - 1);
    }
}
Copy

• LAB me kar rakha hai already

int[]a, b; //-> a-> 1D array, b->1D array
int a[], b; // a-> 1D array, b-> variable

a = new int[3];
a[0] = 1;
a[1] = 2;
a[2] = 3;

int[] a = {1,2,3,4,5};
// or
int[] a = new int[]{1,2,4};
Copy

        int[][] arr;
        int arr2[][];
        int[]a[];

        int[]a, b[]; // → a is 1D array, and b is a 2D array
        int[] a[], b[]; // → both are 2D arrays
        int[][] a, b[]; // → a is 2D and b is 3D array
Copy

int[][]a;
a= new int[2][3];
int[][]a = {{1,2,3},{4,5,6}};
Copy

        int[][] a;
        a = new int[2][];
        a[0] = new int[4];
        a[1] = new int[2];

        // this jagged array will look like this : 

        // x x x x
        // x x

        // doing all of this in a single line : 

        int[][] b = {{1, 2, 3, 4}, {1, 2}};
Copy

        // 3D Jagged Array :
        int[][][]a;
        a=new int[2][][];
        
        a[0] = new int[2][];
        a[0][0] = new int[3];
        a[0][1] = new int[2];
        a[1] = new int[2][];
        a[1][0] = new int[2];
        a[1][1] = new int[3];
Copy

package com.hitarth.IIITL2024;

public class temp {
    public static void main(String[] args) {
        int[][] arr = {{1,2,3,4}, {1,2}};
        System.out.println(arr[0].length); // → 4
    }
}
Copy

package com.hitarth.IIITL2024;

import java.util.Arrays;

public class temp {
    public static void main(String[] args) {
        int[][] arr = {{9, 8}, {1,2,3,4}};

        for(int i =0; i<arr.length; i++)
        {
            for(int j = 0; j<arr[i].length; j++)
            {
                System.out.print(arr[i][j] + " ");
            }
            System.out.println();
        }
    }
}
Copy

• Output :
  

3D Array :

package com.hitarth.IIITL2024;

import java.util.Arrays;

public class temp {
    public static void main(String[] args) {
        int[][][] arr = {{{20, 30}, {10, 40, 60}}, {{80, 25}, {76, 23, 44}} };
        for(int i=0; i< arr.length; i++)
        {
            for(int j = 0; j< arr[i].length; j++)
            {
                for(int k = 0; k< arr[i][j].length; k++)
                {
                    System.out.print(arr[i][j][k] + " ");
                }
                System.out.println();
            }
                System.out.println();
        }
    }
}
Copy

• Output :
  

• It is a comparison based algorithm, it is also referred as syncing sort. It compares each pair of adjacent items and swap them if they are in wrong order.
• the pass through the list is repeated until no swaps are needed, which indicates that the list is sorted.
• No. of rounds = no. of elements in an array - 1
• Asc and desc dono ka padh le bhai

• First find the index of the smallest number.
• We'll interchange it with the element at first position.
• | 36 19 29 12 5< => 5 | 19 29 12< 36 => 5 12 | 29 19< 36 => 5 12 19 | 29< 36 => 5 12 19 29 36

• Is-a : Extend keyword is used.
• Has-a : Reference keyword or new keyword.
• Is-a : Blood relationship b/w parent and child class.
• Has-a : No blood relationship.
• Is-a : Tightly Coupled
• Has-a : Not tightly coupled.

• We make multiple methods of same name.
• In overloading, methods should be in the same class.
• In overriding, methods should be in different class.
• In overloading : The method should have different arguments. This can be achieved by :
  • Either changing the number of arguments or by changing the sequence of arguments ( (int a, string b) and (string a, int b) ) or by changing the type arguments.
• In overriding : method should have same arguments
  • Either the number of arguments should be same or the sequence of args should be the same or the type should be the same.

package com.hitarth;

import java.util.Arrays;

public class temp {
    public static void main(String[] args) {
        fun(67); // → 67
        fun("hello!"); // → hello!
    }

    static void fun (int a)
    {
        System.out.println(a);
    }
    static void fun (String b)
    {
        System.out.println(b);
    }

}
Copy

It means methods with same name but in different classes.

package com.hitarth.packages;

class A
{
    public void show()
    {
        System.out.println("in A show");
    }
    public void config()
    {
        System.out.println("in A config");
    }
}

class B extends A
{
    // method overriding
    public void show()
    {
        System.out.println("in B show");
    }
}

public class _08_Overriding {

    public static void main(String[] args) {
        B obj = new B();
        obj.show(); // → in B show
        obj.config(); // → in A config
    }
}
Copy

• If we still want to use the method from the parent class after overriding it in the child class then we can either make an object of the parent class or use super().

// child class ka method : 

@Override
void show()
{
	super.show(); // calls the method of the parent class
	System.out.println("Child Class"); //prints "Child Class"
}
Copy

• Abstraction is detail / implementation hiding.
• Encapsulation is data / information hiding.
• Data abstraction deals with exposing the interface to the user and hiding the details of the implementation.
• Encapsulation groups together data and a method that acts upon the data.

• 
  • You need to add an abstract keyword to only declare a method.

In this lecture we will learn:
- What is Abstraction?
- Abstract method in Java
- Abstract class in Java
- Abstract vs Concrete classes

#1
Abstraction is a process of hiding the implementation details and showing only functionality to the user.

#2
Abstract method:-
- Instead of defining the method, we can declare the method.
- If we put a semicolon at the end of a method, it means that you only declare the method like:
 public void drive();
- This method does not contain any features and you will not be able to create an object of it.
- You need to add an abstract keyword to only declare a method.

#3
Abstract class:-
- Abstract methods can only be defined in an abstract class.
- We need to add an abstract keyword before a class to make it an abstract class.
- Objects of an abstract class can not be created.
- If you are extending an abstract class, then it is compulsory to define all abstract methods.
- It is not necessary that an abstract class should have an abstract method.
- Abstract class can have an abstract or a normal method or both.
- An abstract class can have more than one abstract method.

#4
Concrete class: A class other than an abstract class is known as a concrete class.
- An object of a concrete class can be created.
Copy

• A method without body (no implementation) is known as an abstract method.

• An abstract method must always be declared inside of an Abstract class, or we can say that if a class has an abstract method it should be declared abstract as well

• It is not necessary that an abstract class will have abstract methods only, we can create simple methods too which has a defined body.

• If a child class extends an abstract class then the class must have to implement all the abstract methods of the abstract parent class or it has to be declared abstract as well.

• Interfaces can be used to implement abstraction as well.

• Abstraction in JAVA can be implemented in two ways :

  • By using Abstract Keyword or by using Interfaces

• In interfaces all the methods are abstract.

• It means Data Hiding.
• Encapsulation in JAVA is a mechanism of wrapping the data (variables) and code acting on the data (methods) together as a single unit.
• Two ways to perform encapsulation
  • Declare the variable of the class as primitive (might be private).
  • Provide public setter and getter methods to modify and view the variable values.
• Getters and Setters can be used to get or set a value of a variable in an object.

• A static method can be accessed without first making an object of the container class and just by using the class name.
• Static keyword saves memory
• it belongs to the class and not to the object
• a static method can be accessed directly by class name and does not need any object
• a static method can access only static data, it cannot access non-static data (instance data)
• a static method can call only static method and cannot call non-static methods
• a static method can't refer to this and super keywords in any way

• Static block is executed even before the main method is executed.

Class test
{
	static {
		sout("static block");
	}

	psvm() {
		sout("Main Method");
	}
}
Copy

Output : static block Main Method
Copy

• Static block executes automatically when the class is loaded into the memory
• Static block is used to initialize the static members, a program can have multiple static blocks.

• ClassNotFoundException, NoSuchMethodException, IOException, SQLException, RemoteException, InterruptedException, RuntimeException, VirtualMachineException, LinkageError, AssertionError
  - IOException has child classes : EOFException (end of file), FileNotFoundException, InterruptedIOException
  - RuntimeException : ArithmeticException, ClassCastException, NullPointException, IndexOutOfBoundException, IllegalArgumentException
  - VirtualMachineException : StackOverflowError, OutOfMemoryError
  - LinkageError : VerifyError, ClassFormatError, NoClassDefFoundError
  

https://www.geeksforgeeks.org/exceptions-in-java/

https://www.geeksforgeeks.org/try-catch-throw-and-throws-in-java/?ref=lbp

Try Block:

• The try block encloses the code that may generate exceptions.
• It is followed by one or more catch blocks.
• If an exception occurs within the try block, the execution of the try block is halted, and the control is transferred to the corresponding catch block.

Catch Block:

• A catch block catches and handles exceptions thrown within the associated try block.
• Each catch block specifies the type of exception it can handle, allowing for selective exception handling.
• If an exception of the specified type occurs, the code inside the corresponding catch block is executed.
• If no catch block matches the thrown exception, it propagates up the call stack, potentially halting the program if unhandled.

try {
    // Code that may throw exceptions
} catch (ExceptionType1 e1) {
    // Exception handling for ExceptionType1
} catch (ExceptionType2 e2) {
    // Exception handling for ExceptionType2
} finally {
    // Optional: Code that always executes, regardless of exceptions
}
Copy

Finally Block:

• Optionally, a finally block can be used after all catch blocks.
• The code inside the finally block executes whether an exception occurs or not.
• Commonly used for cleanup operations like closing files or releasing resources.

Example:

try {
    int result = 10 / 0; // This will throw an ArithmeticException
} catch (ArithmeticException e) {
    System.out.println("An error occurred: " + e.getMessage());
} finally {
    System.out.println("This code always executes.");
}
Copy

public class Example {
    public static void main(String[] args) {
        try {
            // Creating and throwing a NullPointerException with a "custom" esxception explicitly
            throw new NullPointerException("Custom NullPointerException message");
        } catch (NullPointerException e) {
            System.out.println("Caught NullPointerException: " + e.getMessage());
        }
    }
}
Copy

Difference between throw and throws :

1. throw:

   • throw is a keyword used to explicitly throw an exception from within a method or block of code.
   • It is used when a specific condition occurs that warrants the interruption of the normal flow of execution due to an exceptional situation.
   • With throw, you can throw both built-in exceptions provided by Java (such as NullPointerException, IllegalArgumentException, etc.) and custom exceptions that you define in your code.
   • When you throw an exception, you are responsible for creating and specifying the exception object to be thrown.

   Example:

   public void method() {
       if (condition) {
           throw new SomeException("Custom message");
       }
   }
   Copy

2. throws:

   • throws is used in the method declaration to indicate that the method may throw certain types of exceptions during its execution.
   • It specifies the types of exceptions that a method might throw but does not actually throw them itself.
   • When you use throws, you are declaring the exceptions that can be thrown by a method, allowing the caller of the method to handle those exceptions.

   Example:

   public void method() throws SomeException {
       // Method code that may throw SomeException
   }
   Copy

   The caller of this method would then need to handle the SomeException either by catching it or declaring it to be thrown further.

In summary, throw is used to throw an exception explicitly within a method, while throws is used to declare the types of exceptions that a method might throw, allowing the caller to handle them appropriately.

• Performing single task from a single thread
• Performing single task from multiple thread
• Performing multiple tasks from single thread
• Performing multiple tasks from multiple threads

• CurrentThread() provides a reference to the current thread
• Thead.CurrentThread().setName("xyz"); By default the name provided will be : DIY

class Test extends Thread {
    public void run() {
        System.out.println("Thread Task");
        System.out.println(Thread.currentThread().getName());
    }

    public static void main(String[] args) {
        Test t = new Test();
        t.start();
        
        System.out.println(Thread.currentThread().getName());
    }
}

Copy

• Output :

main
Thread Task
Thread-0
Copy

• Here in total there will be two threads : one thread will be the main thread and the other will be the thread-0 which we have created using Test t = new Test(); implementing the run method

class Test extends Thread {
    public void run() {
        System.out.println("Thread Task");
        System.out.println(Thread.currentThread().getName() + " is alive : " + Thread.currentThread().isAlive());

    }

    public static void main(String[] args) {
        Test t = new Test();
        t.start();
        
        System.out.println(Thread.currentThread().getName());
        System.out.println("t is alive : " + t.isAlive());

    }
}
Copy

• Output :

main
Thread Task
t is alive : true
Thread-0 is alive : true
Copy