CGB2107 2021.8.11 day09笔记

为什么用多态？（what where why how）

为什么用多态？（what where why how）

为什么用多态？（what where why how）

why：

1、提高了代码的维护性(继承保证)

2、提高了代码的扩展性(由多态保证)

把不同的子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，以适应需求的不断变化。

复习day08

+异常管道：RunTime

基本类型传具体值  引用类型传地址值

---

1.抽象类

可以定义成员变量、成员常量、普通方法、抽象方法

1.1抽象类中的构造函数的使用

抽象类是否有构造方法？有

 既然抽象类不能实例化，为什么有构造方法？

 不是为了自己创建对象时使用，而是为了子类创建对象时使用 super();

练习1：测试抽象类中的构造函数

package cn.tedu.oop;
//本类用于测试抽象类中的构造函数
/*抽象类是否有构造方法？有
* 既然抽象类不能实例化，为什么有构造方法？
* 不是为了自己创建对象时使用，而是为了子类创建对象时使用 super();*/
public class AbstractDemo2 {
    public static void main(String[] args) {
        Pig2 a=new Pig2();
    }

}

abstract class Animal2{
    public Animal2(){
        System.out.println("我是Animal2的无参构造");
    }




}
class Pig2 extends Animal2{
    public Pig2(){
        super();
        System.out.println("我是Pig2的无参构造");
    }
}

1.2

练习2：测试抽象类中的成员

package cn.tedu.oop;
//本类用于测试抽象类中的成员
public class AbstractDemo3 {
}
abstract class Fruit{
    /*1.抽象类中可以定义成员变量吗？--可以！！！！！！*/
    int sum=100;
    /*2.抽象类中可以定义成员常量吗？--可以！！！！！！！！*/
    final String name="小黄人";
    /*3.抽象类中可以定义普通方法吗？--可以！！！！！
    * 全抽/半抽半普/全普*/
    public void clean(){
        System.out.println("水果嘻嘻再吃");
    }
    /*4.抽象类中可以定义抽象方法吗？--可以！！！！！
    全抽/半抽半普/全普*/
   public abstract void grow();
   public abstract void clean1();

}
/*如果一个子类继承了一个抽象父类，有两种解决方案：
* 方案一：作为抽象子类，不实现父类的抽象方法/实现部分抽象方法
* 方案二：作为普通类，实现抽象父类的所有抽象方法*/
class Banana extends Fruit{

    @Override
    public void grow() {
        System.out.println("一串香蕉老沉了");
    }

    @Override
    public void clean1() {
        System.out.println("香蕉不用洗");
    }
}

1.3面向抽象编程

后天重构的结果 一种思维

设计老师类1

package cn.tedu.oop;
//本类用于面向抽象编程的，设计老师类
/*抽象是后天重构的结果*/
public class DesignTeacher {
    public static void main(String[] args) {
        CGBTeacher a=new CGBTeacher();
        ACTTeacher b=new ACTTeacher();
        SCDTeacher c=new SCDTeacher();
        a.teach();
        a.ready();
        b.teach();
        b.ready();
        c.teach();
        c.ready();
    }
}


abstract class Teacher{
    int id;
    String name;
    abstract public void ready();

    abstract public void teach();


}
class CGBTeacher extends Teacher{
    @Override
    public void ready(){
        System.out.println("正在备课JAVA大数据");
    }
    @Override
    public void teach(){
        System.out.println("正在授课JAVA大数据");
    }
}
class ACTTeacher extends Teacher{
    @Override
    public void ready(){
        System.out.println("正在备课JAVA基础加强");
    }
    @Override
    public void teach(){
        System.out.println("正在授课JAVA基础加强");
    }
}
class SCDTeacher extends Teacher{
    @Override
    public void ready(){
        System.out.println("正在备课大数据拓展模块");
    }
    @Override
    public void teach(){
        System.out.println("正在授课大数据拓展模块");
    }
}

---

2.接口(interface)

作用：定义规则

格式：interface 接口名{代码}

1）接口中不可以有普通方法，全是抽象方法！！！！！

2）接口不是类，通过interface来创建接口

3）不可以创建对象！！！！！

4）接口中没有构造方法！！！！！！

5）接口中没有成员变量，会默认拼接static与final→→静态常量！！！！ 通过类名直接调用静态资源

6）接口中的方法可以简写，会自动拼接public abstract

接口实现类通过implements关键字与接口建立实现关系

* 实现方案有两种：

* 方案一：抽象子实现类，可以不实现，或者实现部分接口中的抽象方法

* 方案二：普通子实现类，实现接口中的所有抽象方法

A   创建接口测试：

package cn.tedu.inter;
//本接口用于创建接口测试
/*1.通过interface关键字来定义接口*/
public interface Inter {
    /*2.接口中可以有普通方法吗？--不可以!!!*/
//    public void play(){}
    /*3.接口中可以有抽象方法吗？--可以有！，而且接口中的方法全部都是抽象方法！*/
    public abstract void play();
    
}

B  Inter接口的实现类，用于实现Inter接口中定义的方法：

package cn.tedu.inter;
//本类用作Inter接口的实现类，用于实现Inter接口中定义的方法
/*1.接口实现类通过implements关键字与接口建立实现关系
* 实现方案有两种：
* 方案一：抽象子实现类，可以不实现，或者实现部分接口中的抽象方法
* 方案二：普通子实现类，实现接口中的所有抽象方法*/
public class InterImpl implements Inter{
    @Override
    public void play() {
        System.out.println("玩代码");
    }
}

C 接口功能的测试：

一般创建的都是接口实现类的对象

package cn.tedu.inter;
//本类用作接口功能的测试类
public class InterTest {
    public static void main(String[] args) {
        /*1.接口可以创建对象吗？--不可以！！！*/
//        Inter a=new InterImpl();
//        a.play();
        /*2.我们一般创建的都是接口实现类的对象*/
        InterImpl b=new InterImpl();
        b.play();
    }
}

拓展：

如果一个类没有明确指明父类，那么它的父类就是顶级父类object

既然接口实现类实现了接口，接口中又没有构造方法，那接口实现类构造方法中的第一行super();调用的是？的构造方法

使用的是默认继承的顶级父类object中的无参构造

练习4：测试接口

package cn.tedu.inter2;

import cn.tedu.inter.InterImpl;

//本类用于进一步测试接口的使用
public class TestUserInter {
    /*如果一个类没有明确指明父类，那么它的父类就是顶级父类object
    * 既然接口实现类实现了接口，接口中又没有构造方法，
    * 那接口实现类构造方法中的第一行super();调用的是？的构造方法
    * 使用的是默认继承的顶级父类object中的无参构造*/
    public static void main(String[] args) {
        System.out.println(Inter2.a);//通过类名直接调用静态资源
    }
//    Inter2.a=22;常量不可被修改


}

interface Inter2{
    /*1.接口中有构造方法吗？--不可以！！！！！*/
//    public Inter(){}
    /*2.接口中可以写成员变量吗？--不可以！！！
    * 接口中的不是变量，而是静态常量，会默认拼接static与final
    * 静态的表现可以通过接口名直接调用
    * 常量的表现：值不可以被修改*/
    int a=2;//静态常量
    /*3.接口中的方法可以简写，会自动拼接public abstract*/
    void eat();
}
class Inter2Impl implements Inter2{
    public Inter2Impl(){
        super();
        System.out.println("我是实现类的无参构造");
    }

    @Override
    public void eat() {

    }
}

2.2面向接口编程

接口是先天设计的结果

设计老师类2

package cn.tedu.inter2;
//本类用于面向接口编程之设计老师类案例
/*1.接口是先天设计的结果*/
public class DesignTeacher2 {
    public static void main(String[] args) {
        CGBTeacher a=new CGBTeacher();
        ACTTeacher b=new ACTTeacher();
        a.ready();
        a.teach();
        b.teach();
        b.ready();
    }
}
//1.创建Teacher2接口--提取共性形成抽象层，体现接口，接口定义的是规则
/*2.我们通过interface关键字定义接口*/
interface Teacher2{
    /*3.接口中的都是抽象方法，可以简写，默认拼接public abstract*/
    void ready();
    void teach();
}
//3.创建接口的实现类
/*4.如果实现类需要使用接口的规则就需要与接口建立实现关系 关键字--implements*/
class CGBTeacher implements Teacher2{

    @Override
    public void ready() {
        System.out.println("正在备课JAVA大数据");
    }

    @Override
    public void teach() {
        System.out.println("正在授课JAVA大数据");
    }
}
class ACTTeacher implements Teacher2{

    @Override
    public void ready() {
        System.out.println("正在备课高手加薪");
    }

    @Override
    public void teach() {
        System.out.println("正在授课高手加薪");
    }
}

2.3 接口与类之间的复杂关系

1）接口可以继承接口，甚至可以继承多个接口（多继承）

之前我们学到：一个类只能有一个父类，单继承

 现在，一个类除了可以继承一个父类意外，还可以同时实现多个接口，叫“多实现”

2）类与接口是实现关系（单实现/多实现）

package cn.tedu.inter2;
//本类用于测试接口与类之间的复杂关系
public class TestRelation {
}
//1.创建接口1
interface Inter1{
    void save();
    void find();

}
//2.创建接口2
interface Inter22 {
    void update();
    void delete();
}
//3.创建接口3 汇总了1 2
/*接口可以继承接口？--可以！！*/
interface Inter3 extends Inter1,Inter22{

}
class Inter3Impl implements Inter1,Inter22{
//class Inter3Impl implements Inter3{
/*之前我们学到：一个类只能有一个父类，单继承
* 现在，一个类除了可以继承一个父类意外，还可以同时实现多个接口，叫“多实现”*/
    @Override
    public void save() {
        System.out.println("正在保存中");
    }

    @Override
    public void find() {
        System.out.println("正在查找中");
    }

    @Override
    public void update() {
        System.out.println("正在下载中");
    }

    @Override
    public void delete() {
        System.out.println("正在删除中");
    }
}

---

面试题考点：

1.类与类的关系

继承关系，只支持单继承

比如：class A extends B  A为子类 B为父类，子类具备父类的所有功能

注意：

1）子类不能使用父类的私有资源

2）构造方法不能继承

3）子类如果想更改父类的功能，可以重写（两同两小一大）

      注意：方法名+参数列表--方法签名 

2.类与接口的关系

实现关系，既可以单实现，也可以多实现

class A implements Inter1{}

class A implements Inter2,Inter3{}

A为实现类，Inter1、Inter2、Inter3为被实现的接口

1）实现类去实现接口必须实现接口中所有的抽象方法，如果有任何一个没有实现，就得声明成抽象子类

2）创建实现类对象时，一般使用实现类对象，而不是多态对象，因为效果一样

3.接口与接口的关系

继承关系，既可以单继承，也可以多继承

interface A extends Inter1{}

interface A2 extends Inter2,Inter3{}

A、A2为子接口，Inter1、Inter2、Inter3为被继承的父接口

注意：接口A2的实现类需要实现接口A2继承自Inter2、Inter3的所有抽象方法

4.抽象类与接口的区别

1）抽象类是一个特殊的类，使用class定义，特殊在这个类中可以定义没有方法体的方法（抽象方法）

2）接口可以理解成一个特殊的抽象类，特殊在接口中所有的方法都是抽象方法，但注意接口不是类，用interface定义

3）抽象类中有构造方法，为了给子类创建对象时调用

4）接口中没有构造方法，子类调用的是父类的构造方法

5）接口可以多继承，抽象类只能单继承

6）抽象类可以定义普通的成员变量，但接口只能定义静态常量

7）接口与抽象类均不可以实例化/创建对象

8）抽象是后天重构的结果，接口是先天设计的结果