Java Features:-

simple
robust
multithreaded
portable
secure
distributed
high performance
architecture neutral

//4 Pillars of java oops:=

AEI OU //
A abstraction - hiring engine
Abstract class to partial abstraction ex. keyboard
interface when we want 100% abstraction ex. banking system
E encapsulation - wrapping the code and data together
Two methods getter and setter
getter- to get values
setter- to set values
I inheritance - acquiring all properties and behaviours of parent class
Single Inheritance
Multilevel Inheritance
O
P polymorphism - doing one thing in different way
U Method Overloading - defining method again in same class
Method Overriding - defining method again in child class

//ACCESS MODIFIERS:
private: data accessible in only same class ex. Roll no
protected: data accessible in child class ex.
default: data within same package
public: data accessible everywhere(all classes/packages)

//CONSTRUCTOR
it is special method which has same name as class name which is called when object
is created.

//int float char class are Keywords in Java

//STRINGS
it is array of characters

types- string immutable

string buffer- used when thread safety is imp
string builder-used when we want high performance

//THREADS:
light weight process
used to run multiple class simultaneously
it will call thread by extends keywords

for thread communication we are using 3 methods wait(), notify(), notifyAll()

//hw
JDBC Database connection

//VARIABLES
Local Variables :
variables declared in method
global:
variables declared outside method in class
static variables:
var declared: at class level

//JVM machine memory ke 3 level

stack
memory
heap

//Data types in java

Primitive ->Numeric->integer
->float
->double
->nonnumeric

non-Primitive->classes
->Interface
->Arrays

//Type Casting:
assigning value of one type toa variable of another type is known as type casting

widening
byte->short->int->long->float->double

Narrowing
double->float->long->int->short->byte

//OPERATORS IN JAVA
Arithmetic: + - * / %
Relational: < > >= <= == !=
Logical: && || !
Unary: + - ++ -- !
Boolean logical: True False

//Java Statements
Sequential Statements:
if-else
nested if-else
Switch case

Control Statements:
do-while
while
for loop

//COLLECTION
group of object is called as collection
List
Set
Map
collection
list
array list, queue, vector, stack
queue
priority queue, deque, arraydeque,
set
hashset, linked hashset sorted set

array list
internal data structure is array
duplicates are allowed
order is maintained
searching operation

linked List
used at the time of deletion addition

hash set:
internally used data structure like hashmap or set is tree

Tree set
internal data structure used tree , duplicates are allowed

/imp/collection-multiple grp of object;

list ,set,queue are the types of collections;

iterable
^
|
collection
^
|

list Queue Set

Array list Priority Queue Hash Set and Linked Hash set
linked list Array queue Tree set
vector stack

*list:-
array list ---Internal DS is Array;
for searching eg.roll no searching
linked list ---Internal DS is linked List
for addtion,deletion operation .

Generics concept//order mainting

eg- ArrayList<string//this is generics> Car = new ArrayList<string>();
cars.add("volvo");
cars.add("BMD");
cars.add("ODII");
cars.add("mazda");//add hote jayenge
SOP(cars);
*SET:-
Duplicate not Allowed
Hash Set:-
internally uses Hash Map or Hash table Data Types
Duplition not Allowed and Order is anything

Linked Hash set:-

eg- LinkedHashSet<string> cars = new LinkedHashSet< string>

Tree Set:-
Internally use Tree Map Data structure And Duplicationn is not
allowed;
Insertion order is Ascending;

//Map

Hash Map
used when we want to use key-value pair then that time ew use map

HashMap<Integer,String> cars = new HashMap<Integer>

cars.put(1,"ALTROZ");
cars.put(2,"EFEFEF");
System.out.println(cars)

Linked hash Map

Tree Hash Map

//wrapper class
Wrapper classes

Wrapper classes are used to convert any primitive type into an object. The
primitive data types are not objects, they do not belong to any class, they
are defined in the language itself. While storing in data structures which
support only objects, it is required to convert the primitive type to object
first, so we go for wrapper class.

Example :
int x = 25;
Integer y = new Integer(x);

//Garbage Collection

programmer doesn't need to worry about dereferencing an object .

it is done auto by JVM

//This Keyword

//final keyword
is the variable
if we apply final on method it cannot be override
if we apply it on class then class cannot be extended
if we apply final on variable then value of variable cannot be changed

//Stream API:-
Stream api does not store elements. It simply coveys elements from source
such as
a data structure, an array, or an I/O channel, through pipeline of computational
operations

two methods in string

1. filer
2. toset

//code:->

import java.util.ArrayList;
public class collectionExample{

public static void main(string args[]){

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

num.add(30);
num.add(40);
num.add(50);
num.add(60);
num.add(60);
List<Integer> ans = num.stream().filter(i->i%20 ==
0).collect(collector.toset());
S.O.P(ans);
List<Integer> ans2 = num.stream().filter(i->i+10).collect(collector.toList());
S.O.P(ans2);

//Exception Handling:-
Exception

Definition:

"An exception is an event, which occurs during the execution of a program, that
disrupts
the normal flow of the program's instructions"

An exception occurs when our code asks the JVM to perform the technically
impossible
and unanticipated (by the compiler)!

1. Anticipate the error by the user/system.

2. Return the program to a safe state that enables the user to execute other
commands.

3. Inform the user of the error's cause.

4. Allow the user to save work and terminate the program gracefully.
//Exception Hierarchy

All exception types are subclasses of the built-in class Throwable

Throwable has two subclasses :

o Exception

o Error

//Types of Exceptions in Java

Checked exceptions

-All exception inherited from Exception Class.

-It is compile time error.

Unchecked exceptions

-All exception inherited from Runtime Exception Class.

-It is run time error.

//handling the exception

public class ExceptionHandling{

public static void main (String[] args) {

try
{
int data=50/0; //may throw exception
}

catch (Exception e)
{
Syatem.out.prinln(e);
}
System.out.println("rest of the code") ;

Output:-
rest of the code

//finally
It is such type block of statements which will execute irrespective of exception.
It will execute always.
public class ExceptionHandling{

public static void main (String[] args) {

try
{
int data=50/0; //may throw exception
}

finally
{
Syatem.out.prinln("Finally Block");
}
System.out.println("rest of the code") ;

Output:-
Finally Block

//Applet in Java

-used for web applications

. Applets are small Java applications that can be accessed on an

internet server, transported over internet, and can be automatically
installed and run as apart of a web document.

. Any applet in Java is a class that extends the java.applet.Applet class.

. An Applet class does not have any main() method.

. It is viewed using JVM. The JVM can use either a plug-in of the
Web browser or a separate runtime environment to run an applet
application.

. JVM creates an instance of the applet class and invokes init()

method to initialize an Applet.

//Advantages of Applets:

. Very less response time as it works on the client side.

. Can be run using any browser, which has JVM running in it.

//An applet can:

· Draw pictures on a web page

· Create a new window and draw in it.
. Play sounds.
. Receive input from the user through the keyboard or the
mouse.
. Make a network connection to the server from which it
came and can send to and receive arbitrary data from
that server.

//Life Cycles of Methods:-

init()->Start()->Paint(Graphicd G)->Stop()->Destroy()

//Events

An event is an object that describes some change in the state of a source.

An event is generated when the user interacts with an element in a graphical

user interface.

Examples of such events are pressing a button, moving the slider in a scroll
bar, 'typing characters into a text field, closing a window or dragging the
mouse.

In addition to these events, events that are not directly caused by user input
can also be generated. For example, arrival of incoming data, buffer overflow,
end of a process or expiry of a software timer.

//Applet's Size

import java.applet.*;
import java.awt .*;
public class SizeApplet extends Applet
{
public void paint(Graphics g)
{
Dimension appletSize = this.getSize();
int appletHeight = appletSize.height;
int appletWidth = appletSize.width;
g.drawString("This applet is " + appletHeight +
"pixels high by "+ appletWidth+
" pixels wide.", 15, appletHeight/2);

}
}

//AWT

Java AWT calls the native platform calls the native platform (operating systems)
subroutine for creating API components like TextField, ChechBox, button, etc.

For example, an AWT GUI wit Ncomponents lke TextField, label and button will
have different look and feel for the different platforms like Windows, MAC OS,
and Unix. The reason for this is the platforms have different view for their native
components and AWT directly calls the native subroutine that creates those
components.
In simple words, an AWT application will look like a windows application in
Windows OS whereas it will look like a Mac application in the MAC OS.

//Components
All the elements like the button, text fields, scroll bars, etc. are called
components. In Java AWT, there are classes for each component as shown in
above diagram. In order to place every component in a particular position on a
screen, we need to add them to a container.

//Container

The Container is a component in AWT that can contain another components

like buttons, textfields, labels etc. The classes that extends Container class are
known as container such as Frame, Dialog and Panel.

Notes

Types of containers:
There are four types of containers in Java AWT:
1.Window
2.Panel
3.Frame
4.Dialog

//SWING
Swing

Swing Framework contains a set of classes that provides more powerful and
flexible GUI components than those of AWT. Swing provides the look and feel of
modern Java GUI.

· swing component provide much flexible user interface because it follow model
view controller(mvc).
· swing works faster.
· swing components are light weight.
· swing occupies less memory space.
· swing component is platform independent.
· swing require javax.swing package.

//JComponent:-

JFrame : JFrame is Swing's version of Frame and is descended directly

from Frame class. The component which is added to the Frame, is refered
as its Content.

. JWindow : This is Swing's version of Window and hass descended directly

from Window class. Like Window it uses BorderLayout by default.

. JLabel : JLabel descended from Jcomponent, and is used to create text

labels.

JButton : JButton class provides the functioning of push button. JButton

allows an icon, string or both associated with a button.

JTextField : JTextFields allow editing of a single line of text.

Introduction to Swing Classes

. JPanel : JPanel is Swing's version of AWT class Panel and uses the same
default layout,
FlowLayout. JPanel is descended directly from