JavaSE学习之旅

1610797071

已于 2022-09-20 22:48:03 修改

阅读量106

点赞数

分类专栏： Javase学习之旅文章标签： java jvm 开发语言

于 2022-09-20 22:47:20 首次发布

本文链接：https://blog.csdn.net/qq_38744955/article/details/126963365

版权

Javase学习之旅专栏收录该内容

1 篇文章 0 订阅

订阅专栏

第二章接口(JDK1.7版本)

2.1 接口概念

当一个抽象类中类，所有的方法全部为抽象方法，这样的抽象类，重新定义一个更加贴切的名词，不再称为抽象类，称为接口。

接口是一个特殊形式的抽象类：抽象类可以有抽象方法，或者是非抽象方法，但是接口全是抽象方法。

接口定义：关键字inertface

public interface 接口名{}

2.2 接口成员定义（非常重要）

成员变量
- 具有固定的定义方式，不可改变
- ```
public static final 变量的数据类型 变量名 = 值;
```
- 修饰符是固定，公共，静态，和最终，变量也称为接口常量.
成员方法
- 具有固定的定义方式，不可改变
- ```
public abstract 返回值类型 方法名(参数列表);
```
- 修饰符固定：公共，抽象

/**
 * 自定义接口：接口名MyInterface
 */
public interface MyInterface {
    //定义接口中的成员变量，常量名大写字母
    //常量名是多个单词全大写，下划线分开
    public static final int A = 1;
    
    //定义接口中的成员方法，抽象
    public abstract void inter();
}

2.3 接口的使用方式（非常重要）

接口不能实例化对象，不能new
定义类，实现接口（实现和继承差不多），关键字 implements(实现)
类重写接口中的抽象方法
创建实现类对象

/**
 * 自定义接口：接口名MyInterface
 */
public interface MyInterface {
    //定义接口中的成员变量，常量名大写字母
    //常量名是多个单词全大写，下划线分开
    public static final int A = 1;

    //定义接口中的成员方法，抽象
    public abstract void inter();
}

/**
 * 定义类：MyInterfaceImpl 实现接口MyInterface
 * MyInterfaceImpl类，称为接口的实现类
 * implements实现，先理解为继承
 */
public class MyInterfaceImpl implements MyInterface{
    @Override
    public void inter() {
        System.out.println("实现类实现接口，重写方法inter");
    }
}

public class MyInterfaceTest {
    public static void main(String[] args) {
        //创建对象，创建接口实现类的对象
        //可以使用多态性: 接口 变量名 =  new 实现类对象
        MyInterface my = new MyInterfaceImpl();
        my.inter();//方法肯定执行实现类的重写

        //调用接口的常量，静态修饰，接口名直接调用
        System.out.println(MyInterface.A);
    }
}

2.4 接口定义注意事项

接口的修饰符是固定：写和不写都是一样的，可以不写。但是我们心里，写不写一样！

另外接口的修饰符，还可以选择性书写

接口修饰符，我们现在还是写比较好，增加阅读性

2.5 接口的多实现（非常重要）

public class A extends B,C{}  //错误写法，不支持多继承

接口允许类的多实现，一个类可以同时实现多个接口

interface A{}
interface B{}
class C implements A,B{}//接口的多实现，允许的

多实现接口，类就要重写所有接口的抽象方法

public interface A {
    public abstract void interA();
}

public interface B {
    public abstract void interB();
}

    public static void main(String[] args) {
        //C类是接口的多实现，创建对象
        C c = new C();
        c.interA();
        c.interB();
    }

/**
 * C类，同时实现多个接口A和B
 * C类要重写A接口的抽象方法
 * C类要重写B接口的抽象方法
 */
public class C implements A,B{
    @Override
    public void interA() {
        System.out.println("重写接口A的方法");
    }

    @Override
    public void interB() {
        System.out.println("重写接口B的方法");
    }
}

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-AQXRwSgd-1663685097077)(images/3.png)]

2.6 怎么定义成员问题

什么时候写 private static  数据类型 成员变量   
什么时候写 public static   数据类型 成员变量，这样声明的同时必须赋值吗

成员变量–称为属性
- 属于该事物的特性
- 定义人，或者定义学生
- 属性人的特性，属于学生的特性
- 都要私有修饰，方法访问方式get/set
- 如果所有的人，或者所有的学生都共享一个数据，就是静态的
- 多个事物中，有些数据是每个事物自己独有，非静态的属性
- 多个事物中，有些数据是所有事物共享数据，静态的属性
- 凡是非静态的属性，私有，没有静态，提供方法get/set
- 凡是静态的属性：公共的，静态的，最终的，直接赋值
成员方法 – 静态或者非静态
- 原则：如果一个方法中，没有使用过类中的非静态成员，就应该定义为静态成员
- 方法使用过类中的非静态成员，这个方法就不能写静态

2.7 接口之间的多继承问题

接口和类是实现关系，一个类可以实现多个接口。接口和接口之间是继承关系，而且接口和接口之间支持多继承关系。一个接口，可以同时继承多个接口。

interface A{}
interface B{}
interface C extends A,B{} //接口之间的多继承，允许的
class D implements C{} //类实现了接口，D类重写接口A，B，C的所有抽象方法

问题：Java中支持多继承吗？类不支持，接口支持多继承

2.8 类继承父类实现多个接口

interface A{}
interface B{}
abstract class C {} //抽象类
class D extends C implements A,B{} //类继承父类，同时实现多个接口

public interface A {
    public abstract void interA();
}
public interface B {
    public abstract void interB();
}
public abstract class C {
    public abstract void interC();
}

/**
 * D类，继承父类C
 * 同时实现接口A和B
 * D类重写父类的抽象方法，也要重写接口中的抽象方法
 * 创建D类的对象
 */
public class D extends C implements A,B{
    public void interC(){
        System.out.println("重写父类方法");
    }

    public void interA(){
        System.out.println("重写接口A的方法");
    }

    public void interB(){
        System.out.println("重写接口B的方法");
    }
}

2.9 实现类还是抽象类

已知一个实现类，实现接口，重写了一部分接口中的抽象方法，这个实现类依然还是抽象类，不能建立对象。

interface A{
    public abstract void m();
    public abstract void n();
}

//实现，理解为继续，拥有父类的成员
class abstract AImpl implements A{
    public  void m(){}
    public abstract void n();
}

2.10 接口的规则

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VHNhw8Dp-1663685097079)(images/4.png)]

更加经典的接口案例：USB接口：鼠标，键盘，手机，网卡，电风扇，打印机。这些设备工作原理都不同，都可以插入到USB接口，满足USB接口的标准规则

2.11 接口案例（非常重要）

USB接口为例子：笔记本上有一个接口，USB接口，很多的外来设备（鼠标，键盘等等），都是连接在USB接口中工作的。

案例的核心：存在接口USB，笔记本使用USB接口上连接的设备（键盘，鼠标。。。）

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-gFZ3h3fS-1663685097079)(images/8.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-j6IG0ioc-1663685097080)(images/9.png)]

案例难度比较大的地方：方法参数是接口类型，传递参数是接口实现类对象，形成多态性！

/**
 * USB接口：抽象方法，就是接口标准规则
 * 任何设备，连接USB接口，必须满足规则 （实现接口，重写抽象方法）
 */
public interface USB {
    //设备开机
    public abstract void powerOn();

    //设备关机
    public abstract void powerOff();
}

/**
 * 鼠标类：满足USB接口标准，实现接口重写方法
 */
public class Mouse implements USB{
    @Override
    public void powerOn() {
        System.out.println("鼠标开机");
    }

    @Override
    public void powerOff() {
        System.out.println("鼠标关机");
    }
}
/**
 * 键盘类：满足USB接口标准，实现接口重写方法
 */
public class KeyBoard implements USB{
    @Override
    public void powerOn() {
        System.out.println("键盘开机");
    }

    @Override
    public void powerOff() {
        System.out.println("键盘关机");
    }
}

/**
 *  笔记本类：
 *    功能，使用USB接口上连接的设备
 */
public class NoteBook {
    /**
     * 定义方法：使用USB接口设备的方法
     * USB接口设备，是未知的，设备可以是无限的
     * 方法：实现功能的，方法的参数就是方法实现功能的未知数
     * 本案例的方法存在未知数，就是USB 接口设备
     * 但是：：这些设备都是USB接口的实现者
     * 方法的参数，不能是键盘，不能是鼠标
     */
    public void useUsb( USB u ){
        //u对象调用方法
        u.powerOn();
        u.powerOff();
    }
}