Inheritance in java computer programming app

• Inheritance in Java is a mechanism in which one object acquires all the properties and behaviors of a parent object.
It is an important part of OOPs (Object Oriented programming system).
used in Inheritance:
• Class: A class is a group of objects which have common properties. It is a template or blueprint from
which objects are created.
• Sub Class/Child Class: Subclass is a class which inherits the other class. It is also called a derived
class, extended class, or child class.
• Super Class/Parent Class: Superclass is the class from where a subclass inherits the features. It is also
called a base class or a parent class.
• Reusability: As the name specifies, reusability is a mechanism which facilitates you to reuse the fields
and methods of the existing class when you create a new class.
The syntax of Java Inheritance
class Subclass-name extends Superclass-name
{
//methods and fields
}

Single Inheritance Example
TestInheritance.java
class Animal{
void eat(){System.out.println("eating...");}
}
class Dog extends Animal{
void bark(){System.out.println("barking...");}
}
class TestInheritance{
public static void main(String args[]){
Dog d=new Dog();
d.bark();
d.eat();
}}
Output:
barking... eating.

Multilevel Inheritance
File: TestInheritance2.java
class Animal{
}
}
class BabyDog extends Dog{
void weep(){System.out.println("weeping...");}
}
class TestInheritance2{
BabyDog d=new BabyDog();
d.weep();
d.bark();
d.eat();
}}
Output:
• weeping... barking... eating...

Hierarchical Inheritance
class Animal{
}
}
class Cat extends Animal{
void meow(){System.out.println("meowing...");}
}
class TestInheritance3{
Cat c=new Cat();
c.meow();
c.eat();
//c.bark();//C.T.Error
}}
Output:
meowing... eating..

#include <iostream>
using namespace std;
// Base class 1
class Base1
{
public:
void show() {
cout << "Base1::show()" << endl;
}
};
// Base class 2
class Base2
{
public:
void display()
{ cout << "Base2::display()" << endl;
}};
// Derived class
class Derived : public Base1, public Base2
{
};
int main()
{
Derived d;
d.show(); // Access method from Base1
d.display(); // Access method from Base2
return 0;
}

// Class 3
// Trying to be child of both the classes
class Test extends Parent1,Parent2 {
// Main driver method
public static void main(String args[]) {
// Creating object of class in main() method
Test t = new Test();
// Trying to call above functions of class
where
// Error is thrown as this class is inheriting
// multiple classes
t.fun();
}
}
import java.io.*;
class Parent1 {
void fun() {
System.out.println("Parent1");
}
}
class Parent2 {
void fun() {
// Print statement if this method is called
System.out.println("Parent2");
}
}
Java doesn’t support Multiple Inheritance

Java Polymorphism
1. Method Overloading
2. Method Overriding
• If a class has multiple methods having same name but different in
parameters, it is known as Method Overloading.
There are two ways to overload the method in java
• By changing number of arguments
• By changing the data type

Method Overloading: changing no. of arguments
class Adder
{
static int add(int a,int b){return a+b;}
static int add(int a,int b,int c){return a+b+c;}
}
class TestOverloading1
{
public static void main(String[] args)
{
System.out.println(Adder.add(11,11));
System.out.println(Adder.add(11,11,11));
}
}
Output:
• 22
• 33

Method Overloading: changing data type of arguments
class Adder
{
static int add(int a, int b){return a+b;}
static double add(double a, double b){return a+b;}
}
class TestOverloading2
{
public static void main(String[] args)
{
System.out.println(Adder.add(11,11));
System.out.println(Adder.add(12.3,12.6));
}}
Output:
22 24.9

Method Overriding
If subclass (child class) has the same method as declared in the parent
class, it is known as method overriding .
Usage of Method Overriding:
• Method overriding is used to provide the specific implementation of a
method which is already provided by its superclass.
• Method overriding is used for runtime polymorphism.
Rules for Java Method Overriding
• The method must have the same name as in the parent class
• The method must have the same parameter as in the parent class.
• There must be an IS-A relationship (inheritance).

class Vehicle
{
//defining a method
void run(){System.out.println("Vehicle is running");}
}
//Creating a child class
class Bike2 extends Vehicle
{
//defining the same method as in the parent class
void run(){System.out.println("Bike is running safely");
}
public static void main(String args[])
{
Bike2 obj = new Bike2();//creating object
obj.run();//calling method
}
}
Output:
Bike is running safely

class Bank{
int getRateOfInterest(){return 0;}
}
class SBI extends Bank{
}
class ICICI extends Bank{
}
class AXIS extends Bank{
}
class Test2{
SBI s=new SBI();
ICICI i=new ICICI();
AXIS a=new AXIS();
System.out.println("SBI Rate of Interest: "+s.getRateOfInterest());
System.out.println("ICICI Rate of Interest: "+i.getRateOfInterest());
System.out.println("AXIS Rate of Interest: "+a.getRateOfInterest());
}
}
• Output: SBI Rate of Interest: 8 ICICI Rate of Interest: 7 AXIS Rate of Interest: 9

Encapsulation in Java
• Encapsulation in Java is a process of wrapping code and data
together into a single unit, for example, a capsule which is mixed of
several medicines.
• We can create a fully encapsulated class in Java by making all the data
members of the class private. Now we can use setter and getter
methods to set and get the data in it.
• The Java Bean class is the example of a fully encapsulated class.

Advantage of Encapsulation:
• By providing only a setter or getter method, you can make the class read-only or
write-only.
• It provides you the control over the data. Suppose you want to set the value of id
which should be greater than 100 only, you can write the logic inside the setter
method. You can write the logic not to store the negative numbers in the setter
methods.
• It is a way to achieve data hiding in Java because other class will not be able to
access the data through the private data members.
• The encapsulate class is easy to test. So, it is better for unit testing.
• The standard IDE's (integrated development environment) are providing the facility
to generate the getters and setters. So, it is easy and fast to create an encapsulated
class in Java.

// set method for age to access
// private variable geekage
public void setAge(int newAge)
{ geekAge = newAge; }
// set method for name to access
// private variable geekName
public void setName(String newName)
{
geekName = newName;
}
// set method for roll to access
// private variable geekRoll
public void setRoll(int newRoll)
{ geekRoll = newRoll; }
}
class Encapsulate {
// private variables declared
// these can only be accessed by
// public methods of class
private String geekName;
private int geekRoll;
private int geekAge;
// get method for age to access
// private variable geekAge
public int getAge() { return geekAge; }
// get method for name to access
// private variable geekName
public String getName() { return geekName; }
// get method for roll to access
// private variable geekRoll
public int getRoll() { return geekRoll; }

// Class to access variables
// of the class Encapsulate
public class Test {
public static void main(String[]
args)
{
Encapsulate obj = new
Encapsulate();
// setting values of the variables
obj.setName("Harsh");
obj.setAge(19);
obj.setRoll(51);
// Displaying values of the variables
System.out.println("Geek's name: " +
obj.getName());
System.out.println("Geek's age: " +
obj.getAge());
System.out.println("Geek's roll: " +
obj.getRoll());
// Direct access of geekRoll is not possible
// due to encapsulation
// System.out.println("Geek's roll:
" +
// obj.geekName);
}
}

Package
• A java package is a group of similar types of classes, interfaces and sub-packages.
• Package in java can be categorized in two form, built-in package and user-defined
package.
• There are many built-in packages such as java, lang, awt, javax, swing, net, io, util, sql etc.
Advantage of Java Package
1) Java package is used to categorize the classes and interfaces so that they can be easily
maintained.
2) Java package provides access protection.
3) Java package removes naming collision.

//save as Simple.java
package mypack;
public class Simple{
System.out.println("Welcome to package");
}
}
Create the folder mypack
Inside mypack save the program file: File name is Simple

To access package from another package
There are three ways to access the package from outside the package.
• import package.*;
• import package.classname;
• fully qualified name.
Using packagename.*
• If you use package.* then all the classes and interfaces of this package
will be accessible but not subpackages.
• The import keyword is used to make the classes and interface of
another package accessible to the current package.

import package.*;
package pack;
public class A
{
public void msg()
{
System.out.println("Hello");
}
}
import pack.*;
class B
{
{
A obj = new A();
obj.msg();
}
}

import package.classname;
package pkg;
public class AA
{
public void msg()
{ System.out.println("Hello")
;
}
}
import pkg.AA;
class BB{
AA obj = new AA();
obj.msg();
}
}

fully qualified name
package pkg1;
public class AAA
{
public void msg()
{
System.out.println("Hello");
}
}
import pkg1.*;
class BBB{
pkg1.AAA obj = new pkg1.AAA();//using
fully qualified name
obj.msg();
}
}

PACKAGE 1:
package student;
public class stud
{
int regno;
String name;
public stud(int r,String n)
{
regno=r;
name=n;
}
public void print()
{
System.out.println("Regino="+regno);
System.out.println("Name="+name);
}
}
package diploma;
public class diplo
{
int regno;
String disp;
String year;
public diplo(String d,String y)
{
disp=d;
year=y;
}
public void print()
{
System.out.println("course="+disp);
System.out.println("year="+year);
}
}
PACKAGE 2:

IMPORT PACKAGE
import student.stud;
import diploma.diplo;
class clg
{
{
stud s=new stud(111,"Anandh");
diplo d=new diplo(“CSE","IIId year");
s.print();
d.print();
}
}

Inheritance in java computer programming app

More Related Content

Similar to Inheritance in java computer programming app (20)

Recently uploaded (20)

Inheritance in java computer programming app