继承的认知–笔记

继承的认知及其详解–笔记

继承

Entends意思是延申也就相当于继承

认识继承之前先来了解一下这个问题~~

问：
编写多个类的属性和方法有很多是相同的怎么能让代码更简便手续能少一点?
解决方案：
用继承解决=>它是减少了代码复用

介绍：

继承可以解决代码的复用性，让我们的编程更靠近人类思维，当多个类存在相同的属性（变量）和方法时，可以从这些类中抽象出父类，在父类中定义这些相同的属性和方法，所有的子类不需要重新定义这些属性和方法，只需要通过extends来声明继承父类即可

继承的基本语法：

class 子类 extends 父类{

}

1. 子类就会自动拥有父类定义的属性和方法

2. 父类又叫超类，基类

3. 子类又叫派生类

   [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8zarDFk1-1668094294170)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20221003201613318.png)]

子类 extends 父类

//子类
public class Graduate extends Student{
    public void Testing(){
        System.out.println("大学生" + name +  "正在考Java");
    }
}

父类
package com.liu.extend_.improve_;
//父类，是 pupil和Graduate的父类
public class Student {

    //共有的属性
    public String name;
    public int age;
    private double score;

    //共有的方法
    public void setScore(double score) {
        this.score = score;
    }
    public void showinfo(){
        System.out.println("学生名=" + name + " 年龄=" + age + " 分数=" + score);
    }

}

继承带来的便利：

1. 代码的复用性提高了
2. 代码的扩展性和维护性也提高了

继承的细节问题：

1. 子类继承了所有的属性和方法，但是私有属性和方法不能在子类直接所访问，
要通过公共的方法去访问
2. 子类必须调用父类的构造器，完成父类的初始化
3. 当创建子类的对象时，不管使用子类的哪个构造器，默认情况下总会去调用父类
4. 的无参构造器，如果父类没有提供构造器，则必须在子类的构造器中用super
去指定使用父类的哪个构造器完成对父类的初始化工作，否则，编译不会通过
5. 如果希望指定去调用父类的某个构造器，则显示调用一下 ： super（参数列表）
6. super在使用时，需要放在构造器第一行
7. super（）和 this（）都只能放在第一行，因此这两个方法不能共存在一个
构造器
8. Java所有类都是Object 类的子类。Object时所有类的基类
9. 父类构造器的调用不限于直接父类！将一直往上追溯直到object类（顶级父类）
 子类最多只能继承一个父类（指直接继承），即Java中时单继承机制
如何让a类继承4类和5类？
先用a类继承4类再用4类继承5类	
10. 你能滥用继承，父类和子类之间必须满足is-a的逻辑关系


### 继承的本质分析

```java
package com.liu.extend_;
//讲解继承的本质
public class ExtendsTheory {
    public static void main(String[] args) {
        Son son = new Son();
//        (1) 首先看子类是否有这个属性
//            （2）如果子类有这个属性并且可以访问，则返回信息
//                （3）如果子类没有这个属性，就看他的父类有没有这个属性 （如果有并且可以访问就返回  没有则向上找）
        System.out.println(son.name);

    }
}
 class Grandpa{
    String name ="大头爷爷";
    String hobby = "旅游";
}
class Father extends Grandpa{
    String name = "大头爸爸";
    int age = 30;
}
class Son extends Father{
    String name = "大头儿子";
}

```

//自己理解部分

package com.liu.extend_;

public class ExtendsExercise {
    public static void main(String[] args) {
        Pc pc = new Pc("inter",1000000,256,"华为");
        NotePad notePad = new NotePad("AMD",4343,435,"深海蓝");
        pc.printInfo();
        notePad.printInfo();
    }
}
//父类
class Computer {
    //属性
    String Cpu;
    double Memory;
    int Disk;
    //构造器
    public Computer(String cpu, double memory, int disk) {
        Cpu = cpu;
        Memory = memory;
        Disk = disk;
    }
    //get和set方法
    public String getDetails(){
        return "cpu=" + Cpu + " 内存= " + Memory + "硬盘=" + Disk;
    }
    public String getCpu() {
        return Cpu;
    }

    public void setCpu(String cpu) {
        Cpu = cpu;
    }

    public double getMemory() {
        return Memory;
    }

    public void setMemory(double memory) {
        Memory = memory;
    }

    public int getDisk() {
        return Disk;
    }

    public void setDisk(int disk) {
        Disk = disk;
    }
}
//pc类 继承 computer
class Pc extends Computer{
    //属性
    String brand;
    //构造器
    public Pc(String cpu, double memory, int disk, String brand) {
        super(cpu, memory, disk);//定位父类的位置
        this.brand = brand;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }
    //输出信息
    public void printInfo(){
        System.out.println("Pc信息");
        //调用父类的方法输出
        System.out.println(getDetails() + "brand = " + brand);
    }
}
//NotePad类 继承 computer
class NotePad extends Computer{
    //属性
    String color;
    //结构体
    public NotePad(String cpu, double 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 printInfo(){
        System.out.println("NotePad信息");
        //调用父类的方法输出
        System.out.println(getDetails() + "color = " + color);
    }
}

super关键字

基本介绍

super代表父类的引用，用于访问父类的属性，方法，构造器

基本语法

1.访问父类的属性，但不能访问父类的private属性【案例】：supper.属性名；

2.访问父类的方法，不能访问父类的private方法	【案例】

supper.方法名（参数列表）；

3.访问父类的构造器（这点前面用过）

supper（参数列表）；只能放在构造器第一句，只能出现一句

super给编程带来的便利/细节

1. 调用父类构造器的好处（明确分工，父类属性有父类初始化，子类属性有子类
初始化）
2. 当子类中有和父类中的成员（属性和方法)重名时，为了访问父类的成员，
必须通过super。如果内有重名使用this,super,直接访问是一样的效果
3. 找方法的顺序调用时先调用本类的，如果没有就去找父类.....
4. supper的访问不限于直接父类，如果爷爷类和本类中有同名的成员，也可以
 使用supper去访问爷爷类的成员；如果多个基类中都有同名的成员，使用
 supper访问遵循就近原则。A-B-C

​

supper和this的区别

this表示当前对象：

   1.this.属性 区别成员变量和局部变量
   2.this.() 调用本类的某个方法
   3.this() 表示调用本类构造方法，只能用在构造方法的第一行语句。
   4..this关键字只能出现在非static修饰的代码中

super表示父类对象：

1.super.属性 表示父类对象中的成员变量
2.super.方法()表示父类对象中定义的方法
3.super() 表示调用父类构造方法
    可以指定参数，比如super("Tom",23);
    任何一个构造方法的第一行默认是super();
    可以写上，如果未写，会隐式调用super();
4.super()只能在构造方法的第一行使用。
5.this()和super()都只能在构造的第一行出现，所以只能选择其一。
6.写了this()就不会隐式调用super()。

方法重写（override）

基本介绍：

方法覆盖就是子类有一个方法，和父类的某个方法的名称，返回类型，参数一样，那么我们就说子类的这个方法覆盖了父类的那个方法

注意事项和使用细节

1. 子类的方法的参数，方法名称，要和父类的方法参数，方法名称完全一样 
2. 子类方法的返回类型和父类方法返回类型一样，或者父类返回类型的子类
3. 子类方法不能缩小父类方法的访问权限(PUBLIC AND PRIVATE)