目录
概述
示例代码：
接口成员访问特点
示例代码：
概述
什么是接口
接口就是一种公共的规范标准，只要符合规范标准，大家都可以调用。
Java 中的接口更多的体现在对行为的抽象！
1. 接口 用关键字 interface 修饰
public interface 接口名 {}
2. 类实现接口用 implements 表示
public class 类 implements 接口 {}
3. 接口不能实例化
- 接口如何实例化呢？
参照多态的方式，通过实现类对象实例化，这叫接口多态。
- 多态的形式：具体类多态，抽象类多态，接口多态。
4. 多态的前提：
- 有继承（抽象类）或者实现（接口）关系；
- 有方法重写；
- 有父（类/接口引用）指向（子/实现）类对象
5. 接口的实现类
要么重写接口中所有的抽象方法、要么是抽象类
示例代码：
Animal.java
package com.面向对象.Demo28;
public interface Animal {
// 接口 Animal
public abstract void eat();
}
CatImpl.java
package com.面向对象.Demo28;
public class CatImpl implements Animal {
// CatImpl————实现类 实现了Animal接口
/**
* 实现类 必须重写 接口中的所有方法
*/
@Override
public 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类中的所有方法
@Override
public 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{
@Override
public 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); //100
System.out.println(dog.code2); //200
System.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); //100
System.out.println(Animal.code2); //200
System.out.println(Animal.code3); //300
}
}
下一篇文章：
