day02面向对象

接口
是java中的一种引用类型,是方法的集合,如果说类的内部封装了成员变量、构造方法和成员方法，那么接口的内部主要就是封装了方法，包含抽象方法、默认方法和静态方法。
使用关键字interface，它也会被编译成.class文件。
抽象类：类中方法不明确做什么，定义为抽象方法，用abstract修饰，没有{}主体。
一个抽象类中，定义了n个方法，全都是抽象的，这个再被称为类就不合适了，更贴切的名字叫接口（方法的集合，抽象）；理解为全是抽象方法的抽象类----接口。
接口的定义：
使用关键字interface
格式：
public interface 接口名字（类名）

public interface MyInterface {
}

----------------------------------------------------------

接口中成员的定义：（JDK版本不同，定义的内容不同）
JDK1.7版本和他之前：
可以定义两种成员：
1.成员变量（固定的修饰符）
public static final 数据类型 变量名=值

public static final int A=1;

2.成员方法（固定的修饰符）
public abstract 返回值类型 方法名（参数列表）；

 public abstract void inter();

接口中的修饰符，可以省略不写！

----------------------------------------------------------

接口的使用——实现类实现接口
使用方式：
1.接口不能new对象
抽象类中有抽象方法和非抽象方法，子类继承后，非抽象方法可以直接被使用，抽象方法需要重写。而接口中全是抽象方法，接口和类称为实现关系。
抽象类中是继承，接口中是实现！！！
2.定义类实现接口（实现类实现接口）
关键字：implements
3.重写接口中的全部抽象方法
4.创建接口实现类对象，也就是new（实现类/子类）

----------------------------------------------------------

支持接口的多实现（一个类可以实现多个接口）
定义格式：
public class A implements 接口1，接口2，接口3{}

public interface MyInterface implements A,B,C{}

实现类重写所有实现的接口中的全部抽象方法。
一个类可以继承另一个类，同时可以实现多个接口。

public interface MyInterface extends C implements A,B{

接口中的多继承（一个接口可以继承多个接口）

public interface MyInterface extends A,B{

----------------------------------------------------------

接口在JDK1.8版本中进行了修改：
1.接口中添加了静态、非抽象方法；（接口名.方法名（）进行调用）

public interface MyInterface{
	//1.接口中添加了静态、非抽象方法；
    public static void staticMethod(){
        System.out.println("接口中的静态方法");
    }
    }

public static void main(String[] args) {
        //使用接口中的静态方法
        //接口名.方法名（）
        MyInterface.staticMethod();
    }

2.接口中添加了默认非抽象方法。（默认方法只能被实现类调用）也就是impl实现接口，然后再调用。

public interface MyInterface{
    //2.接口中添加了默认非抽象方法。
    public default void defaultMethod(){
        System.out.println("接口中的默认方法");
    }
}

public class MyInterfaceImpl implements MyInterface {
}

public class Test {
    public static void main(String[] args) {
        MyInterfaceImpl myInterface = new MyInterfaceImpl();
        myInterface.defaultMethod();
    }
}

注意：对于接口的默认方法，可以被实现类对象impl调用；实现类impl也可以重写默认方法（但是不能有default关键字）。

public interface MyInterface{
    public default void defaultMethod(){
        System.out.println("接口中的默认方法");
    }
}

public class MyInterfaceImpl implements MyInterface {
    public void defaultMethod(){
        System.out.println("实现类impl重写默认方法");
    }
}

public class Test {
    public static void main(String[] args) {
        MyInterfaceImpl myInterface = new MyInterfaceImpl();
        myInterface.defaultMethod();
    }
}

----------------------------------------------------------

对象的多态性
多态：一个事物的多种形态。
多态的前提：
1.要有继承父类或者接口实现（一个即可）
2.要有方法的重写
3.父类或者接口的引用指向子类的对象（代码的实现）
父类引用 = 子类对象
Person p = new Student()

public abstract class Animal {
    public abstract void eat();
}

public class Cat extends  Animal{
    public void eat(){
        System.out.println("猫吃鱼");
    }
}

 //程序中的多态，子类继承父类（抽象类）的形式
        Animal animal=new Cat();
        animal.eat();//执行子类的方法重写

----------------------------------------------------------

对象多态性使用的细节：
成员变量：
编译：检测父类中是否有这个变量，如果有编译成功，否则失败
运行：运行的是父类中的变量
成员方法：
编译：检测父类中是否有这个变量，如果有编译成功，否则失败
运行：运行的是子类的重写

比如：Fu fu=new Zi（）；
精简：（编译就看检测，方法就是运行）
变量：编译运行看左边
方法：编译看左边，运行看右边

public class Fu {
    //变量
    String str="父类";
    //方法
    public void show(){
        System.out.println("父类方法show");
    }
}

public class Zi extends Fu {
    //变量
    String str="子类";
    //方法
    public void show(){
        System.out.println("子类重写方法");
    }
}

public class Test {
    public static void main(String[] args) {
        //创建子类对象，多态性
        Fu fu=new Zi();
        // 变量：编译运行看左边
        System.out.println(fu.str);//输出父类

        // 方法：编译看左边。运行看右边
        fu.show();//输出子类重写方法
    }
}

编译运行原理：

----------------------------------------------------------

多态的好处和弊端：
好处：对子类可以进行扩展，执行子类方法的重写
弊端：多态中，只能调用子类和父类的共有成员，不能调用子类的特有成员
如果，必须调用子类的成员，需要转型

强制转换的安全判断：关键字instanceof
在类型转换之前，进行判断，否则可能出现类型转换异常（因为animal之前可能被赋值为cat，当你再想要将animal转换成dog的时候，需要进行判断才行，否则cat无法直接强转为dog）

public abstract class Animal {
    public abstract void eat();
}

public class Cat extends  Animal{
    public void eat(){
        System.out.println("猫吃鱼");
    }
    //Cat猫类，添加自己特有功能
    public void catchMouse(){
        System.out.println("猫抓老鼠");
    }
}

public class Dog extends Animal{
    public void eat(){
        System.out.println("狗吃骨头");
    }
    //Dog类，添加自己的特有功能
    public void lookDoor(){
        System.out.println("狗看门");
    }
}

public class Test {
    public static void main(String[] args) {
        Animal animal=new Cat();
        animal.eat();
        //Cat对象，提升为父类类型
        //类型强制转换，animal类型转换成Cat
        //出现ClassCastException,类型的转换异常  对象是Dog,强制转成Cat
        //解决异常出现的问题: 对象是Dog,强制转为Dog, 对象是Cat,强制转为Cat

        // 关键字,也是比较运算符  instanceof  计算结果 true,false
        // 变量名 instanceof  类名  例子: animal  instanceof Cat  animal类型是不是Cat对象
        // boolean b = animal instanceof Dog;
        // System.out.println(b);

        //类型转换前,进行判断
        if(animal instanceof Cat){
            //转换，animal类型转换为Cat
            Cat c=(Cat)animal;
            c.catchMouse();
        }
        if(animal instanceof Dog){
            //转换,animal类型转为Dog
            Dog d=(Dog)animal;
            d.lookDoor();
        }
    }
}

----------------------------------------------------------

接口的作用（笔记本案例）：
接口就是一个对外暴露的规则，只要满足此规则，就可以被使用。
接口中的权限，固定为public，解开耦合性。

/**
 * 定义接口: USB接口
 * 定义2个规则,开启和关闭
 */
public interface USB {
    public abstract void open();
    public abstract void close();
}

/**
 * 定义笔记本类
 * 开机,关机,使用USB接口上的外接设备功能
 */
public class Computer {
    //开机
    public void powerOn(){
        System.out.println("笔记本开机");
    }
    //关机
    public void powerOff(){
        System.out.println("笔记本关机");
    }
    /**
     *   使用USB接口上的外接设备功能
     *   什么设备,不确定,设备很多
     *   但是: 确定这些设备都实现USB接口
     *
     *   方法的参数列表的具体含义
     *   参数是方法在运行的时候的不确定因素 (参数)
     *
     *   方法中,添加不确定因素,就是外接设备,但是这设备都实现接口USB
     *
     *    useUSB(  USB u )
     *    方法名   参数USB接口 (不确定因素)
     *    任何USB接口的实现类,都能使用
     *
     *   USB u = mouse
     *   接受的参数是,实现类的对象
     *   可以传递任意的实现类
     */
    public void useUSB(USB u){
        //接口引用调用方法,实现类重写
        u.open();
        u.close();
    }
} 

/**
 * USB接口外接设备,键盘
 * 实现接口,重写方法
 */
public class KeyBoard implements USB{
    @Override
    public void open() {
        System.out.println("键盘开启");
    }

    @Override
    public void close() {
        System.out.println("键盘关闭");
    }
}

/**
 * 鼠标类,外接设备,USB接口的实现类
 * 实现接口,重写方法
 */
public class Mouse implements USB {

    @Override
    public void open() {
        System.out.println("鼠标开启");
    }

    @Override
    public void close() {
        System.out.println("鼠标关闭");
    }
}

public class Test {
    public static void main(String[] args) {
        //创建笔记本对象
        Computer computer = new Computer();
       /* computer.powerOff();
        computer.powerOn();*/

        //创建鼠标对象,是接口USB的实现类
        Mouse mouse=new Mouse();
        computer.useUSB(mouse);

        //使用USB设备方法,使用的是键盘
        //KeyBoard keyBoard = new KeyBoard();
        computer.useUSB(new KeyBoard());

        //   computer.useUSB( 任意接口实现类对象 );
    }
}