接口的用法、常量接口、微观接口和宏观接口（JAVA基础六）

一、接口语法

1.1 基本使用

概念：接口相当于特殊的抽象类，定义方式、组成部分与抽象类类似。使用interface关键字定义接口。

特点：

• 没有构造方法，不能创建对象。
• 只能定义：公开静态常量、公开抽象方法。

案例演示：自定义接口。

package com.qfedu.test01;

public interface ITest01 {

    //1.接口是特定的抽象类：
    //2. 关键字： interface
    //2. 没有构造方法  不能new 对象
   /* public  ITest01() {

    }*/
    //3.通常写的是 ： 公开抽象方法和 公开的常量
    //4. 接口定义的时候，接口名：     Ixxxx
    // 5.  public  static final  public  abstract 可以省略
    public static final int A = 1;

    public abstract void aa();

    String B = "A";

    void bb();

    //方法：
    //新增
    public void add();

    //删除
    public boolean del();

    //修改
    public int update();

    ///查询
    public String[] select();

}
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

实现类：

package com.qfedu.test01;

// 1.实现接口：     xxx  implements  接口
// ITest01 接口
// Test01Impl  ITest01这个接口的实现类
// 实现类： 命名：     接口把I去掉  再加impl   ITest01   Test01Impl
// 如果实现多个接口： 用,隔开就行
public class Test01Impl implements  ITest01,ITest02{
    @Override
    public void aa() {
        System.out.println("执行 重写方法");
    }

    @Override
    public void bb() {
    }

    @Override
    public void add() {
    }

    @Override
    public boolean del() {
        return false;
    }

    @Override
    public int update() {
        return 0;
    }

    @Override
    public String[] select() {
        return new String[0];
    }

    @Override
    public void delBatch() {
    }
}

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

测试类：

package com.qfedu.test01;

public class TMain {
    public static void main(String[] args) {

       // ITest01 t = new ITest01();

       //1. 用多态的方式，去创建对象
        // 接口   xx = new 实现类();
       ITest01 t1 = new Test01Impl();
       t1.aa();

       ITest02 t2 = new Test01Impl();
       t2.delBatch();

       Test01Impl im = new Test01Impl();

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

1.2 和抽象类区别

相同点：

• 不能创建对象。
• 可以作为引用类型。 多态
• 具备Object类中所定义的方法。 java 根基类

不同点：

• 所有属性都是公开静态常量，隐式使用public static final修饰。
• 所有方法都是公开抽象方法，隐式使用public abstract修饰。
• 没有构造方法、动态代码块、静态代码块。

普通类 --》 抽象类 --》 接口类

接口： I打头 IHero IEquip

实现: 类名+Impl

二、微观接口【重点】 --可以实现多个接口

微观概念：接口是一种能力和约定。(功能)

• 接口的定义：代表了某种能力。
• 方法的定义：能力的具体要求。

定义某个类的功能： 增删改查

经验：

• Java为单继承，当父类的方法种类无法满足子类需求时，可实现接口扩充子类能力。
• 接口支持多实现，可为类扩充多种能力。

案例演示：实现类实现多个接口。

package com.qfedu;

public interface IException {

    //显示代码的错误信息
    void show();
}
1
2
3
4
5
6
7

package com.qfedu;

//1. 抽象类实现的关键字: extends
//2. 接口的关键字是:implements  实现接口:  实现接口的对应类： 实现类 比如： hero的实现类
//3. 实现类的命令： 约定 实现类后边加上Impl

// 4. 支持多实现: 可扩展性更好
//     格式：implements 接口1,接口2,........

//Hero   IHero   HeroImpl

public class HeroImpl   implements IHero,IException {

    @Override
    public boolean add() {
        return false;
    }

    @Override
    public void show() {
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

三、接口规范

• 任何类在实现接口时，必须实现接口中所有的抽象方法，否则此类为抽象类。

package com.qfedu;

//任何类在实现接口时，必须实现接口中所有的抽象方法，否则此类为抽象类。

public abstract class Test1 implements  IHero {

}
1
2
3
4
5
6
7

package com.qfedu;

public class Test2 extends  Test1 {
    @Override
    public boolean add() {
        return false;
    }
}
1
2
3
4
5
6
7
8

• 实现接口中的抽象方法时，访问修饰符必须是public。
• 同父类一样，接口也可声明为引用，并指向实现类对象。(多态)

注：
仅可调用接口中所声明的方法，不可调用实现类中独有的方法。
可强转回实现类本身类型，进行独有方法调用。

四、接口常见关系

类与类：extends 单继承

类与接口：

• 多实现
• implements 接口名称1 , 接口名称2 , 接口名称n

接口与接口：

• 多继承
• extends 父接口1 , 父接口2 , 父接口n

案例演示：接口多继承。

package com.qfedu;

//接口可以实现 多继承,
//目的是少写代码: 提高代码重用性,或者叫复用性

public interface Test3  extends IHero ,IException{

/*    void add();

    void show();*/

    void delete();
}
1
2
3
4
5
6
7
8
9
10
11
12
13

五、常量接口

将多个常用于表示状态或固定值的变量，以静态常量的形式定义在接口中统一管理，提高代码可读性。

public interface ConstInterface {
	String CONST1 = "aaa";
	String CONST2 = "bbb";
	String CONST3 = "ccc";
}
1
2
3
4
5

public class TestConstInterface {
	public static void main(String[] args) {
		if(ConstInterface.CONST1.equals("aaa")) {
			System.out.println();
		}
	}
}
1
2
3
4
5
6
7

六、宏观接口【重点】

6.1 概念

宏观概念：接口是一种标准、规范。

案例演示：

public interface IUsb {

    //方法服务:规范
    void serivce();

}
1
2
3
4
5
6

public class MouseImpl  implements  IUsb {
    @Override
    public void serivce() {
        System.out.println("鼠标的相关服务.......");
    }
}
1
2
3
4
5
6

public class FanImpl implements IUsb {
    @Override
    public void serivce() {
        System.out.println("风扇的相关服务......");
    }
}
1
2
3
4
5
6

public class UpanImpl implements  IUsb {
    @Override
    public void serivce() {
        System.out.println("U盘的相关服务......");
    }
}
1
2
3
4
5
6

public class TV  {

    //属性  有usb  依据传入不同的实现类对象： 调用对应的接口方法
    // TV 持有 IUsb的一个引用
    public    IUsb usb;
    //用构造器赋值
    public TV(IUsb usb) {
        this.usb = usb;
    }

    //使用服务
    public  void run() {
        usb.serivce();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

public class Test {

    public static void main(String[] args) {

        //1.定义具体的实现类
        IUsb mouse = new MouseImpl();
        //2.把 实现类对象传到使用者里
        TV tv = new TV(mouse);

        //3.运行方法
        tv.run();

    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

6.2 回调原理

接口回调：先有接口的使用者，后有接口的实现者。

6.3 接口好处

• 程序的耦合度降低。

耦合度: 关联度;

比如： 持有对象的引用 或者 方法调用方法！ 耦合度只能降低，不能消除

降低耦合度： 低耦合,松耦合

• 更自然的使用多态。
• 设计与实现完全分离。
• 更容易搭建程序框架。 cotroller service dao
• 更容易更换具体实现。