第七章 - 复用类

╰半橙微兮° 2022-05-23 09:39 158阅读 0赞

## 组合语法 ##

目前为止，已经多次使用组合技术。只需将对象引用置于新类中即可，例如，假设你需要某个对象，他要具有多个String对象，几个基本类型数据，以及另一个类的对象。对于非基本类型的对象，必须将其引用置于新类中，但可以直接定义基本类型数据。

class WaterSource {
      private String s;
      WaterSource() {
        System.out.println("WaterSource()");
        s = "Constructed";
      }
      public String toString() {
        return s;
      }
    }	
    
    public class SprinklerSystem {
      private String valve1, valve2, valve3, valve4;
      private WaterSource source = new WaterSource();
      private int i;
      private float f;
      public String toString() {
        return
          "valve1 = " + valve1 + " " +
          "valve2 = " + valve2 + " " +
          "valve3 = " + valve3 + " " +
          "valve4 = " + valve4 + "\n" +
          "i = " + i + " " + "f = " + f + " " +
          "source = " + source;
      }	
      public static void main(String[] args) {
        SprinklerSystem sprinklers = new SprinklerSystem();
        System.out.println(sprinklers);
      }
    }

##     ![70][]    ##

## 继承语法 ##

组合的语法比较平实，但是继承使用的是一种特殊的语法，关键字extends实现。

class Cleanser {
      private String s = "Cleanser";
    
      public void append(String a) {
        s += a;
      }
    
      public void scrub() {
        append(" scrub()");
      }
      public String toString() {
        return s;
      }
    }	
    
    public class Detergent extends Cleanser {
    
      public void scrub() {
        append(" Detergent.scrub()");
        super.scrub();
      }
    
    
      public static void main(String[] args) {
        Detergent x = new Detergent();
        x.scrub();
        System.out.println(x);
      }	
    }

![70 1][]

##     初始化基类 ##

class Art {
      Art() {
        System.out.println("Art constructor"); 
      }
    }
    
    class Drawing extends Art {
      Drawing() {
        System.out.println("Drawing constructor"); 
      }
    }
    
    public class Cartoon extends Drawing {
      public Cartoon() {
        System.out.println("Cartoon constructor"); }
      public static void main(String[] args) {
        Cartoon x = new Cartoon();
      }
    }

![70 2][]

通过打印结果看，构建过程是有基类“向外”扩散的，所以基类在导出类构造器可以访问之前就已经初始化了。

##     带参数的构造器 ##

如果想要调用带参数的基类构造器，就 必须使用super显示的编写调用基类的语句，并且配以适当的参数列表。

class Game {
      Game(int i) {
        System.out.println("Game constructor");
      }
    }
    
    class BoardGame extends Game {
      BoardGame(int i) {
        super(i);
        System.out.println("BoardGame constructor");
      }
    }	
    
    public class Chess extends BoardGame {
      Chess() {
        super(11);
        System.out.println("Chess constructor");
      }
      public static void main(String[] args) {
        Chess x = new Chess();
      }
    }

![70 3][]

##    代理 ##

第三种关系成为代理，java并没有提供对他的直接支持。这是继承和组合之间的中庸之道。因为我们将一个成员对象置于所要构造的类中（就像组合），与此同时我们在新类中暴露了该成员的所有方法（就像继承），例如太空船需要一个控制模块：

public class SpaceShipControls {
      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() {}
    }

构造太空船的一种方式是继承：

public class SpaceShip extends SpaceShipControls {
      private String name;
      public SpaceShip(String name) {
        this.name = name; 
      }
      public String toString() {
        return name; 
      }
      public static void main(String[] args) {
        SpaceShip protector = new SpaceShip("NSEA Protector");
        protector.forward(100);
      }
    }

然而，SpaceShip并非真正的SpaceShipControls类型，即便你可以调用SpaceShipControls的方法。跟准确的讲，SpaceShip包含SpaceShipControls，与此同时，SpaceShipControls的所有方法在SpaceShip中都暴露了出来，代理解决此难题。

public class SpaceShipDelegation {
      private String name;
      private SpaceShipControls controls = new SpaceShipControls();
      public SpaceShipDelegation(String name) {
        this.name = name;
      }
      // Delegated methods:
      public void back(int velocity) {
        controls.back(velocity);
      }
      public void down(int velocity) {
        controls.down(velocity);
      }
      public void forward(int velocity) {
        controls.forward(velocity);//这是重点
      }
      public void left(int velocity) {
        controls.left(velocity);
      }
      public void right(int velocity) {
        controls.right(velocity);
      }
      public void turboBoost() {
        controls.turboBoost();
      }
      public void up(int velocity) {
        controls.up(velocity);
      }
      public static void main(String[] args) {
        SpaceShipDelegation protector =  new SpaceShipDelegation("NSEA Protector");
        protector.forward(100);
      }
    }

上述代码 个人理解为加了一个保护类，有保护类（代理类）提供方法，可避免父类中的所有方法在实现中暴露

（关于代理，后面章节会有讲解）

##   结合使用组合和继承 ##

class Utensil {
      Utensil(int i) {
        System.out.println("Utensil constructor");
      }
    }
    
    class Spoon extends Utensil {
      Spoon(int i) {
        super(i);
        System.out.println("Spoon constructor");
      }
    }
    
    
    class Custom {
      Custom(int i) {
        System.out.println("Custom constructor");
      }
    }	
    
    public class PlaceSetting extends Custom {
      private Spoon sp;
     
      public PlaceSetting(int i) {
        super(i + 1);
        sp = new Spoon(i + 2);
        System.out.println("PlaceSetting constructor");
      }
      public static void main(String[] args) {
        PlaceSetting x = new PlaceSetting(9);
      }
    }

![70 4][]

##     final关键字 ##

引用一篇文章吧

https://www.cnblogs.com/lwbqqyumidi/p/3513047.html

[70]: /images/20220523/35a8ab76aef84eba89b7f14e273e242b.png
[70 1]: /images/20220523/84eb3a308d9f44a5b98b5617e9353bd5.png
[70 2]: /images/20220523/d8cc0789577949d3a3a2a0f326f1b049.png
[70 3]: /images/20220523/65beb2221a3f46a6b6b2367e0b51b72a.png
[70 4]: /images/20220523/5dcbf4b60f784e42b11c0a80fd87d027.png