Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                
Scribd
Upload
197 views

Java LAB 8

The document discusses inheritance in object-oriented programming. It defines inheritance as deriving a new class from an existing class, called the base or superclass. The derived class, or subclass, inherits all public and protected members of the superclass. The document provides examples of defining subclasses that inherit from superclasses, calling superclass constructors from subclasses using the super keyword, and hiding superclass members in subclasses. It also outlines two lab tasks - one to create a university course registration system with Student, Teacher, and Course classes, and another to define computer classes with processor subclasses.

Uploaded by

Ramsha Mahar
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
197 views

Java LAB 8

The document discusses inheritance in object-oriented programming. It defines inheritance as deriving a new class from an existing class, called the base or superclass. The derived class, or subclass, inherits all public and protected members of the superclass. The document provides examples of defining subclasses that inherit from superclasses, calling superclass constructors from subclasses using the super keyword, and hiding superclass members in subclasses. It also outlines two lab tasks - one to create a university course registration system with Student, Teacher, and Course classes, and another to define computer classes with processor subclasses.

Uploaded by

Ramsha Mahar
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 6

Inheritance Lab # 8

LAB # 8

INHERITANCE

OBJECTIVE:
To study inheritance and using super to call superclass constructors.

THEORY:

8.1 USING EXISTING CLASSES


Defining a new class based on an existing class is called derivation. The new
class, or derived class, is referred to as a direct subclass of the class from
which it is derived. The original class is called a base class because it forms
the base for the definition of the derived class. The original class is also
referred to as a superclass of the derived class. You can also derive a new
class from a derived class, which in turn was derived from some other derived
class, and so on. This is illustrated in Figure.

8.2 CLASS INHERITANCE

In summary, when you derive a new class from a base class, the process is
additive in terms of what makes up a class definition. The additional members

Object Oriented Programming - OOPs 1


Inheritance Lab # 8

that you define in the new class establish what makes a derived class object
different from a base class object. Any members that you define in the new
class are in addition to those that are already members of the base class.
The inclusion of members of a base class in a derived class so that they are
accessible in that derived class is called class inheritance. An inherited
member of a base class is one that is accessible within the derived class. If a
base class member is not accessible in a derived class, then it is not an
inherited member of the derived class, but base class members that are not
inherited still form part of a derived class object.

Inheriting Data Members:


Figure shows which access attributes permit a class member to be inherited
in a subclass. It shows what happens when the subclass is defined in either
the same package or a different package from that containing the base class.
Remember that inheritance implies accessibility of the member in a derived
class, not just presence.

Inheritance Basics:

To inherit a class, you simply incorporate the definition of one class into
another by using the extends keyword. To see how, let’s begin with a short
example. The following program creates a superclass called A and a subclass
called B. Notice how the keyword extends is used to create a subclass of A.

// A simple example of inheritance.


// Create a superclass.
class A
{
int i, j;
void showij()
{
System.out.println("i and j: " + i + " " + j);
}
}

Object Oriented Programming - OOPs 2


Inheritance Lab # 8

// Create a subclass by extending class A.


class B extends A
{
int k;
void showk()
{
System.out.println("k: " + k);
}
void sum()
{
System.out.println("i+j+k: " + (i+j+k));
}
}

class SimpleInheritance
{
public static void main(String args[])
{
A superOb = new A();
B subOb = new B();
// The superclass may be used by itself.
superOb.i = 10;
superOb.j = 20;
System.out.println("Contents of superOb: ");
superOb.showij();
System.out.println();
/* The subclass has access to all public members of
its superclass. */
subOb.i = 7;
subOb.j = 8;
subOb.k = 9;
System.out.println("Contents of subOb: ");
subOb.showij();
subOb.showk();
System.out.println();
System.out.println("Sum of i, j and k in subOb:");
subOb.sum();
}
}

Output:

Object Oriented Programming - OOPs 3


Inheritance Lab # 8

8.3 CALLING THE BASE CLASS CONSTRUCTOR


Using super:
super has two general forms. The first calls the superclass’ constructor. The
second is used to access a member of the superclass that has been hidden
by a member of a subclass.

Using super to Call Superclass Constructors

A subclass can call a constructor method defined by its superclass by use of


the following form of super:

super(parameter-list);

Here, parameter-list specifies any parameters needed by the constructor in


the superclass. super( ) must always be the first statement executed inside a
subclass’ constructor.

class Box {
private double width;
private double height;
private double depth;
// construct clone of an object
Box(Box ob) { // pass object to constructor
width = ob.width;
height = ob.height;
depth = ob.depth;
}

// constructor used when all dimensions specified


Box(double w, double h, double d) {
width = w;
height = h;
depth = d;
}

// compute and return volume

Object Oriented Programming - OOPs 4


Inheritance Lab # 8

double volume() {
return width * height * depth;
}
}

// BoxWeight now fully implements all constructors.


class BoxWeight extends Box {
double weight; // weight of box
// construct clone of an object
BoxWeight(BoxWeight ob) { // pass object to constructor
super(ob);
weight = ob.weight;
}
// constructor when all parameters are specified
BoxWeight(double w, double h, double d, double m) {
super(w, h, d); // call superclass constructor
weight = m;
}
}

class DemoSuper {
public static void main(String args[]) {
BoxWeight mybox1 = new BoxWeight(10, 20, 15, 34.3);
BoxWeight myclone = new BoxWeight(mybox1);
double vol;

vol = mybox1.volume();
System.out.println("Volume of mybox1 is " + vol);
System.out.println("Weight of mybox1 is " + mybox1.weight);
System.out.println();

vol = myclone.volume();
System.out.println("Volume of myclone is " + vol);
System.out.println("Weight of myclone is " + myclone.weight);
System.out.println();
}
}

Output:

Object Oriented Programming - OOPs 5


Inheritance Lab # 8

LAB TASK

1. Develop a registration system for a University. It should consist of


three classes namely Student, Teacher, and Course. For example, a
student needs to have a name, roll number, address and GPA to be
eligible for registration. Therefore choose appropriate data types for
encapsulating these properties in a Student objects. Similarly a
teacher needs to have name, address, telephone number, and a
degree (or a list of degrees) he/she has received. Finally courses must
have a name, students (5 students) registered for the course, and a
teacher assigned to conduct the course. Create an object of Course
with 5 Students and a Teacher. A call to a method, say printDetails(), of
the selected course reference should print name of the course, details
of the teacher assigned to that course, and names and roll numbers of
the students enrolled with the course.

2. Create a class called computers and two classes MyComputer and


YourComputer which inherits computer class. Define appropriate
features of their processor in the classes. Create another class
processor as a composite class of computer. Write a method which
prints the differences between the processors of two computers.
Example:
single core:
bandwidth = 125GByte/s
speed = slow
processing = sequentially

Object Oriented Programming - OOPs 6

You might also like