通过之前对 JAVA基础 —— 面向对象 以及 JAVA基础 —— 面向对象内存图 的学习。
接下来我们将会进一步学习面向对象进阶的相关知识点。
| static | JAVA基础 （面向对象进阶）—— Static |
| 继承 | JAVA基础 （面向对象进阶）—— 继承 |
| 多态 | JAVA基础 （面向对象进阶）—— 多态 |
| 包、final、权限修饰符、代码块、抽象类和抽象方法方法 | JAVA基础（面向对象进阶） —— 包、final、权限修饰符、代码块、抽象类和抽象方法方法 |
| 接口 | JAVA基础 （面向对象进阶）—— 接口 |
| 内部类 | JAVA基础 （面向对象进阶）—— 内部类 |
目录
一、概念引入
接口其实就是一种规则，是对行为的抽象。
二、接口的定义和使用
- 接口用关键字interface来定义：
public interface 接口名 { }
- 接口不能实例化（接口不能创建对象）
- 接口和类之间是实现关系，通过implements关键字表示：
public class 类名 implements 接口名 { }
- 接口的子类（实现类）：要么重写接口中的所有抽象方法 ； 要么是抽象类
注意1： 接口和类的实现关系，可以单实现，也可以多实现。
public class 类名 implements 接口名1，接口名2 {}
注意2：实现类还可以在继承一个类的同时实现多个接口。
public class 类名 extends 父名 implements 接口名1，接口名2 {}
练习： 编写带有接口和抽象类的标准Javabean类
动物 属性 行为 青蛙 名字，年龄 吃虫子，蛙泳 狗 名字，年龄 吃骨头，狗刨 兔子 名字，年龄 吃胡萝卜
// 动物类 Animal.java
public abstract class Animal {
private String name;
private int age;
public Animal() {}
public Animal(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {return name;}
public void setName(String name) {this.name = name;}
public int getAge() {return age;}
public void setAge(int age) {this.age = age;}
public abstract void eat();
// 游泳不能写在父类当中
// 写在父类当中就说明子类都会游泳
// public abstract void swim();
}
//Swim接口
public interface Swim {
//游泳接口
public abstract void swim();
}
//Frog.java
public class Frog extends Animal implements Swim{
public Frog() {}
public Frog(String name, int age) {super(name, age);
}
@Override
public void eat() {
System.out.println("青蛙在吃虫子");
}
@Override
public void swim() {
System.out.println("青蛙在蛙泳");
}
}
//Rabbit.java
public class Rabbit extends Animal {
public Rabbit() {}
public Rabbit(String name, int age) {super(name, age);}
@Override
public void eat() {
System.out.println("兔子在吃胡萝卜");
}
}
//Dog.java
public class Dog extends Animal implements Swim{
public Dog() {}
public Dog(String name, int age) {super(name, age);}
@Override
public void eat() {
System.out.println("狗吃骨头");
}
@Override
public void swim() {
System.out.println("狗在狗刨");
}
}
//测试类
public class Test {
public static void main(String[] args) {
//创建对象
Frog f = new Frog("小青蛙",1);
System.out.println(f.getName() +"," + f.getAge());
f.eat();
f.swim();
Rabbit r = new Rabbit("小兔子",1);
System.out.println(r.getName() + "," + r.getAge());
r.eat();
//r.swim();
}
}三、 接口中成员的特点
| 成员变量 | 只能是常量 默认修饰符：public static final |
| 构造方法 | 没有 |
| 成员方法 | 只能是抽象方法 默认修饰符：public abstract |
- JDK7以前：接口类只能定义抽象方法。
- JDK8的新特性：接口中可以定义有方法体的方法。
- JDK9的新特性：接口中可以定义私有方法。
四、 接口和类之间的关系
1. 类与类之间
继承关系，只能单继承，不能多继承，但是可以多层继承。
2. 类与接口之间
- 实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口。
- 两个接口中有同名方法只需要重写一次。
//接口1 Inter1
public interface Inter1{
publc abstract void method1();
publc abstract void method2();
publc abstract void method3();
}//接口2 Inter2
public interface Inter2{
publc abstract void method1();
publc abstract void method2();
publc abstract void method3();
publc abstract void method4();
}实现类 重写方法：
//实现类 InerImpl.java
pubic class InerImpl implements Inter1,Inter2{
@Override
public void method1(){
System.out.println(" method1 ");
}
@Override
public void method2(){
System.out.println(" method2 ");
}
@Override
public void method3(){
System.out.println(" method3 ");
}
@Override
public void method4(){
System.out.println(" method4 ");
}
}3. 接口与接口之间
- 继承关系，可以单继承，也可以多继承。
- 实现类实现的是最下面子接口，需要重写所有的抽象方法。
//接口1 Inter1
public interface Inter1{
public abstract void method1();
}//接口2 Inter2
public interface Inter2{
public abstract void method2();
}//接口3 Inter3
public interface Inter3 extends Inter1,Inter2{
public abstract void method3();
}
//实现类 InerImpl.java
pubic class InerImpl implements Inter3{
@Override
public void method1(){
System.out.println(" method1 ");
}
@Override
public void method2(){
System.out.println(" method2 ");
}
@Override
public void method3(){
System.out.println(" method3 ");
}
}五、接口中新增方法
JDK7以前设计好的接口后续再添加新的方法规则，那之前写好的实现类就会报错。因此之前接口发生变化，所有的实现类也就不得不随之发生变化。
所以如果在接口里面的方法可以有方法体就可以解决问题了。
1. JDK8以后接口中新增的默认方法
- 允许在接口中定义默认方法，需要使用关键字default修饰
作用： 解决接口升级的问题
接口中默认方法的定义格式：
- 格式： public default 返回值类型 方法名 （参数列表） { }
- 范例：public default void show （）{ }
接口中默认方法的注意事项：
- 默认方法不是抽象方法，所以不强制被重写。但如果被重写，重写的时候去掉default关键字。
- public可以省略，但default不能省略
- 如果实现了多个接口，多个接口中存在相同名字的默认方法，子类就必须对该方法进行重写。
//InterA 接口A
public interface InterA {
//默认方法不是抽象方法，所以不强制被重写。
//但如果被重写，重写的时候去掉default关键字。
//抽象方法
public abstract void method ();
//默认方法
//public 可省略 ，但是default 不能
public default void show() {
System.out.println("InterA接口默认方法 --- show");
}
}
//InterB 接口B
public interface InterB {
//默认方法
public default void show() {
System.out.println("InterB接口默认方法 --- show");
}
}
//方法类
public class InterImpl implements InterA, InterB {
@Override
public void method() {
System.out.println("实现类重写的抽象方法");
}
// 省略 会报错
// 不知道调用interA中还是interB中show方法
// 所以会自动强制重写
@Override
// 不能强行书写default 否则会报错
public void show() {
System.out.println("重写接口中的默认方法");
}
}
//实现类
public class Test {
public static void main(String[] args) {
//创建实现类的对象
InterImpl ii = new InterImpl();
ii.method(); //实现类重写的抽象方法
ii.show(); //接口默认方法 --- show
}
}2. JDK8以后接口中新增的静态方法
- 允许在接口中定义定义静态方法，需要用static修饰
接口中静态方法的定义格式:
- 格式: public static 返回值类型 方法名 (参数列表) { }
- 范例: public static void show() { }
接口中静态方法的注意事项:
- 静态方法只能通过接口名调用，不能通过实现类名或者对象名调用
- public可以省略，static不能省略
3. JDK9新增的私有方法
接口中私有方法的定义格式:
- 格式1: private 返回值类型 方法名 (参数列表) { }
- 范例|: private void show(){ }
- 格式2: private static 返回值类型 方法名 (参数列表) { }
- 范例2: private static void method () { }
六、 适配器设计模式
1．当一个接口中抽象方法过多，但是我们只要使用其中一部分的
时候，就可以适配器设计模式
2．书写步骤:
编写中间类XXXAdapter ，实现对应的接口对接口中的抽象方法进行空实现
让真正的实现类继承中间类，并重写需要用的方法为了避免其他类创建适配器类的对象，中间的适配器类用abstract进行修饰
145
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
