Java基础笔记 day5

 一、接口interface

接口interface 对行为的抽象，用implements去实现
* 一个类可以实现多个接口 eg：public abstract class AnimalImpl implements JumpInterface1，JumpInterface2
* 一个接口可以继承多个接口 eg：public interface  AniInterface1 extends AniInterface2，AniInterface3

1.接口中定义的成员变量为常量（默认加了public static final修饰），直接通过接口名称访问即可
2.接口中定义的成员方法为抽象方法（默认加了public abstract修饰），实现类需要重写接口中的所有抽象方法或者将实现类定义为抽象的
3.接口没有构造方法
4.jdk8之后在接口中可以定义非抽象方法，用default关键字修饰
5.接口不能被实例化，可以通过实现类对象实例化去实现（接口多态） JumpInterface cat = new AnimalImpl();

定义接口：

package com.clouds.demo05_imterface;

//接口interface 对行为的抽象，用implements去实现
//一个类可以实现多个接口 eg：public abstract class AnimalImpl implements JumpInterface1，JumpInterface2
//一个接口可以继承多个接口 eg：public interface  AniInterface1 extends AniInterface2，AniInterface3
public interface JumpInterface {

    //接口中定义的成员变量为常量（默认加了public static final修饰），直接通过接口名称访问即可
    int jump = 20;//public static final int jump=2

    //接口中定义的成员方法为抽象方法（默认加了public abstract修饰）
    void jump();//public abstract void jump();

    //jdk8之后在接口中可以定义非抽象方法，用default关键字修饰
    /*public default void show() {
        //System.out.println("非抽象方法");
    }*/
    //接口没有构造方法，
}

接口的实现： 

package com.clouds.demo05_imterface;

//一个类可以实现多个接口 eg：public abstract class AnimalImpl implements JumpInterface1，JumpInterface2
public abstract class AnimalImpl implements JumpInterface {
    private String name;
    private int age;
    public abstract void eat();
    public AnimalImpl() {

    }

    public AnimalImpl(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
/*//实现类需要重写接口中的所有抽象方法或者将实现类定义为抽象的

    @Override
    public void jump() {

    }*/

}

class AnimalImpl1 implements JumpInterface{
    @Override
    public void jump() {

    }
}

 继承接口的实现：

package com.clouds.demo05_imterface;

public class Cat extends AnimalImpl{

    public Cat(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("猫爱吃鱼");
    }

    @Override
    public void jump() {
        System.out.println("猫向上跳");
    }

}
class Cat1 extends AnimalImpl1{

}

  继承接口的实现：

package com.clouds.demo05_imterface;

public class Dog extends AnimalImpl{
    @Override
    public void jump() {
        System.out.println("狗冲刺跳起");
    }
    @Override
    public void eat() {
        System.out.println("狗爱吃骨头");
    }
}

 二、多态

多态：成员变量：编译、运行看左边
      成员方法：编译看左边，运行看右边
* 有继承或者实现的关系
* 方法的重写
* 父类的引用指向子类 父类引用指向子类对象 向上转型（多态机制）从子到父
* 向下转型（强制转换）从父到子 父类引用转为子类对象 就可调用子类的属性和方法

* instance of （体现多态，可以判断强行转换是否可以）通过返回一个布尔值来指出某个对象是否是某个特定类或者是该特定类的子类的一个实例
即instanceof就是用来判断该对象是否是右边的类或者右边类的子类所创建的，如果是则返回true，否则返回false
* 编译时 class可以是object对象的父类、自身类和子类
* 运行时 class可以是object对象的父类、自身类、Object（返回true），不能是子类（不报错但返回false）
即在运行状态下，class可以是实际对象类型的父类、自身类、子类。
比自己等级高的包括自身类都返回true，属于自己的子类或者兄弟类的都返回false。

例子为接口的多态：

package com.clouds.demo05_imterface;


public class Test {
    public static void main(String[] args) {
        //接口中定义的成员变量为常量（默认加了public static final修饰），直接通过接口名称访问即可
        System.out.println("跳高的标准为" + AnimalImpl.jump + "cm");

        //接口不能被实例化，可以通过实现类对象实例化去实现（接口多态） JumpInterface cat = new AnimalImpl();
        //定义了一个类，如果没有继承任何父类，则在默认情况下就继承了Object类
        JumpInterface cat1 = new Cat("小橘猫", 2);
        cat1.jump();

        AnimalImpl cat2 = new Cat("小黑猫", 3);
        cat2.jump();
        cat2.eat();
        System.out.println(cat2.getName() + "已经" + cat2.getAge() + "岁了");
        Dog dog = new Dog();
        dog.setAge(4);
        dog.setName("拉布拉多");
        dog.eat();
        dog.jump();
        System.out.println(dog.getName() + "已经" + dog.getAge() + "岁了");
        //instance of 体现多态，可以判断强行转换是否可以
        //通过返回一个布尔值来指出某个对象是否是某个特定类或者是该特定类的子类的一个实例
        //即instanceof就是用来判断该对象是否是右边的类或者右边类的子类所创建的，如果是则返回true，否则返回false
        //ctrl+Y 删除行
        AnimalImpl dog1 =new Dog();
        AnimalImpl1 cat01 =new AnimalImpl1();
        //编译时 class可以是object对象的父类、自身类和子类
        if(dog1 instanceof Cat){
            System.out.println("dog1是Dog类型");
        }
        else{
            System.out.println("dog1不是Dog类型");
        }
        //运行时 class可以是object对象的父类、自身类、Object（返回true），不能是子类（不报错但返回false）
        //即在运行状态下，class可以是实际对象类型的父类、自身类、子类。
        //比自己等级高的包括自身类都返回true，属于自己的子类或者兄弟类的都返回false。
        if(cat01 instanceof Cat1){
            System.out.println("cat01是AnimalImpl类型");
        }
        else{
            System.out.println("cat01不是AnimalImpl类型");
        }

    }
}

三、运行结果 

跳高的标准为20cm
猫向上跳
猫向上跳
猫爱吃鱼
小黑猫已经3岁了
狗爱吃骨头
狗冲刺跳起
拉布拉多已经4岁了
dog1不是Dog类型
cat01不是AnimalImpl类型

四、接口与继承的区别

抽象abstract与接口interface的区别
* 接口interface 对行为的抽象，用implements去实现
* 抽象abstract 对事物的抽象,对类抽象包括属性行为, 通过extends去实现

案例如下：（把门去抽象化，把额外的报警功能通过接口扩展）

package com.clouds.demo05_imterface;

//抽象abstract与接口interface的区别
//接口interface 对行为的抽象，用implements去实现
//抽象abstract 对事物的抽象,对类抽象包括属性行为,通过extends去实现
public class demo_AbsTestInter {
    public static void main(String[] args) {
        //智能门锁通过接口去扩展功能，获取了警报功能
        Door door1 = new smartDoorImpl(200, 80, "小新智能门");
        door1.open();
        door1.close();
        //通过强转去实例化接口的报警功能
        smartDoorImpl door3 = (smartDoorImpl) door1;
        door3.alarm();
        System.out.println(door1.getName() + "," + door1.getHigh() + "-" + door1.getWidth());
        System.out.println("_______________________________");
        //基础的木门，可以开门和关门
        Door door2 = new woodenDoor(280, 180, "朴树木门");
        door2.open();
        door2.close();
        System.out.println(door2.getName() + "," + door2.getHigh() + "-" + door2.getWidth());

    }
}

abstract class Door {
    private int high;
    private int width;
    private String name;

    public abstract void open();

    abstract void close();

    public Door(int high, int width, String name) {
        this.high = high;
        this.width = width;
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getHigh() {
        return high;
    }

    public void setHigh(int high) {
        this.high = high;
    }

    public int getWidth() {
        return width;
    }

    public void setWidth(int width) {
        this.width = width;
    }
}

//基础的木门，可以开门和关门
class woodenDoor extends Door {
    public woodenDoor(int high, int width, String name) {
        super(high, width, name);
    }

    @Override
    public void open() {
        System.out.println("我是木门，可上锁开门");
    }

    @Override
    void close() {
        System.out.println("我是木门，可上锁关门");
    }
}

abstract class ironDoor extends Door {
    public ironDoor(int high, int width, String name) {
        super(high, width, name);
    }
}

//智能门锁通过接口去扩展功能，获取了警报功能
class smartDoorImpl extends Door implements Alarm {
    public smartDoorImpl(int high, int width, String name) {
        super(high, width, name);
    }

    @Override
    public void alarm() {
        System.out.println("我是智能门锁，我支持警报功能");
    }

    @Override
    public void open() {
        System.out.println("我是智能门锁，支持指纹、刷卡、声音、虹膜、人脸开门");
    }

    @Override
    void close() {
        System.out.println("我是智能门锁，可自动关门");
    }
}

interface Alarm {
    void alarm();
}

案例运行结果： 

我是智能门锁，支持指纹、刷卡、声音、虹膜、人脸开门
我是智能门锁，可自动关门
我是智能门锁，我支持警报功能
小新智能门,200-80
_______________________________
我是木门，可上锁开门
我是木门，可上锁关门
朴树木门,280-180