2021/07/10笔记

我们于2021/07/10 的学习目标是:面向对象编程，核心任务为:

1、学习技术:

1)、多态

2)、抽象abstract

3)、接口interface

4）、类型转换

2、文档总结

1)、多态

多态指一种事物的多种表现形态，行为的多态以及一个行为的不同实现方式。

多态的前提是类的继承和接口的实现。

父类的引用指向子类的对象是多态的最终体现。

多态调用会调用子类中重写的方法。

多态要想有意义，要配合方法的重写。

多态调用会调用子类中重写的方法。

配合方法的重写，当父类引用指向不同的子类对象，同一个方法具有不同的实现方式。这就是行为多态。

例：

public class Class001_Polymorphic {

    public static void main(String[] args) {

        //对应类型的数据赋值给对应类型的变量

        int i = 1;

        Person p = new Person();

        Student s = new Student();

        //多态的最终体现

        Person person = new Teacher();

        person.test();

    }

}

class Person{

    void test(){

        System.out.println("Person");

    }

}

class Student extends Person{

    void test(){

        System.out.println("Student");

    }

}

class Teacher extends Person{

    void test(){

        System.out.println("Teacher");

    }

}

多态调用成员的特点：

父类引用调用成员变量，编译运行看父类|左边|类型

父类引用调用成员方法，编译看父类|左边|类型，运行找子类|右边|对象。

做题四大原则：

• 继承链：自己没有再找父
• 编译看类型、确定方法，运行找对象
• 就近最优原则
• 父类引用对子类新增方法不可见

2)、抽象abstract

被abstract修饰的类叫抽象类。

被abstract修饰的方法叫抽象方法，其中抽象方法没有方法体，存在于抽象类中。

抽象类的特点：

1.抽象类不能实例化

2.抽象类可以定义任意内容(属性,功能(抽象的方法,具体的方法))

3.抽象方法必须要求被重写

4.抽象类使用: 通过具体子类对象使用

具体子类: 重写所有的抽象方法 + 按需新增

抽象子类: 按需重写抽象方法 + 按需新增

5.一个抽象方法一旦被重写,可以不再被重写,根据需求决定

6.abstract不能与private,final,static,native 一起使用

7.抽象类可以实现多态

例：

/*

    开发部门:

        Develop 开发部  work()

        java攻城狮  work(){"服务器端开发"}

        web程序猿   work(){"客户端开发"}

*/

public class Class001_Abstract {

    public static void main(String[] args) {

        //Develop d = new Develop();

        //具体子类对象

        Develop java = new Java();

        java.work();

        java.sleep();

        //java.mr();

    }

}

//父类

abstract class Develop {

    //方法体: 不知道怎么写,不知道写什么

    public abstract void work();

    //具体方法

    public void sleep(){

        System.out.println("胡吃海喝!!!!");

    }

}

//子类

class Java  extends Develop{

    @Override

    public void work() {

        System.out.println("服务器端开发");

    }

    //新增功能

    public void mr(){

        System.out.println("与测试,产品,谈论...探讨...");

    }

}

//抽象子类

abstract class Web extends Develop{

    //public abstract void work();

    public void haha(){

        System.out.println("每天哈哈傻笑...");

    }

}

3)、接口interface

接口就是比“抽象类”还“抽象”的“抽象类”，可以更加规范的对子类进行约束。

接口是功能的集合

数据类型是引用数据类型

类是单继承，接口多实现

1.接口不能实例化

2.接口需要通过实现类的对象使用

3.父类需要通过子类继承  extends  -->父类中的成员,子类继承父类有权可以直接使用

接口需要通过实现类去实现  implements --> 因为接口中几乎都是抽象方法没有方法体,需要实现类自己实现方法体,所有叫做实现

接口的实现与类的继承很像,都拥有了父类的成员使用权,或者拥有接口中定义的功能,但是一个侧重点在拿过来就用,一个侧重点在拿过来要实现才能用

4. 接口的使用:

具体的实现类 : 重写所有的冲向方法 + 按需新增

抽象的实现类 : 按需重写 + 按需新增

5.接口可以多实现,类只能单继承

6.如果一个类同时继承父类实现接口,要求先继承后实现

4）、类型转换

之前我们已经学过基本数据类型的类型转换，引用数据类型也有类型转换。

向上转型：自动类型提升（多态调用: 对子类新增内容不可见）

Person p = new Student();

向下转型：强制类型转换（通过s引用调用Student类型所有的内容）

Student s = (Student)p;

ClassCastException 类型转换异常：引用强转类型的时候,没有转为指向的子类对象类型,转为了其他子类类型,出现的异常。

要预防出现类型转换异常，可以使用instanceof 运算符，它会判断前面的引用是否指向后面类型的对象或者后面类型子类的对象，并返回布尔值。