【狂神说JAVA笔记（八）】P71~P76 多态，instanceof和类型转换，static关键字，抽象类abstract， 接口的定义和实现Interface， N种内部类_狂神n种内部类

B站视频课《狂神说JAVA》P71~P76

（一）多态

一个对象的实际类型是确定的，但是它可以指向的引用类型是不确定的。
可以用父类的引用指向子类的类型。

public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();//创建一个学生对象
        Person s2 = new Student();//创建了一个父类对象，却指向子类
        //父类的引用指向子类的类型
    }
}

1
2
3
4
5
6
7
8

1）子类能调用的方法都是自己的，或者继承父类的；
2）父类可以指向子类，但是不能调用子类独有的方法；
3）对象能执行那些方法，主要看对象左边的类型（就是Student()这个部分），和右边关系不大。

 Person s2 = new Student();//创建了一个父类对象，却指向子类
1

Example:
主类：

public class Application {
    public static void main(String[] args) {
        Student s1 = new Student();//创建一个学生对象
        Person s2 = new Student();//创建了一个父类对象，却指向子类
        //父类的引用指向子类的类型

        //这种对象可以调用父类的方法
        s2.run();//run是一个父类的方法
        s1.run();//如果子类重写了父类的方法，则执行子类

        ((Student) s2).eat();//父类对象不能直接调用子类
        s1.eat();
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

父类：

public class Person { //父类
    public  void run(){
        System.out.println("Father Function Run.");
    }
}

1
2
3
4
5
6

子类：

public class Student extends Person{ //学生类继承父类
   //重写一个父类的方法run()
    public  void run(){
        System.out.println("Son Function Run.");
    }

    public  void eat(){
        System.out.println("Son Function Eat");
    }
}

1
2
3
4
5
6
7
8
9
10
11

多态的注意对象

1.多态是方法的多态，属性没有多态。（属性一般是私有的，方法一般是公有的。）
2.父类和子类之间有联系，可以强制转换。如果乱转换则会产生异常：ClassCastException

((Student) s2).eat();//父类对象不能直接调用子类
1

3.多态的存在条件：类之间具有继承关系，而且方法需要重写。
4.父类引用可以指向子类对象。

（二）instanceof 和类型转换

1. instanceof 关键字——引用类型的类型转换

只有两个类具有父子关系才可以类型转换，instanceof关键字就是检测两个对象之间是否具有父子继承关系。

父子关系才能比较，同级不能比较。在这个例子中，student类和teacher类是同级的，因此不能比较，会返回FALSE。

需要注意的是，两个对象之间至少要有关系，在一条继承线上才能比较，否则会直接编译报错。

public class Application {
    public static void main(String[] args) {
        //创建一个Object类，指向Student
        //Object > Person > Teacher
        //Object > Person > Student
        Object object = new Student();
        //满足父子关系，instanceof就会产生TRUE，否则FALSE
        System.out.println(object instanceof  Student);
        System.out.println(object instanceof Person);
        System.out.println(object instanceof  Object);
        System.out.println(object instanceof  Teacher);
        System.out.println(object instanceof  String);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2. 类型转换

基本的变量类型转换，小转大自动转换，大转小需要强制转换。

对于类的对象来说，就是父转子需要强制转换，小转大则不需要。
（“儿子终究会长成父亲的年纪，父亲想转换成儿子就需要想想办法了。”）

((Student) s2).eat();//父类对象不能直接调用子类, 得先强制转换成子类
1

（三）static关键字详解

在类中使用，方法和属性前面都可以加。加上之后就是静态属性和静态方法。

静态的变量推荐直接使用类名来调用。

假设这是一个Student类。它的静态属性是age。

public class Student extends Person{ //学生类继承父类
    private  static int age; //静态的变量
    private  double score; //非静态的变量

}
1
2
3
4
5

那么在主类之中最好直接用类名Student来调用静态属性，因为静态属性是固定的，是类的所有对象共有的。

Student.age; //直接用类名调用，而不是先创建一个对象然后调用。
1

静态方法中只能调用静态方法，不能调用正常方法。

(四）抽象类 Abstract

1. 在一个类上使用abstract关键字，就直接可以产生抽象类。

public abstract class Action {
}

1
2
3

2. 在一个方法上使用abstract——只有方法的约束，没有方法的名字，让别人帮我们实现（其他的类来实现），只有方法名字，没有方法的实现。

public abstract class Action {
    public  abstract  void doSomething();//一个抽象类，只有名字，没有方法，其他的类可以来实现它。
}

1
2
3
4

也就是说，抽象类的所有方法，必须要由继承了它的子类来实现它的方法。
除非它的子类也是抽象类，那就只有孙子类来实现方法。

public class A extends Action{
    @Override
    public void doSomething() {

    }
}
1
2
3
4
5
6

在这个例子中，A继承了抽象类Action。对于A来说，由于它的父类Action是一个抽象类，而且具有一个抽象方doSomething()，因此A必须重写这个doSometing()方法蔡才能使用。

3. 抽象类是new不出对象来的，只能靠子类来实现它。
抽象类中可以写普通的方法，但是抽象的方法必须在抽象类中。
抽象的抽象：约束。

（五）接口的定义和实现 Interface

（JAVA的类是单继承的，但是接口却可以多继承！）
（接口只有方法的定义！没有方法的实现！）

普通的类：只有具体实现；
抽象类：具体实现和抽象方法都有；

接口：只有规范，无法自己写方法——专业的约束，只能约束不能实现——即约束和实现的分离。
也即面向接口编程。
在大型项目之中，只负责把接口定义好，然后让别人来实现接口。

接口的本质就是规范，定义的是一组规则。

接口的本质是契约，最能体现面向对象一点的地方就是接口。

1.接口中的所有定义都是抽象的

就算不写abstract，默认就是抽象的。

2. 接口一般都需要有实现类，这些类通常以Impl结尾

实现了接口的类，就必须重写接口中的所有方法。

接口：

public interface UserService {
    void add(String name);
    void delete(String name);
    void updata(String name);
    void query(String name);
}

1
2
3
4
5
6
7

实现接口的类：

public class UserServiceImpl implements UserService{
    @Override
    public void add(String name) {

    }

    @Override
    public void delete(String name) {

    }

    @Override
    public void updata(String name) {

    }

    @Override
    public void query(String name) {

    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

实现接口的类可以有很多。这就是接口多继承。

（六）N种内部类

内部类就是在一个类的内部再定义一个类。

比如，A类中定义一个B类，那么B类相对于A类来说就称为内部类，而A类相对于B类来说就是外部类了。

1.成员内部类

2.静态内部类

3.局部内部类

4.匿名内部类