OOPl Core Principles of OOP Lesson002
OOPl Core Principles of OOP Lesson002
Inheritance
class base
{
.....
.....
}
class derive extends base
{
.....
..
...
}
Single inheritance- One class inherits from another
class Teacher {
void teach() {
System.out.println("Teaching subjects");
void listen() {
System.out.println("Listening to teacher");
}
class CheckForInheritance {
output
Teaching subjects
Listening to teacher
Student is the child (subclass) that extends Teacher and adds its own method
listen().
In this type of inheritance, a derived class gets created from another derived
class and can have any number of levels.
class Teacher {
void teach() {
System.out.println("Teaching subject");
}
}
class CheckForInheritance {
public static void main(String[] argu) {
HomeTution h = new HomeTution
h.explains(); // Output: Does homework
h.teach(); // Inherited from Teacher
h.listen(); // Inherited from Student
}
}
Output
Does homework
Teaching subject
Listening
In this type of inheritance, there are more than 1 derived classes which get
created from one single base class.
class Teacher {
void teach() {
System.out.println("Teaching subject");
void listen() {
System.out.println("Listening");
void evaluate() {
System.out.println("Evaluating");
}
class CheckForInheritance {
Output
Evaluating
Teaching subject
Here ;Teacher is the base class.Student and Principal both inherit from
Teacher.
Let us imagine a situation where there are three classes: A, B and C. The C
class inherits A and B classes. In case, class A and class B have a method
with same name and type and as a programmer, you have to call that method
from child class's (C) object, there will be ambiguity as which method will
be called either of A or of B class.
So Java reduces this hectic situation by the use of interfaces which
implements this concept and reduce this problem; as compile-time errors are
tolerable than runtime faults in the program.
Encapsulation
Encapsulation is one of the four fundamental OOP concepts. The other three are
inheritance, polymorphism, and abstraction. Encapsulation in Java is a
mechanism of wrapping the data variables and code acting on the data
methods together as a single unit. In encapsulation the variables of a class will be
hidden from other classes, and can be accessed only through the methods of their
current class, therefore it is also known as data hiding. To achieve encapsulation in
Java Declare the variables of a class as private. Provide public setter and getter
methods to modify and view the variables values.
Example: Below given is an example that demonstrates how to achieve
Encapsulation in Java:
public class EncapTest{
// Step 1: Data Hiding
private String name;
private String idNum;
private int age;
// Step 2: Public Getters - Controlled access
public int getAge(){
return age;
}
public String getName(){
return name;
}
public String getIdNum(){
return idNum;
}
// Step 3: Public Setters - Controlled modification
public void setAge( int newAge){
age = newAge;
}
public void setName(String newName){
name = newName;
}
public void setIdNum( String newId){
idNum = newId;
}
}
The public setXXX and getXXX methods are the access points of the instance
variables of the EncapTest class. Normally, these methods are referred as getters
and setters. Therefore, any class that wants to access the variables should access
them through these getters and setters.
The variables of the EncapTest class can be accessed as below:
public class RunEncap{
public static void main(String args[]){
EncapTest encap = new EncapTest();
encap.setName("James");
encap.setAge(20);
encap.setIdNum("12343ms");
System.out.print("Name : " + encap.getName() + " Age : " + encap.getAge());
}
}
Output
Name : James Age : 20
Benefits of Encapsulation:
The fields of a class can be made read-only or write-only. A class can have total
control over what is stored in its fields. The users of a class do not know how the
class stores its data. A class can change the data type of a field and users of the
class do not need to change any of their code.