面向对象学习26 - 接口&关键字interface

1.接口的理解：接口的本质是契约、标准、规范。制定好之后需要遵守
2.定义接口的关键字：interface
3.接口内部结构的说明：
>可以声明：
属性：必须使用public static final 修饰
方法：jdk8以前：声明抽象方法，修饰为public abstract
jdk8：声明静态方法、默认方法
jdk9：声明私有方法
>不可以声明：构造器、代码块等
4.接口和类的关系：实现关系
5.格式:class A extends SuperA implements B,C{}
A相较于superA来讲，叫做子类
A相较于B、C来讲，叫做实现类
6.满足此关系后，说明：

类可以实现多个接口
类针对于接口的多实现，一定程度上就弥补了类的单继承的局限性
类必须将实现的接口中所有的抽象方法都重写（或实现），方可实例化。否则，此实现类必须声明为抽象类。
7.接口与接口的关系:继承关系，且可以继承
8.接口的多态性：接口名 变量名 = new 实现类对象；
例：Flyable f1 = new Bullet();
f1.fly();//接下例二

//例一
interface AA{
    void method1();
}

interface  BB{
    void method2();
}

interface CC extends AA,BB{
}

//例二
interface Flyable{
    //全局常量
    public static final int MIN_SPEED = 0;
    //可以省略public static final，表示含义不变
    int MAX_SPEED = 7900;
    //方法可以省略public abstract声明
    void fly();
}

interface Attackable{
    public abstract void attack();
}
abstract class Plane implements Flyable{
}
class Bullet implements Flyable{
    @Override
    public void fly(){
        System.out.println("让子弹飞一会")；
    }
}

9.抽象类和接口的区别

共性：都可以声明抽象方法
都不能实例化

不同：1.抽象类一定有构造器。接口没有构造器
2.类与类之间是继承关系，类与接口之间是实现关系，接口与接口之间是多继承关系

10.题目
1.声明接口Eatable，包含抽象方法public abstract void eat();
2.声明实现类中国人Chinese，重写抽象方法，打印用筷子吃饭。
3.声明实现类美国人American，重写抽象方法，打印用刀叉吃饭。
4.声明实现类印度人Indian，重写抽象方法，打印用手抓饭。
5.声明测试类EatableTest，创建Eatable数组，存储各国人对象，并遍历数组，调用eat()方法

public interface Eatable{
    void eat();
}
public class Chinese implements Eatable{
    @Override
    public void eat(){
        System.out.println("中国人使用筷子吃饭");
    }
}
public class American implements Eatable{
    @Override
    public void eat(){
        System.out.println("美国人使用刀叉吃饭");
    }
}
public class Indian implements Eatable{
    @Override
    public void eat(){
        System.out.println("印度人使用手抓饭");
    }
}
public class EatableTest{
    public static void main(String[] args){
        Eatable[] eats = new Eatable[3];
        eats[0] = new Chinese();
        eats[1] = new American();
        eats[2] = new Indian();

        for(int i = 0;i < eats.length;i++){
            eats[i].eat();
        }
    }
}

定义一个接口来实现两个对象的比较

interface CompareObject{
//若返回值是 0 ，代表相等；若为正数，代表当前对象大；负数表示当前对象小
public int compareTo(Object o)；
}
定义一个Circle类，声明radius属性，提供getter和setter方法
定义一个ComparableCircle类，继承Circle类并实现CompareObject接口。
在ComparableCircle类中给出接口中方法compareTo的实现体，用来比较两个圆的半径大小。

定义一个测试类InterefaceTest，创建两个ComparableCircle对象，调用compareTo方法比较两个类的半径大小。

public interface CompareObject {
    //若返回值是 0，代表相等；若为正数，代表当前对象大；负数代表当前对象小
    public int compareTo(Object o);
}
public class Circle{
    private double radius;//半径
    public Circle(){
    }
    public Circle(double radius){
        this.radius = radius;
    }
    @Override
    public string toString(){
        return "Circle{" +
               "radius = " radius +
               '}';
    }
}
public class ComparableCircle extends Circle implements CompareObject{
    public ComparableCircle(){
    }
    public ComparableCircle(double radius){
        super(radius);
    }

    //根据对象的半径的大小，比较对象的大小
    @Override
    public int compareTo(Object o){
        if(this == o){
            return 0;
        }
        if(o instanceof ComparableCircle){//方式1
            ComparableCircle c = （ComparableCircle)o;
            if(this.getRadius() > c.getRadius()){
                return 1;
            }else if(this.getRadius() < c.getRadius()){
                return -1;
            }else{
                return 0;
            }
        }
        if(o instanceof ComparableCircle){//方式2
            //或者这里也可以这样
            return Double，compare(this.getRadius(),c.getRadius());
        }else{
            throw new RuntimeException("输入类型不匹配")；

        }

    }
} 
public class InterfaceTest{
    public static void main(String[] args){
        ComparableCircle c1 = new ComparableCircle(2.3);
        ComparableCircle c2 = new ComparableCircle(5.3);
    
        int compareValue = c1.compareTo(c2);
        if(compareValue > 0){
            System.out.println("c1对象大")；
        }else if(compareValue < 0){
            System.out.println("c2对象大")；
        }else{
            System.out.println("c1和c2一样大");
        }
    }
}