Java中接口interface关键字的基本语法

怼烎@ 2023-02-24 11:23 25阅读 0赞

**接口interface关键字的基础语法：**

1、接口也是一种引用数据类型，编译之后也是一个class字节码文件。

2、接口是完全抽象的，抽象类是半抽象的，或者也可以说接口是一种特殊的抽象类。

3、接口怎么定义？  
\[修饰符列表\] **interface** 接口名\{ \}

4、接口中所有的元素都是用public修饰的，都是公开的。

5、接口中只有两部分内容：  
**常量**（public final static修饰的变量）  
**抽象方法**（public abstract修饰的方法）

附提：java8新特性，让接口内容更多。

6、接口中的方法都是抽象方法，抽象方法不能有方法体。

7、接口中的常量都是public final static修饰的，抽象方法都是public abstract修饰的，修饰符可以省略不写。

8、接口支持多继承，一个接口可以继承多个接口。

9、类与类之间叫做继承，接口与接口之间也叫继承，那么类与接口之间叫什么关系？

答：我们称类与接口的关系为”实现“，接口不能实现类，只能类去实现接口，一个类可以实现多个接口。**这种机制弥补了java中类只能单继承的缺陷**。

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

如何理解类“实现”接口？  
答：我们先把接口理解为一种特殊的抽象类，类“实现”多个接口，相当于这个类 “特殊的继承（实现）” 了多个 “特殊的抽象类（接口）”。

继承使用extends关键字，实现使用implements关键字。

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

10、非抽象类继承抽象类，必须重写父类的所有抽象方法。  
非抽象类实现接口，必须实现接口的所有抽象方法。

所以抽象类实现接口，可以实现接口的抽象方法，也可以不实现。因为抽象方法可以在出现抽象类里面，实际上抽象方法就是只能在抽象类中。

如果抽象类实现了接口的抽象方法，则抽象类的子类无需再重写。没实现的抽象方法，抽象类的子类一定得重写，不重写会报错。

测试代码：

public class Test { 
        public static void main(String[] args) { 
            //访问接口的常量，接口可以理解为一种特殊的抽象类，直接使用“接口名.”访问
            System.out.println("π = " + MyMath.PI);
            System.out.println("e = " + MyMath.E);
    
            //把接口理解成一种特殊的抽象类，那可以使用多态吗？可以，并且以后开发就是这么写代码的。
            //多态：父类型引用指向子类型对象，鹦鹉算数
            MyMath m1 = new Parrot();
            int res1 = m1.add(10, 20);
            int res2 = m1.sub(10, 20);
            System.out.println("a = " + res1 + ", b = " + res2);
    
            //多态：人算数
            MyMath m2 = new Person();
            int res3 = m2.add(10, 20);
            int res4 = m2.sub(10, 20);
            System.out.println("a = " + res3 + ", b = " + res4);
        }
    }
    
    //定义一个接口M1
    interface M1 { 
    
    }
    
    //定义一个接口M2
    interface M2 { 
    
    }
    
    //定义一个MyMath接口
    interface MyMath extends M1, M2 { 
        //常量：圆周率PI
        public final static double PI = 3.1415926;
    
        //常量：自然对数的底数E
        double E = 2.718281828;  //接口中常量的public final static可以省略
    
        //抽象方法：加add
        public abstract int add(int a, int b);
    
        //抽象方法：减sub
        int sub(int a, int b);  //接口中抽象方法的public abstract可以省略
    }
    
    //定义一个人的类，实现M1，M2，MyMath接口
    class Person implements M1, M2, MyMath{ 
        @Override
        public int add(int a, int b) { 
            return a + b;
        }
    
        @Override
        public int sub(int a, int b) { 
            return a - b;
        }
    }
    
    //定义一个抽象鸟类，实现MyMath接口
    abstract class Bird implements MyMath{ 
        //抽象类Bird实现了MyMath的sub方法，Bird的子类不需要再重写
        public int sub(int a, int b) { 
            return a - b;
        }
    
        //抽象类Bird没有实现MyMath的add方法，就必须留给Bird的子类实现。
        //抽象类中没实现接口的方法相当于继承过来了
        public abstract int add(int a, int b);
    }
    
    //定义一个鹦鹉类，继承抽象类Bird
    class Parrot extends Bird { 
    
        public int add(int a, int b) {   //重写父类的抽象方法
            return a + b;
        }
    
    }

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

接口看成一种特殊的抽象类，故也存在多态语法：

测试代码

public class Test02 { 
        public static void main(String[] args) { 
            /*D d = new D(); d.m1(); //输出：m1()方法实现 d.m2(); //输出：m2()方法实现*/
    
            //运用多态：父类型的引用指向子类型的对象
            //先测试一下接口与接口之间的转换关系
            A a = new D();
            B b = (B)a;  //此行编译通过，所以得出结论，java编译中允许没有继承关系的两个接口之间强制转换。
            //为什么？答：因为在编译时不实例化对象，编译器不知道a1指向的是什么类对象，万一这个类实现了这两个接口，这两个接口之间就可以强制转换，所有编译器认定所有两个接口之间都能强制转换。
            //C c = (C)a; //此行编译通过，但运行时报错：ClassCastException: class D cannot be cast to class C (D and C are in unnamed module of loader 'app')
            //虽然java中允许没有继承关系的两个接口之间强制转换，但运行时可能出现ClassCastException，为防止这种情况，建议使用instanceof判断
            //上面两行转型代码应该这样写
            if (a instanceof B) { 
    
            }
            if (a instanceof C) { 
    
            }
    
            //现在我们再来测试接口的多态
            //D类实现了2个接口A，B，相当于父类型有2个，那怎么用多态？
            //第一种：A类型接口指向D类型引用
            A a1 = new D();
            //a1.m1(); //输出：m1()方法实现
            //a1.m2(); //编译报错：a1里找不到m2()方法，如果a1想调用a2方法，可以转换接口或者向下转型成D，下面再讲
            //第二种：B类型接口指向D类型引用
            //B b1 = new D();
            //b1.m2(); //输出：m2()方法实现
    
            //通过向下转型：接口A a1 --> D类型，向下转型用instanceof关键字先判断
            if (a1 instanceof D) {   //条件为true，因为a1指向的堆对象是D类型
                D d1 = (D) a1;
                //d1.m1(); //输出：m1()方法实现
                //d1.m2(); //输出：m2()方法实现
            }
    
            //接口A a1 --> B接口型
            if (a1 instanceof B) {   //条件为true，因为a1指向的堆对象是D类型，D类型实现（继承）了B接口，D属于B，条件成立
                B b1 = (B)a1;
                b1.m2();  //输出：m2()方法实现
            }
            //试一下A a1接口能不能 --> C接口
            if (a1 instanceof C) {   //条件不成立，因为a1指向的堆对象是D类型，D类型没有实现（继承）B接口，D不属于B，条件不成立
                C c1 = (C)a1;
                c1.m3();  //条件不成立，里面代码不执行，没输出
            }
    
        }
    }
    
    //接口A
    interface A { 
        void m1();
    }
    
    //接口B
    interface B { 
        void m2();
    }
    
    //接口C
    interface C { 
        void m3();
    }
    
    //类D，实现了接口A，B
    class D implements A, B{ 
        @Override
        public void m1() { 
            System.out.println("m1()方法实现");
        }
    
        @Override
        public void m2() { 
            System.out.println("m2()方法实现");
        }
    
    }

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

**不同的类实现同一接口会有不同的作用：**

测试代码：

/* * 继承和实现都存在的话，代码应该怎么写 * extends关键字在前，implements关键字在后，例如：class B extends A implements C1, C2 { } * * */
    public class Test03 { 
        public static void main(String[] args) { 
            Wings w1 = new Duck();
            w1.fly();
    
            Wings w2 = new Cat();
            w2.fly();
        }
    }
    
    //定义一个接口：Wings（翅膀）
    interface Wings { 
        void fly();
    }
    
    //定义一个类：Animal（动物）
    class Animal { 
    
    }
    
    //定义一个子类：Duck（鸭子）
    class Duck extends Animal implements Wings { 
        @Override
        public void fly() { 
            System.out.println("有了翅膀接口，我就是一只会飞的鸭子！");
        }
    }
    
    //定义一个子类：Cat（猫）
    class Cat extends Animal implements Wings { 
        @Override
        public void fly() { 
            System.out.println("有了翅膀接口，我就是一只会飞的猫！");
        }
    }

————————————————————————————  
**总结：**

1、接口是一种引用数据类型，编译之后也产生“.class”文件。

2、接口是完全抽象的，抽象类是半抽象的。

3、接口怎么定义：\[访问修饰符\] interface 接口名 \{ \}

4、接口支持多继承，一个接口可以继承多个接口。

5、接口中的元素都是公开的，都是public修饰的。

6、接口中只有常量（public final static修饰）和抽象方法（public abstract）。

7、接口中常量的public final static，抽象方法的public abstract修饰符都可省略不写。

8、接口中的抽象方法不能有方法体。

9、一个非抽象类实现接口时，必须将接口中所有抽象方法重写。

10、一个类可以同时实现多个接口。

11、一个类继承父类，同时实现接口时，extends在前，implements在后。