day10_java继承(java三大特点之二)

继承

一、继承的概念：

​ 多个类中存在相同的属性和方法（行为）时，将这些相同的内容单独封装到一个类当中，那么多个其他类无需再定义这些属性和行为，只需要继承这个单独类即可；

继承中类之间体现的是：“is a”的关系

案例

学生，军人，老师等都有相同的属性
​ 姓名，年龄

相同的方法：
​ eat()

那么就需要将这些相同内容提取到一个单独的Person类中，让学生，军人，老师继承Person类即可。

二、继承的语法

// 父类
class Person{
    String name;
    int age;
    public void eat(){
        // 方法体
        System.out.println("吃饭");
    }
}
// 子类1
class Studnet extends Person{
    // 子类将自动有父类的非private修饰的属性和方法，不需要再定义。
}
// 子类2
class Teacher extends Person{
    // 子类将自动有父类的非private修饰的属性和方法
}
// 主类
public class Demo1 {
    public static void main(String[] args) {
        Student student = new Student();
        student.name = "张三";
        student.age = 18;
        System.out.println(student.name); // 张三
        student.eat(); // 吃饭
    }
}

三、继承的优缺点：

1. 优点
   • 提高了代码的复用性
   • 提高了代码的维护性
   • 让类与类产生了关系，是多态的前提
2. 缺点（弊端）
   • 让类与类产生类关系（耦合度增高）

**四、继承的特点：**单继承多层继承

Java中只能单继承（只能有一个直接父类）
java中继承支持多层继承

1、继承的注意事项：

1. 子类不能继承父类的私有成员（属性，方法）

2. 子类不能继承父类的构造方法，但可以通过super关键字访问父类的构造方法

3. 不要为了继承而继承

   可能会不光继承了需要的，还继承了不需要的
   

   什么时候用继承？？？

   继承中类之间体现的是：“子类 is a 父类”的关系

   Person（人）
   	Student（学生）
   	Teacher（老师）
   

   通过假设法，判断是否满足is-a关系

2、super关键字

this与super的区别：

1. this指当先类的对象
2. super代表父类的对象（super代表父类存储空间的标识），可以通过super去操作父类的属性和方法。

怎么使用：

1. 调用成员：

   this.成员变量

   super.成员变量：super.成员方法(); // 一般当子类和父类的成员冲突时调用加super

2. 调用构造方法

   this(参数…)：调用本类的构造方法

   super(参数…)：调用父类的构造方法，子类会自动调用无参的构造方法

3、继承中变量的关系

1. 子类成员变量与父类成员变量名称不一样，直接用名称调用
2. 子类成员变量与父类名称相同，子类使用变量的顺序
   1. 找子类的局部变量
   2. 找子类的成员变量
   3. 找父类的成员变量
   4. 没找到报错

4、继承中构造方法的关系

1. 子类中所有的构造方法默认都会访问父类的无参构造方法

   why？？？

   因为子类会继承父类的数据，使用父类的数据

   所以：子类初始化之前，一定要先完成父类的数据初始化

   注：子类每个构造方法的第一句都会默认是super()

2. 继承中构造方法的注意事项：

   如果父类没有无参构造方法，将会报错

   • 给父类写一个无参的构造方法
   • 把子类每一个构造方法第一句都写上super(参数…)
   • 子类通过this去调用本类的其他构造方法，其他构造方法先访问父类构造方法

   注：this(…)，super(…)都必须放在构造方法的第一句

   面试题

class Fu{
    public int num=10;
    static {
        System.out.println("父类静态代码块");
    }
    {
        System.out.println("父类构造代码块");
    }
    public Fu() {
        System.out.println("fu");
    }
}
class Zi extends Fu{
    public int num=20;
    static {
        System.out.println("子类静态代码块");
    }
    {
        System.out.println("子类构造代码块");
    }
    public Zi() {
       // super();
        System.out.println("zi");
    }
    public void show() {
        int num=30;
        System.out.println(num);
        System.out.println(this.num);
        System.out.println(super.num);
    }
}
public class Demo {
    public static void main(String[] args) {
        Zi zi=new Zi();
        zi.show();
    }
}
// 父类静态代码块 子类静态代码块 父类构造代码块  fu  子类构造代码块 zi  30 20 10

5、继承中成员方法的关系

继承中成员方法的关系

1. 子类方法与父类方法声明**不一样**，直接调用

2. 子类方法与父类方法声明**一样**，就近原则。

   通过子类调用方法：

   • 先找子类中有没有这个方法
   • 再看父类中有没有这个方法
   • 都没有：报错

面试题

一个类的对象的初始化new
如果有父类，先对父类初始化--》子类初始化
0. 父类初始化（成员变量--》构造函数）
1. 子类成员变量默认初始化
2. 子类成员变量显示初始化
3. 子类构造方法 
class X {
    Y b = new Y();
    X() {
        System.out.print("X");
    }
}
 class Y {
    Y() {
        System.out.print ("Y");
    }
}
public class Demo9 extends X {
    Y y = new Y();
    Demo9() {
        //super();
        System.out.print("Z");
    }
    public static void main(String[] args) {
        new Demo9();
    }
}
// Y X Y Z

6、重写

子类与父类方法相同，我们应用的是子类，所以可以称子类重写父类的方法，java中我们称这种情况为：重写（override）

重载（overload）：同一个类中，方法名相同，参数类型或个数不同

**重写（override）：**继承关系中，子类去重写父类已经有的方法，方法的声明要一致（包括方法名，返回值，参数都要一致）

重写的注意事项：

1. 父类私有方法不能重写，因为父类的私有方法根本没有办法被继承

2. 子类的重写父类时，权限不能更低（最好保持一致）

   权限访问修饰符：public > protected > default > private

3. 父类的静态方法，子类必须是静态的，

@override // 通过override注解检查是否重写父类的方法，如果写了该注解，则必须重写父类的可以重写的方法。
public void call(){
    // 重写的方法体
}

7、final关键字

final：最终的意思，常用于修饰类，方法，变量

1. final修饰的类：不能被继承
2. final修饰的方法：不能被重写（覆盖）
3. final修饰的变量：不能被重新赋值（初始化之后就不能改变），因为被final修饰的变量其实就是常量

final只初始化一次。

final修饰不同的数据类型：

1. 基本类型：存储的值不能改变
2. 引用类型：存储的是地址值，但是地址存储的数据可以改变