第七章 复用类

组合

只需在新的类中产生现有类的对象.

toString()

每一个非基本类型的对象都有一个toString()方法,当编译器需要一个String对象而却只有一个对象时,该方法便会被调用.

初始化的方式

1.在定义对象的地方.这意味着它们总是能够在构造器被调用之前被初始化.

2.在类的构造器中.

3.就在正要使用这些对象之前,这种方式称为惰性初始化.在生成对象不值得及不必每次都生成对象的情况下,这种方式可以减少额外的负担.

4.使用实例初始化.

class Soap{
    private String s;
    Soap(){
        System.out.println("Soap()");
        s="Constructed";
    }
    public String toString(){
        return s;
    }
}
public class Bath {
    private String s1="Happy",s2="Happy",s3,s4;    //定义对象处
    private Soap castille;
    private int i;
    private float toy;
    public Bath(){
        System.out.println("Inside Bath()");
        s3="Joy";    //构造器中    构造器是初始化的最后一道屏障
        toy=3.14f;
        castille=new Soap();    
    }
    {i=47;}        //实例初始化,伴随着new 对象在堆中开辟内存 进行.
    @Override
    public String toString() {
        if(s4==null){    //惰性初始化
            s4="Joy";
        }
        return "Bath{" +
                "s1='" + s1 + '\'' +
                ", s2='" + s2 + '\'' +
                ", s3='" + s3 + '\'' +
                ", s4='" + s4 + '\'' +
                ", castille=" + castille +
                ", i=" + i +
                ", toy=" + toy +
                '}';
    }
    public static void main(String[] args) {
        Bath b = new Bath();
        System.out.println(b);
    }
}

继承

构造器的访问权限会导致子类所在包的位置影响能否继承.

按照现有类的类型来创建类;

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

为了继承,一般的规则是将所有的数据成员都指定为private,将所有的方法指定为public.

java使用 extends 和 implements 这两个关键字来实现继承.

class Animal {
    String name;
    public Animal(String name) {
        this.name = name;
    }
    Animal() {
        System.out.println("Animal no name");
    }
    public void eat() {
        System.out.println("animal eat");
    }
}

public class Dog extends Animal {
    Dog(){
        //super();  这行代码即便不写，也会默认执行
                 // 只要调用了子类的构造器，在第一行就会执行supper（），调用父类的构造器
        //如果父类构造器中都有参数，那么必须在第一行写super（），详情看下面图片
        System.out.println("Dog no name");
    }
    public Dog(String name){
        this.name=name;
        super.eat();
        this.eat();
    }
    @Override
    public void eat(){
        System.out.println("dog eat");
    }
    public static void main(String[] args) {
        Dog dog1 = new Dog("jack");
        System.out.println(dog1.name);
        System.out.println();
        Dog dog2 = new Dog();
        System.out.println(dog2.name);
    }
}
/*out
 Animal no name
 animal eat
 dog eat
 jack
 Animal no name
  Dog no name
  null
  */

Animal（父类）中的构造器都有参数，所以在Dog（子类）构造器第一行需要写supper（）；否则会报错

代理

代理者须保持和被代理者相同的接口,该接口的理解为方法

不直接使用,加一层中间关系 由中间类完成对方法的使用.

需要将相同的接口给暴露出去 让原本调用者调用代理类的接口

可以手动选择要暴露出去的接口(public方法的子集)

class Tea{
    public void sell(){
        System.out.println("sell tea");
    }
}
class TeaSeller{
    private Tea tea = new Tea();
    public void sell(){
        System.out.println("其他操作1");
        tea.sell();
        System.out.println("其他操作2");
    }
}
public class Proxy {
}