Thinking in Java,Fourth Edition(Java 编程思想,第四版)学习笔记(八)之Reusing Classes

The trick is to use the classes without soiling the existing code.

　　1. composition--simply create objects of your existing class inside the new class. simply reusing the functionality of the code, not its form

　　2.inheritance--creates a new class as a type of an existing class. Take the form of the existing class and add code to it without modifying the existing class.

　　　　Inheritance is one of the cornerstones of object-oriented programming, and has additional implications that will be explored in the Polymorphism chapter.

Composition syntax

　　references initialized:　

　　　　1. At the point the objects are defined

　　　　2. In the constructor for that class

　　　　3. Right before you actually need to use the object (lazy initialization)

　　　　4. Using instance initialization

　　如：

　　　　public class Bath  {

　　　　　　private String s1 = "Happy"; //Initialization at the point of definition

　　　　　　private String s2,s3,s4;

　　　　　　public Bath() {

　　　　　　　　s2 = "Happy"; // In the constructor

　　　　　　}

　　　　　　{ s3 = "Happy";　} // Instance Initialization

　　　　　　public String toString() {

　　　　　　　　// Lazy initialization

　　　　　　　　if( s4 == null) {

　　　　　　　　　　s4 = "Happy";

　　　　　　　　}

　　　　　　　　return s4;

　　　　　　}

　　　　}

Inheritance syntax

　　super.methodName() 调用父类的方法

　　Initializing the base class

　　When you create an object of the derived class, it contains within it a subobject of the base class. This subobject is the same as if you had created an object of the base class by itself. It's just that from the outside, the subobject of the base class is wrapped within the derived-class object.

　　Java automatically inserts calls to the base-class constructor in the derived-class constructor.

　　Constructors with arguments

　　The call to the base-class constructor with arguments must explicit, and be the first thing you do in the derived-class constructor, etc: super(1)

Delegation

　　A third relationship, which is not directly supported by Java, is called delegation. This is midway between inheritance and composition.

　　You place a member object in the class you're building (like composition), but at the same time you expost all the methods from the member object in your new class (like inheritance).

Combining composition and inheritance

　　Guaranteeing proper cleanup

　　If you want something cleaned up for a class, you must explicitly write a special method to do it, and make sure that the client programmer knows that they must call this method.

　　On top of this--as described in the Erro Handling with Exceptions chapter-- you must guard against as exception by putting such cleanup in a finally clause.

　　Note that in your cleanup method, you must also pay attention to the calling order for the base-class and member-object cleanup methods in case one subobject depends on another. In general, First perform all the cleanup work specific to your class, in the reverse order or creationg. Then call the base-class cleanup method.

　　用户可以自己调用对象的finalize方法，但是这种调用是正常的方法调用，和对象的销毁过程无关

　　Name hiding

　　Overloading works regardless of whether the method was defined in the base-class or the derived-class

　　overload　重载

　　override　 重新、覆盖

　　Java SE5 has added the @Override annotation. Whne you mean to override a method, you can choose to add this annotation and the compiler will produce an error message if you accidentally overload instead of overriding.

Choosing composition vs. inheritance

　　Composition is generally used when you want the features of an existing class inside your new class, but not its interface. That is, you embed an object so that you can use it to implement features in your new class, but the user of your new class sees the interface you've defined for the new class rathg than the interface from the embedded object. For this effect, you embed private objects of existing classes inside your new class.

　　Sometimes it makes sense to allow the class user to directly access the composition of your new class; that is,to make the member objects public. When the user know you're assembling a bunch of parts, it makes the interface easier to understand

　　例子： 汽车，包含 门（行为：open)、发动机(行为：start)

　　　　　汽车.门.open  (public 门)

　　　　　汽车.start　　(private 发动机)

　　Note keep in mind that in general you should make fields private.

　　When you inherit, you take an existing class and make a special version of it. In general, this means that you're taking a general-purpose class and specializing it for a particular need.

　　Composition: has-a relationship

　　Inheritance: is-a relationship

　　Interface: like-a relationship

protected

　　This is private as far as the class user is concerned, but available to anyone who inherits from the class or anyone else in the same package.

Upcasting

　　The most important aspect of inheritance is not that it provides methods for the new class. It's the relationship expressed between the new class and the base class.

　　Upcasting is always safe because you're going from a more specific type to a more general type.

　　You can also perform the reverse of upcasting, called downcasting, but this involves a dilemma that will be examined further in the next chapter, and in the Type Information chapter.

　　Composition vs. inheritance revisited

　　In object-oriented programming, the most likely way that you'll create and use code is by simply packaging data and methods together inti a class, and using object of that class. You'll also use existing class to build new classes with composition. Less frequently, you'll use inheritance.

　　One of the clearest ways to determine whether you should use composition or inheritance is to ask whether you'll ever need to upcast from your new class to the base class.If you don't need to upcast, then you should look closely at whether you need inheritance.

The final keyword

　　final can be used: for data, methods, and classes.

　　final data

　　to tell the compiler that a piece of data is constant. A constant is useful for two reasons:

　　　　1. It can be a compile-time constant that won't ever change.

　　　　2. It can be a value initialized at run time that you don't want changed.

　　In the case of a compile-time constant, the compiler is allowed to "fold" the constant value into any calculations in which it's used; that is, the calculation can be performed at compile time, eliminating some run-time overhead. In java, these sorts of constants must be primitives and are expressed with the final keyword. A value must be given at the time of definition of such a constant.

　　A field that is both static and final has only one piece of storage that cannot be changed.

　　When final is used with object references rather than primitives, makes the reference a constant. Once the reference is initialized to an object, it can never be changed to point to another object. Howerver, the object itself can be modified.

　　private static final int i = 5; //compile-time

　　private final int i = 5; //comile-time

　　private static final int i = new Random().nextInt(20); //run-time

　　private final int i = new Random().nextInt(20); //run-time

　　Making references final seems less useful than making primitives final.

　　Blank finals

　　public class BlankFinal {

　　　　private final int i = 0; // Initialized final

　　　　private final int j; // Blank final

　　　　public BlankFinal(int jj) {

　　　　　　j = jj; // Initialize blank final

　　　　}

　　}

　　You're forced to perform assignments to finals either with an expression at the point of definition of the field or in every constructor.

　　final arguments

　　Java allows you to make arguments final by declaring them as such in the argument list. This means that inside the method you cannot change what the argument reference points to.

　　This feature is primarily used to pass data to anonymous inner classes

　　final methods

　　There are two reasons for final methods.

　　　　1. to put a "lock" on the method to prevent any inheriting class from changing its meaning.

　　　　2. efficiency.(old, Java SE5之后由编译器和JVM来考虑)

　　final and private

　　Any private methods in a class are implicitly final. Because you can't access a private method, you can't override it.

　　"Overriding" can only occur if something is part of the base-class interface. (即父类和子类中的private方法即时签名一样，也互不影响) If a method is private, it isn't part of the base-class interface.

　　final classes

　　When you say that an entire class is final, you state that you don't want to inherit from this class or allow anyone else to do so.

　　Note that the fields of a final class can be final or not. The same rules apply to final for fields regardless or whether the class is defined as final. However, because it prevents inheritance, all methods in a final class are implicitly final, since there's no way to override them.

　　final caution

Initialization and class loading

　　In general, you can say that "class code is loaded at the point of first use." This is usually when the first object of that class is constructed, but loading also occurs when a static field or static method is accessed.

　　The point of first use is also where the static initialization takes place. All the static objects and the static code block will be initialized in textual order at the point of loading. The statics are initialized only once.

　　Initialization with inheritance

Summary

　　Both inheritance and composition allow you to create a new type from existing types. Composition reuses existing types as part of the underlying implementation of the new type, and inheritance reuses the interface.

　　With Inheritance, the derived class has the base-class interface, so it can be upcast to the base which is critical for polymorphism.

　　When you set out to design a system, it's important to realize that program development is an incremental process, just like human learning. It relies on experimentation; you can do as much analysis as you want, but you still won't know all the answers when you set out on a project. You'll have much more success-and more immediate feedback-if you start out to "grow" your project as an organic, evolutionary creature, rather than constructing it all at once like a glass-box skyscraper.