Java
16
+area() : double
<<abstract>>
Shape
+area() : double
Circle
+area() : double
HalfCircle
+area() : double
Square
//client or calling code
double dim = 5.0; //ie 5 meters radius or width
List listShapes = new ArrayList(20);
Shape s = new Circle();
listShapes.add(s); //add circle
s = new Square();
listShapes.add(s); //add square
getTotArea (listShapes,dim); //returns 78.5+25.0=103.5
//Later on, if you decide to add a half circle then define
//a HalfCircle class, which extends Circle and then provide an
//area(). method but your called method getTotArea(...) remains
//same.
s = new HalfCircle();
listShapes.add(s); //add HalfCircle
getTotArea (listShapes,dim); //returns 78.5+25.0+39.25=142.75
/** called method: method which adds up areas of various
** shapes supplied to it.
**/
public double getTotArea(List listShapes, double dim){
Iterator it = listShapes.iterator();
double totalArea = 0.0;
//loop through different shapes
while(it.hasNext()) {
Shape s = (Shape) it.next();
totalArea += s.area(dim); //polymorphic method call
}
return totalArea ;
}
Sample code:
For example: given a base
class/interface Shape,
polymorphism allows the
programmer to define
different area(double
dim1) methods for any
number of derived classes
such as Circle, Square etc.
No matter what shape an
object is, applying the area
method to it will return the
right results.
Later on HalfCicle can be
added without breaking
your called code i.e.
method getTotalArea(...)
Depending on what the
shape is, appropriate
area(double dim) method
gets called and calculated.
Circle Æ area is 78.5sqm
Square Æ area is 25sqm
HalfCircle Æ area is 39.25
sqm
+area() : double
Circle
+area() : double
HalfCircle
+area() : double
Square
+area() : double
«interface»
Shape
I
nheritance – is the inclusion of behaviour (i.e. methods) and state (i.e. variables) of a base class in a derived
class so that they are accessible in that derived class. The key benefit of Inheritance is that it provides the formal
mechanism for code reuse. Any shared piece of business logic can be moved from the derived class into the
base class as part of refactoring process to improve maintainability of your code by avoiding code duplication. The
existing class is called the superclass and the derived class is called the subclass. Inheritance can also be
defined as the process whereby one object acquires characteristics from one or more other objects the same way
children acquire characteristics from their parents.
There are two types of inheritances:
1. Implementation inheritance (aka class inheritance): You can extend an applications’ functionality by reusing
functionality in the parent class by inheriting all or some of the operations already implemented. In Java, you can
only inherit from one superclass. Implementation inheritance promotes reusability but improper use of class
inheritance can cause programming nightmares by breaking encapsulation and making future changes a problem.
With implementation inheritance, the subclass becomes tightly coupled with the superclass. This will make the
design fragile because if you want to change the superclass, you must know all the details of the subclasses to
avoid breaking them. So when using implementation inheritance, make sure that the subclasses depend only
on the behaviour of the superclass, not on the actual implementation. For example in the above diagram the
subclasses should only be concerned about the behaviour known as area() but not how it is implemented.
2. Interface inheritance (aka type inheritance): This is also known as subtyping. Interfaces provide a mechanism
for specifying a relationship between otherwise unrelated classes, typically by specifying a set of common
methods each implementing class must contain. Interface inheritance promotes the design concept of program to
interfaces not to implementations. This also reduces the coupling or implementation dependencies between
systems. In Java, you can implement any number of interfaces. This is more flexible than implementation
inheritance because it won’t lock you into specific implementations which make subclasses difficult to maintain. So
care should be taken not to break the implementing classes by modifying the interfaces.
Which one to use? Prefer interface inheritance to implementation inheritance because it promotes the design
concept of coding to an interface and reduces coupling. Interface inheritance can achieve code reuse with the
help of object composition. If you look at Gang of Four (GoF) design patterns, you can see that it favours
interface inheritance to implementation inheritance. CO
剩余236页未读，继续阅读
leogod
- 粉丝: 3
- 资源: 2
我的内容管理
展开
最新资源
- Lombok 快速入门与注解详解
- SpringSecurity实战：声明式安全控制框架解析
- XML基础教程：从数据传输到存储解析
- Matlab实现图像空间平移与镜像变换示例
- Python流程控制与运算符详解
- Python基础：类型转换与循环语句
- 辰科CD-6024-4控制器说明书：LED亮度调节与触发功能解析
- AE particular插件全面解析：英汉对照与关键参数
- Shell脚本实践：创建tar包、字符串累加与简易运算器
- TMS320F28335：浮点处理器与ADC详解
- 互联网基础与结构解析：从ARPANET到多层次ISP
- Redhat系统中构建与Windows共享的Samba服务器实战
- microPython编程指南：从入门到实践
- 数据结构实验：顺序构建并遍历链表
- NVIDIA TX2系统安装与恢复指南
- C语言实现贪吃蛇游戏基础代码
资源上传下载、课程学习等过程中有任何疑问或建议，欢迎提出宝贵意见哦~我们会及时处理！
点击此处反馈
