小工具知识网

当前位置: 首页 > 行业知识 > Java基础-接口

行业知识

Java基础-接口

2026-11-18 10:32:34 来源:互联网转载

文章目录

    • 1.快速入门
        • 代码:
        • 结果:
        • 2.接口基本介绍
            • 1.语法
              • 注意:在jdk1.8以后接口才可以有静态方法,默认方法
              • 2.代码实例
              • 3.接口的应用场景
                  • 1.场景介绍
                  • 2.代码实例
                  • 4.接口使用细节
                  • 5.接口课堂练习
                      • 题目:
                      • 答案:
                      • 注意:
                      • 6.接口和继承的比较
                          • 1.代码实现
                          • 2.比较
                          • 7.接口多态特性
                              • 1.接口引用可以指向任何实现了接口的类的对象
                              • 2.多态数组
                              • 8.接口的多态传递
                                  • 一个类实现了子接口也就相当于实现了父接口
                                  • 9.接口课堂练习
                                      • 题目:
                                      • 代码:
                                      • 10.关于Object类型引用指向一个实现了接口的类的情况

                                        1.快速入门

                                        代码:
                                        package interface_;public class interface01 {    public static void main(String[] args) {        new Implements(new Phone()); //使用Implements的构造方法来调用接口,只需要传入实现接口类型的对象就可以        new Implements(new Computer());    }}//一个Usb接口,可以让手机和电脑实现interface Usb {    public void start();    public void stop();}//手机实现接口class Phone implements Usb{    @Override    public void start() {        System.out.println("手机开始工作");    }    @Override    public void stop() {        System.out.println("手机停止工作");    }}//电脑实现接口class Computer implements Usb {    @Override    public void start() {        System.out.println("电脑开始工作");    }    @Override    public void stop() {        System.out.println("电脑停止工作");    }}//这个类是用来调用接口的class Implements {    public Implements(Usb usb) {        usb.start();        usb.stop();    }}
                                        结果:

                                        2.接口基本介绍

                                        1.语法
                                        interface 接口名 {属性方法(1.抽象方法 2.默认实现方法 3.静态方法)}
                                        class 类名 implements 接口 {自己属性自己方法必须实现的接口的抽象方法}
                                        注意:在jdk1.8以后接口才可以有静态方法,默认方法
                                        2.代码实例
                                        package interface_;public class Interface02 {    public static void main(String[] args) {        A a = new B(); //调用接口        a.printA();        A.printB();        a.abmetnod();    }}interface A {    int a = 10;    int b = 20; //属性    default public void printA() { //默认实现方法        System.out.println("我是接口A的默认实现方法");        System.out.println(a);    }    public static void printB() { //静态方法        System.out.println("我是接口A的静态方法");        System.out.println(b);    }    public void abmetnod(); //抽象方法}class B implements A {    @Override    public void abmetnod() {        System.out.println("我是被B实现的A接口的抽象方法");    }}

                                        3.接口的应用场景

                                        1.场景介绍

                                        定义一个接口,连接数据库,要求分别连接mysql,Oracle两种数据库,这样就可以提现接口的强大

                                        1. 方法名已经规定好了,体现了规范性
                                        2. 想要使用哪种方式,就使用那个类来实现接口,实现了统一调用的
                                        2.代码实例
                                        package interface_;import com.sun.org.apache.xpath.internal.operations.Or;public class interface03 {    public static void main(String[] args) {        print(new Mysql());        print(new Oracle());    }    //静态方法用来统一调用接口    public static void print(DBconnect dBconnect) {        dBconnect.connect();    }}interface DBconnect {    public void connect();}class Mysql implements DBconnect {    @Override    public void connect() {        System.out.println("连接mysql数据库");    }}class Oracle implements DBconnect {    @Override    public void connect() {        System.out.println("连接Oracle数据库");    }}
                                        4.接口使用细节
                                        1. 接口不能被实例化
                                        2. 接口中所有的方法默认都是public abstract
                                        3. 接口中所有的属性都是public static final,并且必须初始化
                                        4. 接口中的属性在外部访问最好是 :接口名.属性名
                                        5. 一个普通类实现接口,就必须将该接口的所有方法都实现,使用alt + Enter
                                        6. 抽象类实现接口,可以不用实现接口的方法
                                        7. 一个类可以同时实现多个接口
                                        8. 接口不能继承其他的类,但是可以继承多个别的接口
                                        9. 接口的修饰符只能是public 和 默认,这点和类的修饰符是一样的

                                        5.接口课堂练习

                                        题目:
                                        答案:
                                        package interface_;public class InterfaceExercise01 {    public static void main(String[] args) {        BB b = new BB();        System.out.println(b.a); //可以通过子类引用的方式来访问接口的属性但是不推荐        System.out.println(AA.a); //使用父类类名访问静态变量 ok        System.out.println(BB.a); //使用子类类名访问静态变量 ok    }}interface AA {    int a = 23;}class BB implements AA {}
                                        注意:

                                        子类继承父类,或者子类实现接口,则静态变量就变成两者共享的了,所以,使用子类的类名访问共享的静态变量也是可以的

                                        6.接口和继承的比较

                                        1.代码实现
                                        package interface_;public class ExtendsVsInterface {    public static void main(String[] args) {        littleMonkey littleMonkey = new littleMonkey("悟空");        littleMonkey.climbing();        littleMonkey.flying();        littleMonkey.swiming();    }}class Monkey {    private String name;    public Monkey(String name) {        this.name = name;    }    public void climbing() { //猴子类具有的爬树功能        System.out.println("猴子" + name + "会爬树");    }}//鱼接口interface Fishable {    void swiming(); //游泳的功能}//鸟接口interface Birdable {    void flying(); //鸟的飞翔功能}class littleMonkey extends Monkey implements Fishable,Birdable{ //小猴子类继承了猴子类,就继承了猴子类的爬树功能    public littleMonkey(String name) {        super(name);    }    //小猴子类实现了鱼接口的游泳功能    @Override    public void swiming() {        System.out.println("小猴子会像鱼一样游泳");    }    //小猴子实现了鸟接口的飞翔功能    @Override    public void flying() {        System.out.println("小猴子会像鸟一样飞翔");    }}
                                        2.比较
                                        1. 类是单继承多实现的,接口是多继承(只能继承接口)的机制
                                        2. 当子类继承了父类,则自动拥有父类的功能
                                        3. 如果子类需要扩展功能,就可以通过实现接口的方式去扩展
                                        4. 可以理解为:实现接口是对java单继承机制的补充
                                        5. 接口与继承解决的问题不同
                                          1. 继承:解决代码的复用性和可维护性
                                          2. 接口:设计好各种规范(方法),让其他类去实现这些方法
                                        6. 接口比继承更加灵活
                                          1. 继承:满足is - a的关系
                                          2. 接口:满足like - a的关系
                                        7. 接口在一定程度上实现代码解耦

                                        7.接口多态特性

                                        1.接口引用可以指向任何实现了接口的类的对象
                                        2.多态数组
                                        package interface_;public class InterfacePolyArr {    public static void main(String[] args) {        Usb_[] usb = new Usb_[2]; //接口引用的数组usb指向两个接口引用的空间        usb[0] = new Phone_();        usb[1] = new Camera();        for (int i = 0; i   

                                        8.接口的多态传递

                                        一个类实现了子接口也就相当于实现了父接口
                                        package abstract_;/** * 接口的多态传递 */public class InterFacePolyPass {    public static void main(String[] args) {        IH ih = new Teacher();        IG ig = new Teacher();        //一个类实现了子接口也相当于实现了父接口    }}//两个接口,是继承关系interface IH {    }interface IG extends IH{    }//一个类,实现了子接口class Teacher implements IG {        }

                                        9.接口课堂练习

                                        题目:
                                        代码:
                                        package interface_;public class InterFaceExercise02 {    public static void main(String[] args) {        new C_().pX();    }}interface A_ {    int x = 0;}class B_ {    int x = 1;}class C_ extends B_ implements A_ {    public void pX(){//        System.out.println(x); 不能直接输出x,因为这样不知道要找的是哪个x        System.out.println("接口的x:" + A_.x);        System.out.println("父类的x:" + super.x);    }}

                                        10.关于Object类型引用指向一个实现了接口的类的情况

                                        在java源码中,经常会看到返回的是一个实现了接口的类但是用来接收的却是一个Object类型。这时就发生了Object类型引用指向了一个实现了接口类型的类的情况。

                                        此时这个Object类型的引用:

                                        1. 既可以被看作是指向了实现了接口的类的类型
                                        2. 也可以看作是指向了这个接口的类型
                                        3. 根据向下转型的定义,既可以将这个引用转换成接口类型也可以将这个引用转换成实现了接口的类的类型
                                        4. 当将这个引用转换成接口类型的时候,就是一个接口类型的引用指向一个实现了接口的类的类型,就是一个向上转型,此时这个引用只能使用接口的属性和方法
                                        5. 当将这个引用转换成实现接口的类的类型时,就是变成了一个实现了接口的类的引用,可以调用这个类的所有属性和方法

上一篇:解决无法下载QQ的问题

下一篇:服务器跟域名怎么购买?