参考资料
[1]. 疯狂Java讲义(第三版) 李刚
继承与组合
继承是实现类复用的重要手段,但继承带来了一个最大的坏处,破坏封装。相比之下,组合也是实现类复用的重要方式,而采用组合方式来实现类复用则能提供更好的封装性。
使用继承的注意点
为了保证父类有良好的封装性,不会被子类随意改变,设计父类通常应该遵循如下规则:
1. 尽量隐藏父类的内部数据。例如成员变量使用private修饰。
2. 不要让子类可以随意访问、修改父类的方法。例如父类中作为辅助和工具的方法设置为private;需要被外部类调用,又不希望被修改的方法,使用final修饰符;希望被重写,又不希望被其他类访问,则可以使用protected修饰符。
3. 尽量不要在父类中调用将要被子类重写的方法。
如果在子类中重写了父类在构造器中调用的方法,那么在实例化的时候父类会调用子类的重写的扩展方法。代码如下:
/**
* 父类
*/
public class Base {
/**
* 构造器
*/
public Base()
{
test();
}
public void test() // ①号test()方法
{
System.out.println("将被子类重写的方法");
}
}
子类
/**
* 子类
*/
public class Sub extends Base{
private String name;
/**
* 因为继承了父类
* 所以父类在构造器中会调用此方法
*/
public void test() // ②号test()方法
{
System.out.println("子类重写父类的方法,"
+ "其name字符串长度" + name.length());
}
public static void main(String[] args)
{
// 下面代码会引发空指针异常
// 直接父类会调用被子类重写的test方法
Sub s = new Sub();
}
}
类图如下:
利用组合实现复用
如果需要复用一个类,除了把这个类当成基类来继承之外,还可以把该类当成另一个类的组合成分,从而允许新类直接复用该类public方法。不管是继承还是组合,都允许在新类(对于继承就是子类)中直接复用旧类的方法。
Animal、Wolf、Bird三个类的代码如下:
class Animal
{
private void beat()
{
System.out.println("心脏跳动...");
}
public void breath()
{
beat();
System.out.println("吸一口气,吐一口气,呼吸中...");
}
}
// 继承Animal,直接复用父类的breath()方法
class Bird extends Animal
{
public void fly()
{
System.out.println("我在天空自在的飞翔...");
}
}
// 继承Animal,直接复用父类的breath()方法
class Wolf extends Animal
{
public void run()
{
System.out.println("我在陆地上的快速奔跑...");
}
}
public class InheritTest
{
public static void main(String[] args)
{
Bird b = new Bird();
b.breath();
b.fly();
Wolf w = new Wolf();
w.breath();
w.run();
}
}
类图如下:
现在使用组合的方式重写上面的类。
/**
* Description:
* <br/>网站: <a href="http://www.crazyit.org">疯狂Java联盟</a>
* <br/>Copyright (C), 2001-2016, Yeeku.H.Lee
* <br/>This program is protected by copyright laws.
* <br/>Program Name:
* <br/>Date:
* @author Yeeku.H.Lee kongyeeku@163.com
* @version 1.0
*/
class Animal
{
private void beat()
{
System.out.println("心脏跳动...");
}
public void breath()
{
beat();
System.out.println("吸一口气,吐一口气,呼吸中...");
}
}
class Bird
{
// 将原来的父类组合到原来的子类,作为子类的一个组合成分
private Animal a;
public Bird(Animal a)
{
this.a = a;
}
// 重新定义一个自己的breath()方法
public void breath()
{
// 直接复用Animal提供的breath()方法来实现Bird的breath()方法。
a.breath();
}
public void fly()
{
System.out.println("我在天空自在的飞翔...");
}
}
class Wolf
{
// 将原来的父类组合到原来的子类,作为子类的一个组合成分
private Animal a;
public Wolf(Animal a)
{
this.a = a;
}
// 重新定义一个自己的breath()方法
public void breath()
{
// 直接复用Animal提供的breath()方法来实现Wolf的breath()方法。
a.breath();
}
public void run()
{
System.out.println("我在陆地上的快速奔跑...");
}
}
public class CompositeTest
{
public static void main(String[] args)
{
// 此时需要显式创建被组合的对象
Animal a1 = new Animal();
Bird b = new Bird(a1);
b.breath();
b.fly();
// 此时需要显式创建被组合的对象
Animal a2 = new Animal();
Wolf w = new Wolf(a2);
w.breath();
w.run();
}
}
类图如下所示: