Transcript Notes

Encapsulation,
Inheritance & Interfaces
CSE 115
Spring 2006
February 27, March 1 & 3, 2006
Three Pillars of Object-Oriented
Programming
 Encapsulation
 Inheritance
 Polymorphism
Encapsulation
Keeping data and operations that work on
that data in one computational unit
 “public face” versus “private
implementation”

Inheritance (from before exam)

Ability to extend another class and inherit
all its public capabilities.
Inheritance
Every class in Java uses inheritance.
 Either specify a specific superclass by
using the keyword extends when defining
the class.
 Use default superclass, which is
java.lang.Object

One superclass

In Java, a class can extend one class (ie –
only one class name can appear after the
keyword extends in a class definition)

However, if the class that is extended has
a superclass, the new subclass inherits
from both its direct superclass as well as
that class’ superclass.
Method Overriding

Defining a method in a subclass that has
the same signature as one in the
superclass.

Can:



Call the superclass’ method
Add on to the superclass’ method
Completely redefine the method.
Interface
Contract (of methods)
 If a class chooses to enter into the
agreement with the interface, the class
promises to have methods with the same
signatures as those in the interface.

Interfaces
Are NOT classes
 But they are types (just like classes are).
So, they can be the type of




Variables (local or instance)
Return types
Formal Parameters
Defining an Interface
No instance variables allowed.
 Everything is public.
 No implementation of methods, just
method signatures followed by ;


These types of methods are called abstract
methods because they have no method bodies.
The keyword abstract might be seen in the
method signatures of methods in an interface
Java Code: Interfaces
public interface InterfaceName {
public abstract void method1();
abstract public Object method2();
void method3(Object obj);
//Note that all three method signatures are valid for an
//interface and which you use is a matter of style.
}
Implementing an Interface
A class realizes an interface using the
keyword implements.
 The formal name for this relationship is
realization and the informal name is
“implements” or “implements an interface”
 Inside the code, the class must create
methods with the same signatures as
those in the interface and give each
method a method body.

Java Code: Implementing an Interface
public class name implements InterfaceName {
public void method1() { }
public Object method2() { return new Object(); }
public void method3(Object obj) { }
//Note that each method must have a method body, but
//that method body could be empty.
}
Interface Facts
We can implement more than one interface.
 We can have a superclass and implement
one or more interfaces.
 An interface can extend another interface or
multiple other interfaces.
 You can NEVER create an instance of an
interface.

Inheritance Recap

The next set of slides presents a recap of
all the topics we have discussed with
inheritance.
ClassA extends ClassB

ClassA now inherits (can access and use)
all public and protected elements of
ClassB

We can expect the behavior from the
subclass that the superclass had.
ClassA extends ClassB

When the constructor from ClassA is
called, it automatically calls the noargument constructor for ClassB. If
ClassB does not have a no-argument
constructor, ClassA must explicitly call
one of the other constructors from
ClassB using the keyword super.
ClassA extends ClassB

A subclass is the specialization of the
superclass, so we can add instance
variables, add methods, change
parameters on methods, or change the
way methods behave.
ClassA extends ClassB

When we have a method that has the
same signature in a subclass as one in the
superclass, we have method overriding.
Method overriding is how we change the
behaviors of methods in a subclass.
Inheritance

Looking at inheritance in reverse – if we
have a lot of commonality amongst some
classes, we can create one superclass to
generalize amongst the subclasses.

Ex) Got a lot of classes that do the same
thing?

Create a common superclass!
What’s the difference?
Method overloading
 Method inheritance
 Method overriding
