Java 基础 面向对象: 接口(interface )概念 以及接口之练习3 -定义一个接口用来实现两个对象的比较并 判断instanceof是否为同类

接口(interface )概念概念笔记 及测试代码:

/** 面向对象: 接口(interface ) 是与类并行的一个概念:
 *      1.接口可以看成一个特殊的抽象类,它是常量与抽象方法的一个集合
 *      2.接口里的常量默认: public static final 类型!
 *      3.接口里的抽象方法,默认所有方法是: public abstract 修饰
 *      4.接口没有构造器.
 *      5.接口定义的是一种功能 ,此功能可以被类所实现(implements),比如:class BB (extends DD) implements AA;
 *      6.实现接口的类必须重写其中的所有抽象类,方可实例化;若没有重写所有的抽象方法,则此类仍是一个抽象类.
 *      7.类是可以实现(implements )多个接口, 类的继承(extends)是单继承!
 *      8.接口与接口之间的继承关系,是可以多继承!一个可以继承多个!
 *      ----------
 **  接口与具体的实现类之间也存在多态性
 *      1.通过接口可以实现不相关类的相同行为,而不需要考虑这些类之间的层次关系
 *      2.接口主要用于定义规范,解除耦合关系.
 */

测试代码:

public class Main_of_Coding {  //TestAbstract
    public static void main(String[] args) {
        Duck  d=new Duck();
        d.fly();
        d.run();
        d.swim();
        System.out.println("*************");
        Main_of_Coding.test1(d);
        Main_of_Coding.test2(d);
        Main_of_Coding.test3(d);

    }
    public static void test1(Runner r){
        r.run();
    }
    public static void test2(Swimmer s){
        s.swim();
    }
    public static void test3(Flier f){
        f.fly();
    }
}
interface Runner{
    public abstract void run();
}
interface Swimmer{
    void swim();
}
interface Flier{
    void fly();
}
class Duck implements Runner,Swimmer,Flier{
    @Override
    public void run() {
        System.out.println("鸭子跑啊跑,不然变成黄焖鸭!");
    }

    @Override
    public void swim() {
        System.out.println("红掌拨清波");
    }

    @Override
    public void fly() {
        System.out.println("丑小鸭也可以变成白天鹅!");
    }
}

测试输出:

丑小鸭也可以变成白天鹅!
鸭子跑啊跑,不然变成黄焖鸭!
红掌拨清波
*************
鸭子跑啊跑,不然变成黄焖鸭!
红掌拨清波
丑小鸭也可以变成白天鹅!

---

练习3:

练习要求:

/** 面向对象: 接口之练习3
 * 定义一个接口用来实现两个对象的比较。
 * interface CompareObject{
 *     public int compareTo(Object o);   //若返回值是 0 , 代表相等; 若为正数，代表当前对象大；负数代表当前对象小
 *  }
 * 定义一个Circle类。
 * 定义一个ComparableCircle类，继承Circle类并且实现CompareObject接口.
 * 在ComparableCircle类中给出接口中方法compareTo的实现体，用来比较两个圆的半径大小。
 * 定义一个测试类TestInterface，创建两个ComparableCircle对象，调用compareTo方法比较两个类的半径大小。
 */

编写代码:

public class Main_of_Coding {  //TestAbstract
    public static void main(String[] args) {
        ComparableCircle c1=new ComparableCircle(1);
        ComparableCircle c2=new ComparableCircle(2);
        ComparableCircle c3=new ComparableCircle(3);
        System.out.println(c1.CompareTo(c1));
        System.out.println(c1.CompareTo(c2));
        System.out.println(c1.CompareTo(c3));
     //   System.out.println(c1.CompareTo(new String("6666")));
    }
}
interface CompareObject{
    public int CompareTo(Object o);
}
class Circle{
    int radio;

    public Circle(int radio) {
        this.radio = radio;
    }

    public int getRadio() {
        return radio;
    }

    public void setRadio(int radio) {
        this.radio = radio;
    }
}
class ComparableCircle extends Circle implements CompareObject{
    public ComparableCircle(int radio) {
        super(radio);
    }
    @Override
    public int CompareTo(Object o) {
        if(this==o)
            return 0;
        else if(o instanceof ComparableCircle){ //判断o是否是ComparableCircle
            ComparableCircle c=(ComparableCircle)o;
            if(this.getRadio()>c.getRadio())
                return 1;
            else if(this.getRadio()<c.getRadio())
                return -1;
            else
                return 0;
        }
        else{
           // return -2;
            throw new RuntimeException("传入的非ComparableCircle对象 不可进行比较!");
        }
    }
}

输出结果:

0
-1
-1

添加测试代码段:

System.out.println(c1.CompareTo(new String("6666")));

结果:

Exception in thread "main" java.lang.RuntimeException: 传入的非ComparableCircle对象 不可进行比较!
    at Coding.ComparableCircle.CompareTo(Main_of_Coding.java:61)
    at Coding.Main_of_Coding.main(Main_of_Coding.java:21)