继承111

两个类的属性和方法具有很多相似的点。就要用继承啦。

继承可以解决代码复用。

当多个类存在相同的属性（变量）和方法时，可以从这些类中抽象出父类，在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过extends来声明继承父类即可。（儿子可以使用父亲的钱，儿子还有自己的私房钱）

关于字类和父类的关系：就像族谱图一样。

1、建立父类，寻找子类相同的属性和方法。

 2、建立子类，写独特的属性。建立名字的时候，就加上extends  父类名。

         这样的话，子类对于父类的属性和方法就都能使用啦。

---

 3、创建子类对象的时候，不管使用子类的那个构造器，（这里需要注意一下，在调用执行子类的构造器之前就需要先返回父类，去调用父类的无参构造器【顺序是：先父类再子类】），默认情况下都回去调用父类的无参构造器，如果父类没有提供无参构造器，就必须在子类的每个构造器中使用super去指定使用父类的那个构造器，进而完成对父类的初始化，否则必须编译不会通过。（如果父类不定义构造器，就会有一个默认的构造器，但是如果定义了一个构造器，默认的构造器就会被覆盖。）

2.super必须在构造器中使用。this表示本类，super表示父类。

怎么查看ctrl + H，能看出类的继承关系 

 小细节方法调用（call）：

  super（）；默认调用父类的无参构造器。

由于是继承了，所以我们不需要通过对象调用方法。 debug调试

1、关于内存分配，先加载最顶级的父类，然后逐次递减加载子类，一直加载到最后的子类。将进本数据类型存放在堆中间，引用数据类型加载存储在方法区中的常量池中。

2、如果新建立对象了，怎么访问信息呢？这个时候就要按照查找关系来查找。

        （1）首先看子类是否有这个信息

         （2）如果子类有这个信息的话就访问该属性

        （3）如果没有这个属性的话，就查看父类的信息，如果有就可以访问。        

        （4）依次类推，知道找到Object类。

上述只针对【public】，若有中间有的属性是private的话，没有使用get方法，就不能获取信息。

这个时候就不再向后面继续查找，过程被终止。提示报错信息。

总结：分配内存：从上到下（爷爷到孙子）（父类到子类）

            访问属性：从下到上（孙子到爷爷）（子类到父类）---->其实仔细想一想也是这样的情况，我从子类新建一个对象，就会从子类先进行访问啦。

 这里需要注意的点：

在子类B新建对象，先看继承关系，B是继承A的，先执行B的无参构造器，在无参构造器的内部，有个this，这个this就是代表的B这个类，this（"abc"）【可以看成方法的调用】，【记住一句话，有this，就不能有super】，就代表执行B类中的有参数的构造器。在执行之前有参数的构造器中间会默认有一个super（）----》来执行父类的无参构造器。这个时候就会输出a，接着执行bname。然后返回调用方法处，接着执行输出结果b。

在执行子类的构造器之前，我必须调用父类的构造器，若父类还有父类，name我就需要在意次向上执行上一级的父类。然后依次返回。

---

 测试主类：

public class Test {
    public static void main(String[] args) {
        PC pc = new PC("intel",18,15,"IBM");
        System.out.println(pc.getDetails());
        pc.print();
        NotePad notePad = new NotePad("iii",82,15,"黑色");
        notePad.print1();
    }
}

 Computer类

public class Computer {
    private String cpu;
    private int memory;
    private int disk;

    public Computer() {

    }

    public Computer(String cpu, int memory, int disk) {
        this.cpu = cpu;
        this.memory = memory;
        this.disk = disk;
    }

    public String getCpu() {
        return cpu;
    }

    public void setCpu(String cpu) {
        this.cpu = cpu;
    }

    public int getMemory() {
        return memory;
    }

    public void setMemory(int memory) {
        this.memory = memory;
    }

    public int getDisk() {
        return disk;
    }

    public void setDisk(int disk) {
        this.disk = disk;
    }
    public String getDetails(){
        return "cpu= " + cpu + "内存" + memory + "硬盘" + disk;
    }
}

 pc类

public class PC extends Computer {
    private String brand;

    public PC(String cpu, int memory, int disk, String brand) {
        //直接根据继承的规则，自动把构造器的调用给写好了。
        //这里体现出的继承的一个基本思想：父类的构造器，完成父类属性的初试化，
        //子类的构造器完成子类的构造器。
        super(cpu, memory, disk);
        this.brand = brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    public String getBrand() {
        return brand;
    }
    public void print(){
        System.out.println("PC信息");
        System.out.println(getDetails() +"brand = " +  brand);
        //调用父类的信息
    }
}

NotePad类

public class NotePad extends Computer {
    private String color;

    public NotePad(String cpu, int memory, int disk, String color) {
        super(cpu, memory, disk);
        this.color = color;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
    public void print1(){
        System.out.println("加上颜色的信息");
        System.out.println(getDetails() + "颜色" + color );
    }
}