***********Constructor – NO RETURN(ITS VOID)

SAM NAME AS CLASS ITS FORMED IN

Its a way of setting value for an OBJ,ex = Al3 obj = new Al3(3,9); we
just gav parameters

***********NON ACCESS MODIFIERS

*****FOR ATT/METHDS

1)Final =Att n methds cant be modified.

2)Static=ATT/METHD BELONGS TO A CLASS,WE don’t hav to make

an OBJ to initialize a static methd of a class.Also a normal methd
cant call a static,only static methd can do so,sam goes for att.

3)Abstract=Methds are left empty n their body is filled in the

extended class(child class)

*****FOR CLASS

1)Final=We can’t extend this class i.e no inheritance.

2)Abstract=We can’t make OBJs of this class,w gotta extend it i.e

imply inheritance.

***************PACKAGES

Packages are nothing but collection of classes n their methds in thr.

Import Package.name.class; // import package.name.*;

***************INNER CLASSES

WE CAN HAVE CLASS INSIDE OF A CLASS.

Then we can excess the OBJ inside inner class by using

OUTER.INNER name = new OUTER.INNER();
class OuterClass {int x = 10;

private class InnerClass { y = 5; }}

public class Main {public static void main(String[] args) {

OuterClass muter = new OuterClass();OuterClass.InnerClass myInner = muter.new InnerClass();

 System.out.println(myInner.y + muter.x); }}

TYPES;

1)Private inner class=If u try to access a private inner class from an outside class, an error occurs

2)Static inner class=An inner class can also be static, which means that u can access it without creating an OBJ of the outer class

************INTERFACE

Its a static class i.e it holds all methds without body(as they all are
static from inside)

interface Animal {

public void animalSound(); // interface methd (does not have a

body)

public void sleep(); // interface methd (does not have a body) }

class Pig implements Animal {

public void animalSound() {

System.out.println("The pig says: wee wee");}

public void sleep() {System.out.println("Zzz"); } }

*******************ENUMS

Stuffs that can’t be modified.Sorta class of constants(They should

be in UPPERCASE letters.)

public class Main {enum Level {LOW, MEDIUM, HIGH }

public static void main(String[] args) {Level myVar = Level.MEDIUM; System.out.println(myVar); }}

1)We can use it in switch stm

enum Level {LOW, MEDIUM, HIGH }public class Main { public static void main(String[] args) {Level myVar = Level.MEDIUM;

switch(myVar) {

case LOW: System.out.println("Low level");break;

case MEDIUM: System.out.println("Medium level");break;

case HIGH: System.out.println("High level");break;

}}}
2)We can use it in for each loop using values() methd

enum moods{ANGRY; HAPPY; BLUE; }

Main(){

For(moods Var : moods.values() ) { /// body } }

********************TIME IN JAVA

Import java.time.*; // package

Or alot of classes =>

import java.time.LocalDateTime; // Import the LocalDateTime class

import java.time.format.DateTimeFormatter; // Import the DateTimeFormatter class

public class Main {

public static void main(String[] args) {

LocalDateTime myDateObj = LocalDateTime.now();System.out.println("Before formatting: " + myDateObj);

DateTimeFormatter myFormatObj = DateTimeFormatter.ofPattern("dd-MM-yyyy HH:mm:ss");

String formattedDate = myDateObj.format(myFormatObj); System.out.println("After formatting: " + formattedDate);

}}

Other classes;

LocalDate ; LocalTime ; LocaDateTime; DateTimeFormatter

******************ARRAYLIST

ArrayList<String> cars = new ArrayList<String>();

We can change its size later as well after defining unlike an array.

*****We use add(); get(); size(); set(index num,element); clear();

[emptiesit] remove(index);[removes an individual element]

*****We gotta use Integer,Boolean,String,Character(i.e classes not

primitive types)

*******import java.util.ArrayList; import java.util.Collections;

Collections.sort(cars); THIS BAD BOY SORTS THE ARRAYLIST CALLED cars

******FOR EACH LOOP for (String i : cars) {System.out.println(i);

************************LINKEDLISTS

Both are sam but linked is used to manipulate data n arraylist is

used to store data

******Arraylists;When we add a new element old arraylist is

destroyed n a new one is made up with a higher size n so.

WHILE IN Linkedlist;Its like every thing is stored in a container n 1 st

container is having link to the list while when we add a new element
,that containers link is given the one that comes prior to it.

**** addFirst(); addLast(); removeFirst(); removeLast(); getFirst();

getLast();

********************HASHMAPS

***OUTPUT {USA=Washington DC, Norway=Oslo, Engln=London, Germany=Berlin}

Int it things go upside down with a logic similar to 2D array. But with key/value concept

Here USA IS KEY FOR WASHINGTON DC N SO ON.

***OPERATIONS import java.util.HashMap; // import the HashMap class

HashMap<String, String> capitalCities = new HashMap<String, String>();

capitalCities.put("Engln", "London");capitalCities.get("Engln");capitalCities.remove("Engln");

capitalCities.clear(); capitalCities.size();

***WE can do mapping of Strings to an Integer;n varooius kinds.

******************HASHSETS

import java.util.HashSet; // Import the HashSet class

HashSet<String> cars = new HashSet<String>()cars.add("Volvo");

cars.contains("Mazda"); cars.remove("Volvo"); cars.size();

for (String i : cars) {System.out.println(i); }

**************************ITERATOR
An Iterator is an OBJ that can be used to loop through collections

Note: Trying to remove items using a for loop or a for-each loop would not work correctly because the collection is changing size at
the sam time that the code is trying to loop

ArrayList<String> cars = new ArrayList<String>();

cars.add("Volvo");cars.add("BMW");cars.add("Ford");cars.add("Mazda");

<String> it = cars.iterator(); // Get the iterator

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

numbers.add(12); numbers.add(8); numbers.add(2); numbers.add(23);

Iterator<Integer> it = numbers.iterator();

while(it.hasNext()) { i = it.next();

if(i < 10) {it.remove();} }

System.out.println(numbers);

*********************EXCEPTIONS(TRY N CATCH)

*******TRY N CATCH,FINALLY n THROW

TRY N CATCH JAVA ON THIS N IF IT FINDS ERROR ITS GONNA GO

TO CATCH N GONNA RUN IT

FINALLY JAVA WILL RUN IT NO MATTER WHAT

THORW-> WE make our own custom error with various tyopes of

existing errors
ex=ArithmeticException, FileNotFoundException, ArrayIndexOutOfBoundsException, SecurityException

*****************FILE HNLING

import java.io.File; // Import the File class

File myObj = new File("filename.txt"); // Specify the filename

CREARTING A FILE

File myObj = new File("filename.txt");

 if (myObj.createNewFile()) {System.out.println("File created: " + myObj.getName())

WRITING TO A FILE

FileWriter myWriter = new FileWriter("filename.txt");

myWriter.write("Files in Java might be tricky, but it is fun enough!");

myWriter.close();

try {

File myObj = new File("filename.txt");

READING THE FILE

Scanner myReader = new Scanner(myObj);

while (myReader.hasNextLine()) {

String data = myReader.nextLine();

System.out.println(data);

DELETING THE FILE

myReader.close();

File myObj = new File("filename.txt");

if (myObj.delete()) {

System.out.println("Deleted the file: " + myObj.getName());

KEYWORD ‘super’ used to refer parent class obj(used in inheritance)

Say if a class N extends M n they have sam methd ONO() where

their body is different. So an obj of N with keyword super will
implement methd body in M.

Encapsulation ; public , private, protected

Methd overriding; We have a methd with sam name in a class n in its

subclass(the one that extends class) n an OBJ created otta
subclass will initialize the body of methd in subclass,not in the
class.

Interfaces; almost like an abstract class i.e have a methd with

empty body.

Public interface name{

Void namemethd () ; }

Public class wolf implements name {

Public Void name(){ //code }

That’s how u create an interface n use it in class

Class name implements interface1,interface2 // having two

interfaces

Methds in interface can have body by adding ‘default’ before

methd type.(feature of java 8 )We can even override those methds.

Static n private methd in interfaces; can have a body

Public interface Animal()

{ Static void talk(){ System.out.println(“ soy hablar ”);

Private void scream(){ System.out.println(“AAAaah”); }

Class next{ Main() { Animal.talk(); Animal.scream(); } }

Exception hnling ;We do it so that we can hnle error manually rather

than by default hnler

Keywords;Try, Catch, Throw, Throws N Finally

int c ;
try{

int bob = 89; c= bob/0;}

catch(ArithmaticeException e){ c=o; } //
exceptions are nothing but OBJs in java
as u see we are gonna get an arithmetic exc

Thr’re many exc types in java;so google search it

methd () throws exceptionName {}

that’s how u use throws keywor
MULTITHREADED PROGRAMMING

Multithreads means running different things in a programs at sam

time ex; watching video on yt n also searching for other video.

Methds; getName , getPriority , isAlive , join , run , sleep , start

public class Main(){
public static void main(String[], args) {
Thread myThread = Thread.currentThread();
myThread.setName("name of thread");
myThread.setPriority(3);//main methd usually have priority 5
Thread.sleep(mills 1000); // means thread sleeps for 1sec

BELOW SHOWS THAT WE NEED TO USE THE THREAD OBJ TO INITIALIZE A THREAD

class MyThread implements Runnable{

Thread t;
MyThread(){ t = new Thread(target this,name "my thread"); // this means t meantioned above
System.out.println("Child thread created"); }
@override
public void run(){ // this will run when MyThread is called
try { for(int i =5;i>0;i--) System.out.println(i);
Thread.sleep(mills 1000)}
catch(InterreptedException e){ System.out.println(e);}}
public class Main(){public static void main(String[], args) {
MyThread bear= new MyThread();
bear.t.start(); // WE ARE USING OBJ OF THREAD TO INITIALIZE IT
try{ for(int i =5;i>0;i--)System.out.println(i);Thread.sleep(mills 1000)} // TWO DIFFERENT THREAD WILL RUN IN OUR PROGRAM
catch(InterreptedException e){ystem.out.println(e); }}}

BELOW IS ALT TO ABOVE CODE

class MyThread extends Thread{

MyThread(){super(name " my thread ");}}
public class Main(){public static void main(String[], args) {
MyThread bear= new MyThread();
bear.start();
try{ for(int i =5;i>0;i--)
System.out.println(i);Thread.sleep(mills 1000)}
catch(InterreptedException e){
System.out.println(e); }}

Creating multiple threads in a class

class MyThread implements Runnable{

String name; Thread t;
MyThread(String name){
this.name= name;
t = new Thread( target this, name);
}
public void run(){ // this will run when MyThread is called
try { for(int i =5;i>0;i--) System.out.println(i);
Thread.sleep(mills 1000)}
catch(InterreptedException e){ System.out.println(e);}

}
main(){
MyThread thread1 = new MyThread(name "Thread1 "); thread1.t.start();
MyThread thread2 = new MyThread(name "Thread2"); thread2.t.start();
MyThread thread3 = new MyThread(name "Thread3"); thread3.t.start();
}

isAlive() n join()
class MyThread implements Runnable{
 String name;
Thread t;
MyThread(String name){
this.name=name;
t = new Thread(target this, name );
}
public void run(){ // this will run when MyThread is called
try { for(int i =5;i>0;i--) System.out.println(i);
Thread.sleep(mills 1000)}
catch(InterreptedException e){ System.out.println(e);}
}
main(){
MyThread thread1 = new MyThread(name "Thread1 ");
MyThread thread2 = new MyThread(name "Thread2");
MyThread thread3 = new MyThread(name "Thread3");
thread1.t.isAlive(); /// WILL PRINT FALSE
thread1.t.start()
try{thread1.t.join()}
catch(InterreptedException e){ System.out.println(e);}
thread1.t.isAlive(); // WILL PRINT TRUE
thread2.t.start(); // so what join does is is will let thread1 run
thread3.t.start(); // completely n then thread2 will come in action
}

So what isAlive() returns is a Boolean n join() don’t let others

threads to join unless the thread it’s joined to is finished with
beeswax.

Synchronized Threads
THREADS THEORY

TWO WAYS TO DO THREADING IN JAVA

1)Create a class n extend in to Thread. Override run() methd. Then

in main create OBJ of that class n invoke start() methd
public class MyThread extends Thread{ public void run(){Sy .. //code} }

public static void main(String[] args){ MyThread newobj = new MyThread(); newobj.start(); }

2)Create a class n implements Runnable interface(in JAVA we cant

extend a class to 2-3 other classes but we can implement 2-3
interfaces to it so this can be useful in that situation) then override
run() methd in that class. Create an OBJ in main class n invoke
start() .
public class MyThread implements Runnable { public void run(){// code } }

public static void main (String[] args){ Thread t = new Thread(new MyThread()); t.start();}

DEMON THREAD IS THE THREAD THAT GETS EXECUTED ALONG

WITH MAIN

MUTLITHREADING –

class Printer{

synchronized void printDocument(int m, String docName) {

for(int i= 0;i<=10;i++) {
try { Thread.sleep(500); }
catch( InterruptedException e) { }
System.out.println(">> Printing " + docName+ " " + i);
}
}
}

class MyThread extends Thread{

Printer pRef;
MyThread(Printer p){
pRef =p;
}
@Override
public void run() {
pRef.printDocument(10, "Alice");
}
}
class UrThread extends Thread{

Printer pRef;
UrThread(Printer p){
pRef =p;
}
@Override
public void run() {
synchronized(pRef) {
pRef.printDocument(10, "Chris");
}
}

Main()=

System.out.println("START");

Printer printer = new Printer();

printer.printDocument(10, "II.pdf");

MyThread mRef = new MyThread(printer);

mRef.start();
//try { mRef.join(); }
//catch(InterruptedException e) {}

UrThread yRef = new UrThread(printer);

yRef.start();
System.out.println("END");

So whats all these pieces of words huh!!

So we made a class called Printer n gave it a methd call printDocument. Then we

made two child classes of class Thread(i.e basically thread classes) n filled them
with constructors that take in a Printer OBJ as arg.For each thread class we made
a Printer OBJ that takes the given parameter to the constructor then implies that
in the run() methd.In run() methd we are impling the printDocument methd using
this given parameter.

Now in main we made a Printer OBJ n OBJs of other two classes.While making so we
gave in the Printer OBJ as the parameter for the constructor of those two classes.
Then we implemented start() methd for those two OBJs of thread class to make them
run but we got jumbled output so we used something called join() methd // NOTE;
use try catch for join(),sleep() n so on // This will help in synchronization or
else go to the Printer class n put ‘ synchronized ‘ that will do sam.

THEAD POOL –
LAMBA EXPRESSION IN JAVA

It’s Functional programming in java.

It’s parameter -> expression body

FUNTIONALAL INTERFACE

ITS AN INTERFACE THAT CONTAINS ONLY ONE ABSTRACT METHD

Runnable , ActionListner, Comparable

@FunctionalInterface // optional to add

interface Cab // When an interface hac exactly 1 abstract methd its called
//as Functional Interface
{

void bookCab(); // by default public abstract void bookCab();

}

MAIN=

// USING LAMBA EXP FOR ABOVE

Cab cab = ()-> {
System.out.println("Hey o ");
};
cab.bookCab();

LAMBA PARAMETERS

ZERO ()-> System.out.println(“Sd”);

ONE (param)-> System.out.println(“sdf”+ param);

MULTIPLE (p1 p3 )-> System.out.println(p1+p2);

LAMBA WITH RETURN TYPE

interface cab2 {
double bookCab(String source,String destination);

MAIN=

cab2 cabby = (source,destination)-> {

System.out.println("sd"+ source + destination);

return 222.2;
} ;
double fare = cabby.bookCab("s", "Df" );
System.out.print(fare);
LAMBA AS AN OBJ

INTERFACE = public interface LambdaComparator{

Public boolean compare(int a,int b); }

IMPLEMENTING CLASS = LambdaComparator myComparator = (a,b)-> return a>b;

boolean result = myComparator.compare(3,4);

LAMBA VARIABLE CAPTURE

LOCAL String str =”sdf”;

MyLambda dis = (chars)->{

Return str + new String(chars); };

STATIC

INSTANCE private String st = “sdf”;

Public void attach (Lam) {

public class Al22 {

int instanceVar =11;

static int sVar = 112;

public static void main(String[] args) {

OUTSIDE MAIN =

cab2 cabby = (source,destination)-> {

int localVar = 112; // LOCAL VARIABLE
System.out.println("sd"+ source + destination);
System.out.println(instanceVar + Al22.sVar + localVar );
return 222.2;
};

METHD REFERENCES AS LAMBDAS

Easier form of lambda exps

Below is the example of 3 ways of ref to methds

interface calculator{
void add (int a ,int b);
}

class calc{
public static void addsomething(int a,int b){
System.out.println(a+b);
}

public void adddda(int a,int b){

System.out.println(a+b);
}

interface Messanger{
Message getMessage(String mgs);
}

class Message{
Message(String msg){
System.out.println(msg);
}
}

main=

// Ref to a static methd

calculator cref = calc::addsomething; // Mthod ref
cref.add(4,2);

// Ref to non static methd or instance methd

calc cal = new calc();
calculator cref = cal::adddda; // Methd ref
cref.add(45,5);

//Ref to a constructor
Messanger mref = Message::new; //Methd ref
mref.getMessage("sdf");
PARSING XML USING DOM,SAX N StAX PARSER IN JAVA

XML =

// java.io.* // have everything for input output

In above we made a file obj first giving the path inside the
constructor. Then we made a methd cuz that’s a good programming
practise n also bcuz of that we can use that methd next time for
other file obj as well. Now in methd we supplied the file OBJ as
parameter as we wonna work with that n we wrote a try catch thing
cuz this process gives errors by def in java. Now we made an obj of
PrintWriter out of try catch as we would have to use it in finally as
well(since we wonna close the file ). In try we used this obj n
passed the methd parameter into the PrintWriter constructor(which
is gonna work on the original file we wonna workl with). El fin.
This is reading from a file.We use scanner.

NOW BELOW SHOWS USING A FILEWRITER TO DO THE JOB

WRITE TO FILE WAY

SERIALIZATION N DESERIALIZATION

Process of converting OBJs into binary data n sending it to other

computer is serialization.
FILES

Don’t make this file in src folder,make it in root folder

GENERICS

7;30-8;20 we gotta see

List,queue,set-hash ,enums allthat + generics

Generic detailed explanation

Part 1 expl

Ex1 class gen <type> {

type var;
void setvar(type a) {
this.var= a;
}
MAIN =
gen f = new gen();
f.setvar(4);
f.setvar("ef");
System.out.println(f.var);

Ex 2 class gen <type> {

type var;
public gen(type string) {
// TODO Auto-generated constructor stub
this.var= string;
}
public gen() {
// TODO Auto-generated constructor stub
}
void setvar(type a) {
this.var= a;

Main = gen<String> ad = new gen<String>("sd");System.out.println(ad.var);

gen<Double> ads = new gen<Double>(1.5); System.out.println(ads.var);

Part 2 explanation

class generic<T1,T2>{

int val;
T1 a;
T2 b;
generic(T1 a,T2 b){
this.a=a;
this.b=b;
System.out.println(a +" " + b);
}

MAIN =

generic as = new generic("asd",5);

BUT FIRST LOOK INTO TYPECASTING

Its converting one data type into other data type

Types= 1) implicit; automatically performed by compiler.

Ex int a 19; double s a;

2) explicit;

EX double a 34.34; int b (int) a; means double got converted into int

TYPE WRAPPERS

1st way = Character cs = new Character('c');

2nd way = Character css = Character.valueOf('c');

Double sdsd = Double.valueOf(4.4);

double sda = sdsd.doubleValue();

AUTOBOXING

Auto conversation of primitive into OBJ

ENUMS

Its a special type of class that lets u make a new data type n then u
can decide what data that data type will take(we don’t have to deal
with new keyword) enums can inherit n extends.

enum Days{
Monday, Tuedays, WED // they are static n final n constant by default}
MAIN =

Days days = Days.Monday;

// now we have a variable made called days

Days ar[] = Days.values(); // fill ar[] with all Days value

XML - Designed to store n transport data.

Rukes= 1] considers space as data

2] xml tags are case sensitive 3] close tag n open tag bt exist.

//FINDING STUFF IN STRING

// endsWith() n startsWith() gives what it says
for string
// indexOf(' ') used to find characters in
strings
// concat() joins two strings to a one word
// replace('a','ad') replaces in string

//RECURSION
// ITS A METHD THAT CALLS ITSELF
/* PUBLIC STATIC LONG FACT(INT A) {
IF(A<=1)
RETURN 1;
ELSE RETURN A*FACT(A-1);
}
COLLECTION ;

ITERATOR

// Iterator<String> i = l1.iterator(); ( l1 name of list )

//Iterator = goes through each list item by item

// i.hasNext() , i.next() , i.remove()

/*

List<String> la = new ArrayList< String>();

List<String> lb = new ArrayList< String>();
la.add("AS"); la.add("ASA") ; la.add("ASAS");
lb.add("df"); la.add("ASAS"); lb.add("fe");

editlist(la,lb);

public static void editlist (List<String> lla,List<String> llb) {

Iterator<String> it = lla.iterator();
while(it.hasNext()) {
if(llb.contains(it.next()))
it.remove(); //

LINKED LIST

String[] things = {"a","as","asd"}; //

list1.add(list2)
// will give list1 all
list2 data
List<String> l1 = new LinkedList<String>();
for(String c : things)
l1.add(c);
//.subList(from,to) seprates a chunk
in a list
*/ // .clear() deletes list

/* //ARRAY TO LIST N
EITHER

String[] stuff = {"a","d","f","g"};

LinkedList<String> list = new LinkedList<String>(Arrays.asList(stuff));

//we just made an array into

a list
list.add("pimp");
list.addFirst("I'M ADDED AT INDEX 0"); // LOOK AT THIS DAMN GAL

stuff = list.toArray(new String(list.size()));

// conv list to array
 // LIST METHDS

String[] crap = {"a","d","f"};

List<String> lst = Arrays.asList(crap);
Collections.sort(lst); // sorted our list in alphabetical
order
System.out.printf(null, lst); // we gave a list as a string

Collections.sort(lst, Collections.reverseOrder()); // will sort list in reverse

order

Character[] ra = {'a','s', 'f', 'g' };

List<Character> lst = Arrays.asList(ra);

// Collections ; rverse n pritn opt the

lsut
Collections.reverse(lst);

// fill collection wtih crap

Collection.fill(l,'X');

// METHD addAll()
// adds one collection data into other collection
// this is ognan add elements of stuff to list2
//Collections.addAll(list2, stuff);

//FREQUENCY
//frequency gives output of how many times an element appear in
list
// Collections.frequency(list, "FI");

// DISJOINT
// boolean t = Collections.disjoint(list, lst);
// True is no items in common
// False if items in common
*/

STACKS

// DATA STRUCTURE => STACKS ;

//PUSH N POP(take sometig off it)
/*
Stack<String> st = new Stack<String>();
st.push("BOT");
printStack(st);
st.push("sd");
printStack(st);
st.push("sd3");
printStack(st);
 // printStack is a methd we made
st.pop();
printStack(st); _ first to pop
st.pop(); _
printStack(st); _ last to pop
st.pop();
printStack(st);

private static void printStack(Stack<String> a) {

if(a.isEmpty())
System.out.println("Nothing in stack");
else
System.out.printf("Top", a);
}

// DATA STRUCTURE = QUEUE

PriorityQueue<String> q = new PriorityQueue<String>();

q.offer("sd");
q.offer("asd");
q.offer("gd");
System.out.printf("%s", q); // prints whole queue at once

System.out.printf("%s",q.peek()); // output = sd; it has high

priority

q.poll(); // removes high priority

element

// Set = Collection that doesn't have

duplicate
//elements in it

// 1) HashSet
String[] stuff = {"a","s","a"};
List<String> li = Arrays.asList(stuff); // we made array into list n got it
System.out.printf("%s", li); // print

Set<String> set = new HashSet<String>(li); // we made set obj

System.out.printf("%s", set); // set eliminated 2nd a in list
CALENDAR CLASS

Its an abstract class so cant make obj so create an instance of it.

Calendar c = Calendar.getInstance();

Methds c.get(Calendar.YEAR) n many more

RNOM CLASS

Able to generate rnom data type

Rnom r = new Rnom();
System.out.println(r.nextInt()); will give rnom number

TIMER N TIMER TASK

MAIN=

HASHMAPS = KEY/DATA

HashMap<String, Integer > pn = new HashMap<>();

 pn.put("Bob",52232);
System.out.println(pn.get("Bob"));

Special loop for( Map.Entry<String, Integer> set : pn.entrySet() ) {

System.out.println(set.getValue());

ITERATOR N LISTITERATOR- used to loop over a list or a collection