java编程思想第四版第七章总结

小程序：扫一扫查出行
【扫一扫了解最新限行尾号】
复制小程序

1. 实现类的复用通常有两种方式

组合：在新的类中产生现有类的对象
继承：按照现有类的类型来创造新类

2. 一个特殊的方法toString()

在非基本类型的对象中, 都有toString()方法
当编译器需要一个String而你只有一个对象时, toString()方法会被自动调用

3. 父类方法的定义要求

所有的方法都是public的.
- 原因: 如果没有修饰符,则是包访问权限, 那么包以外的其他类继承了这个类, 依然不能访问这个父类的方法. 所以, 定义父类的公用方法需要时public的.
- 为了继承一般的规则是: 成员变量是private的, 方法是public的.

4. 基类初始化

java会在子类中自动调用父类的构造器
父类如果没有默认构造器, 子类需要用super显示的调用父类的构造器. 而且调用父类构造器,必须是子类构造器要做的第一件事
- 基类的默认构造器, 也要显示的调用父类的有参构造器

5. 复用的第三种方式: 代理

代理: java并不直接支持他, 它是继承和组合之间的一种中庸之道.

无论我们使用的时组合, 还是继承. 都会暴露所有对象的成员方法

组合：在类中new一个对象，然后该对象的所有成员方法在这个类中就都可以被使用。
继承：继承了父类，那么父类的方法对这个子类来说，更是完全可见的。

这两种方法都会完全暴掠被使用的那个类的成员方法，而有的时候，我们不希望这样，不想父类或者被调用类的成员方法被暴露在外，就可以采用代理的方式，如下例：太空船需要一个控制模块

package net.mindview.reusing;

public class SpaceShipControls {

    //velocity 速度

    void up(int velocity){}

    void down(int velocity){}

    void left(int velocity){}

    void right(int velocity){}

    void forward(int velocity){}

    void back(int velocity){}

    void turboBoost(int velocity){} //发动

}

构造一个太空船，可以使用组合或者继承。我们这里使用继承的方式构造。

package net.mindview.reusing;

public class SpaceShip extends SpaceShipControls {

    private String name;

    public SpaceShip(String name) {

        this.name = name;

    }

    @Override

    public String toString() {

        return name;

    }

    public static void main(String[] args) {

        SpaceShip protector = new SpaceShip("太空号");

        protector.up();

    }

}

然而， SpaceShip并非一个真正的SpaceShipControls类型。太空船是太空船，并不是太空控制器，只是使用了太空控制器而已。更准确的说：SpaceShip包含SpaceShipControls。而且，一旦继承， SpaceShipControls的所有方法都在SpaceShip中暴露了。这时我们可以使用代理方式来解决这个问题：

package net.mindview.reusing;

/**

 * 太空船代理

 */

public class SpaceShipDelegation {

    String name;

    public SpaceShipControls controls = new SpaceShipControls();

    public SpaceShipDelegation(String name){

        this.name = name;

    }

    public void up(int velocity){

        controls.up(velocity);

    }

    void down(int velocity){

        controls.down(velocity);

    }

    void left(int velocity){

        controls.left(velocity);

    }

    void right(int velocity){

        controls.right(velocity);

    }

    void forward(int velocity){

        controls.forward(velocity);

    }

    void back(int velocity){

        controls.back(velocity);

    }

    void turboBoost(int velocity){//发动

        controls.turboBoost(velocity);

    }

    public static void main(String[] args) {

        SpaceShipDelegation protector = new SpaceShipDelegation("太空号2");

        protector.up();

    }

}

这就是使用了代理。主要关注上面的方法是如何传递给底层的controls对象的。其接口与使用继承得到的接口一样了。然而，我们使用代理时却得到了更多的控制力。

6. 如何选择组合和继承

组合通常是想在新类中使用现有类的功能而非他的接口。就是说，在新类中嵌入某个对象，让其实现所需要的功能，但新类的用户看到的只是为新类所定义的接口。而非锁嵌入对象的接口。为取得这个效果，应该将现有类定义为private的。看下面的这个例子：

package net.mindview.reusing;

class Engine {

    public void start(){}

    public void rev(){}

    public void stop(){}

}

class Wheel {

    public void inflate(int psi){}

}

class Window{

    public void rollup(){}

    public void rolldown(){}

}

class Door{

    public Window window = new Window();

    public void open(){}

    public void close(){}

}

public class Car {

    public Engine engine = new Engine();

    public Wheel[] wheels = new Wheel[];

    public Door left = new Door(),right = new Door();

    public Car(){

        for(int i=;i<; i++){

            wheels[i] = new Wheel();

        }

    }

    public static void main(String[] args) {

        Car car = new Car();

        car.left.window.rollup();

        car.wheels[].inflate();

    }

}

这里面，显示的car的组成部分，所以使用的是组合的方式。而如果有一个“交通工具”和car是什么关系呢？显然他们车不是交通工具组成的。car确实一类交通工具，所以，交通工具和car应该是继承的关系。

向上转型

package net.mindview.reusing;

/**

 * 乐器

 */

class Instrument {

    public void play(){}

    //用乐器弹奏曲调

    static void tune(Instrument i){

        i.play();

    }

}

//乐器的一种

public class Wind extends Instrument{

    public static void main(String[] args) {

        Wind wind = new Wind();

        //使用wind弹奏曲调

        Instrument.tune(wind);

    }

}

上面的Instrument类中, 接收的Instrument的引用，在使用的时候，我们可以将继承了Instrument的乐器传给tune方法。这称之为向上转型。
到底什么时候使用组合，什么时候使用继承呢？
- 一个最清晰的判断就是，问问自己，是否需要从新类向基类向上转型。如果需要转型，那么就必须使用继承，否则就要好好想想了，是否有使用集成的必要性。

7.final关键字

final关键字的含义通常是“这是无法改变的
- 作用于成员变量，表示该变量编译时不可变。
- 作用于成员变量，和public static一起使用，表示全局常量
- 成员变量是对象类型时使用final表示，对象的引用不可改变。

空白final

所谓“空白final“指的是，在定义final变量的时候不给他赋初始值，而是在构造函数中为其赋值。这样就提供了更大的灵活性。使用方法如下所示：

package net.mindview.reusing;

class Poppet {

    private int i;

    Poppet(int i){

        this.i = i;

    }

}

public class BlankFinal {

    //定义的时候赋初始值

    private final int i = ;

    //空白final

    private final int j;

    //空白final引用

    private final Poppet p;

    public BlankFinal(){

        j = ;

        p = new Poppet();

    }

    public BlankFinal(int x){

        j = x;

        p = new Poppet(x);

    }

    public static void main(String[] args) {

        new BlankFinal();

        new BlankFinal();

    }

}

在参数列表中以声明的方式将参数指明为final

如果final作用的参数是对象，则表明在方法中无法更改参数引用所指向的对象。

如果final作用的是基本类型的参数，则表示不可以改变传递过来的参数值。

package net.mindview.reusing;

class Gizmo{

    public void spin() {}

}

//final作用于方法参数

public class FinalArguments {

    //final作用于对象类型的方法参数

    void with(final Gizmo g) {

        //在这里不可以对传递过来个g重新指向新的引用

        //g = new Gizmo();

    }

    void without(Gizmo g){

        g = new Gizmo();

        g.spin();

    }

    //final作用于基本类型的方法参数

    void f(final int i) {

        //在这里不可以对i重新赋值

        //i++;

    }

    int g(final int i) {

        return i+;

    }

    public static void main(String[] args) {

        FinalArguments bf = new FinalArguments();

        bf.with(null);

        bf.without(null);

    }

}