Java学习日记:面向对象继承，多态，接口（复习）

后面的内容大多都以继承，多态，接口为基础。(有些不懂后面的知识了，前面的知识还需要巩固补上之前没有写博客的笔记)

封装我清楚这里跳过

继承 extends

继承父类的所有方法（先把子类new出来）

new出类时会执行构造方法（分为空参和有参）

且如果new出子类也会先后执行其父类与自己的构造方法

可以多重继承但是不能多继承

this();本类的构造

super():父类的构造!

方法的重写（override）

方法重写只存在于子类和父类(包括直接父类和间接父类)之间。

在同一个类中方法只能被重载，不能被重写

静态方法不能重写

子类可以定义与父类的静态方法同名的静态方法(但是这个不是覆盖）

🔷abstract修饰符可以用来修饰方法也可以修饰类,如果修饰方法, 那么该方法就是抽象方法;如果修饰类,那么该类就是抽象类。

🔷抽象类中可以没有抽象方法,但是有抽象方法的类一定要声明为抽象类。

🔷抽象类,不能使用new关键字来创建对象,它是用来让子类继承的。

🔷抽象方法,只有方法的声明,没有方法的实现,它是用来让子类实现的。

🔷子类继承抽象类,那么就必须要实现抽象类没有实现的抽象方法,否则该子类也要声明为抽象类

1.不能new 这个抽象类，只能靠子类去实现它；约束！

2.抽象类中可以写普通方法~

3.抽象方法必须在抽象类中~ 抽象的抽象：约束！

static（在自己的类里为所欲为，我还是不太理解看看就行）

🍭static 关键字是静态的意思,是Java中的一个修饰符,可以修饰成员方法,成员变量

static修饰的特点

🍭被类的所有对象共享是我们判断是否使用静态关键字的条件

🍭随着类的加载而加载，优先于对象存在对象需要类被加载后，才能创建

🍭可以通过类名调用也可以通过对象名调用

注意事项(理解)

🍭静态方法只能访问静态的成员

🍭非静态方法可以访问静态的成员，也可以访问非静态的成员

🍭静态方法中是没有this关键字

匿名代码块(一次)，静态代码(每次)，构造方法(每次)

代码块的优先级 静态代码块>构造代码块>构造方法;

public class Demo9 {
    {
        System.out.println("匿名代码块");
    }//执行一次
    static {
        System.out.println("静态代码块");
    }//new一次运行一次
    public Demo9(){
        System.out.println("构造方法");
    }//new一次运行一次
    public static void main(String[] args) {
        new Demo9();
        System.out.println("---------------------");
        new Demo9();
    }
}
//静态代码块
匿名代码块
构造方法
---------------------
匿名代码块
构造方法

final(代表最终的意思，可以修饰成员方法，成员变量，类)

💦fianl修饰类：该类不能被继承（不能有子类，但是可以有父类）

💦final修饰方法：该方法不能被重写

💦final修饰变量：表明该变量是一个常量，不能再次赋值

变量

(🍭变量是基本类型,不能改变的是值

🍭变量是引用类型,不能改变的是地址值,但地址里面的内容是可以改变的)

小结

子父类都有静态代码块、构造代码块、构造方法，那么他们六者之间的执行流程是什么？

1.父类静态代码块 2.子类静态代码块

3.父类构造代码块 4.父类构造方法

5.子类构造代码块 6.子类构造方法

继承的好处、弊端分别是什么？

好处：提高代码的复用性 提高代码的维护性 让类与类之间产生关系，是多态的前提

弊端：类的耦合性增强了； 开发的原则是：高内聚，低耦合 耦合是类与类的关系 内聚是自己完成某件事的能力

为什么子类中所有的构造方法默认都会访问父类的空参构造？

假如父类没有无参构造方法，子类应该怎么办?

1、因为子类继承父类中的数据，也可能会使用父类的数据；

2、子类初始化前，必须要要先将父类初始化。 如果父类没有空参构造，就用this或者super来调用父类的有参构造。

super关键字和this关键字可以在构造方法中共存吗？

this()或者super()都必须是在构造方法中的第一行；

多态

一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多（父类，有关系的类）

多态存在的条件

💠有继承关系 💠子类重写父类 💠父类引用指向子类对象

🔷注意：多态是方法的多态，属性没有多态性。

对象能执行哪些方法，主要看对象左边的类型，和右边关系不大！

如Person s2 = new Student();主要看Person类下有什么方法，有的才能调用，反之不行

但是结果看Student类重写的方法（所谓的成员方法 编译看父类，运行看子类）

成员变量 编译看父类（左），运行看父（左）类（同理不做解释）

instanceof：通俗的理解：判断关键字左边的变量，是否是右边的类型，返回boolean类型结

public class Action {
2 public static void main(String[] args) {
3
4 // Object > String
5 // Object > Person > Teacher
6 // Object > Person > Student
7 Object object = new Student();
8
9 System.out.println(object instanceof Student); // true
10 System.out.println(object instanceof Person); // true
11 System.out.println(object instanceof Object); // true
12 System.out.println(object instanceof Teacher); // false
13 System.out.println(object instanceof String); // false
14 System.out.println("-----------------------------------");
15
🔷向上转型
父类引用指向子类对象就是向上转型
🔷向下转型
格式：子类型 对象名 = (子类型)父类引用;
代码实例
16 Person person = new Student();
17
18 System.out.println(person instanceof Student); // true
19 System.out.println(person instanceof Person); // true
20 System.out.println(person instanceof Object); // true
21 System.out.println(person instanceof Teacher); // false
22 //System.out.println(person instanceof String); // false //编译就报错
23 System.out.println("-----------------------------------");
24
25 Student student = new Student();
26
27 System.out.println(student instanceof Student); // true
28 System.out.println(student instanceof Person); // true
29 System.out.println(student instanceof Object); // true
30 //System.out.println(student instanceof Teacher); // false //编译就报错
31 //System.out.println(person instanceof String); // false //编译就报错
32
33 //System.out.println(X instanceof Y); //能不能编译通过 ！ 看x和y有没有父子关系
34 }
35 }

向下转型（子类型 对象名 = (子类型)父类引用）

目前没什么用，后面学习会用到

接口（属性为全局静态常量）

自我理解：由于不能多继承，所以有了接口可以更丰富子类的方法应用且接口可以接入多个

为什么用

分析： 门有“开”和“关”的功能，锁有“上锁”和“开锁”的功能，将门和锁分别定义为抽象类

思路： 将门定义为抽象类，锁定义为接口 防盗门继承门，实现锁的接口

特性

接口不可以被实例化

实现类必须实现接口的所有方法

实现类可以实现多个接口

接口中的变量都是静态常量 ：public static final

接口中所有的方法必须是抽象方法：public abstract

Java 8 之后 接口中可以使用 default 关键字修饰的非抽象方法。

接口的设置interface

1 public interface Lock {
2 void lockUp(); //锁
3 void openLock(); //开锁
4 }

接口的接入implements

public class TheftproofDoor extends Door implements Lock {

在接口的设置里面

😀 成员变量 ：只能是常量 默认修饰符：public static final

构造方法：没有，因为接口主要是扩展功能的，而没有具体存在

成员方法：只能是抽象方法 默认修饰符：public abstract