【JavaSE 第十一天】

【JavaSE 第十一天】

一、 接口

1. 接口之间的关系

①类和类之间是继承的关系（单继承）
②类和接口之间是实现的关系（多实现 implements）
③接口和接口之间是继承的关系，支持多继承，一个接口可以同时继承多个接口。
示例：

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

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

public interface C extends A,B{
   
    //继承前面的接口
}

/**
 * 实现接口 C ， C 接口继承 A , B
 * 实现接口 D 类，重写接口 A ， B ， C ，的抽象方法
 */
public class D implements C{
   
    @Override
    public void a() {
   

    }
    @Override
    public void b() {
   

    }
}

2. 实现类依旧是抽象类问题

若实现类实现接口，重写一部分抽象方法，实现类还是一个抽象类。

public interface A {
   
    public abstract void a1();
    public abstract void a2();
}

若实现类只重写一部分方法，实现类就必须加上前缀 abstract，此时也就默认为 B 类，拥有 a2 的抽象方法（可以看作是继承），B 类也就是抽象类。

public abstract class B implements A {
   
    public  void a1(){
   

    }
   // public abstract void a2();
}

public class C extends B {
   
	// C 类继承 B 类，B 类实现接口 A，那么 C 类也就是接口 A 的实现类
	public void a2(){
   
	
	}
	// C 类也就同时拥有了 a1 和 a2 方法
}

3. 接口规则案例：

• 以电脑，USB接口，鼠标，键盘等 作类比，更方便理解。
• 电脑主体：

public class Computer {
   
    /**
     *  电脑通过 USB 接口，使用外接设备
     *  因此方法的定义：实现设备的使用
     *      返回值类型：这个方法经过运算后的结果的数据类型
     *      参数：方法的参数，是方法运算过程中的未知数据
     *  因此电脑通过 USB 接口，使用外接设备，这个功能的未知数据就是外接设备
     *       外接设备都有一个共同特性，满足 USB 接口的规则，才能使用
     *  因此参数是引用类，要传递对象，传递接口实现类的对象
     */
    public void useUSB(USB usb){
   
        // 此类的方法一经被调用，传递参数，就相当于:
        // USB usb = new Mouse();  的相应操作
        //    ⬆          ⬆
        //   接口      实现类       这体现了多态性
    }
}

• USB 接口：

public interface USB {
   
    /**
     *  定义 USB 接口：规则的制定
     *  接口的规则：程序中的抽象方法(再用具体的外接设备作实现类，重写抽象方法)
     */
    public abstract void start();
    public abstract void end();
}

• 具体的外接设备：

public class Mouse implements USB{
   
    /**
     *  鼠标类：接入 USB 接口工作
     *  实现接口：要重写抽象方法，具体为外接设备的具体操作
     */
    @Override
    public void start() {
   
        System.out.println("设备开始工作！");
    }

    @Override
    public void end() {
   
        System.out.println("设备结束工作！");
    }
}

• 调用，使用设备：

public class USBTest {
   
    public static void main(String[] args) {
   
        // 创建电脑的对象
        Computer computer=new Computer();
        // 调用 useUSB 方法
        Mouse mouse=new Mouse();
        // 调用电脑的对象，传递鼠标对象（传递接口实现类对象）
        // 也可以不设参数直接写为
        // computer.useUSB(new Mouse()); 匿名参数的传递
        computer.useUSB(mouse);
        // 调用鼠标的方法，实现外接设备的应用
        mouse.start();
        mouse.end();
    }
}

• 这种操作做到了极高的解耦，即使后续仍有其他的外接设备，依旧是调用电脑的方法，传递相应的对象。
  只要方法的参数是接口的时候，那就在调用时传递实现类对象（引用数据类型）。

二、 静态修饰符

static 修饰符：最早出现在 main 方法中，只能修饰成员，不能写在方法的内部，被 static 修饰的成员，被称为静态成员变量和静态的成员方法。

1. 静态修饰成员变量

由示例，引出静态修饰符:

public class Person {
   
    String name;
    String country;
}

public class StaticTest {
   
    public static void main(String[] args) {
   
        Person p1=new Person();
        p1.name="张三";
        p1.country="中国";
        Person p2=new Person();
        p2.name="李四";
        p2.country="中国";
    }
}

• 在这种情况下，由于张三和李四两个人同时都是中国国籍，在系统的内存中出现了两个地址下有重复的数据，造成了重复，冗杂。
  所以如果创建多个对象，共享一个数据，这个数据，就应该是被静态修饰符修饰。
• static 修饰的成员变量：是被所有的对象共享的数据，没有被 static 修饰的成员变量，是每个对象的独享数据或者是特有数据。

public class Person {
   
    String name;
    static String country = "中国";
}

public class StaticTest {
   
    public static void main(String[] args) {
   
        Person p1 = new Person();
        p1