03 面向对象(多态，接口)

如果要求程序员必须在某个类中特定的方法中实现一个特定的功能, 应该如何实现?

使用抽象方法或者使用接口(interface)

抽象方法只能单继承,不能多继承,子类必须使用里面的抽象方法

接口可以多继承,实现类必须重写里面的方法

接口的作用?

接口是一种约定的规范,体现了规范和实现分离的思想

体现低耦合思想(减少依赖关系)

接口和接口实现类定义的语法

接口的语法

public interface 接口名{
void walk();//抽象方法1,里面没有语体
//有默认的实现方法
default void A(){
    System.out.println("有默认实现的方法, 属于对象");
    }
 static void defaultMethod(){
        System.out.println("有默认实现的方法, 属于类");
    }
}
}

一个子类接口可以继承多个接口:

public interface IAmphibiable  extends IWalkable,ISwimable{

}

实现类(implements)的语法:

public class A implements IAmphibiable{
    //重写覆盖IAmphibiable里面的抽象方法
    
}

注意:

//接口名命名规范:I+驼峰命名法
//接口不能创建对象,必须有子类

实现类在实现一个接口的时候, 需要注意哪些问题?

作用:实现接口里面的抽象方法,完成功能具体的实现

1.必须覆盖接口里面的抽像方法

2.可以同时实现多个接口,并且继承在前,实现在后

3.必须完全实现接口中的所有抽象方法,或者他自己也是一个抽象类,直到里面的抽象方法被子类完全实现.

4.实现类的访问修饰符的权限必须大于接口的访问权限

接口和抽象类的区别?

分析
相同点：
1、都可以定义抽象方法
2、都不能创建对象
  
不同点：
1、接口里面全部必须是抽象方法，抽象类中可以定义普通方法。
2、接口可以多继承，抽象类只能单继承。
3、抽象类是用于约定子类应该具备的功能；接口约定的是实现类应该具备的功能；
当需要实现某个功能时，关心的侧重点不同，接口关注的是你有没有这个功能，你是谁他不关心；
抽象类需要关心功能的同时，还得关心你是不是该类的子类。
所以，接口未来用于解耦，体现了软件开发的低耦合要求。

如何理解编译类型和运行类型?

例子

 Animal d2=new Dog();//只要是Animal的子类型,d2里面的方法都有,这样的功能扩展性更好
        //编译时类型-->Animal d2,声明对象变量的类型,编译通过了再到运行时期,否则报错
        //运行时类型__>new Dog,对象的真实类型
        d2.eat();//先找父类有不有这个方法,有的话找子类有不有这个方法覆盖重写,有的话执行子类,否则执行父类
       

编译类型和运行类型只在创建对象的时候进行使用,

编译类型可以是类和接口,并且是运行类型的父类或者接口,而运行类型不可以是抽象类

什么是多态? 如何体现多态?好处是什么?

多态含义:当编译类型和运行类型不一致,一个对象具有多种状态

注意:编译类型必须是运行类型的父类或者接口

如何实现示例:

Dog 	d 	= 	new Dog();  	//创建一只狗对象,赋给子类类型变量

Animal  a  	=	new Cat();    	//创建一只猫对象,赋给父类类型变量

好处:

1.对已存在代码具有可替换性

2.增加新的子类不影响已存在类的多态性、继承性，以及其他特性的运行和操作

3.向子类提供了一个共同接口

操作多态继承关系

语法:

父类 变量名 = new 子类();
变量名.方法();

public class Animal {
	public void shut() {
		System.out.println("Animal...shout...");
	}
}

public class Cat extends Animal{
	public void shut() {
		System.out.println("妙妙妙...");
	}
}

public static void main(String[] args) {
        // 创建Cat对象
       Animal animal = new Cat();
		animal.shut();
    
    //妙妙妙...

结论:父类引用变量指向于子类对象，调用方法时实际调用的是子类的方法。

操作实现关系

接口 变量名 = new 子类();
变量名.方法();

public interface ISwimable{
	void swim();
}

public class Fish implements ISwimable{
    void swim(){
        System.out.println("自由遨游");
    }
}

public static void main(String[] args){
    ISwimable fish=new Fish();
    fish.swim();

}
//运行结果:自由遨游

结论：接口引用变量指向实现类对象，调用方法时实际调用的是实现类实现接口的方法。

多态情况下, 方法访问的流程?

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-UOIc8FRX-1684759193666)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20230228201405261.png)]

流程:

编译时期:先去父类中寻找该方法,找到的话就到裕兴时期,否则报错

运行时期:继续去子类找有不有该方法,有的话就运行子类的方法,没有的话就执行父类的方法

多态中的类型转换(概念和数组一样)

1.自动类型转换：把子类对象赋给父类变量（多态）

语法

父类 变量=new 子类对象();

//该变量只拥有父类自己的方法

Animal a = new Dog();//Animal是DOg的父类
Object  obj = new Dog();	//Object是所有类的根类

2.强制类型转换：把父类类型对象赋给子类类型变量,父类不能直接调用子类的方法时使用强转,否则编译报错

子类类型 变量=(子类变量) 父类对象;

//该变量同时具有父类和子类的方法

由于父类没有这个方法,且需要使用子类这个方法就要强转

**注意:**父类对象的真实类型必须是子类类型

instanceof关键字

作用:判断对象是否是指定的类型

语法格式：
boolean b = 对象A   instanceof  类B;  //判断 A对象是否是 B类的实例？如果是,返回true

综合总结

需求中的功能做接口来用:

package cn.wolfcode._10_network;

public interface IFunction {
    //共同的上网(IInternet)和打电话(ICall)的功能
    void iInternet();
    void iCall();
}

需求中相同的行为做父类方法,字段来使用或者抽象类(abstract)来使用(少用)

public class NetworkOperator {
    //网络类型
private String type;

    public NetworkOperator() {
    }

    public NetworkOperator(String type) {
        this.type = type;
    }

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    @Override
    public String toString() {
        return "网络类型是:" + type ;
    }
    //安装宽带(installBroadband)和安装有线电视(installCableTV)的行为.
    public void installBroadband(){
        System.out.println("可以安装宽带");
    }
    public void installCableTV(){
        System.out.println("可以安装有线电视");
    }

需求中自己特有的行为在子类中定义一个方法使用

需要继承父类的方法和功能,实现接口的功能

public class ChinaMobile extends NetworkOperator implements IChat,IFunction{//继承两个接口,并且必须重写父类的方法
    public ChinaMobile(String type){
        setType(type);//用来接收测试类传进来的实参
    }
    //中国移动
    @Override
    public void ichat() {
        System.out.println("通过飞信实现了聊天");
    }

    @Override
    public void iInternet() {
        System.out.println("实现了上网");
    }

    @Override
    public void iCall() {
        System.out.println("实现了打电话");
    }

}

测试类用来创建对象,做类型转换,instanceof用作对象类型的比较

package cn.wolfcode._10_network;

public class Demo {
    public static void main(String[] args) {
        NetworkOperator m=new ChinaMobile("DT-LTE");
        dowork(m);
        System.out.println("=========");
        NetworkOperator u=new ChinaUnicom("WCDMA");
        dowork(u);
        System.out.println("=========");
        NetworkOperator t=new ChinaTelecom("LTE");
        dowork(t);

    }
    public static void dowork(NetworkOperator n){
        if(n instanceof ChinaUnicom){//使用instanceof进行类型的判断,instanceof用作对象类型的比较
            ChinaUnicom u=(ChinaUnicom) n;
            System.out.println("中国联通:");
            System.out.println(u);
            u.installBroadband();
            u.installCableTV();
            u.iCall();
            u.iInternet();

        }
        if(n instanceof ChinaTelecom){
            ChinaTelecom t=(ChinaTelecom) n;
            System.out.println("中国电信:");
            System.out.println(t);
            t.installBroadband();
            t.installCableTV();
            t.iCall();
            t.iInternet();

        }
        if(n instanceof ChinaMobile){
            ChinaMobile m=(ChinaMobile) n;
            System.out.println("中国移动:");
            System.out.println(m);
            m.installBroadband();
            m.installCableTV();
            m.iCall();
            m.iInternet();
            m.ichat();

        }
    }
}

();
t.iInternet();

    }
    if(n instanceof ChinaMobile){
        ChinaMobile m=(ChinaMobile) n;
        System.out.println("中国移动:");
        System.out.println(m);
        m.installBroadband();
        m.installCableTV();
        m.iCall();
        m.iInternet();
        m.ichat();

    }
}

}