Alugg's Blog
0%

java-Day5——接口

发表于 分类于
本文字数： 6.1k 阅读时长 ≈ 6 分钟

接口（interface)

1.接口： 本质就是契约、规范、标准

2.接口关键字：interface

3.接口内部结构的说明：

​ 可以声明：

  • ​ 属性：必须使用public staic final 修饰

  • ​ 方法： jdk8之前：声明抽象方法，修饰为public abstract

    ​ jdk8:声明静态方法、默认方法

    ​ jdk9：声明私有方法

​ 不可以声明：构造器、代码块

4.接口与类的关系：实现关系

5.格式：class A extends super A implements B,C{}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
interface Flyable {
    //全局常量
    public static final int MIN_SPEED = 0;
    //可以省略 public static final
    int MAX_SPEED = 7900;
    //可以省略 public abstract
    public abstract void fly();
}
interface Attackbale{
    public abstract void attack();
}

abstract class Plane implements Flyable{
}

class Bullet implements Flyable, Attackbale{
    @Override
    public void fly() {
        System.out.println("bullet fly");
    }

    @Override
    public void attack() {
        System.out.println("Bullet attack");
    }
}

常见实现方式：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
public class USBTest {
    public static void main(String[] args) {
        //1.创建接口实现类的对象
        Computer c1 = new Computer();
        Printer p1 = new Printer();
        c1.transferData(p1);

        //2.创捷接口实现类的匿名对象
        c1.transferData(new Camera());

        //3.创建接口匿名实现类的对象
        USB usb1 = new USB(){
            public void start(){
                System.out.println("U盘开始工作");
            }
            public void stop(){
                System.out.println("U盘停止工作");
            }
        };
        c1.transferData(usb1);

        //4.创建接口匿名实现类的匿名对象
        c1.transferData(new USB() {
            @Override
            public void start() {
                System.out.println("xx开始工作");
            }

            @Override
            public void stop() {
                System.out.println("xx停止工作");
            }
        });
    }
}
----------------------------------------------------------------------------------------------

class Computer{
    public void transferData(USB usb){ //多态 USB usb = new Printer();
        System.out.println("设备链接成功");
        usb.start();
        System.out.println("数据传续细节");
        usb.stop();
    }
}

class Printer implements USB{
    @Override
    public void start() {
        System.out.println("开始工作打印机");
    }

    @Override
    public void stop() {
        System.out.println("打印机停止工作");
    }
}
class Camera implements USB{
    @Override
    public void start() {
        System.out.println("照相机开始");
    }
    @Override
    public void stop() {
        System.out.println("照相机停止工作");
    }
}

interface USB{
    public abstract void start();
    void stop();
}

6.说明

  • 类可以实现多个接口
  • 类针对于接口的多实现，一定程度上就弥补了类的单继承性和局限性
  • 类必须将实现的接口中的所有抽象方法重写，方可实例化。否则类必须得声明为抽象类
  • 重写的方法的访问级别不小于原方法

7.接口和接口关系：继承关系，且可以多继承

8.接口的多态性： 接口名 变量名 = new 实现类对象

9.区分抽象类和接口

  • 共性：都可以声明抽象方法，都不能实例化

  • 不同：抽象类一定有构造器，接口没有构造器

    ​ 类与类直接继承关系，类与接口之间是实现关系，接口与接口直接是多继承关系

10.jdk8之后引入了default方法，引用了静态和default方法

  • 接口类声明的静态方法，只能由接口
  • 接口中声明的默认方法可以被实现类继承，实现类在没有重写此方法的情况下，默认调用接口中声明的方法。
  • 类实现了两个接口，而两个接口中定义了同名同参数的默认方法。如果实现类没有重写此两个接口的方法，则会报错接口冲突
  • 子类（或实现类）继承了父类并实现了接口。父类和接口中声明了同名同参数的方法。子类（或实现类）在类没有重写的情况下，默认调用的是父类的方法。
  • 实现类继承了两个接口的两个同名方法。指定调用方法可采用”接口.super.方法()”

内部类

定义：将一个类A定义在另一个类B里面，类A为内部类，类B为外部类

为什么需要内部类：当一个事物A的内部，还有一个部分需要一个完整的结构B进行描述，而这个完整的结构B又只为外部事物A提供服务，不在其他地方单独使用，那么整个内部的完整结构B最好使用内部类

分类：

  • 成员内部类：直接声明在外部类里面

    • 使用static修饰: 静态的成员内部类

    • 不使用static修饰:非静态的成员内部类

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      14
      15
      16
      17
      18
      19
      20
      21
      22
      23
      24
      25
      26
      27
      28
      29
      30
      31
      32
      33
      34
      35
      36
      37
      38
      39
      40
      41
      42
      43
      44
      45
      46
      47
      48
      49
      50
      51
      52
      53
      54
      55
      56
      57
      58
      59
      60
      61
      62
      63
      64
      public class PersonTest {
          public static void main(String[] args) {
              //1.创建Person的静态成员内部类的实例
              Person.Dog dog = new Person.Dog(); 
              dog.eat();//chien manger

              //2.创建Person的非静态成员内部类的实例
              Person p1 = new Person();
              Person.Bird bird = p1.new Bird();
              bird.eat();//Bird manger
              bird.show("YY");//age1, nameYY, this.nameTTN, person.nameTom
              bird.show1();
          }
      }

      public class Person {
          String name = "Tom";
          int age = 1;

          //静态成员内部类
          static class Dog{
              public void eat(){
                  System.out.println("chien manger");
              }
          }
          //非静态成员内部类
          class Bird {
              String name="TTN";
              public void eat(){
                  System.out.println("Bird manger");
              }
              public void show(String name){
                  System.out.println("age"+age);
                  System.out.println("name"+name);
                  System.out.println("this.name"+this.name);
                  System.out.println("person.name"+Person.this.name);
              }
              public void show1(){
                  eat();
                  this.eat();
                  Person.this.eat();
              }
          }

          public void eat(){
              System.out.println("人吃饭");
          }
          //局部内部类
          public void method(){
              class InnerClass1{

              }
          }
          public Person(){
              class InnerClass1{

              }
          }
          {
              class InnerClass1{

              }
          }
      }

  • 局部内部类：声明在方法内、构造器内、代码块内的内部内

    • 匿名成员内部类

    • 非匿名成员内部类

关于成员内部类的理解

  • 从类的角度看：

    • 内部可以声明属性、方法、构造器、代码块、内部类等结构

    • 此内部类可以声明父类、可以实现接口

    • 可以使用final修饰

    • 可以使用abstract修饰

  • 从外部成员的角度来看

    • 在内部可以调用外部类的结构。比如属性、方法
    • 除了使用public、缺省权限修饰之外。还可以使用private、protected
    • 可以使用static

Ex

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
public class OuterClass {
    public static void main(String[] args) {
        //接口ex1
        SubA a1 = new SubA();
        a1.method();

        //接口ex2
        A a2 = new A() {
            public void method() {
                System.out.println("匿名实现类的对象");
            }
        };
        a2.method();

        //接口ex3
        new A() {
            public void method() {
                System.out.println("匿名实现类的匿名对象");
            }
        }.method();


        //抽象类 ex1
        SubB s1 = new SubB();
        s1.method1();
        //抽象类 ex2
        B b1 = new B() {
            @Override
            public void method1() {
                System.out.println("匿名重写");
            }
        };
        b1.method1();
        //抽象类 ex3
        new B() {
            @Override
            public void method1() {
                System.out.println("匿名重写匿名对象");
            }
        }.method1();

        //内部类ex6
        C c = new C();
        c.method2();

        //内部类ex7
        C c1 = new C(){
            @Override
            public void method2() {
                System.out.println("xxix");
            }
        };
        c1.method2();
        //内部类ex8
        new C(){
            @Override
            public void method2() {
                System.out.println("haha");
            }
        }.method2();
        
    }
}
------------------------------------------------------------------------------------------
interface A{
    public void method();
}

class SubA implements A{
    @Override
    public void method() {
        System.out.println("subA");
    }
}

abstract class B{
    public abstract void method1();
}

class SubB extends B{
    @Override
    public void method1() {
        System.out.println("SubB");
    }
}

class C{
    public void method2(){
        System.out.println("ccc");
    }
}

常见问题

1.接口与抽象类的区别

LALij.png

2.接口是否可继承接口，抽象类是否可实现接口？抽象类是否可以继承实现类？

是；是；是；

3.接口可以有自己属性吗？

可以。必须是public static final

4.访问接口的默认方法如何使用？

使用实现类的对象进行调用。而且实现还可以重写此默认方法。

5.内部类的特点说一下

6.匿名类说一下

-------------本文结束感谢您的阅读-------------