Java接口的调用和实现

野性酷女 2023-09-27 14:29 232阅读 0赞

//public class Main {//表示Main是一个类，是一个public共有的类
    //    //Main{}表示一个类的开始和结束
    //    public static void main(String[] args) {//表示一个主方法，即我们程序的入口
    //        //main(){}表示方法的开始和结束
    //        System.out.println("Hello world!");//表示输出“Hello world!”，“;”表示语句结束
    //    }
    //}
    package Interfaces;
    //接口是一个引用类型，是方法的集合。jdk7以前包含抽象方法，jdk8以前包含默认方法和静态方法，jdk9包含了私有方法。
    //定义接口语法
    //接口的使用，它不能创建对象，但可以被实现(implements,类似于被继承)。一个实现接口的类(可以看做是接口的子类)，
    // 需要实现接口中所有的抽象方法，创建该类对象，就可以调用方法了，否则它必须是一个抽象类。
    public  interface Main {
        //在接口里面这个抽象方法，静态方法，默认方法就是用public修饰(抽象方法不被实现就没有什么存在意义了)，可以省略掉public
        //jdk7:只能定义抽象方法
        public abstract void saveUser();
        //abstract void saveUser();//public可以省略
        //void saveUser();//还可以在这个基础上把abstract省略，这样代表的也还是抽象方法
        //jdk8:静态方法(这个方法就有方法体了)，不过这个静态方法换成private也行
        public static void deleteUser(){
            System.out.println("删除用户1");
        };
        //jdk8:默认方法，public去掉也可以
    //默认方法的使用，可以继承，可以重写，二选一，但只能通过实现类的对象来调用
        //私有方法在实现类中不能重写。私有方法是给接口里面的默认方法提供调用的
        //用默认方法调用私有方法
        public default void modifyUser(){
            System.out.println("修改用户");
            findUserById();
            //静态不能调用非静态的，非静态的可以调用静态的
            deleteUser();
        }
        //jdk9:增加了私有方法，这里的private底下会标红是因为此时使用的jdk是1.8版本
        private void findUserById(){
            System.out.println("根据编号获取用户");
        }
    }

package Interfaces;
    //实现类要实现接口，必须要实现接口中的抽象方法(不过除了该实现类为抽象类，可以不用实现)，选择实现接口里面的默认方法
    public class MainImpl implements Main{
        @Override
        public void saveUser() {
            System.out.println("添加用户2");
        }
    //    @Override
    //    public void modifyUser() {
    //        //Main.super.modifyUser();
    //        System.out.println("实现类重写接口的默认方法");
    //    }
    
    //这里并不是重写，静态方法无法重写
        public static void deleteUser() {
            System.out.println("删除用户。。。");
    
        }
    }

package Interfaces;
    public class TestMain {
        public static void main(String[] args) {
            //由于接口不能被实例化，故只好创建接口实现类的实例
            MainImpl ma = new MainImpl();
            ma.saveUser();//调用实现方法
            ma.modifyUser();//调用默认方法
            //接口的静态方法调用(静态方法跟字节码文件有关,只能通过接口名调用)
            Main.deleteUser();
            //要调用实现类当中的接口，要用实现类里面的名字，然后.deleteUser
            MainImpl.deleteUser();
        }
    }

![fcd0b0b523430cb1d709743ff25a7501.png][]

同时Java中：

单继承：类与类之间是单继承的，直接父类只有一个。一个类只能继承一个类（如果[子类][Link 1]继承的多个父类里面有相同的方法或者属性，子类将不知道具体继承哪一个，会产生歧义，类是单继承，多实现。通俗的讲，子类只能有一个亲身父亲，但是一个父类可以有多个孩子。）

多继承：接口与接口之间是[多继承][Link 2]的。类与接口之间是多实现的，一个接口可以继承多个类，一个类可以实现多个接口（接口可以继承多个父接口的相同方法，不同的属性，不能继承多个父接口中相同的属性）。

一个类实现多个接口的情况：

package Interfaces;
    //定义多个接口
    //定义实现类：class  类名  【extends 父类名】 implements 接口名1，接口名2，接口名3，......
    public interface A {
        //public abstract void showA();
        void showA();//这样简写也可以
        //public abstract void show();
        void show();
        //默认方法
        default void showX(){
            System.out.println("A......showX");
            showZ();
        }
        //静态方法
        //接口中，存在同名的静态方法并不会冲突，原因是只能通过各自接口访问静态方法。
        //优先级的问题
        //当一个类，即继承一个父类，又实现若干个接口时，父类中的成员方法与接口中的默认方法重名，子类就近选择执行父类的成员方法
        public static void showY(){
            System.out.println("静态。。。showY");
        }
        private  void showZ(){
            System.out.println("私有。。。showZ");
        }
    }

package Interfaces;
    public interface B {
        void showB();//这样简写也可以
        void show();
        //默认方法
        default void showX(){
            System.out.println("B......showX");
            showZ();
        }
        //静态方法
        public static void showY(){
            System.out.println("静态。。。showY");
        }
        //私有方法
        private void showZ(){
            System.out.println("私有。。。showZ");
        }
    }

package Interfaces;
    public class C implements A,B{
        //实现所有的抽象方法
        @Override
        public void showA() {
            System.out.println("实现A方法");
        }
        @Override
        public void showX() {
            System.out.println("重写。。。showX");
            //调用指定接口的  默认方法
            //接口名称.super.方法名（）
            A.super.showX();//调用A中的showX()方法
            B.super.showX();//调用B中的showX()方法
        }
        @Override
        public void showB() {
            System.out.println("实现B方法");
        }
        @Override
        public void show() {
            System.out.println("实现show");
        }
        //不用再写一个测试类了，直接写一个主函数就可以测试了
        //psvm
        public static void main(String[] args) {
            C c = new C();
            c.show();
            c.showB();
            c.showA();
            c.showX();
            A.showY();
            B.showY();
    
        }
    }

一个类继承一个类实现若干个接口的情况：（接口的多继承）

接口的多继承
    在Java中，类的多继承是不合法，但接口允许多继承。
    在接口的多继承中extends关键字只需要使用一次，在其后跟着继承接口。

public interface Hockey extends Sports, Event

**以上的程序片段是合法定义的子接口，与类不同的是，接口允许多继承，而 Sports及 Event 可能定义或是继承相同的方法**

[fcd0b0b523430cb1d709743ff25a7501.png]: https://img-blog.csdnimg.cn/img_convert/fcd0b0b523430cb1d709743ff25a7501.png
[Link 1]: https://so.csdn.net/so/search?q=%E5%AD%90%E7%B1%BB&spm=1001.2101.3001.7020
[Link 2]: https://so.csdn.net/so/search?q=%E5%A4%9A%E7%BB%A7%E6%89%BF&spm=1001.2101.3001.7020