文章目录
- 1.接口的概念
- 2.接口格式
- 3.接口的特点
- 3.1 练习-1:创建接口
- 3.2 练习-2:创建接口实现类
- 3.3 练习-3:创建接口测试类
- 4.接口的用法
- 5.接口的多继承多实现
- 6.接口总结
- 6.1 类与类的关系
- 6.2 类与接口的关系
- 6.3 接口与接口的关系
- 6.4 抽象类与接口的区别
1.接口的概念
与之前学习过的抽象类一样,接口( Interface )在Java中也是一种抽象类型，接口中的内容是抽象形成的需要实现的功能,接口更像是一种规则和一套标准.
2.接口格式
interface 接口名{代码...}
3.接口的特点
- 通过interface关键字来定义接口
- 通过implements让子类来实现接口
- 接口中的方法全部都是抽象方法(JAVA8)
- 可以把接口理解成一个特殊的抽象类(但接口不是类!!!)
- 类描述的是一类事物的属性和方法,接口则是包含实现类要实现的方法
- 接口突破了java单继承的局限性
- 接口和类之间可以多实现,接口与接口之间可以多继承
- 接口是对外暴露的规则,是一套开发规范
- 接口提高了程序的功能拓展,降低了耦合性
3.1 练习-1:创建接口
package partTwo;
/* 本接口用于接口的入门案例1
* 1.我们通过interface关键字来定义接口*/
public interface Inter {
//2.接口里可以有普通方法吗？ 不可以
// public void eat(){}
//3.接口里可以有抽象方法吗？ 可以,接口中的方法都是抽象方法
public abstract void eat();
public abstract void play();
}
3.2 练习-2:创建接口实现类
package partTwo;
/* 本类用于接口的实现类
* 1.我们通过implements建立实现类与接口的实现关系
* 2.实现类与接口建立了实现关系以后，有俩种方案
* 方案一：不实现或实现部分接口中的抽象方法，作为抽象子类:;
* 方案二：实现父接口中的所有的抽象方法，作为普通子类；*/
// 方案一：abstract public class InterImpl implements inter{}
// 方案二
public class InterImpl implements Inter{
@Override
public void eat() {
System.out.println("下雨天和火锅更配");
}
@Override
public void play() {//作为标记，标记实现了父接口的抽象方法
System.out.println("玩啥玩，我爱敲代码");
}
}
- 我们通过implements建立实现类与接口的实现关系
- 实现类与接口建立了实现关系以后，有俩种方案
- 方案一：不实现或实现部分接口中的抽象方法，作为抽象子类:
- 方案二：实现父接口中的所有的抽象方法，作为普通子类；
3.3 练习-3:创建接口测试类
package partTwo;
public interface TestInterImpl {
public static void main(String[] args) {
/* 接口可以创建对象吗? 不可以*/
//Inter i = new Inter();
/* 创建多态对象进行测试*/
Inter i = new InterImpl();
i.eat();
i.play();
/* 创建纯纯的子类对象进行测试*/
InterImpl i2 = new InterImpl();
i2.eat();
i2.play();
}
}
4.接口的用法
package partTwo;
/* 创建一个interface接口，用于进一步测试接口的使用*/
public interface Inter2 {
/* 1.接口中是否有构造方法---没有*/
//public Inter2(){}
/* 2.接口中是否有成员变量---没有
* 接口中的变量，实际上是静态常量
* 静态：可以被接口名直接调用
* 常量：值不可以被修改，并且定义时必须赋值
* 所以，接口会默认给每个变量自动拼接public static final
* 完整格式：public static final int age = 10; */
int age = 10; //实际上是静态常量，不是成员变量
/* 3.接口中有抽象方法吗 有
* 而且会给方法自动拼接 public abstract，我们写方法时可以简写*/
public abstract void play();
void eat();
}
-
:接口里是没有构造方法的
- 在创建实现类的对象时默认的super()，是调用的默认Object的无参构造
- 如果一个类没有明确指定自己的父类，那么这个类默认继承顶级父类Object
- 所以，虽然接口中没有构造方法，但是并不影响实现类构造函数中的super（）
- 因为这个构造方法是object的，与接口无关
-
接口中是否有成员变量—没有
- 接口中的变量，实际上是静态常量
- 静态：可以被接口名直接调用
- 常量：值不可以被修改，并且定义时必须赋值
- 所以，接口会默认给每个变量自动拼接public static final
- 完整格式：public static final int age = 10;
-
接口中有抽象方法吗 有
- 而且会给方法自动拼接 public abstract，我们写方法时可以简写
package partTwo;
/* 本类用作Inter2接口的实现类*/
//public class Inter2Impl extends Object implements Inter2{
public class Inter2Impl implements Inter2{
//1.创建接口实现类的构造方法
public Inter2Impl(){
/*如果一个类没有明确指定自己的父类，那么这个类默认继承顶级父类Object
* 所以，虽然接口中没有构造方法，但是并不影响实现类构造函数中的super（）
* 因为这个构造方法是object的，与接口无关*/
super();//表示调用父类的无参构造
System.out.println("我是接口实现类的无参构造");
}
//如果接口中添加了抽象方法，那么实现类中要实现所有所有未实现的实现方法
@Override
public void play() {
System.out.println("玩一玩");
}
@Override
public void eat() {
System.out.println("吃一吃");
}
}
-
如果一个类没有明确指定自己的父类，那么这个类默认继承顶级父类Object
* 所以，虽然接口中没有构造方法，但是并不影响实现类构造函数中的super（）
* 因为这个构造方法是object的，与接口无关 -
如果接口中添加了抽象方法，那么实现类中要实现所有所有未实现的实现方法
package partTwo;
/* 本类用作Inter2接口的实现类的测试类*/
public class TestInterImpl2 {
//1.创建测试类中的入口函数main
public static void main(String[] args) {
//2.创建接口实现类的对象
Inter2Impl i = new Inter2Impl();
System.out.println(i.age);
//3.可以被接口直接调用，证明是静态的
System.out.println(Inter2.age);
//值不可以被修改，证明是final
//Inter2.age = 100;
i.eat();
i.play();
}
}
- 我们通过interface关键字定义接口
- 接口实现类需要通过关键字implements与接口建立实现关系
- 接口不可以创建对象/实例化
- 在java8中，接口中所有的方法都是抽象方法，方法可以简写，会自动拼接public abstract
- 接口中没有构造方法，接口实现调用的构造方法是父类的，不是父接口的
注意：如果一个类没有明确指定父类的话，会默认继承顶级父类object - 接口中没有成员变量，都是静态常量，默认会拼接public static final
- 接口不是类！！！你可以把接口理解成一个特殊的抽象类，特殊在，所有的方法都是抽象方法
- 如果一个实现类实现了接口，要不变成一个抽象子类，【不实现/实现部分】，要不变成一个普通子类【全部实现】
- 接口用来指定规则的【有哪些方法，方法有参数吗？有返回值类型吗？】并不做具体的实现
- 接口可以多继承【一个接口可以继承多个接口】多实现【一个类可以实现多个接口】
5.接口的多继承多实现
- 接口可以继承接口，并且可以多继承，多个接口之间用逗号隔开
- 接口与实现类是实现的关系，并且可以多实现，多个接口之间用逗号隔开
- 对于java中的类而言，遵循：单继承，多实现
— 一个类只能有一个父类，但是一个类可以实现多个接口
package partTwo;
/*本类用于测试接口与类之间的复杂关系*/
public class TestRelation {
public static void main(String[] args) {
//创建对象进行功能测试
Inter3Impl i = new Inter3Impl();
i.save();
i.delete();
i.update();
i.find();
}
}
//1.创建接口1
interface Inter1{
void save();//保存功能
void delete();//删除功能
}
//2.创建接口22
interface Inter22{
void update();//更新功能
void find();//查询功能
}
//3.创建接口1的实现类
class Inter1Impl implements Inter1{
@Override
public void save() { }
@Override
public void delete() { }
}
//4.创建接口3,同时继承两个接口
/*1.接口可以继承接口，并且可以多继承，多个接口之间用逗号隔开*/
interface Inter3 extends Inter1,Inter22{ }
//5.创建接口3的实现类
/*2.接口与实现类是实现的关系，并且可以多实现，多个接口之间用逗号隔开
* 对于Java中的类而言，遵循：单继承 多实现
* 一个类只能有一个父类，但是一个类可以实现多个接口*/
//class Inter3Impl implements Inter3{//写法1
class Inter3Impl implements Inter1,Inter22{//写法2
@Override
public void save() {
System.out.println("稍等...正在努力保存中...");
}
@Override
public void delete() {
System.out.println("删除成功！");
}
@Override
public void update() {
System.out.println("小二正在马不停蹄的更新~");
}
@Override
public void find() {
System.out.println("客官，马上就查询好啦，稍等一丢丢~");
}
}
6.接口总结
6.1 类与类的关系
继承关系,只支持单继承
比如,A是子类 B是父类,A具备B所有的功能(除了父类的私有资源和构造方法)
子类如果要修改原有功能,需要重写(方法签名与父类一致 + 权限修饰符>=父类修饰符)
6.2 类与接口的关系
实现关系.可以单实现,也可以多实现
class A implements B,C{}
其中A是实现类,B和C是接口,A拥有BC接口的所有功能,只是需要进行方法的重写,否则A就是抽象类
6.3 接口与接口的关系
是继承关系,可以单继承,也可以多继承
interface A extends B,C{}
其中ABC都是接口,A是子接口,具有BC接口的所有功能(抽象方法)
class X implements A{}
X实现类需要重写ABC接口的所有方法,否则就是抽象类
class A extends B implements C,D{}
其中A是实现类,也是B的子类,同时拥有CD接口的所有功能
这时A需要重写CD接口里的所有抽象方法
6.4 抽象类与接口的区别
- 抽象类是一个特殊的类,这个类被abstract修饰,抽象类中可以包含没有方法体的方法(抽象方法)
接口可以理解成一个特殊的抽象类,特殊在,接口里的都是抽象方法,没有普通方法
但是注意：接口不是类，接口使用interface关键字来定义
接口会为方法自动拼接public abstract,还会为变量自动拼接public final static - 抽象类可以有构造方法–用来给子类创建对象,接口中没有构造方法
注意：抽象类的子类调用的就是抽象类的构造，但接口的实现类调用的是自己父类的构造方法 - 抽象类和接口都不能实例化(创建对象)
- 接口可继承接口，并可多继承接口，但类只能单继承
- 抽象方法只能声明，不能实现，接口是设计的结果 ，抽象类是重构的结果
抽象类中可以定义普通的成员变量，但接口中都是静态常量 - 抽象是后天重构的结果，接口是先天设计的结果
