组合和继承之间选择
组合和继承都允许在新的类中放置子对象，组合是显示 地这么做的，而继承是隐式 地做。 组合技术通常用于想在新类中使用现有类的功能而非它的接口这种情况。在新类中我们只能看到的是为新类所定义的接口，而非所嵌入对象的接口。为取得这个效果，需要在新类中嵌入一个现有类的private 对象。 有时，允许类的用户直接访问新类中组合成分是极据意义的，声明为public （一般情况下是private ）；如果成员对象自身都隐藏了具体实现，那么这种做法是安全的 “is-a” （是一个）的关系是用继承来表达，而has-a （有一个）的关系是用组合来表达的。
protected关键字
在实际项目中，经常会想要将某些事物尽可能对这个世界隐藏起来，但仍然允许导出类的成员访问它们。 关键字protected 它指明“就类用户而言，这是private 的，但对于任何继承此类的导出类或其他任何位于同一个包内的类来说，它却是可以访问的。”（protected 也提供了包内访问权限。） 尽管可以创建protected 域，但是最好的方式还是将域保持为private ；你应当一直保留“修改底层实现”的权力，然后通过protected 方法来控制类的继承者的访问权限。
向上转型
“新类是现有类的一种类型 ”这句话用来概括新类和基类之间的关系。
class Instrument {
public void play () {}
static void tune(Instrument i) {
i.play();
}
}
public class Wind extends Instrument public static void main (String[] args) {
Wind flute = new Wind();
Instrument.tune(flute);
}
}
在此例中，tune ()方法可以接受Instrument 的引用。但在Wind.main() 中，传递的给tune() 方法的是一个Wind 引用，java会严格检查类型，除非你认识到Wind 对象同样是一种Instrument 对象，而且也不存在任何tune() 方法是可以通过Instrument 来调用的，同时又不存在与Wind 之中。将导出类的引用转换为基类的引用的动作，叫向上转型 。 由导出类转型为基类，在继承图上是向上移动的，因此一般称为向上转型 。由于向上转型是从一个较专用类型向比较通用的类型转换，所以总是安全的。也就是说导出类是基类的一个超集。它可能会有跟多的方法，但是至少具备基类中所含的方法。在向上转型的过程中，类接口唯一可能发生的事情是丢失方法，而不是获取它们，这就是为什么编译器在“未曾”明确表示转型 或未曾指定特殊标记 的情况下，仍然支持这种行为。
再论组合与继承
尽管在教授OOP的过程中我们多次强调继承，但这并不意味着尽可能使用它。相反，应当慎用这一技术，其使用场合仅限于你确信使用该技术确实有效的情况下。使用组合还是继承取决于你：你是否需要向上转型 。
final关键字
根据上下文环境，Java的关键字final 的含义存在着细微的区别，但通常它指的是“这是无法改变的” 。不想做改变的可能出于两个理由：设计或效率，由于这两个原因相差很远，所以关键字final 有可能被误用。 final 可能使用到的三种情况：数据、方法和类。
final数据
有时数据的恒定不变是很有用的，比如：
一个永不改变的编译时常量 。 一个在运行时被初始化的值，而你不希望它被改变。 对于编译期常量这种情况，编译器可以将该常量值带入任何可能用到它的计算式中，减轻了一些运行时的负担。在Java中，这类常量必须是基本数据 类型，并且以关键字final 表示。在对这个常量进行定义的时候，必须对其进行赋值 。 一个既是static 又是final 的域只占据一段不能改变的存储空间。 当对对象引用而不是基本类型运行final 时，与对于基本类型不同，基本类型是使数值不变，而引用是使引用恒定不变。一旦引用被初始化指向一个对象，就无法再把它改为指向另一个对象。然而，对象其本身是可以修改的。
空白final
Java允许生成“空白的final ”，所谓空白的final 是指被声明为final 但又未给定初值的域。无论什么情况，编译器都会确保空白的final 在使用前必须被初始化。但是空白final 在关键字final 的使用上提供个更大的灵活性。
class Poppet {
private int i;
Poppet(int ii) { i = ii; }
}
public class BlankFinal private final int i = 0 ;
private final int j;
private final Poppet p;
public BlankFinal () {
j = 1 ;
p = new Poppet(1 );
}
public BlankFinal (int x) {
j = x;
p = new Poppet(x);
}
public static void main (String[] args) {
new BlankFinal();
new BlankFinal(47 );
}
}
必须在域的定义处或者每个构造器中用表达式对final 进行赋值，这正是final 域在使用前总是被初始化的原因。
final参数
Java允许在参数列表中以声明的方式将参数指明为final 。这意味着你无法在方法中更改参数引用所指的对象。 你可以阅读参数，但却无法修改参数。
final方法
使用final 方法的原因有两个。第一个原因是把方法锁定，以防任何继承类修改它的含义。这是出于设计的考虑：想要确保在继承中使方法行为保持不变，并且不会被覆盖。 过去建议使用final 方法的第二个原因是效率。不过在最近的Java版本中，这种做法正在逐渐的受阻，已经不再需要使用final 方法来进行优化了，只有在想要明确禁止覆盖时，才将方法设置为final 。
final和private关键字
类中所有的private 方法都隐式地指定为是final 的。由于无法取用private 方法，所以也就无法覆盖它。可以对private 方法添加final 修饰词，但这并不能给该方法增加任何额外的意义。
import static net.mindview.util.Print.*;
class WithFinals {
private final void f () { print("WithFinals.f()" ); }
private void g () { print("WithFinals.g()" ); }
}
class OverridingPrivate extends WithFinals {
private final void f () {
print("OverridingPrivate.f()" );
}
private void g () {
print("OverridingPrivate.g()" );
}
}
class OverridingPrivate2 extends OverridingPrivate {
public final void f () {
print("OverridingPrivate2.f()" );
}
public void g () {
print("OverridingPrivate2.g()" );
}
}
public class FinalOverridingIllusion public static void main (String[] args) {
OverridingPrivate2 op2 = new OverridingPrivate2();
op2.f();
op2.g();
OverridingPrivate op = op2;
WithFinals wf = op2;
}
}
“覆盖” 只有在某方法是基类的接口的一部分时才会出现。即：必须将一个对象向上转型为它的基本类型并调用相同的方法。如果某方法是为private ，它就是不是类的接口的一部分，它仅是一些隐藏于类中的程序代码，只不过是具有相同的名称而已。但如果导出类中以相同的名称生成一个public 、protected 或包访问权限方法的话，该方法就不会产生在基类中出现的“仅具有相同名称”的情况。此时你并没有覆盖该方法，仅是生成了一个新的方法。由于private 无法触及而且能有效隐藏，所以除了把它看成是因为它所属类的组织结构的原因而存在外，其他任何事情不需要考虑到它。
final类
当将某个类的整体定义为final 时，就表明了你不打算继承该类，而且也不允许别人这么做。换句话说，出于某种考虑，你对该类的设计永不需要做任何改动，或者出于安全考虑，你不希望它有子类。 无论类是否被定义为final ，相同的规则都适用于定义为final 的域。然而，由于final 类禁止继承，所以final 类中所有的方法都隐式指定为是final 的，因为无法覆盖它们。在final 类中可以给方法添加final 修饰词，但这并没有添加任何意义。
初始化及类的加载
在许多语言之中，程序是作为启动过程的一部分立刻被加载的。然后是初始化，紧接着程序开始运行。这些语言的初始化过程必须小心控制，以确保定义为static 的东西，其初始化不会造成麻烦。例如C++中，如果某个static 期望在另一个static 在被初始化之前就能有效地使用它，那么就会出现问题。 Java不会出现这个问题，因为它采用的是一种不同的加载方式，因为Java中的所有事物都是对象，每个类的编译代码都存在于它自己的独立文件中，该文件只在需要使用程序代码的时候才会被加载。一般来说，可以说：“类的代码在初次使用时才被加载。”。这通常是指加载发生在创建类的第一个对象之时，但是当访问static 域或者static 方法时，也会发生加载。 初次使用之处也是static 初始化发生之处，所有的static 对象和static 代码段都会在加载时按程序中的顺序而依次初始化。当然这只会发生一次。
继承和初始化
import static net.mindview.util.Print.*;
class Insect {
private int i = 9 ;
protected int j;
Insect() {
print("i = " + i + ", j = " + j);
j = 39 ;
}
private static int x1 =
printInit("static Insect.x1 initialized" );
static int printInit(String s) {
print(s);
return 47 ;
}
}
public class Beetle extends Insect private int k = printInit("Beetle.k initialized" );
public Beetle () {
print("k = " + k);
print("j = " + j);
}
private static int x2 =
printInit("static Beetle.x2 initialized" );
public static void main (String[] args) {
print("Beetle constructor" );
Beetle b = new Beetle();
}
}
构造器也是static 方法，尽管static 关键字并没有显示的写出来。 （这个待日后深入理解） 在Beetle 上运行Java时，所发生的第一件事情就是试图访问Beetle.main() (一个static 方法)于是加载器开始启动并找出Beetle 类的编译代码(其实就是在名为Beetle.class 的文件中)。对于这次加载，编译器注意到它有个基类（通过关键字extend得知的），于是它继续进行加载。不管你是否打算产生一个该基类的对象，这都要发生。 如果该基类还有基类就继续加载，如此类推。接下来，根基类中的static 初始化即会被执行（这里是Insect ），然后是下一个导出类，依次类推。 至此为止，必要的类都被加载完成了，对象可以被创建了。首先，对象中的所有基本类型都会被设为默认值，对象引用被设为null ,然后基类的构造器会被调用，在基类的构造器完成之后，实例变量按次序被初始化，最后，构造器的其余部分被执行。
本文探讨了面向对象编程中的组合与继承概念，解释了如何根据需求选择合适的编程模式。文章还介绍了Java中的protected关键字、向上转型的概念以及final关键字的各种用途。
扫一扫
467
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
