Dt : 14/7/2022

Ex:

Cars.java

package test;
public enum Cars {
figo(700),alto(500),dezire(600);//elements
public int price;
private Cars(int price){
this.price=price;
}
public int getPrice() {
return price;
}

DemoEnum.java(MainClass)

package maccess;
import test.Cars;
public class DemoEnum {
public static void main(String[] args) {
Cars c[] = Cars.values();//Generating Array Object
System.out.println("===Displat Enum===");
for(Cars k : c) {
System.out.println(k.toString()+" costs "+
k.getPrice()+" thousand dollars");
}
System.out.println("===Based on index===");
System.out.println(c[0].getPrice());
c[0].price = 13000;
System.out.println("===Based on index===");
System.out.println(c[0].getPrice());

}
}

o/p:

===Displat Enum===

figo costs 700 thousand dollars

dezire costs 600 thousand dollars

Diagram:

========================================================

Note:

=>Each element in enum is internally generated as Enum<E> object

=>The constructors which are declared within the enum are

automatically 'private constructor'.

=>In realtime Enum<E> is used when we have defined list of

collection.

(Enum<E> is less used when compared to Classes and Interfaces)

===========================================================

*imp
Summary of objects generated from CoreJava:(Container objects)

1.User defined Class objects

2.String Objects

3.WrapperClass Objects

4.Array Objects

5.Collection<E> Objects

6.Map<K,V> objects

7.Enum<E> Objects

List of objects by Sub-category:

1.User defined Class objects

2.String Objects

a.String Object

b.StringBuffer Object

c.StringBuilder Object

3.WrapperClass Objects

a.Byte Object

b.Short Object

c.Integer Object

d.Long Object

e.Float Object

f.Double Object

g.Character Object

h.Boolean Object
4.Array Objects

a.Array holding User defined Class Objects

b.Array holding String Objects

c.Array holding WrapperClass Objects

d.Object Array(Array holding Dis-Similer Objects)

e.Jagged Array(Array holding Array objects)

5.Collection<E> Objects

a.Set<E>

(i)HashSet<E> object

(ii)LinkedHashSet<E> object

(iii)TreeSet<E> object

b.List<E>

(i)ArrayList<E> object

(ii)LinkedList<E> object

(iii)Vector<E> object

=>Stack<E> object

c.Queue<E>

(i)PriorityQueue<E> object

=>Deque<E>

(ii)ArrayDeque<E> object

(iii)LinkedList<E> object

6.Map<K,V> objects

(a)HashMap<K,V> object

(b)LinkedHashMap<K,V> object
 (c)TreeMap<K,V> object

(d)Hashtable Object

7.Enum<E> Objects

======================================================

List of Cursor Objects:

1.Iterator<E>

2.ListIterator<E>

3.Enumeration<E>

4.Spliterator<E>

====================================================

List of Utility Objects:

1.Scanner

2.StringTokenizer

3.StringJoiner

4.Collections

5.Arrays

===============================================

faq:

wt is the diff b/w

(i)Container Objects

(ii)Cursor Objects

(iii)Utility Objects

(i)Container Objects:
 =>The Objects which contain data or which hold data are known

as Container objects.

(ii)Cursor Objects:

=>The objects which are used to retrieve the elements from the

objects are known as Cursor objects.

(iii)Utility Objects:

=>The Objects which perform operations on other objects are

known as Utility Objects.

======================================================

faq:

wt is the diff b/w

(i)Array

(ii)ArrayList<E>

=>Array size once defined cannot be modified at runtime and which

is not preferable to hold dynamic data.

=>ArrayList<E> is not size restricted and can hold unlimited data

to runtime.

==========================================================

Ex:(Program to demonstrate Array Sorting)

ArraySort.java

package maccess;
import java.util.ArrayList;

import java.util.Arrays;

public class ArraySort {

public static void main(String[] args) {

ArrayList<Integer> al = new ArrayList<Integer>();

al.add(new Integer(13));

al.add(new Integer(11));

al.add(new Integer(12));

al.add(new Integer(9));

Object o[] = al.toArray();//Convert into Array

Arrays.sort(o);//Sorting on Array

System.out.println("===Sorted Array===");

for(Object k : o) {

System.out.print(k.toString()+" ");

o/p:

===Sorted Array===

9 11 12 13

=========================================================

faq:

define Data Structure?

=>The process of organizing data in a proper order or Structure

Note:

=>We construct Data Structures in Java using Collection<E> and

Map<K,V>

==========================================================

Dt : 15/7/2022

PolyMorphism in Java:

=>The process in which the programming components having more

than one form is known as PolyMorphism.

Poly - Many

Morphism - Forms

=>This PolyMorphism is categorized into two types:

1.Dynamic PolyMorphism

2.Static PolyMorphism

1.Dynamic PolyMorphism:

=>The PolyMorphism at execution stage is known as Dynamic

PolyMorphism or Runtime PolyMorphism.

Ex:

Method Overriding process

Note:

=>Through Method Overriding process we can have more than one

process comes under Dynamic PolyMorphism or Runtime PolyMorphism.

Diagram:

=====================================================

2.Static PolyMorphism:

=>The PolyMorphism at compilation stage is known as Static

PolyMorphism or Compile time PolyMorphism.

Ex:

Method Overloading process.

Note:

=>Through Method overloading process we can have more than

compilation stage is known as Method Overloading process.

add(int)

add(int,int)

add(int,float)

Ex:

public class Addition {

public void add(int x) {

public void add(int x,int y) {

public void add(int x,float y) {

=====================================================

=>The compiler at compilation stage will control the following

keywords:

1.static

2.private

3.final

1.static:

=>The following are the static programming components:

b.static methods

c.static blocks

d.static classes

e.static Interfaces

f.static AbstractClasses

=>There is no concept of static constructors in Java.

Behaviour:

=>Static programming components will get the memory within the

class while class loading and can be accessed with class_name.

faq:

define Static binding?

=>The process of binding all the static components to class at

compilation stage is known as static binding or Compile time

binding.

faq:

define Dynamic binding?

=>The process of binding all the NonStatic components to object

while execution stage is known as Dynamic Binding or Runtime

Binding.

===================================================
*imp

2.private:

=>The following are the private programming components:

a.private variables

b.private methods

c.private constructors

d.private classes

=>There is no concept of private blocks,private Interfaces and

private abstract classes.

a.private variables:

=>The variables which are declared with private keyword are

known as private variables.

Behaviour:

=>private variables are accessed only inside the class,which

means accessed by the methods of same class.

Note:

=>In realtime private variables are used in Bean classes and

POJO classes. (POJO - Plain Old Java Object)

b.private methods:

=>The methods which are declared with private keyword are known
as private methods.

Behaviour:

=>Private methods are accessed only inside the class,which means

can be accessed by the NonPrivate methods of same class

Ex:

PTest.java

package test;
public class PTest {
private int z=100;
private void dis() {
System.out.println("====Private dis()====");
System.out.println("The value z:"+z);
}
public void access() {
this.dis();//Private method_call
}
}

DemoPoly1.java(MainClass

package maccess;
import test.PTest;
public class DemoPoly1 {
public static void main(String[] args) {
PTest ob = new PTest();
//ob.dis();//Compilation
ob.access();
}
}

o/p:

====Private dis()====

The value z:100

======================================================

*imp

c.private constructors:

=>The constructors which are declared with private keyword

are known as Private Constructors.

Behaviour:

=>private constructor is executed when the object is created

inside the same class where Private constructor is declared.

=>Private Constructor will restrict the object creation from

=======================================================

faq:

define SingleTon class?

=>The class which generate only one object is known as SingleTon

class.

faq:

define SingleTon class design pattern?

=>The process of constructing SingleTon class using the

following components is known as 'SingleTon class design pattern'.

(i)private static reference variable

(ii)private constructor

(iii)static method

(i)private static reference variable:

=>private static reference variable will hold the reference of

object created inside the same class.

(ii)private constructor:

=>private constructor will restrict the object creation from

externally and executed when object is created inside the same

class
(iii)static method:

=>This static method is used to access the object reference

outside the class.

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

=>Based on Object creation process the SingleTon class design

pattern is categorized into two types:

(a)Early Instantiation process

(b)Late Instantiation process

(a)Early Instantiation process:

=>In Early Instantiation process the object is created while

class loading.

=>In Early Instantiation process the object is created through

static block.

Ex:

CTest1.java

package test;
public class CTest1 {
private CTest1() {}
private static CTest1 ob = null;
static {
ob = new CTest1();//Con_Call
}
public static CTest1 getRef() {
return ob;
}
public void dis(int z) {
System.out.println("====dis(z)====");
System.out.println("The value z:"+z);
}
}
DemoPoly2.java(MainClass);

package maccess;
import test.CTest1;
public class DemoPoly2 {
public static void main(String[] args) {
//CTest1 ob = new CTest1();//Con_Call Error
CTest1 ob = CTest1.getRef();//Accessing the object_ref
ob.dis(123);
}
}

(b)Late Instantiation process:

=>In Late Instantiation process the object is created after

class loading.

=>In Late Instantiation process the object is created through

method.

Ex:

CTest2.java

package test;
public class CTest2 {
private CTest2() {}
private static CTest2 ob = null;
public static CTest2 getRef() {
if(ob==null)
{
ob = new CTest2();//Con_Call
}
return ob;
}
public void dis(int z) {
System.out.println("====dis(z)====");
System.out.println("The value z:"+z);
}
}
DemoPoly3.java(MainClass)

package maccess;
import test.CTest2;
public class DemoPoly3 {
public static void main(String[] args) {
//CTest2 ob = new CTest2();//Con_Call Error
CTest2 ob = CTest2.getRef();//Accessing the object_ref
ob.dis(123);
}
}

=============================================================

Dt : 16/7/2022

Note:

=>In realtime SingleTon class design pattern is used part of

DAO(Data Access Object) layer in MVC(Model View Controller) to

hold DataBase Connection code.

d.private classes:

=>The classes which are declared with private keyword are known

as private classes.

Rule:

=>Private classes can be declared only as InnerClasses,which

means OuterClasses cannot be private.

Note:

=>private InnerClass objects are created inside the NonPrivate

method of same class.

Diagram:
Ex:

SubClass1.java

package test;
public class SubClass1 {
private class SubClass2{
public void m2(int x) {
System.out.println("===m2(x)===");
System.out.println("The value x:"+x);
}
}//Private InnerClass
private static class SubClass3{
public void m3(int y) {
System.out.println("====m3(y)====");
System.out.println("The value y:"+y);
}
}//Private InnerClass
public void access(int x,int y) {
SubClass2 ob2 = new SubClass2();
SubClass3 ob3 = new SubClass3();
ob2.m2(x);
ob3.m3(y);
}
}//OuterClass

DemoPoly4.java(MainClass)

package maccess;

import test.SubClass1;

import java.util.*;

public class DemoPoly4 {

public static void main(String[] args) {

Scanner s = new Scanner(System.in);

System.out.println("Enter the value of x:");

int x = s.nextInt();

System.out.println("Enter the value of y:");

SubClass1 ob1 = new SubClass1();//OuterClass object

ob1.access(x, y);

s.close();

o/p:

Enter the value of x:

12

Enter the value of y:

13

===m2(x)===

The value x:12

====m3(y)====

The value y:13

==========================================================

*imp

3.final:

=>The following are the final programming components:

a.final Variables

b.final Methods

c.final Classes

=>There is no concept of final blocks,final constructors,final

Interfaces and final abstractClasses.

=>The Variables which are declared with 'final' keyword in

classes are known as final Variables.

Rule:

=>These final variables must be initialized with values and

once initialized cannot be modified.

Note:

=>These final variables are also known as Secured variables or

Constant Variables.

=>final variables in classes can be initialized using

constructor.

b.final Methods:

=>The methods which are declared with final keyword are known

as final methods.

Rule:

=>final methods cannot be Overrided.

c.final Classes:

=>The classes which are declared with final keyword are known

as final classes
Rule:

=>final classes cannot be extended,which means there is no

inheritance for final classes.

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

Note:

=>In realtime using final programming components we can construct

Immutable Classes.

faq:

define Immutable Classes?

=>The classes which are constructed using the following rules

are known as Immutable Classes:

Rule-1 : The class must be final class

Rule-2 : The variables declared in class must be private

and final

Rule-3 : The class must be declared with only 'Getter methods'.

Rule-4 : These 'Getter methods' must be final methods

Note:

=>These Immutable classes will generate Immutable objects.

Ex:
UserLogin.java

package test;
public final class UserLogin {
private final String userName,passWord;
public UserLogin(String userName,String passWord) {
this.userName = userName;
this.passWord = passWord;
}
public final String getUserName() {
return userName;
}
public final String getPassWord() {
return passWord;
}
}

DemoPoly5.java(MainClass)

package maccess;

import test.UserLogin;

import java.util.*;

public class DemoPoly5 {

public static void main(String[] args) {

Scanner s = new Scanner(System.in);

System.out.println("Enter the UserName:");

String uName = s.nextLine();

System.out.println("Enter the PassWord:");

String pWord = s.nextLine();

UserLogin ob = new UserLogin(uName,pWord);

//Immutable Object

System.out.println("UserName:"+ob.getUserName());

System.out.println("PassWord:"+ob.getPassWord());
 s.close();

o/p:

Enter the UserName:

nit.v

Enter the PassWord:

mzu672

UserName:nit.v

PassWord:mzu672

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

Note:

=>In realtime Immutable Objects are used to record transaction

details in banking domain.

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

Note:

=>Based on security the objects are categorized into two types:

(i)Mutable Objects

(ii)Immutable Objects

(i)Mutable Objects:

=>The Objects once created can be modifed are known as Mutable

Objects.
(ii)Immutable Objects:

=>The Objects once created cannot be Modified are known as

Immutable Objects or Secured Objects or Constant objects

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

faq:

wt is the diff b/w

(i)Getter methods

(ii)Setter methods

(i)Getter methods:

=>Getter methods are used to get the data from the objects.

(ii)Setter methods:

=>Setter methods are used to set the data to the objects.

Rule of Setter and Getter methods:

=>Every variable which is declared in classes will have its

own Setter method and Getter method.

==============================================================