接口(重点)

  • 基本概念

    接口主要指比抽象类还抽象的类，因此不能实例化对象。

    定义类的关键字使用class，而定义接口使用interface关键字。

  • 类和接口之间的关系

    类和类之间的关系 – 使用extends关键字表达继承的关系 – 支持单继承

    类和接口之间的关系 – 使用implements关键字表达实现的关系 – 支持多实现

    接口和接口之间的关系-- 使用extends关键字表达继承的关系 – 支持多继承

  • 抽象类和接口之间的主要区别(笔试题)

    (1)定义抽象类的关键字是abstract class，而定义接口的关键字是interface。

    (2)继承抽象类的关键字是extends，而实现接口的关键字是implements。

    (3)继承抽象类支持单继承，而实现接口支持多实现。

    (4)抽象类中可以有构造方法，而接口中不可以有构造方法。

    (5)抽象类中可以有成员变量，而接口中只可以有常量。

    (6)抽象类中可以有成员方法，而接口中只可以有抽象方法。

    (7)抽象类中增加方法可以不影响子类，而接口中增加方法通常都会影响实现类。

    (8)从jdk1.8开始允许接口中有非抽象方法，但必须使用default关键字修饰。

1
2
3
4
5
6
7
8
public interface Metal {
  // 自定义抽象方法描述发光的行为
  public abstract void shine();

  public default void show() {
    System.out.println("我就是不想增加抽象方法，看你咋办？");
  }
}
1
2
3
4
public interface Money {
  // 自定义抽象方法描述购物的行为
  public abstract void buy();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
public class Gold implements Metal, Money {

  @Override
  public void buy() {
    System.out.println("买了好多好吃的...");
  }
  @Override
  public void shine() {
    System.out.println("发出了金黄色的光芒...");
  }

  public static void main(String[] args) {
    // 接口类型的引用指向实现类的对象，形成了多态
    Metal mt = new Gold();
    mt.shine();
    System.out.println("----------------------------");

    Money mn = new Gold();
    mn.buy();
  }
}

匿名内部类(重点、难点)

  • 语法格式

    接口/父类类型 引用变量名 = new 接口/父类类型(){ 方法的重写 };

  • 经验的分享

    当接口类型的引用作为方法的形参时，实参的传递方式主要有两种：

    a.自定义类实现接口，然后创建该类的对象作为实参传递。

    b.使用匿名内部类得到接口类型的引用作为实参传递。

1
2
3
4
public interface A {
  // 自定义抽象方法
  public abstract void show();
}
1
2
3
4
5
6
public class SubA implements A {
  @Override
  public void show() {
    System.out.println("这里是A接口的实现类！");
  }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class ATest {
  // A a = new SubA();
  // 接口类型的引用指向实现类的对象，形成了多态
  public static void test(A a) {
    // 编译阶段调用接口版本，运行阶段调用实现类的版本
    a.show();
  }

  public static void main(String[] args) {
    //ATest.test(new A()); error  A是个接口不能new对象
    ATest.test(new SubA());
    System.out.println("----------------------------------");

    // 接口/父类类型 引用变量名 = new 接口/父类类型(){ 方法的重写 };
    A ta = new A() {
      @Override
      public void show() {
        System.out.println("这就是匿名内部类的用法！");
      }
    };
    ATest.test(ta);
  }
}