object-oriented design and programming (java)
DESCRIPTION
Object-Oriented Design and Programming (Java). Topics Covered Today. 2.3 Advanced Class Design 2.3.1 Abstract Classes ( 抽象类 ) 2.3.2 Polymorphism ( 多态 ) 2.3.3 Interfaces( 接口 ). Abstract Method. Definition: Methods that do not have implementation (body) - PowerPoint PPT PresentationTRANSCRIPT
Object-Oriented Design and Programming (Java)
2
Topics Covered Today
• 2.3 Advanced Class Design– 2.3.1 Abstract Classes (抽象类 )– 2.3.2 Polymorphism (多态 )– 2.3.3 Interfaces(接口 )
3
Abstract Method
• Definition:– Methods that do not have implementation (body)
• To create an abstract method, just write the method declaration without the body and use the abstract keyword– No { }
• For example, // Note that there is no body public abstract void eat(int amount); public abstract void sleep(int hours);
4
Abstract Class.
• Definition: An abstract class is a class that contains one or more abstract methods– Any class which contains an abstract method must
itself be declared abstract.
• An abstract class is denoted by using the abstract modifier– public abstract class ClassName { . . . }
5
Abstract Class..
• An abstract class cannot instantiated– No instance of an abstract class can be created.
// You will get a compile error on the following codeMyAbstractClass a1 = new MyAbstractClass();
• If a subclass of an abstract class does not
implement all abstract methods inherited from its parent, the subclass must also be defined as abstract.
6
Example
• Consider a chemical company that transports its products in two kinds of containers: wagons and tanks:
7
Class Diagram
+computeVolume() : double
Container
+computeVolume() : double
-width : double
-height : double
-length : double
Wagon
+computeVolume() : double
-radius : double
-length : double
Tank
8
Class Container
public abstract class Container {
/**
* Computes the volume of this container.
* @return the volume of this container.
*/
public abstract double computeVolume();
}
9
Class Wagonpublic class Wagon extends Container {
private double width;private double height;private double length;
public Wagon(double initialWidth, double initialHeight, double initialLength) {
width = initialWidth; height = initialHeight; length = initialLength;
} public double computeVolume() {
return width * height * length; }
}
10
Class Tankpublic class Tank extends Container {
private double radius;
private double length;
public Tank(double initialRadius,
double initialLength) {
radius = initialRadius;
length = initialLength;
}
public double computeVolume() {
return Math.PI * radius * radius * length;
}
}
11
Business System
+getName() : String-name : String
Person
+getAge() : int-age : int
Employee
+getCredit() : double-credit : double
Client
12
Class Person
public abstract class Person {private String name;
public Person(String initialName) {name = initialName;
}
public String getName() { return name; }}
Class can be defined as abstract but it does not contain any abstract methods.
13
Class Employee
public class Employee extends Person {
private int age;
public Employee(String initialName,
int initialAge) {
super(initialName);
age = initialAge;
}
public int getAge() {
return age;
}
}
14
Class Client
public class Client extends Person {
private double credit;
public Client(String initialName,
double initialCredit) {
super(initialName);
credit = initialCredit;
}
public double getCredit() {
return credit;
}
}
15
Using Person 、 Employee & Client
• No instances of class Person can be created because Person is abstract– Person person = new Person();
• Instances of class Employee and Client can be created because they are concrete classes(实体类 )– Employee employee = new Employee("John", 21);– Client client = new Client("Mary", 6000.0);
X
16
When to use Abstract Methods & Abstract Class?
• Abstract methods are usually declared where two or more subclasses are expected to fulfill a similar role in different ways through different implementations
• These subclasses extend the same Abstract class and provide different implementations for the abstract methods
17
Abstract Class Summary
• For some applications we might want a generic base class that we will never instantiate.
• Note that if any method is declared abstract, the class must be declared abstract as well or the compiler will give an error message.
• An abstract class can include concrete methods and fields.• In fact, an abstract class does not need to include any
abstract methods.. • Note that an abstract method has no code body, no braces
{}. • All of the abstract methods must be overridden by
methods in the concrete subclasses.
18
Topics Covered Today
• 2.3 Advanced Class Design– 2.3.1 Abstract Classes (抽象类 )– 2.3.2 Polymorphism (多态 )– 2.3.3 Interfaces(接口 )
19
Upcasting Again
public class CellPhone { CellPhone() { //…} public void ring(Tune t) { t.play(); }}public class Tune { public void play() { System.out.println("Tune.play()"); }}public class ObnoxiousTune extends Tune{ ObnoxiousTune() { // …} // …}
20
An ObnoxiousTune “is-a” Tune
Tune
ObnoxiousTune
A “UML” diagram
public class CellPhoneDemo { public static void main(String[] args) { CellPhone noiseMaker = new CellPhone(); ObnoxiousTune ot = new ObnoxiousTune(); noiseMaker.ring(ot); // ot works though Tune called for }}
21
Aspects of Upcasting
• Upcasting is a cast• The exact type of the object is lost• What gets printed in the CellPhone example?
– Tune.play() (what were you expecting?)
• Is this “the right thing to do”?– The alternative: write separate play() methods for each
subclass of Tune?
22
A little Improvementclass CellPhone { CellPhone() { //…} public void ring(Tune t) { t.play(); }}class Tune { Tune() { //…} public void play() { System.out.println("Tune.play()"); }}class ObnoxiousTune extends Tune{ ObnoxiousTune() { // …} public void play() { System.out.println("ObnoxiousTune.play()"); }}
23
What Gets Printed Now?public class CellPhoneDemo { public static void main(String[] args) { CellPhone noiseMaker = new CellPhone(); ObnoxiousTune ot = new ObnoxiousTune(); noiseMaker.ring(ot); // ot works though Tune called for }}
Tune
+play()
ObnoxiousTune
+play()
24
Polymorphism
• The second example prints ObnoxiousTune.play()– Since an ObnoxiousTune object was sent to ring(),
the ObnoxiousTune’s play() method is called.
• Definition– Through inheritance, a class can be used as more than
one type; it can be used as its own type, any base types, or any interface type if it implements interfaces. This is called polymorphism.
25
Method-Call Binding
• The correct method is attached (“bound”) to the call at runtime.
• The runtime system discovers the type of object sent to ring(), and then selects the appropriate play() method:– if it’s a Tune object, Tune’s play() is called– if it’s an ObnoxiousTune object, ObnoxiousTune’s
play() is called
26
Is Java Always Late-Binding?
• Yes, always, except for final methods.
• final methods can’t be overridden, so the compiler knows to bind it.
• The compiler may be able to do some speed optimizations for a final method.
• In C++, binding is always at compile-time, unless the programmer says otherwise.
27
Another Polymorphism Example
public static void main(String[] args) { CellPhone noiseMaker = new CellPhone(); Tune t; double d = Math.random(); if (d > 0.5) t = new Tune(); else t = new ObnoxiousTune(); noiseMaker.ring(t);}
28
References and Subclasses
• A Tune reference can refer to an ObnoxiousTune object.
• This doesn’t work the other way around: any old Tune may not be an ObnoxiousTune.
• So, an ObnoxiousTune reference cannot refer to a Tune object.
29
Let’s Fool the Compiler!
public static void main(String[] args) { CellPhone noiseMaker = new CellPhone(); Tune t1 = new Tune(); Tune t2 = new ObnoxiousTune(); noiseMaker.ring(t1); noiseMaker.ring((Tune)t2);}
Nothing changes… ObnoxiousTune.play() ObnoxiousTune.play() is still printed.is still printed.
30
Let’s Fool the Compiler!
public static void main(String[] args) { CellPhone noiseMaker = new CellPhone(); Tune t1 = new Tune(); Tune t2 = new ObnoxiousTune(); noiseMaker.ring(t1); noiseMaker.ring((ObnoxiousTune) t2);}
Nothing changes…
31
Let’s Fool the Compiler!
public static void main(String[ ] args) { CellPhone noiseMaker = new CellPhone(); Tune t1 = new Tune(); Tune t2 = new ObnoxiousTune(); noiseMaker.ring((ObnoxiousTune) t1); noiseMaker.ring(t2);}
This compiles, but gets a CastClassExceptionat runtime (even though Tune has a play() method).
“Downcasting” can be dangerous!
32
Class Container
+computeVolume() : double
Container
+computeVolume() : double
-width : double
-height : double
-length : double
Wagon
+computeVolume() : double
-radius : double
-length : double
Tank
33
Polymorphism
• A reference variable can hold a reference to an object of the declared type or any subtype of the declared type (一个引用变量可以引用它所属类型及它的子类的对象 )– Container container;
– container = new Wagon(1, 1, 3);
– container = new Tank(1, 3);
• When a polymorphic method is called, the Java Virtual Machine (JVM) determines which version of the method to execute by examining the reference variable used in the method call.– double volume = container.computeVolume();
34
Exampleimport java.io.*;
public class ContainerDemo {
private static PrintWriter stdOut = new PrintWriter(System.out, true);
public static void main(String[] args) {
Container container;
container = new Wagon(1, 1, 3);
stdOut.println("Volume: " + container.computeVolume());
container = new Tank(1, 3);
stdOut.println("Volume: " + container.computeVolume());
}
}Volume:3.0
Volume:9.4247777
35
Method-Call Binding
• Static binding – The compiler determines which method implementation to use in advance– 编译时就确定了要调用的方法– C++
• Dynamic binding(late binding, virtual binding) – The compiler can't determine which method implementation to use in
advance– The runtime system (JVM) selects the appropriate method at runtime, based
on the class of the object– 在运行阶段才确定要调用的方法– 是实现多态必不可少– JAVA – RTTI
36
Method-Call Binding
• The runtime system discovers the type of object sent to computeVolume():– if it’s a Wagon object, Wagon’s computeVolume() is
called
– if it’s a Tank object, Tank’s computeVolume() is called
37
Topics Covered Today
• 2.3 Advanced Class Design– 2.3.1 Abstract Classes (抽象类 )– 2.3.2 Polymorphism (多态 )– 2.3.3 Interfaces(接口 )
38
Interface
• An interface is collection of constants and abstract methods.
• Syntax:
interface interface_name {
constant -declarations;
abstract methods;
}
39
Example
• All methods in an interface are implicitly public and abstract.
• All data fields in an interface are implicitly public, static, and final.
public interface MyInterface { int CONSTANT = 10; void methodOne(); double methodTwo(); void methodThree(double value); }
40
Technical Details
• Use the interface keyword rather than class. An Interface usually sits in its own .java file.
• Use public or nothing, private and protected aren’t allowed.
• To implement, write a class using the implements keyword.
• Interface methods are always public.• You can inherit from an interface to create a new
interface.• A single class can implement several interfaces
simultaneously (Java’s version of multiple inheritance).
41
Interface Implementationpublic class ClassA implements MyInterface { public void methodOne() { ... }
public double methodTwo() { ... }
public void methodThree(double value) { ... } }
42
A Class Implements an Interface
• When a class implements an interface, it agrees to implement all methods in the interface.
• If the class does not implement all the methods, the class must be defined as abstract.
43
Inherit form an interface
• An interface can extend another interface
public interface MyInterface extends InterfaceOne {
void aMethod();
}
44
interface can extend several interfaces
public interface MyInterface extends InterfaceOne, InterfaceTwo { void aMethod(); }
45
A class can implements several interfaces
public class ClassA implements Interface1, Interface2, Interface3 { ... }
46
UML Representation of Interfaces
+methodOne()
+methodTwo() : double
+methodThree(newValue : double)
<<interface>>
MyInterface
+methodOne()
+methodTwo() : double
+methodThree(newValue : double)
ClassA
+methodOne()
+methodTwo() : double
+methodThree(newValue : double)
ClassB
47
UML Representation of Interfaces
48
Case Study
+turnon()
+turnoff()
<<interface>>
Device
+turnon()
+turnoff()
DeviceDemo
+turnon()
+turnoff()
Stopwatch
49
Interface Device
public interface Device {
/**
* Turns the device off.
*/
void turnOff();
/**
* Turns the device on.
*/
void turnOn();
}
50
Class DeviceDemoimport java.io.*;public class DeviceDemo implements Device {
private static PrintWriter stdOut = new PrintWriter(System.out, true);private String name;
public static void main (String[] args) {Device device = new DeviceDemo("demo"); device.turnOn();
device.turnOff(); }
public DeviceDemo (String initialName) {name = initialName;
}
public void turnOff() {stdOut.println("Turn off device " + name);
}
public void turnOn() { stdOut.println("Turn on device " + name);
}}
51
Class Stopwatch import java.io.*;public class Stopwatch implements Device {
public static final int OFF = 0; public static final int ON = 1;
private static PrintWriter stdOut = new PrintWriter(System.out, true);
private int state;private long startTime;
public Stopwatch () { state = Stopwatch.OFF; startTime = 0; }
52
Class Stopwatch public void turnOn() {
startTime = System.currentTimeMillis();state = Stopwatch.ON;
}
public void turnOff() {if (state == Stopwatch.OFF) {
stdOut.println("The device is off");} else {
long rightNow = System.currentTimeMillis(); stdOut.println("Time: " + (rightNow - startTime));startTime = 0;state = Stopwatch.OFF;
} }
53
Class DeviceDemopublic static void main (String[] args) {
Device device = new Stopwatch();
device.turnOn();
for (int i = 0; i < 50000000; i++);
device.turnOff(); }
}
54
Comparing Abstract Classes and Interfaces
• An abstract class can define instance variables, whereas an interface cannot.
• An abstract class can implement methods, whereas an interface cannot.
• Interfaces do not contain constructors. • If a class extends an abstract class, it cannot extend
another class; if a class implements an interface, it is free to extend another class and implement many other interfaces.
55
Why do we use Interfaces?.
• To reveal an object's programming interface (functionality of the object) without revealing its implementation– This is the concept of encapsulation– The implementation can change without affecting the
caller of the interface– The caller does not need the implementation at the
compile time• It needs only the interface at the compile time
• During runtime, actual object instance is associated with the interface type
56
Why do we use Interfaces?..
• To have unrelated classes implement similar methods (behaviors)– One class is not a sub-class of another
• Example:– Class Line and class MyInteger
• They are not related through inheritance• You want both to implement comparison methods
– checkIsGreater(Object x, Object y)– checkIsLess(Object x, Object y)– checkIsEqual(Object x, Object y)
– Define Comparison interface which has the three abstract methods above
57
Why do we use Interfaces?...
• To model multiple inheritance – A class can implement multiple interfaces while it can
extend only one class
58
Interface as a Type
• When you define a new interface, you are defining a new reference type
• You can use interface names anywhere you can use any other type name
• If you define a reference variable whose type is an interface, any object you assign to it must be an instance of a class that implements the interface
59
Example: Interface as a Type
• Let's say Person class implements PersonInterface interface
• You can do:– Person p1 = new Person();– PersonInterface pi1 = p1;– PersonInterface pi2 = new Person();
60
Interface and Polymorphism
• Interfaces exhibit polymorphism as well, since program may call an interface method, and the proper version of that method will be executed depending on the type of object instance passed to the interface method call
61
Rewriting Interfaces
• Problem of Rewriting an Existing Interface
62
Solution of Rewriting an Existing Interface