Java学习-7.复用类

复用类

组合语法

组合技术：只需将对象引用置于新类中即可。

class WaterSource {
    private String s;
    WaterSource() {
       System.out.println("WaterSoource()");
       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);

   }
}

继承语法

当创建一个类时，总是在继承，除非明确指出要从其他类中继承，否则就是在隐式地从Java的标准根类Object进行继承

在继承过程中，通过在类主体的左边花括号之前，书写后面紧随 基类名称的关键字extend而实现的，，这么做会自动得到基类中所有的域和方法

初始化基类

在构造器中调用基类构造器来执行基类子对象的初始化，Java会自动的在导出类的构造器中插入对积累构造器的调用

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();
    }
}

带参数的构造器

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();
   }
}

如果不在BoardGame（）中调用基类构造器，编译器则无法找到符合Game（）形式的构造器

结合使用组合和继承

class Plate {
  Plate(int i) {
    System.out.println("Plate constructor");
  }
}
class DinnerPlate extends Plate {
  DinnerPlate(int i) {
    super(i);
    System.out.println("DinnerPlate constructor");
  }
}
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 Fork extends Utensil {
  Fork(int i) {
    super(i);
    System.out.println("Fork constructor");
  }
}
class Knife extends Utensil {
  Knife(int i) {
    super(i);
    System.out.println("Knife constructor");
  }
}
class Custom {
  Custom(int i) {
    System.out.println("Custom constructor");
  }
}
public class PlaceSetting extends Custom {
  private Spoon sp;
  private Fork frk;
  private Knife kn;
  private DinnerPlate pl;
  public PlaceSetting(int i) {
    super(i+1);
    sp=new Spoon(i+2);
    frk=new Fork(i+3);
    kn=new Knife(i+4);
    pl=new DinnerPlate(i+5);
    System.out.println("PlateSetting constructor");
  }
  public static void main(String[] args) {
    PlaceSetting x=new PlaceSetting(9);
  }
}

在组合与继承之间选择

组合和继承都允许在新的类中放置子对象，组合是显式地这样做，而继承则是隐式地做。

组合技术通常用于想在新类中使用现有类的功能而非它的接口这种情形。为取得此效果，需要在新类中嵌入一个现有类的private对象

在继承的时候，使用某个现有类，并开发一个它的特殊版本

“is-a（是一个）的关系使用继承来表达的，而”has-a“（有一个）的关系则是用组合来表达的

protected关键字

关键字protected指明就类用户而言，这是private的，但对于任何继承与此类的导出类或其他任何位于同一个包内的类来说，它却是可以访问的。

向上转型

由导出类转型成基类，在继承图上是向上移动的，因此一般称为向上转型。是由一个较专用类型向较通用类型转换

final关键字

关键字final通常指的是“这是无法改变的”。

final数据

对于基本类型，final是数值恒定不变；对于对象引用，final使引用恒定不变（一旦引用被初始化指向一个对象，就无法再把它改为指向另一个对象，然而对象本身却是可以修改的）

空白final

空白final是指被声明为final但又未给定初值的域。

必须在域的定义处或者每个构造器中用表达式对final进行赋值

final参数

Java允许在参数列表中以声明的方式将参数指明为final，这意味着你无法在方法中更改参数引用所指向的对象。

final方法

使用final方法的原因：

1.把方法锁定，以防任何继承类修改它的含义

2.效率

final和private关键字

类中所有的private方法都隐式地指定为final的。

参考书《Java编程思想》