Notes.txt

Java Features
---------------

1. Java Platform independent
2. Simple
3. Object oriented(Not Pure)
4. Multithreaded
5. High Performance
6. Dynamic
7. Robust
8. Secure


Datatypes
Integers
1. byte- 1 byte  age   default value=0
2. short- 2 byte employeeID, studentId default value 0
3. int- 4 byte bankaccount number default value 0
4. long- 8 byte  mobile number default value 0L
Decimal Numbers
5. float- 4 byte    123.987676   default value 0.0f
6. double- 8 byte   123.090980980980 default value 0.0
True or False
7. boolean- 1 bit    default value is false
8. char- 2 bytes     /u00000


default values are applicable only if the variable is instance variablem,
not for local variable


Creating an object in Java

class Sample{

}

Sample sample=new Sample();
Anything that starts with capital letter are classes

class User{

}

User user=new User();

class Demo{

}
Demo demo=new Demo();

Super most class in Java is Object



Conditional Statements
----------------------

lines will be executed only when the condition is True
used to check the condition and then executed

1. if
2. if else
3. if else if
4. switch

Nested if- if inside another if


forloop
3 parts

1. Initialization - 1 time
2. condition-n+1 times
3. increment/decrement - n times

Switch is mainly used for menu driven approach
we can use int,byte, char, string in switch case; other datatypes are not allowed


break is used to stop the execution
continue is used to skip the iteration

For loop will executed until the condition fails, you will know number of iteration before running the code
if you don't know number of iteration before running the code, you cannot use for loop.


Array-> we can store multiple values in single variable
int a=10;

int marks[]={65,87,98,86}

int marks[]=new int[6];
marks[0]=65;
marks[1]=87;
marks[2]=98;
marks[3]=86;

Array index starts with zero

number of elements in an array can be taken using length property
marks.length

marks index start with 0 and ends with marks.length-1

Above array is single dimentional array 1 row many columns

2D array more than 1 rows and more than 1 columns

int marks[3][6]={{65,87,96,55,63,72},{64,81,92,53,73,82},{75,97,96,58,63,52}}
i                     0                     1                    2
j                 0   1  2  3  4 5    0   1  2  3  4  5    0  1  2  3  4  5
int marks[][]=new int[3][6];

marks[0][0]=65;
marks[0][1]=87;
.
.
.
.
.
Harikumar-65 87 96 55 63 72 total=678 grade=A
Jagan-64 81 92 53 73 82
Moorthy-75 97 96 58 63 52


if percenta >90 A
81-90  B
71-80  C
       D
       E
<50    F

String is a collection of characters
String is a class

String s1="Java"; String literal
String s2="Java"; String literal

In String literal if the value of two literals are same then it will share the memory in String Constant Pool(SCP)


String s3= new String("Java");//String object- will be stored in heap

String s4=new String("Java");

String object will store the data in new location, even if the content are same it will store the value in different
location.


Object Oriented Programming
---------------------------

1. class- Fruit(variables and methods, objects)
2. object- Apple(will have state and behaviours, occupy memory in heap)
3. inheritance
4. polymorphism
5. Data Encapsulation
6. Dynamic binding
7. Message passing
8. Data Abstraction


Constructor:

Same name like a classname without any return type
constructor will be called automatically when we create an object
Constructor is used for initializing variables
Constructor should be public(not private)
Constructor can be overloaded

Types of constructor
1. Empty Contructor(no parameters)
class User{
public User(){
//initialize variables
}
}
User user=new User();
2. Parameterized Constructor

class User{
public User(int id, String Name, String addr){

}
}
User user=new User(10,'XYZ','Chennai');


Constructor Overloading:
Constructor with same name and different arugments;


Method Overloading:
Method with same name and Different Parameters and Different Return type

00
01
10
11

0-void
1-any return type(datatype)

void add()-> method without return type and without parameter
void sub(int,int)-> method without return type with parameters
int add()-> method with return type without parameter
int add(int, int)-> method with return type with parameter


this keyword


it is a reference to the current object within an instance method or a constructor.

1. Resolve the naming conflicts
2. Invoke the constructor in the same class
3. refer to the current instance of the class

this() must be at the beginning of the method
this cannot be used inside the static method
this is used to call the constructor of the same class
this is used to call the variables and methods inside the same class


Inheritance
-----------
Deriving a property of one class to the other
Class which is being inherited is called Super class(parent,Base)
Class which inherits other class is called Sub class(child,derived)
Child class has all the privilege to access the parent class variables and methods

Protected is an access specifier we used in inheritance relationship

Protected variable and method of a parent class can be accessed inside child class not outside

is a keyword

Dog is a Animal
Dog extends Animal
Homeloan is a Loan
Homeloan extends Loan
Car is a Vehicle
Car extends Vehicle

Pencil extends Book
ScienceBook extends Book

How many public classes can be in a java file?

only one public class, file name will be named as per the public class

Advantage
1. Reusability
2. Reduce code
3. Overriding

Overriding(closed for Modification open for extension)

Method with same name in both base class and derived class

class A{
void display(){
}

}
class B extends A{
void display(){

}
}


Super Keyword

used to call super class variable, methods and constructor

like this keyword, super keyword must be at the beginning of the method or constructor

no need to redeclare the variables and methods

super()
super.emiAmount
super.displayLoanDetails()



Constructor in Inheritance


Both Super class and Subclass has empty constructor

Subclass Constructor will call Super class constructor by default in the case of
empty constructor

Super class has empty constructor and Sub class has parameterized constructor

Subclass object will call Super class Empty constructor and Sub class parameterized constructor
if Super class doesn't have empty constructor then it will throw Compiler Error


Super class has parameterized constructor and Sub class has parameterized constructor

Subclass constructor must call super class parameterized constructor via super keyword

The above concept is called constructor Chaining. this ensures that all constructors in the chain are executed in a proper order
allowing for proper initialization of objects(follows the hierarchy)

Note: Base class constructor needs to be called before the derived class constructor, to ensure the base class part has been initialized 1st.

Hierarchical Inheritance

1 Base class
multiple derived class
multiple objects

Multilevel Inheritance

1 base
1 intermediate class
1 derived class

derived class is an indirect child class to base class

Vehicle

Light Vehicle

Car


Multiple Inheritance

Not supported in Java Directly, we can used interface for that


more than one base class
and 1 derived class

why it is not supported?
we cannot extends more than one class
because of Diamond problem(2 different classes have same variable name)


Abstract:
Hiding the unwanted details and showing only the required details

Abstract class:
Class with abstract keyword
for class we cannot create object.why?
abstract class have both abstract method(abstract void display();) and non abstract method(public void display())
abstract method has no definition
Ex: abstract void display();
abstract methods are defined in the derived class
derived must define the abstract
abstract class are incomplete class, so we cannot create object

Abstract class is a collection of Abstract method and Non Abstract method

Interface:

Interface is a collection of abstract method and final variables
Interface will be implemented by a class
one class can implement multiple interfaces using comma ','
the class which implements the interface must define all the abstract methods of the
interface
one interface can extend another interface.

When you make change in the the interface which is impletement by n classes
then you have to make changes in all the classes
instead you can create a new interface with the required changes and extend it with
the existing interface. implement the new interface in the class only where you want the changes


Exception Handling
------------------

Any abnormal error condition occur during runtime

1. Error(compile time error, syntax errors)
2. Exception(Runtime errors, caused by User, Storage, Compute)

Super most class of Exception is Throwable
Exception is a class
Available in default package lang
Exception is the super class for all the exceptions
Every exception must extends the class Exception

Exceptions are two time
1. Checked Exception(will be known during compile time(IOException)
2. Unchecked Exception(will be known only at Runtime(Arithmetic Exception)

Blocks to Handle Exception
1. try-> this block will have the code which raise the exception condition
2. catch-> this block will catch the exception and display to the user
3. finally-> this block will have all the resource(DB, files) closing codes, this block will execute compulsorily irrespecitve of Exception occur or not

Try block may have multiple line which may cause the exception, but it will address
only the 1st Exception it finds.

Super class catch block must be always at the bottom of the sub class Catch block
catch (ArithmeticException|ArrayIndexOutOfBoundsException ae){
            System.out.println(ae.getMessage());
        }catch (Exception e ){

        }

throws keyword can be used to handle the checked exception and it will be given
next to the method definition.

void add()throws IOException{

}
the above add method will be called inside either try/catch block or any method
that throw the IOException


throw keyword is used to throw the exception explicitly by user based on some condition
(Invalid marks exception)


Static Keyword
---------------
Static variables and methods are not belong to object but it belongs to class
static keyword is used to access the variable and methods without object
Static keyword can be used for class also but the class should be a inner class
Static variable and methods belongs to a class not to a object
memory will be shared by static variable, only one copy will be maintained

Static method allows only static variable inside the method definition
Non Static method allows both static and non static variable

Inner class

if inner class static no need to instantiate
Non static method of inner class allows only static variables

Static methods are not overridable


Final
Final variable does not allow to change the value
noofmonths,noofdayinaweek,pi

Final method cannot be overriden
Final class cannot be inherited


Threads in Java
----------------


to bring concurrency(parallel execution)
By default every Java program will have one thread by default
Thread is a class
Running of Thread is decided by OS
add, sub, mul, div on one thread,
each task will take 1 min-> 4mins
those 4 task will be taken care by 4 thread
1 min per task-> all four task will be completed in 1 min


Creating a Thread
1. By extending a Thread class
2. By implementing a Runnable Interface


Method Overriding(Runtime Polymorphism)

used when type of the object is not know before execution
Method with same name in both base class and derived class
Base class reference=new Derive class object()
Runtime polymorphism
Using Base class reference we cannot access derived class methods, only override methods are accessible


Collections
Its a Framework
All collection class supports Generic class
4 Main interfaces in collections framework
1. List
2. Set
3. Map
4. Queue and Deque

ArrayList

DynamicArray
Follows the order
allows duplicate values
Insertion and Deletion is costly
search is easy

1 2 3 4 5 45 6 7 8 9 11 2 3 4 5 5 6 6 7


Linked List

Implements List and Deque interface.
Dynamic Resizing(expansion and shrinking)
Best for insertion and deletion
used Double linked list


Map

Stores the value in Key-Value paris.
Each key maps to one value.
Keys must be unique
One null key is allowed in (HashMap)

Types;
HashMap
LinkedHashMap
TreeMap

Hashmap(1 one null keys, non synchronized) and Hashtable(Synchronized, null keys are not allowed)