Java-接口

2023-12-13 17:34:04

【1】接口声明 格式

【访问修饰符】interface 接口名【extends 父接口1,父接口2......】

{

常量定义;

方法定义

}

1.package com.msb.test04;
2.
3./**
4. * 1.类是类,接口是接口,它们是同一层次的概念。
5. * 2.接口中没有构造器
6. * 3.接口如何声明:interface
7. * 4.在JDK1.8之前,接口中只有两部分内容:
8. * (1)常量:固定修饰符:public static final
9. * (2)抽象方法:固定修饰符:public abstract
10. * 注意:修饰符可以省略不写,IDE会帮你自动补全,但是初学者建议写上,防止遗忘。
11. */
12.public interface TestInterface01 {
13.    //常量:
14.    /*public static final*/ int NUM = 10;
15.    //抽象方法:
16.    /*public abstract*/ void a();
17.    /*public abstract*/ void b(int num);
18.    /*public abstract*/ int c(String name);
19.}
20.
21.interface TestInterface02{
22.    void e();
23.    void f();
24.}
25./*
26.5.类和接口的关系是什么? 实现关系  类实现接口:
27.6.一旦实现一个接口,那么实现类要重写接口中的全部的抽象方法:
28.7.如果没有全部重写抽象方法,那么这个类可以变成一个抽象类。
29.8.java只有单继承,java还有多实现
30.一个类继承其他类,只能直接继承一个父类
31.但是实现类实现接口的话,可以实现多个接口
32.9.写法:先继承 再实现:extends Person implements TestInterface01,TestInterface02
33. */
34.class Student extends Person implements TestInterface01,TestInterface02 {
35.    @Override
36.    public void a() {
37.        System.out.println("---1");
38.    }
39.
40.    @Override
41.    public void b(int num) {
42.        System.out.println("---2");
43.    }
44.
45.    @Override
46.    public int c(String name) {
47.        return 100;
48.    }
49.
50.    @Override
51.    public void e() {
52.        System.out.println("---3");
53.    }
54.
55.    @Override
56.    public void f() {
57.        System.out.println("---4");
58.    }
59.}
60.
61.
62.class Test{
63.    //这是一个main方法,是程序的入口:
64.    public static void main(String[] args) {
65.        //10.接口不能创建对象:
66.        //TestInterface02 t = new TestInterface02();
67.        TestInterface02 t = new Student();//接口指向实现类 ---》多态
68.
69.        //11.接口中常量如何访问:
70.        System.out.println(TestInterface01.NUM);
71.        System.out.println(Student.NUM);
72.        Student s = new Student();
73.        System.out.println(s.NUM);
74.        TestInterface01 t2 = new Student();
75.        System.out.println(t2.NUM);
76.    }
}

【3】接口的作用是什么?

定义规则,只是跟抽象类不同地方在哪?它是接口不是类。

接口定义好规则之后,实现类负责实现即可。

【4】

继承:子类对父类的继承

实现:实现类对接口的实现

手机 ?是不是 ?照相机 ??

继承:手机 ? extends 照相机 ? ? “is-a”的关系,手机是一个照相机?

上面的写法 不好:

实现: ?手机 ? ?implements ? 拍照功能 ??“has-a”的关系,手机具备照相的能力

案例:飞机,小鸟,风筝

? 定义一个接口: Flyable

【5】多态的应用场合

(1)父类当做方法的形参,传入具体的子类的对象

(2)父类当做方法的返回值,返回的是具体的子类的对象

(3)接口当做方法的形参,传入具体的实现类的对象

(4)接口当做方法的返回值,返回的是具体的实现类的对象

【6】接口和抽象类的区别:

JDK1.8以后的接口新增内容

在JDK1.8之前,接口中只有两部分内容:
(1)常量:固定修饰符:public static final
(2)抽象方法:固定修饰符:public abstract??

在JDK1.8之后,新增非抽象方法:?

(1)被public default修饰的非抽象方法:

注意1:default修饰符必须要加上,否则出错

注意2:实现类中要是想重写接口中的非抽象方法,那么default修饰符必须不能加,否则出错。

1.public interface TestInterface {
2.    //常量:
3.    public static final int NUM= 10;
4.    //抽象方法:
5.    public abstract void a();
6.    //public default修饰的非抽象方法:
7.    public default void b(){
8.        System.out.println("-------TestInterface---b()-----");
9.    }
10.}
11.class Test implements TestInterface{
12.    public void c(){
13.        //用一下接口中的b方法:
14.        b();//可以
15.        //super.b();不可以
16.        TestInterface.super.b();//可以
17.    }
18.    @Override
19.    public void a() {
20.        System.out.println("重写了a方法");
21.    }
22.
23.    @Override
24.    public void b() {
25.
26.    }
27.}

(2)静态方法:

注意1:static不可以省略不写

注意2:静态方法不能重写

1.public interface TestInterface2 {
2.    //常量:
3.    public static final int NUM = 10;
4.    //抽象方法:
5.    public abstract  void a();
6.    //public default非抽象方法;
7.    public default void b(){
8.        System.out.println("-----TestInterface2---b");
9.    }
10.    //静态方法:
11.    public static void c(){
12.        System.out.println("TestInterface2中的静态方法");
13.    }
14.}
15.
16.class Demo implements TestInterface2{
17.    @Override
18.    public void a() {
19.        System.out.println("重写了a方法");
20.    }
21.    public static void c(){
22.        System.out.println("Demo中的静态方法");
23.    }
24.}
25.
26.class A {
27.    //这是一个main方法,是程序的入口:
28.    public static void main(String[] args) {
29.        Demo d = new Demo();
30.        d.c();
31.        Demo.c();
32.        TestInterface2.c();
33.    }
34.}

疑问:为什么要在接口中加入非抽象方法???

如果接口中只能定义抽象方法的话,那么我要是修改接口中的内容,那么对实现类的影响太大了,所有实现类都会受到影响。

现在在接口中加入非抽象方法,对实现类没有影响,想调用就去调用即可。

文章来源:https://blog.csdn.net/weixin_45503872/article/details/134976308
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。