接口 - Java

在Java中，接口可以看成是：多个类的公共规范，是一种引用数据类型；

接口的语法：

接口的定义格式与定义类的格式基本相同，将class关键字换成 interface 关键字，就定义了一个接口。

public interface 接口名称{
	// 抽象方法
	public abstract void method1(); // public abstract 是固定搭配，可以不写
	public void method2();
	abstract void method3();
	void method4();
	// 注意：在接口中上述写法都是抽象方法，跟推荐方式4，代码更简洁
}

提示:

1. 创建接口时, 接口的命名一般以大写字母 I 开头.
2. 接口的命名一般使用 “形容词” 词性的单词.
3. 阿里编码规范中约定, 接口中的方法和属性不要加任何修饰符号, 保持代码的简洁性

接口的使用：

接口不能直接使用，必须要有一个"实现类"来"实现"该接口，实现接口中的所有抽象方法。

public class 类名称 implements 接口名称{
	// ...
}

public interface Ishape {
    void draw();
}  

public class Cycle implements Ishape{
    @Override
    public void draw() {
        System.out.println("画一个圆圈...");
    }
}
public class Rect implements Ishape{
    @Override
    public void draw() {
        System.out.println("画一个矩形...");
    }
}

举个例子：

请实现笔记本电脑使用USB鼠标、USB键盘的例子

1. USB接口：包含打开设备、关闭设备功能
2. 笔记本类：包含开机功能、关机功能、使用USB设备功能
3. 鼠标类：实现USB接口，并具备点击功能
4. 键盘类：实现USB接口，并具备输入功能

public interface USB {
    void openDevice();
    void closeDevice();
}

public class Mouse implements USB{
    @Override
    public void openDevice() {
        System.out.println("打开鼠标");
    }

    @Override
    public void closeDevice() {
        System.out.println("关闭鼠标");
    }

    public void click(){
        System.out.println("点击鼠标");
    }
}

public class KeyBoard implements USB{
    @Override
    public void openDevice() {
        System.out.println("打开键盘");
    }

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

    public void input(){
        System.out.println("键盘打字");
    }
}

public class Computer {
    public void open(){
        System.out.println("开机");
    }

    public void close(){
        System.out.println("关机");
    }

    public void useUSBDevice(USB usb){
        usb.openDevice();
        if (usb instanceof Mouse){
            Mouse mouse = (Mouse) usb;
            mouse.click();
        }else {
            KeyBoard keyBoard = (KeyBoard) usb;
            keyBoard.input();
        }
        usb.closeDevice();
    }
}

public class Test {
    public static void main(String[] args) {
        Computer computer = new Computer();
        computer.open();

        computer.useUSBDevice(new KeyBoard());
        computer.useUSBDevice(new Mouse());

        computer.close();
    }
}

接口特性

1. 接口当中的成员变量，默认是 public static final 修饰的；

   public interface USB {
   	double brand = 3.0; // 默认被：final public static修饰
   	void openDevice();
   	void closeDevice();
   }
   public class TestUSB {
   	public static void main(String[] args) {
   		System.out.println(USB.brand); // 可以直接通过接口名访问，说明是静态的
   		// 编译报错：Error:(12, 12) java: 无法为最终变量brand分配值
   		USB.brand = 2.0; // 说明brand具有final属性
   	}
   }
   

2. 接口当中的抽象方法，默认都是 public abstract修饰的；（只能是public abstract，其他修饰符都会报错）

   public interface USB {
   	// Error:(4, 18) java: 此处不允许使用修饰符private
   	private void openDevice();
   	void closeDevice();
   }
   

3. 如果接口当中的方法被 default 修饰，那么可以有具体的实现

   default void test(){
   	System.out.println("default 方法...");
   }
   

4. 如果接口当中的方法被static修饰，那么可以有具体的实现

   static void test(){
   	System.out.println("static 方法...");
   }
   

5. 接口是不可以进行实例化的；

   public class TestUSB {
   	public static void main(String[] args) {
   		USB usb = new USB();
   	}
   }
   
   // Error:java: day20210915.USB是抽象的; 无法实例化
   

6. 类和接口之间可以使用关键字 implements 来实现接口；

7. 接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是.class。也就是一个接口对应一个字节码文件；

8. 如果一个类不想实现这个接口当中的方法，那么此时这个类就可以被定义为抽象类，但是这个抽象类如果被继承，那么就得实现所有的没有被实现的方法；

9. 重写接口中方法时，不能使用默认的访问权限；

   public interface USB {
   	void openDevice(); // 默认是public的
   	void closeDevice(); // 默认是public的
   }
   public class Mouse implements USB {
   @Override
   	void openDevice() {
   		System.out.println("打开鼠标");
   		}
   		// ...
   	}
   // 编译报错，重写USB中openDevice方法时，不能使用默认修饰符
   // 正在尝试分配更低的访问权限; 以前为public
   

实现多个接口

在Java中，类和类之间是单继承的，一个类只能有一个父类，即Java中不支持多继承，但是一个类可以实现多个接口。所以，接口的出现解决了Java不能多继承的问题；

先创建一个动物类：

public abstract class Animal {
    public String name;
    public int age;

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public abstract void  eat();
}

紧接着再提供一组接口, 分别表示 “会飞的”, “会跑的”, "会游泳的”：

interface IFlying {
	void fly();
}
interface IRunning {
	void run();
}
interface ISwimming {
	void swim();
}

接下来我们创建几个具体的动物:

鱼是会游泳的动物

public class Fish extends Animal implements ISwimming{
    public Fish(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println(this.name + "正在吃鱼粮");
    }

    @Override
    public void swim() {
        System.out.println(this.name + "正在游泳");
    }
}

狗是会游泳且会跑步的动物

ublic class Dog extends Animal implements IRunning,ISwimming{
    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println(this.name + "正在吃狗粮");
    }

    @Override
    public void swim() {
        System.out.println(this.name + "正在游泳");
    }

    @Override
    public void run() {
        System.out.println(this.name + "正在跑步");
    }
}

鸭子是会飞，跑步，游泳的动物

public class Duck extends Animal implements ISwimming,IFly,IRunning{
    public Duck(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println(this.name + "正在吃鸭梁");
    }

    @Override
    public void fly() {
        System.out.println(this.name + "正在飞");
    }

    @Override
    public void run() {
        System.out.println(this.name + "正在跑");
    }

    @Override
    public void swim() {
        System.out.println(this.name + "正在游泳");
    }
}

注意：一个类实现多个接口时，每个接口中的抽象方法都要实现，否则类必须设置为抽象类。

上面的代码展示了 Java 面向对象编程中最常见的用法: 一个类继承一个父类, 同时实现多种接口。
继承表达的含义是 is - a 语义, 而接口表达的含义是 具有 xxx 特性 。

接口间的继承

在Java中，类和类之间是单继承的，一个类可以实现多个接口，接口与接口之间可以多继承。即：用接口可以达到多继承的目的。
接口可以继承一个接口, 达到复用的效果. 使用 extends 关键字。

interface IRunning {
	void run();
}
interface ISwimming {
	void swim();
}
// 两栖的动物, 既能跑, 也能游
interface IAmphibious extends IRunning, ISwimming {
}
class Frog implements IAmphibious {
	...
}

Object类

Object是Java默认提供的一个类。Java里面除了Object类，所有的类都是存在继承关系的。默认会继承Object父类。即所有类的对象都可以使用Object的引用进行接收。

Object obj = new Dog("旺财",11);
Object obj = new Duck("唐老鸭",11);

所以在开发之中，Object类是参数的最高统一类型。但是Object类也存在有定义好的一些方法。如下:

对于整个Object类中的方法需要实现全部掌握。

这里将 equals 方法 和 hashcode 方法，toString 方法之前讲过这里就不提了。

对象比较：equals方法

就比如说对于上面那个狗类，我实例化了两个对象：

public static void main(String[] args) {
        Dog dog1 = new Dog("旺财",11);
        Dog dog2 = new Dog("旺财",11);

        System.out.println(dog1 == dog2);
    }
    
    false

我想根据姓名和年龄来比较对象是否相等，也就是说如果两个对象中的name和age都相等，我就认为这两个对象是同一个对象。

所以，如果要比较对象中内容，必须重写Object中的equals方法，因为equals方法默认也是按照地址比较的：

没有重写equals方法：

public class Dog extends Animal implements IRunning,ISwimming{
	...
}
 public static void main(String[] args) {
        Dog dog1 = new Dog("旺财",11);
        Dog dog2 = new Dog("旺财",11);

        System.out.println(dog1 == dog2);
        System.out.println(dog1.equals(dog2));
    }
}

false
false

重写equals方法：

public class Dog extends Animal implements IRunning,ISwimming{
		....
    @Override
    public boolean equals(Object obj) {
        Dog dog = (Dog) obj;
        return this.name.equals(dog.name) && this.age == dog.age;
    }
}

 public static void main(String[] args) {
        Dog dog1 = new Dog("旺财",11);
        Dog dog2 = new Dog("旺财",11);

        System.out.println(dog1 == dog2);
        System.out.println(dog1.equals(dog2));
    }
}

false
true

hashcode方法

hashCode()这个方法，他帮我算了一个具体的对象位置，这里面涉及数据结构，但是我们还没学数据结构，没法讲述，所以我们只能说它是个内存地址。

hashcode方法源码：

public native int hashCode();

该方法是一个native方法，底层是由C/C++代码写的。我们看不到。

我们假设两个名字相同，年龄相同的对象，将存储在同一个位置。

不重写hashcode()方法，我们可以来看示例代码：

public static void main(String[] args) {
        Dog dog1 = new Dog("旺财",11);
        Dog dog2 = new Dog("旺财",11);

        System.out.println(dog1.hashCode());
        System.out.println(dog2.hashCode());
    }
    
1831932724
1747585824

像重写equals方法一样，我们也可以重写hashcode()方法。

public class Dog extends Animal implements IRunning,ISwimming{
		...
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }
}

public static void main(String[] args) {
        Dog dog1 = new Dog("旺财",11);
        Dog dog2 = new Dog("旺财",11);

        System.out.println(dog1.hashCode());
        System.out.println(dog2.hashCode());
}

26208868
26208868

我们也就发现俩个哈希值是一样的了。

结论：

1. hashcode方法用来确定对象在内存中存储的位置是否相同。
2. 事实上hashCode() 在散列表中才有用，在其它情况下没用。在散列表中hashCode() 的作用是获取对象的散列码，进而确定该对象在散列表中的位置。

内部类

在 Java 中，可以将一个类定义在另一个类或者一个方法的内部，前者称为内部类，后者称为外部类。内部类也是封装的一种体现。

public class OutClass {
	class InnerClass{
	}
}
// OutClass是外部类
// InnerClass是内部类

内部类分类：

1. 静态内部类
2. 实例内部类
3. 匿名内部类
4. 局部内部类

静态内部类

被static修饰的内部成员类称为静态内部类。

class  OutClass{
    public int data1 = 1;
    private int data2 = 2;
    public static int data3 = 3;

    //静态内部类
    static class InnerClass{
        public int data4 = 4;
        private int data5 = 5;
        public static int data6 = 6;

        public void test(){
            OutClass outClass = new OutClass();
            System.out.println(outClass.data1);//不能直接调用外部类非静态成员变量/方法
            System.out.println(data3);
            System.out.println(data4);
            System.out.println("test方法被执行了...");
        }
    }
}

public class Test {

    public static void main(String[] args) {
        //如何实例化一个静态内部类对象
        OutClass.InnerClass innerClass = new OutClass.InnerClass();
        innerClass.test();
    }
}

1
3
4
test方法被执行了...

【注意事项】

1. 在静态内部类中只能访问外部类中的静态成员.
2. 创建静态内部类对象时，不需要先创建外部类对象.

实例内部类

即未被static修饰的成员内部类。

class  OutClass2{
    public int data1 = 1;
    private int data2 = 2;
    public static int data3 = 3;

    //内部类
    class InnerClass{
        public int data1 = 100;
        public int data4 = 4;
        private int data5 = 5;
        public static int data6 = 6;

        public void test(){
            OutClass outClass = new OutClass();
            System.out.println(outClass.data1);
            System.out.println(OutClass2.this.data1);
            System.out.println(this.data1);
            System.out.println(data3);
            System.out.println(data4);
            System.out.println("test方法被执行了...");
        }
    }
}

public class Test {

    public static void main(String[] args) {
        //如何实例化一个实例内部类对象
        OutClass2 outClass2 = new OutClass2();
        OutClass2.InnerClass innerClass = outClass2.new InnerClass();
        innerClass.test();
    }
}

1
1
100
3
4
test方法被执行了...

【注意事项】

1. 对于实力内部类来说 包含2个this，一个this是实例内部类自己的，一个是外部类名 .this
2. 外部类中的任何成员都可以在实例内部类方法中直接访问
3. 实例内部类所处的位置与外部类成员位置相同，因此也受public、private等访问限定符的约束
4. 在实例内部类方法中访问同名的成员时，优先访问自己的，如果要访问外部类同名的成员，必须：外部类名称.this.同名成员 来访问
5. 实例内部类对象必须在先有外部类对象前提下才能创建
6. 实例内部类的非静态方法中包含了一个指向外部类对象的引用
7. 外部类中，不能直接访问实例内部类中的成员，如果要访问必须先要创建内部类的对象。

匿名内部类

class Out{
    public void test1(){
        System.out.println("haha");
    }
}

public class Test {

    public static void main(String[] args) {
		    //匿名内部类
        new Out(){

        }.test1();

        new Out(){
            @Override
            public void test1() {
                System.out.println("hehe");
            }
        }.test1();
    }
}

haha
hehe

如果匿名内部类的这个类是一个正常的类的话。他是不能用引用来指向的，会报错；

匿名内部类一般是使用在抽象类和接口中；

interface IA{
    void test1();
}

public class Test {

    public static void main(String[] args) {
        new IA(){
            @Override
            public void test1() {
                System.out.println("haha");
            }
        }.test1();
        //这个类实现了IA接口并且同时重写了test1这个方法；
        IA ia = new IA(){
            @Override
            public void test1() {
                System.out.println("haha");
            }
        };
        ia.test1();
    }
}

haha
haha

对于抽象类和接口来说，是可以用引用来指向它的；

局部内部类

public class OutClass {
		int a = 10;
		public void method(){
			int b = 10;
			// 局部内部类：定义在方法体内部
			// 不能被public、static等访问限定符修饰
			class InnerClass{
				public void methodInnerClass(){
					System.out.println(a);
					System.out.println(b);
					}
				}
				// 只能在该方法体内部使用，其他位置都不能用
				InnerClass innerClass = new InnerClass();
				innerClass.methodInnerClass();
		}
		public static void main(String[] args) {
		// OutClass.InnerClass innerClass = null; 编译失败
		}
	}

【注意事项】

1. 局部内部类只能在所定义的方法体内部使用
2. 不能被public、static等修饰符修饰
3. 编译器也有自己独立的字节码文件，命名格式：外部类名字$数字内部类名字.class
4. 几乎不会使用

• 问题：如何通过方法交换实参的值：

  public static void main(String[] args) {
          int a = 10;
          int b = 20;
          System.out.println("交换前: a: " + a + " b: " + b);
          swap(a,b);
          System.out.println("交换后: a: " + a + " b: " + b);
      }
  
      private static void swap(int x, int y) {
          int tmp = x;
          x = y;
          y = tmp;
      }
      
      交换前: a: 10 b: 20
  		交换后: a: 10 b: 20
  

  

  在main函数中想要通过方法交换a和b的值，但是通过上述代码，我们发现并不能实现我们的想法，上述代码的失败的原因在于，将a和b的值传入swap函数之后，赋值给了形参x和y，在函数中实现了交换x和y的逻辑，但是也仅限于交换x和y，它并没有影响到main函数中的a和b，类似C语言里的传值调用，因此，也就没法实现交换a和b的值。

  想要实现通过方法来交换实参的值，需要借助对象来实现：

  public class Test {
  
      public static void main(String[] args) {
          Myvalue myvalue1 = new Myvalue();
          Myvalue myvalue2 = new Myvalue();
  
          myvalue1.val = 10;
          myvalue2 .val = 20;
          System.out.println("交换前: a: " + myvalue1.val + " b: " + myvalue2 .val);
          swap1(myvalue1,myvalue2);
          System.out.println("交换后: a: " + myvalue1.val + " b: " + myvalue2 .val);
      }
  
      private static void swap1(Myvalue myvalueX, Myvalue myvalueY) {
          int tmp = myvalueX.val;
          myvalueX.val = myvalueY.val;
          myvalueY.val = tmp;
      }
  }
  
  public class Myvalue {
      public int val;
  }
  
  交换前: a: 10 b: 20
  交换后: a: 20 b: 10
  

  

  这里了解一下，对象储存在堆区，对象的引用，基本类型在栈区，堆区里面的内容可以理解为共用的，因此，将实参myvalue1和myvalue2传给形参myvalueX和myvalueY，形参myvalueX和myvalueY里的val和实参myvalue1和myvalue2里的val是共用的，也就是同一个，因此，修改形参myvalueX和myvalueY的val也就相当于修改实参myvalue1和myvalue2的val了从而实现交换实参的值。

Clonable 接口和深拷贝

Object 类中存在一个 clone 方法, 调用这个方法可以创建一个对象的 "拷贝”。但是要想合法调用 clone 方法, 必须要先实现 Clonable 接口，否则就会抛出 CloneNotSupportedException 异常。

public class Person implements Cloneable{
    public int age;
    public String name;

    public Person(int age, String name) {
        this.age = age;
        this.name = name;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

public class Test {
    public static void main(String[] args)
            throws CloneNotSupportedException{
        Person person1 = new Person(10,"lisi");
        Person person2 = (Person) person1.clone();
    }
}

整个流程思路：

注意：

我们打开Cloneable接口的源码的时候我们会看到里面什么都没有实现。

public interface Cloneable{
}

这是一个空接口，空接口也叫做标记接口，表示当前类是可以被克隆的。

• 浅拷贝 VS 深拷贝

  Cloneable 拷贝出的对象是一份 “浅拷贝”。

  class Money implements Cloneable{
      public double money = 9.9;
  
      @Override
      protected Object clone() throws CloneNotSupportedException {
          return super.clone();
      }
  }
  
  public class Person implements Cloneable{
      public int age;
      public String name;
      public Money money = new Money();
  
      public Person(int age, String name) {
          this.age = age;
          this.name = name;
      }
  
      @Override
      protected Object clone() throws CloneNotSupportedException {
          return super.clone();
      }
  }
  
  public static void main(String[] args) throws CloneNotSupportedException {
          Person person1 = new Person(10,"lisi");
          Person person2 = (Person) person1.clone();
  
          System.out.println("修改前：" + person1.money.money);
          System.out.println("修改前：" + person2.money.money);
          person2.money.money = 99.99;
          System.out.println("修改后：" + person1.money.money);
          System.out.println("修改后：" + person2.money.money);
      }
      
  修改前：9.9
  修改前：9.9
  修改后：99.99
  修改后：99.99
      
  

  上述代码，我们发现和我们的预期是不一样的，我只想要修改person2.money.money的值，却发现person1.money.money的值也发生改变了。

  

  画个图，我们发现问题，只克隆了Person对象，没有克隆Money对象。那么此时看到的这种现象就叫做“浅拷贝”。那什么是“深拷贝”？如果将Money也克隆了，那么就是深拷贝。

  让Money克隆：

  @Override
      protected Object clone() throws CloneNotSupportedException {
          Person tmp = (Person) super.clone();
          tmp.money = (Money) this.money.clone();
          return tmp;
      }
      
  修改前：9.9
  修改前：9.9
  修改后：9.9
  修改后：99.99
  

  

  此时完成的就是深拷贝。深拷贝和浅拷贝是根据代码的实现去实现的。

抽象类和接口的区别

核心区别: 抽象类中可以包含普通方法和普通字段, 这样的普通方法和字段可以被子类直接使用(不必重写), 而接口中不能包含普通方法, 子类必须重写所有的抽象方法.

如之前写的 Animal 例子. 此处的 Animal 中包含一个 name 这样的属性, 这个属性在任何子类中都是存在的. 因此此处的 Animal 只能作为一个抽象类, 而不应该成为一个接口。

class Animal {
	protected String name;
		public Animal(String name) {
		this.name = name;
	}
}

再次提醒：
抽象类存在的意义是为了让编译器更好的校验, 像 Animal 这样的类我们并不会直接使用, 而是使用它的子类.万一不小心创建了 Animal 的实例, 编译器会及时提醒我们。