Instanceof operator

*******************************************************************
class Parent1 {}
class InstanceOp extends Parent1 {

public static void main(String args[]) {

Parent1 m = new Parent1();
InstanceOp d = new InstanceOp();

System.out.println(m instanceof Parent1);

System.out.println(d instanceof InstanceOp);
System.out.println(d instanceof Parent1);
System.out.println(m instanceof InstanceOp);

}
}

*******************************************************************
Upcasting

*******************************************************************

class Employee {
String name="Amit";
void display(){System.out.println(name);};

class Salary extends Employee {

double salary=2000; // Annual salary
void display(){System.out.println(name + " "+ salary);};
}

class Increment extends Employee {

double increment=100; // Annual salary
void display(){System.out.println(name + " "+ increment);};
}

public class upcasting1 {

public static void main(String[] args) {

Salary s = new Salary();
s.display();

Employee e = new Salary(); //implicit upcasting

e.display();

e =(Employee) new Salary(); //explicit upcasting

e.display();

e = new Increment(); //implicit upcasting

e.display();

System.out.println(s instanceof Salary);

System.out.println(s instanceof Employee);
System.out.println(e instanceof Salary);
System.out.println(e instanceof Employee);
System.out.println(e instanceof Increment);

}
*******************************************************************
Downcasting

*******************************************************************
class Animal
{
void eat(){System.out.println("eating...");}
}

class Dog extends Animal

{
void bark(){System.out.println("barking...");}
}

class Cat extends Animal

{
void meow(){System.out.println("meowing...");}
}

public class Downcasting1 {

public static void main(String args[])

{
Animal a = new Dog();
System.out.println(a instanceof Animal);
System.out.println(a instanceof Dog);

Dog d =(Dog) a; //explicit downcasting

System.out.println(d instanceof Animal);
System.out.println(d instanceof Dog);

Animal a1 = new Animal();

System.out.println(a1 instanceof Animal);
System.out.println(a1 instanceof Dog);

Animal a2 = new Cat();

System.out.println(a2 instanceof Animal);
System.out.println(a2 instanceof Dog);
System.out.println(a2 instanceof Cat);

*******************************************************************
Upcasting, Downcasting and Instanceof

*******************************************************************

class Animal1
{
void eat(){System.out.println("eating...");}
}

class Dog1 extends Animal1

{
void bark(){System.out.println("barking...");}
}

class Cat1 extends Animal1

{
void meow(){System.out.println("meowing...");}
}

class AnimalSound
{
void identifySound(Animal1 a)//upcasting
{
if(a instanceof Dog1)
{
Dog1 d=(Dog1)a;//Downcasting
d.bark();
}
else if(a instanceof Cat1)
{
Cat1 c=(Cat1)a;//Downcasting
c.meow();
}
else
{
a.eat();
}
}
}
public class upDown {
public static void main(String args[])
{
Animal1 a1=new Dog1();

AnimalSound s=new AnimalSound();

s.identifySound(a1);
 a1=new Cat1();
s.identifySound(a1);

a1=new Animal1();
s.identifySound(a1);

*******************************************************************

Conversion
*******************************************************************
public class conversion {
public static void main(String args[]){

int i=10;
long m=10000L;
double d=3.141;

i=(int)m;//narrowing through casting

m=i;//widening
m=(long)d;//cast
d=m;

String s="200";
i=Integer.parseInt(s);
System.out.println(i+100);

s=String.valueOf(i);
//s= Integer.toString(i);
System.out.println(s+100);

}
}

*******************************************************************
Static polymorphism- Overloading

*******************************************************************

public class Ploy {

public static int minFunction(int n1, int n2) {
int min;
if (n1 > n2)
min = n2;
else
min = n1;
return min;
}

public static double minFunction(double n1, double n2) {

double min;
if (n1 > n2)
min = n2;
else
min = n1;
return min;
}

public static String minFunction(String s1, String s2) {

String min;
if (s1.compareTo(s2)>0)
min = s2;
else
min = s1;
return min;
}

public static void main(String[] args)

{
int a = 11;
int b = 6;
double c = 7.3;
double d = 9.4;
String e="ABC";
String f="D";
System.out.println("Minimum Value = " + minFunction(a, b));
System.out.println("Minimum Value = " + minFunction(c, d));
System.out.println("Minimum Value = " + minFunction(e, f));
}
}
*******************************************************************
Overriding- Single inheritance

*******************************************************************
class Bike{
void run(){System.out.println("running");}
}
class Splender extends Bike{
void run(){System.out.println("running safely with 60km");}

public static void main(String args[]){

Bike b = new Splender();//upcasting
b.run();
}
}

*******************************************************************

Overriding- Multilevel inheritance

*******************************************************************
class Animal{
void eat(){System.out.println("eating");}
}
class Dog extends Animal{
void eat(){System.out.println("eating bones");}
}
class BabyDog extends Dog{
void eat(){System.out.println("drinking milk");}

public static void main(String args[]){

Animal a1;
a1=new Animal();
a1.eat();

a1=new Dog();
a1.eat();

a1=new BabyDog();
a1.eat();
}
}

*******************************************************************
Overriding- Hierarchical inheritance

*******************************************************************
class Bank{
float getRateOfInterest(){return 0;}
}
class SBI extends Bank{
float getRateOfInterest(){return 8.4f;}
}
class ICICI extends Bank{
float getRateOfInterest(){return 7.3f;}
}
class AXIS extends Bank{
float getRateOfInterest(){return 9.7f;}
}

class TestPolymorphism{
public static void main(String args[]){
Bank b;
b=new SBI();
System.out.println("SBI Rate of Interest: "+b.getRateOfInterest());
b=new ICICI();
System.out.println("ICICI Rate of Interest: "+b.getRateOfInterest());
b=new AXIS();
System.out.println("AXIS Rate of Interest: "+b.getRateOfInterest());
}
}

*******************************************************************
Overriding – Super keyword

*******************************************************************
class Animal2 {
public void move() {
System.out.println("Animals can move");
}
}

class Dog2 extends Animal2 {

public void move() {
super.move();
System.out.println("Dogs can walk and run");
}
}

class TestDog {

public static void main(String args[]) {

Animal2 b = new Dog2();
b.move();
}
}

*******************************************************************

No overriding in data member

*******************************************************************
class Bike31{
int speed=90;
void speedlimit(){System.out.println("Bike31");};
}
class Honda31 extends Bike31{
int speed=150;
void speedlimit(){System.out.println("Honda31");};

public static void main(String args[]){

Bike31 obj=new Honda31();
obj.speedlimit();
System.out.println(obj.speed);
}
}

*******************************************************************
Multiple Inheritance in Interface

*******************************************************************
interface Printable{
void print();
}
interface Showable{
void print();
}

class A7 implements Printable,Showable{

public void print(){System.out.println("Hello");}

public static void main(String args[]){

A7 obj = new A7();
obj.print();
}
}

*******************************************************************

Interface extends Interface

*******************************************************************
interface Printable1{
void print();
}

interface Showable1 extends Printable{

void show();
}

class TestInterface4 implements Showable1{

public void print(){System.out.println("Hello");}
public void show(){System.out.println("Welcome");}

public static void main(String args[]){

TestInterface4 obj = new TestInterface4();
obj.print();
obj.show();
}
}

*******************************************************************
Default method in Interface

*******************************************************************
interface Drawable2{
void draw();
default void calArea(){System.out.println("calculating area");}
}
class Rectangle2 implements Drawable2{
public void draw(){System.out.println("drawing rectangle");}
}
class TestInterfacedefault{
public static void main(String args[]){
Drawable2 d=new Rectangle2();
d.draw();
d.calArea();
}}

*******************************************************************

Default method in Interface- Multiple Inheritance

*******************************************************************
interface Drawable3{
void draw();
default void msg(){System.out.println("default method3");}
}

interface Drawable4{
void draw();
default void msg(){System.out.println("default method4");}
}

class Rectangle4 implements Drawable3,Drawable4{

public void draw(){System.out.println("drawing rectangle");}
public void msg(){Drawable3.super.msg();}

}
class TestInterfacedefault1{
public static void main(String args[]){
Drawable3 d=new Rectangle4();
d.draw();
d.msg();
}}

*******************************************************************
Static method in Interface

*******************************************************************
interface Drawable5{
void draw();
static int cube(int x){return x*x*x;}
}

class Rectangle5 implements Drawable5{

public void draw(){System.out.println("drawing rectangle");}
}

class InterfaceStatic{
public static void main(String args[]){
Drawable5 d=new Rectangle5();
d.draw();
System.out.println(Drawable5.cube(3));
}}

*******************************************************************
Checked Exception- throws keyword

*******************************************************************
import java.io.*;

public class ExceptionHandling {

public static void main(String[] args) throws IOException

{
InputStreamReader r1= new InputStreamReader(System.in);
BufferedReader b1 = new BufferedReader(r1);
String s1 = b1.readLine();
int i1 = Integer.parseInt(s1);
System.out.println("Entered number is " + i1);
}

*******************************************************************

Checked Exception- try-catch block

*******************************************************************
import java.io.*;
public class EH1 {
public static void main(String[] args)
{
try
{
InputStreamReader r1= new InputStreamReader(System.in);
BufferedReader b1 = new BufferedReader(r1);
String s1 = b1.readLine();
int i1 = Integer.parseInt(s1);
System.out.println("Entered number is " + i1);
}
catch(IOException ex)
{
System.out.println("Something went wrong");
}

System.out.println("Sucessful completion ");

}
}

*******************************************************************
Creating Risky Method

*******************************************************************

import java.io.IOException;
import java.sql.SQLException;

public class TestThrow1{

static void validate(int age) throws IOException, SQLException
{
if(age<18)
throw new IOException("not valid");
else if (age>60)
throw new SQLException("not valid");
}
public static void main(String args[]) throws IOException, SQLException
{
validate(13);
System.out.println("rest of the code...");
}
}

*******************************************************************

Unchecked Exception
*******************************************************************

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

int i=50;
int j=0;
int data=i/j;

System.out.println("rest of the code...");

}
}

*******************************************************************
Handling Unchecked Exception

*******************************************************************
public class Testtrycatch2{
public static void main(String args[]){
try{
int i=80;
int j=0;
int data=i/j;

}catch(ArithmeticException e){System.out.println(e);}

System.out.println("rest of the code...");

}
}

*******************************************************************

Finally Block- without exception

*******************************************************************
class TestFinallyBlock{
public static void main(String args[]){
try{
int data=25/5;
System.out.println(data);
}
catch(ArithmeticException e){System.out.println(e);}
finally{System.out.println("finally block is always executed");}
System.out.println("rest of the code...");
}
}
*******************************************************************
Finally Block- with exception

*******************************************************************
public class TestFinallyBlock1{
public static void main(String args[]){
try{
int data=25/0;
System.out.println(data);
}
catch(ArithmeticException e){System.out.println(e);}
finally{System.out.println("finally block is always executed");}
System.out.println("rest of the code...");
}
}

*******************************************************************

Custom Exception
*******************************************************************
class InvalidAgeException extends Exception{
private String msg;
InvalidAgeException(String s){
this.msg = s;
}
public String getMsg() {
return msg;
}
}

class TestCustomException1{
static void validate(int age)throws InvalidAgeException{
if(age<18)
throw new InvalidAgeException("Age is not valid");
else
System.out.println("welcome to vote");
}
public static void main(String args[]){
try{
validate(13);
}catch(InvalidAgeException m){System.out.println("Exception occured: "+m.getMsg());}
System.out.println("rest of the code...");
}
}
*******************************************************************
JDBC Driver- extracting data from the database

*******************************************************************
import java.sql.*;
class jdbcEx{
public static void main(String args[]) throws ClassNotFoundException, SQLException
{
Class.forName("oracle.jdbc.driver.OracleDriver");

Connection con=DriverManager.getConnection( "jdbc:oracle:thin:@localhost:1521:xe",

"system", "system");

Statement stmt=con.createStatement();

ResultSet rs=stmt.executeQuery("select * from EMP");

while(rs.next())
System.out.println("ID="+ rs.getInt(1) + " --- name=" + rs.getString("name"));
con.close();

}
}

*******************************************************************

JDBC- inserting record

*******************************************************************
import java.sql.*;

public class insertRecord {

public static void main(String args[]) throws ClassNotFoundException, SQLException
{

Class.forName("oracle.jdbc.driver.OracleDriver");

Connection con=DriverManager.getConnection( "jdbc:oracle:thin:@localhost:1521:xe",

"system", "system");

Statement stmt=con.createStatement();
stmt.executeUpdate("INSERT INTO Emp VALUES(3, 'Bob')");
con.close();
}
}

*******************************************************************
JDBC- updating record

*******************************************************************
import java.sql.*;

public class updateRecord {

public static void main(String args[]) throws ClassNotFoundException, SQLException
{

Class.forName("oracle.jdbc.driver.OracleDriver");

Connection con=DriverManager.getConnection( "jdbc:oracle:thin:@localhost:1521:xe",

"system", "system");

Statement stmt=con.createStatement();

stmt.executeUpdate("UPDATE Emp SET name = 'Tom' WHERE id=1");

con.close();
}
}

*******************************************************************

JDBC- deleting record

*******************************************************************
import java.sql.*;

public class deleteRecord {

public static void main(String args[]) throws ClassNotFoundException, SQLException
{

Class.forName("oracle.jdbc.driver.OracleDriver");

Connection con=DriverManager.getConnection( "jdbc:oracle:thin:@localhost:1521:xe",

"system", "system");

Statement stmt=con.createStatement();
stmt.executeUpdate("DELETE from Emp WHERE id=2");
con.close();
}
}
*******************************************************************
PreparedStatement

*******************************************************************
import java.sql.*;

public class PreparedStatementEx {

public static void main(String args[]) throws ClassNotFoundException, SQLException
{

Class.forName("oracle.jdbc.driver.OracleDriver");

Connection con=DriverManager.getConnection( "jdbc:oracle:thin:@localhost:1521:xe",

"system", "system");

PreparedStatement stmt=con.prepareStatement("update EMP set name=? where id=?");

stmt.setString(1,"Hary");
stmt.setInt(2,3);

int i=stmt.executeUpdate();
System.out.println(i+" records updated");

}
}

*******************************************************************