Lab4: Object-Oriented Programming Concept

Lab4: Object-Oriented Programming Concept

LAB OBJECTIVE: Deep understanding about Object-Oriented Programming concepts and its paradigm.

Polymorphism in Java

Polymorphism reduces the complexity of an object. It can only be achieved via the behavior of an object, properties of an object do not play any role in the case of polymorphism.

Achieving polymorphism via function overloading, can be done by changing only in no. of arguments

//save as: FunctionOverloading.java
class FunctionOverloading{  
	void show(){
		System.out.println("hello");
	}
	void show(int x){
		System.out.println("Hello by calling single arguments");
	}
	void show(int x,int y){	
		System.out.println("Hello by calling double arguments");
	}
	void show(int  x, char  y, long  L){    // method calling by different data types
		System.out.println("Hello by calling tripple arguments");
	}
	
	public static void main(String args[]) {
                FunctionOverloading fl = new FunctionOverloading();
		fl.show(10);  // method calling via an argument
		fl.show(10,10);  //method calling via double arguments
		fl.show(10,'A',100L);
	}    // end of main ()
}   // end of class

Output

javac FunctionOverloading.java   // for compilaton
Java FunctionOverloading              // To run   
Hello by calling single arguments 
Hello by calling double arguments
Hello by calling triple arguments

Via changing the data type of their arguments to achieve Function Overloading

//save as: FunctionOverloading1.java
class FunctionOverloading1{  
	void show(){
		System.out.println("hello");
	}
	void show(int  x){
		System.out.println("hello integer");
	}
	void show(long  x){	
		System.out.println("Hello by long");
	}
	void show(char  x){
		System.out.println("Hello by Character");
	}
	
	public static void main(String args[])
	{
		FunctionOverloading1 fl = new FunctionOverloading1();
		fl.show(10);
		fl.show(10L);
		fl.show('z');
		
	}
}

Output

javac FunctionOverloading1.java
java FunctionOverloading1
Hello by long
Hello Integer
Hello by character

Scenario of why ” this”

Case 0:

//save as: This.java
class This{
	int x=10;
	void show(int y){
		System.out.println(x);
		System.out.println(y);
	}
	public static void main(String arguments[]){
		This t= new This();
		t.show(20);
	}
}

/*Output:
                Javac This.java
                Java This

                10
                20
*/

Case 1:

//save as: This1.java
class This1{
	int x=10;
	void show(int x){
		System.out.println(x);
		System.out.println(x);
	}
	public static void main(String arguments[]){
		This1 t= new This1();
		t.show(20);
	}
}
/*note: priority always goes to local variables.
Output:
               
              Javac This1.java
              Java This1
              20
              20

*/

Case 2:

//save as: This2.java
class This2{
	int x=10;
	
	void show(int x,This2  z){
		System.out.println(x);
		System.out.println(z.x);
	}
	public static void main(String arguments[]){
		This2 t= new This2();
		t.show(20,t);
		System.out.println(t.x);
	}
}
/*
Output:
              javac This2.java
              java This2                                   
              20
              10
              10
*/

Case 3:

//save as: This3.java
class This3{
	int x=10;
        // "this is the feature of oops not java"
	void show(This3 this, int y){
        // "this" is always used to refer  current object which is   being used not creating or created.    
		System.out.println(this.x);    
		System.out.println(y);
	}
	public static void main(String arguments[]){
		This3 t= new This3();
		t.show(20);
	}
}

/*
Output:
               javac This3.java
               javac This3
               10
               20

*/

Case 4:

This example proved that if you add “this” or remove “this”, does not matter at all because JVM implicitly add “this”, hence no error occurs.

 //save as: This4.java
     class This4{
	int x=10;
        // (This this, int y ) by default will be added by JVM
	void show(int y){    
		System.out.println(this.x);
		
		System.out.println(y);
	}
	public static void main(String arguments[]){
		This4 t= new This4();
		t.show(20);
	}
}

Output

javac This4.java 
java This4
10
20

'this' is a special keyword which refers to the current object means an object which is being used to access the data or call the method

Constructor in Java

A Java constructor is a special method that is called when an object is instantiated. In other words, when you use the new keyword. The purpose of a Java constructor is to initialize the newly created object before it is used.

  • Constructor as class name
  • It does not have any return type
  • Cannot be called explicitly

Case 0:

//save as: Employee.java
class Employee{
	int salary;
	Employee()  {  //Constructor
		salary =15000;
	        System.out.println(salary);
        }
	public static void main(String arguments[]){
              // Anonymous object creation
	      new Employee();  //”new” operator is used to allocate new memory in heap area   
                                           
	}
}

Output

javac Employee.java
java Employee
15000

In java, every class has a constructor by default which is known as default constructor. A constructor with no parameter known as a non-parameterized constructor, if you don’t write a constructor explicitly then a default constructor will automatically added in a class by JVM.

Case 1:

// save as: Constructor.java
class Constructor{
	int salary;
	Constructor(){
		this.salary=15000;
		System.out.println(salary);	
	}
	public static void main(String argument[]){
		new Constructor();   //constructor will run before anonymous object executed
		new Constructor();  //constructor will run before anonymous object executed
	}
}
/*
Output:
              javac  Constructor.java         
              java  Constructor              
              15000 
              15000

*/

Case 2: When to use default constructor

//save as Temp.java
class Temp{
	int x;             
	int y;
	Temp(){     // default constructor
		x=10;
		y=20;
	}
	void show(){
		System.out.println(x);
		System.out.println(y);
	}
	public static void main(String...s){
		Temp t= new Temp();   // object creation
		t.show();
		Temp t1=new Temp();
		t1.show();
		
	}
}
/*
Output:
             Javac Temp.java
             Java Temp
             10
             20
             10
             20
*/

Case 3: Parameterized Constructor

Whenever you want to initialize data members for each object with a different value then always use parameterize constructor.

//save as Temp1.java
class Temp1{
	int x;  // instance variable
	int y;
	Temp1(int x,int y){   // Parameterised Constructor
		this.x=x;
		this.y=y;
	}
	void show(){
		System.out.pritnln(x);
		System.out.println(y);
	}
	public static void main(String args[]) {
		new Temp1(10,20);    // passing the argument of int type
	}
}

/*
Output: 
            Javac Temp1.java
            Java Temp1
            10
            20
*/

Init Block

Init block is always executed before any constructor whenever that constructor is used for creating a new object. Instance Initialization Blocks or IIB are used to initialize instance variables.

//save as InitBlock.java
class InitBlock{
	{    // opening of init_Block
            System.out.println("Hello, Rstians! i am init Block");
	}   // end of init_Block
            InitBlock()  {      // constructor
		System.out.println("default constructor");
	}
	public static void main(String args[]){
		new InitBlock();  // Anonymous object
	}
}
/*
Output: 
            Javac InitBlock.java
            Java InitBlock

            Hello, Rstians! i am init Block
            default constructor
*/

Static Block

A static block is used for initializing the static variables. This block gets executed when the class is loaded in the memory. A class can have multiple Static blocks, which will execute in the same sequence in which they have been written into the program.

//save as StaticBlock.java
class StaticBlock{
        static String countryName;     
       // this block will always executed whether constructor runs or not
        static{
		countryName = "INDIA";
	}
	static{
		System.out.println("hello i'm static block from "+countryName   ); 
	}
	public static void main(String ...s){
		new StaticBlock();
	}
  }

Output

javac StaticBlock.java
java StaticBlock
hello i'm static block from INDIA

Inheritance in Java

Inheritance in Java is a mechanism in which one object acquires all the data members and methods of a parent class object. Inheritance is a concept that is used to reusability among the objects. When you inherit from an existing class, you can reuse methods and fields of the parent class. It is used to achieve dynamic binding, by default all the data members and member function of a parent class are available to child class if they are not private.

Case 0:

//save as Child.java
class Base{
	int x; int y;
	void show(){
		System.out.println(x);
		System.out.println(y);
	}
}
class Child extends Base {     //"extends" is a keyword to make Is a relationship b/w objects
	void get(int x,int y){ 
		this.x=x;
		this.y=y;
	}
	public static void main(String ...s){
		Child c1=new Child();
		c1.get(10,20);   // passing the int  parameter 
		c1.show();
	}
}

/*
Output:
             javac Child.java
             java Child
             10
             20
*/

Case 1: For private data member

//save as Child1.java
class Base{
	private int x=20;
	void show(){
		System.out.println(x);
	}
}
class Child1 extends Base{      // ‘extends’ keyword to make connection between two objects
	public static void main(String...s){
		Child1 c1=new Child1();
               // System.out.println(c1.x); 
		c1.show();
	}
}

/*
Output:
             javac Child1.java
             java Child1
             10
             20
*/

Case 2: Data Hiding:

//save as Child2.java
class Parent{
	int x=50;   // instance variable of Parent
}
class Child2 extends Base{
	int x=20;     // instance variable of Child2
	void show(){
              System.out.println(x);
              // System.out.println( super.x );  // ‘super’ keyword used to access parent data member
       }
	public static void main(String...s){
		Child2 c1=new Child2();
		c1.show();
	}
}
/*
Output:
             javac Child2.java
             java Child2
             20

*/

Case 3: Multilevel Inheritance:

//save as
class Base extends Dadaji{
	int x=50;
}
class Dadaji{
	int x=70;
}
class Child3 extends Base{
	int x=20;
	//int y=20;
	void show(){
              int x = 10;
              System.out.println(x);    // priority always goes to local variable 
              System.out.println(this.x);
	      System.out.println(super.x); // 'super' used to access parent class data member
	      System.out.println(((Dadaji)this).x); // accessing to parent to parent class data member
	}
	public static void main(String...s){
		Child3 c1=new Child3();
		c1.show();
	}
}

/*
Output:
             javac Child3.java
             java Child3
             10
             20
             50
             70

*/

Case 4: Function Inheritance

// save as Child.java
class Base{
	void show(){
		System.out.println("Base");
	}
}
class Child extends Base{
	void show(){
		System.out.println("Child");
		super.show();    // to call parent class method
	}
	public static void main(String ...s){
		Child c=new Child();
		c.show();
	}
}
/*
Output:
F:\coreJAVA\Inheritance\member function inheritance>javac Child.java
F:\coreJAVA\Inheritance\member function inheritance>java Child
Child
Base
*/

Case 5: Function Overriding via different return type

//save as Child2.java
class Base{
	A show( ){
		System.out.println("Base");
		return new A( );
	}
}
class Child2 extends Base{
	B show( ){
		System.out.println("Child");
		super.show( );
		return new B( );
	}
	public static void main(String ...s){
		Child2 c=new Child2( );
		c.show( );
	}
}
class A{ 
}
class B extends A{ 
}

Output

javac Child2.java
java Child2
Child
Base

Case 6: Upcasting in java

//save as Child5.java
/*
Keeping the reference id of child class into the reference variable of parent class
*/
class Base{
	void show( ){
		System.out.println("Base");
	}
}
class Child5 extends Base{
	void show( ){
		System.out.println("Child");
	}
	public static void main(String ...s){      // another way of writing main() method
		Base c=new Child5( );    // upcasting
		c.show( );
	}
}

Output

javac Child5.java
java Child5
Child

Constructor Inheritance in Java

Case 0: Default Constructor

// save as C.java
class A{
	A( ){
	        // super(); by default
                System.out.println("A");
	}
}
class B extends A{
                 B( ){
                 // super(); by default
	         System.out.println("B");
	}
}
class C extends B{
    	 C( ){
	         // super(); by default
                 System.out.println("C");
	}
	public static void main(String arguments[]){
	          new C( );	
	}
}

Output

Javac C.java
java C
A
B
C

Case 1: Parameterized Constructor

//save as C1.java
class A{
	A(){
		System.out.println("A");
	}
}
class B extends A{
	B(int x){
		super();
		System.out.println("default");
	}
	B(){
		super();
		System.out.println("B");
	}
}
class C1 extends B{
	C1(){
		super(10);
		System.out.println("C");
	}
	C1(int x){
		super();
		System.out.println(x);
	}
	public static void main(String arguments[]){
		new C1();
		new C1(20);
		
	}
}

Output

Javac C1.java
java C1
A
Default
C
A
B
20

Abstraction in Java

An abstract class is a class that is declared abstract—it may or may not include abstract methods. Abstract classes cannot be instantiated, but they can be subclassed. An abstract method is a method that is declared without an implementation (without braces, and followed by a semicolon), like this:

public abstract class GraphicObject {
   // declare fields
   // declare non abstract methods
   abstract void draw(); // abstract method
}

Case 0: For instance

//save as Child .java
/*
‘abstract’ is a keyword to declare abstract classes, methods as abstract
*/
abstract class Base{   
	int x;
	int y;
	void show(){
		System.out.println(x);
		System.out.println(y);
	}
	abstract int add(int x, int y);
}
class Child extends Base {
	int add(int x, int y){
		return x+y;
	}
	public static void main(String args[]){
		Child c1=new Child();
		int res = c1.add(10,20);
		System.out.println(res);
		c1.show();
	}
}

Output

javac Child.java
java Child
30
0
0

Case 1: Practice Question

//save as Child1 .java
abstract class Base{    // abstract class
	int x;
	int y;
	void show(){
		System.out.println(x);
		System.out.println(y);
	}
	abstract void display();   // abstract method
}
class Child1 extends Base {
	void get(int x, int y){
		this.x=x;
		this.y=y;
	}
	void display(){
		System.out.println("display");
	}
	public static void main(String args[]){
		Child1 c1=new Child1();
		c1.get(10,20);
		c1.show();
		c1.display();
	}
}
/*
kam kisi aur ka, karna kisi aur ko 
*/

Case 2: Process of Registration

In case of registration, a child class has to register itself with parent class by passing its reference to a parent class.

//save as Child2 .java
abstract class Base{
	int x;
	int y;
	abstract void display();
	void registration(Base b){     // resistration method
		System.out.println("Jake display method ko chala na");
		b.display();
	}
}
class Child2 extends Base {
	void display(){
		System.out.println("Display");
	}
	public static void main(String args[]){
		Base c1=new Child2();    // upcasting
		c1.registration(c1);         // doing restration
	}
}

Output

javac Child2.java
java Child2
Jake display method ko chala na
Display

Interface in Java

Interfaces are the contract between a java programmer and a java programming language. it is implicitly abstract so that it cannot be instantiated.

Case 0: Creation of Interface

//save as Child.java
interface My{ // ‘interface’ is keyword to make interface
	void show();
}
class Child implements My{ // ‘implements’ is keyword to use or implement interface
	public void show(){
		System.out.println("show");
	}
	public static void main(String args[]){
		Child c1=new Child();
		Temp t=new Temp();  
		t.register(c1);// doing registration with interface My
	}
}
class Temp{
	public void register(My m){
		m.show();// calling show method 
	}
}

Output

Javac Child.java
java Child
show

Case 1: Child class can implements more than one interface simultaneously

//save as Child2 .java
interface My{    
	void show();
}
interface My1{
	void display();
}
class Child2 implements My,My1 {         // implementing more than one interface
	public void show(){
		System.out.println("show");
	}
	public void display(){
		System.out.println("display");
	}
	public static void main(String args[]){
		My m=new Child2();            // upcasting
		m.show();
		My1 m1=new Child2();     // upcasting
		m1.display();
		
	}
}

/*
Output:
            F:\coreJAVA\7Interface>javac Child2.java
            F:\coreJAVA\7Interface>java Child2
            show
            display

*/

Case 2: If child class is getting the same default method from more than one then it has to override that method otherwise it’s a compilation error.

//save as Child5 .java
interface My{    
	public default void show(){
		System.out.println("My");
	}
} 
interface My1{
	public default void show(){
		System.out.println("My1");
	}
}
class Child5 implements My,My1{      // implementing more than one interface      
	public void show(){
		System.out.println("Child");
	}
	public static void main(String args[]){
		My m=new Child5 ();
		m.show();
		My1 m1=new Child5 ();
		m1.show ();
		
	}
}

Case 3: Static method of an interface inherited in child class can only be access via interface name.

//save as Child6 .java
interface My{
	public static void show() {  // show 
		System.out.println("My");
	}
}
class Child6 implements My{
	public static void main(String ...s){
		My.show();   // My is a variable of  type interface 
	}
}
/*
Output:
            F:\coreJAVA\7Interface>javac Child6.java
            F:\coreJAVA\7Interface>java Child6
            My

*/

Aggregation in Java

Aggregation is a ‘has-a’ relationship whereas Inheritance is a ‘is-a’ relationship.

//save as Emp.java
class Address{
	String city;
	String state;
	String country;
	public Address(String city, String state, String country){
		this.city = city;
		this.state = state;
		this.country = country;
	}
}
public class Emp{
	int id;
	String name;
	Address address;
	public Emp(int id, String name,Address address){
		this.id = id;
		this.name = name;
		this.address=address;
	}
	void display(){
		System.out.println(id+" "+name);
		System.out.println(address.city+" "+address.state+" "+address.country);
	}
	public static void main(String[] args) {
		Address address1=new Address("New delhi","Delhi","india");
		Address address2=new Address("gno","UP","india");
		Emp e=new Emp(111,"VIVEK",address1);
		Emp e2=new Emp(112,"arun",address2);
		e.display();
		e2.display();
    }
}

Output

javac Emp.java
java Emp
111 VIVEK
New delhi Delhi indi
112 arun
gno UP india