【Java】接口 interface-编程知识

概述

什么是接口

接口就是一种公共的规范标准，只要符合规范标准，大家都可以调用。

Java 中的接口更多的体现在对行为的抽象！

1. 接口用关键字 interface 修饰

public interface 接口名 {}

2. 类实现接口用 implements 表示

public class 类 implements 接口 {}

3. 接口不能实例化

接口如何实例化呢？

参照多态的方式，通过实现类对象实例化，这叫接口多态。

多态的形式：具体类多态，抽象类多态，接口多态。

4. 多态的前提：

有继承（抽象类）或者实现（接口）关系；
有方法重写；
有父（类/接口引用）指向（子/实现）类对象

5. 接口的实现类

要么重写接口中所有的抽象方法、要么是抽象类

示例代码：

Animal.java

package com.面向对象.Demo28;public interface Animal {// 接口 Animalpublic abstract void eat();}

CatImpl.java

package com.面向对象.Demo28;public class CatImpl implements Animal {// CatImpl————实现类 实现了Animal接口/*** 实现类 必须重写 接口中的所有方法*/@Overridepublic void eat() {System.out.println("CatImpl-eat()-鱼");}/*** abstract class AnimalParent————抽象类  父类* Cat extends AnimalParent————子类** 接口 主要体现抽象的行为* interface Animal————接口  父类* CatImpl implements Animal 实现类Animal接口  子类** 抽象类 与 接口 有哪些区别？*/
}

Test01.java

package com.面向对象.Demo28;public class Test01 {public static void main(String[] args) {
//        new Animal();// 报错，抽象类与接口 不能被实例化// 都是通过 多态机制Animal animal = new CatImpl();animal.eat(); //CatImpl-eat()-鱼}
}

DogImpl.java

package com.面向对象.Demo28;//public class DogImpl implements Animal{// 不想在实现类里重写Animal接口——abstract//    @Override
//    public void eat() {}
public abstract class DogImpl implements Animal{}

MayiktDogImpl.java

package com.面向对象.Demo28;public class MayiktDogImpl extends DogImpl{//类图 Ctrl+Alt+u// MayiktDogImpl类 继承 DogImpl类，就必须重写 DogImpl类中的所有方法@Overridepublic void eat() {}
}

接口成员访问特点

1. 成员变量只能是常量；（直接通过接口的名称访问即可）

默认修饰符 public static final

2. 成员方法只能是抽象方法；（JDK8开始是可以在接口中定义非抽象方法需要加上default）

默认修饰符 public abstract

3. 接口没有构造方法；

因为接口只要对行为进行抽象，没有具体存在，一个类如果没有父类，默认继承自Object类

示例代码：

Animal.java

package com.面向对象.Demo29;public interface Animal {
//    public int code1 = 100;
//    public final int code2 = 200; // final 修饰 不能修改
//    public  int code2 = 200; // final 修饰 不能修改, 默认是已经加上final
//    public static int code3 = 300; //static 修饰 Animal.属性名称 访问
//    public  int code3 = 300; //static 修饰 Animal.属性名称 访问,默认是已经加上static///*** 综上，上述代码可以简化,* 成员变量只能是常量；* 默认修饰符 public static final*/int code1 = 100; //==>public final static int code1 = 100;int code2 = 200;int code3 = 300;/*** 抽象方法* 默认前面已经加上了public abstract*/void eat();//==>public abstract void eat();/*** 在接口中 是否可以定义 非抽象方法呢？ jdk8 是可以在接口中定义 非抽象方法 default* jdk8之前是不可以在接口中定义非抽象方法的*/default void show(){ // ==> public default void show(){System.out.println("接口中-非抽象方法-show()");}/*** 在我们的接口中 是没有构造方法* 抽象类 和 接口 都是不能 直接 new* 抽象类 是有 构造方法* 接口 主要是对我们的行为来做抽象的概念*/
//    public Animal(){}  // 报错，接口是没有抽象方法的
}

DogImpl.java

package com.面向对象.Demo29;public class DogImpl implements Animal { //==>public class DogImpl extends Object implements Animal{@Overridepublic void eat() {System.out.println("DogImpl-eat()");}public DogImpl() {super(); // 默认，父类中 无参构造方法 是我们Object 父类}/*** 既然 Animal接口中不可以定义无参构造方法（也不属于父类），那这里的是如何super()访问父类的？*  ∵ 定义了一个类 如果没有继承任何父类，则在默认情况下 就继承了我们的 object父类*  任何类的父类 都是 Object*  new DogImpl()————先执行Object父类-无参构造方法，再执行DogImpl-无参构造方法*/
}

Test01.java

package com.面向对象.Demo29;public class Test01 {public static void main(String[] args) {/*** 1.在接口中 定义的 成员变量 都是为 常量*      默认的成员变量是已经加上public final static 关键字的，* 2.在接口中 定义的 成员方法 默认的情况下 就是为 抽象方法*      默认已经加上了 public abstract 修饰成员方法，实现类 必须重写 接口中所用的抽象方法*/Animal dog = new DogImpl();System.out.println(dog.code1); //100System.out.println(dog.code2); //200System.out.println(dog.code3); //300//        dog.code1 = 300;//报错，常量是不可以修改
//        dog.code2 = 200;//报错，Cannot assign a value to final variable 'code2'
//        dog.code3 = 100;//报错，在接口中 定义的 成员变量 都是为 常量System.out.println("===========");System.out.println(Animal.code1); //100System.out.println(Animal.code2); //200System.out.println(Animal.code3); //300}
}

下一篇文章：