Java
1、接口
1.1 接口的概念
接口，是Java语言中一种引用类型，是方法的集合，如果说类的内部封装了成员变量、构造方法和成员方法，那么接口的内部主要就是封装了方法（功能），包含抽象方法 (JDK7及以前) , 默认方法和静态方法（JDK8）私有方法（JDK9）。
- 可以理解为大量抽象方法的抽象。
1.2 接口的定义格式
接口用关键字
interface修饰
public interface 接口名 {}
1.3 接口成员的特点
1.3.1 成员变量
接口中的成员变量只能是静态常量，默认修饰符：public static final（基本不使用）
1.3.2 成员方法
接口中书写的方法只能是抽象方法，默认修饰符：public abstract
1.3.3 构造方法
没有构造方法，因为接口主要是扩展功能的，而没有具体存在
1.4 接口的使用
接口是不能创建对象，必须有实现类才能使用，类实现接口用
implements表示
public class 类名 implements 接口名 {}
用于实现接口的类称之为实现类,实现类必须实现所实现接口的所有抽象方法，否则需要定义为抽象类。
注意: 接口的实现类必须重写接口中的所有的抽象方法，要么该类是一个抽象类
1.5 继承父类并实现多个接口
在继承体系中，一个类只能继承一个父类。而对于接口而言，一个类是可以实现多个接口的，这叫做接口的多实现。并且，一个类能继承一个父类，同时实现多个接口。
- 接口中，有多个抽象方法时，实现类必须重写所有抽象方法。
- 如果实现类继承了父类，这个父类是一个抽象类时，我们还需要再重写抽象类中的所有抽象方法。
- 多实现格式
class 类名 [extends 父类名] implements 接口名1,接口名2,接口名3... {
// 重写接口中抽象方法【必须】
// 重写接口中默认方法【不重名时可选】
}
1.6 接口之间的多继承
一个接口能继承另一个或者多个接口，这和类之间的继承比较相似。接口的继承使用extends关键字，子接口继承父接口的方法。如果父接口中的默认方法有重名的，那么子接口需要重写一次。
public interface 接口名 extends 接口名1,接口名2，接口名3 {}
接口多继承之后，如果想使用，我们还必须定义实现类，才能使用
1.7 抽象类和接口的区别
语法区别： 抽象类使用abstract关键字修饰class 接口使用interface关键字创建
成员变量区别： 抽象类可以书写任意变量，接口中只能书写静态常量
成员方法区别： 抽象类中既可以书写实现方法也可以书写抽象方法，接口中只能拥有抽象方法
修饰符区别： 抽象类中修饰符与类的修饰符默认书写一致，接口中方法修饰符默认为public abstract
构造方法区别： 抽象类中可以书写构造方法，由子类调用进行赋值，接口中不能书写构造方法
关系区别： 类与类之间只存在单继承关系，类与接口存在多实现关系，接口与接口可以多继承
设计理念区别： 抽象类为了继承而来，让子类强制重写父类中的抽象方法，接口是对行为抽象，主要是行为的集合。
1.8 接口总结
- 接口中只有常量和抽象方法
- 接口是没有静态代码块和构造方法的。
- 一个类的直接父类是唯一的，但是一个类可以同时实现多个接口。 单继承多实现。
public class MyInterfaceImpl implements MyInterfaceA, MyInterfaceB { // 覆盖重写所有抽象方法}- 如果实现类所实现的多个接口当中，存在重复的抽象方法，那么只需要覆盖重写一次即可。
- 如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类就必须是一个抽象类。
2、多态
2.1 多态的概念
- 一个父类不同的子类形态,根据不同的形态决定代码的调用与执行。
- 多态是同一个行为具有多个不同表现形式或形态的能力。
2.2 多态发生的前提
- 子类继承父类或实现类实现接口
- 方法重写
- 向上转型（声明父类变量保存子类对象）
2.3 多态的书写和使用
- 普通类多态的格式
父类 对象 = new 子类();- 抽象类多态的格式
抽象类 对象名 = new 抽象类子类();- 接口多态的格式
接口 对象名 = new 接口实现类();
2.4 多态的优缺点
-
优点
减少代码书写，增强可维护性与扩展性
-
缺点
不能使用子类特有的属性与方法（只能使用父类的属性与方法）
2.5 多态的转型
2.5.1 向上转型
声明父类变量,保存子类对象，类似于java的自动类型转换
- 使用格式
父类类型 变量名 = new 子类类型();
如：Animal a = new Cat();
2.5.2 向下转型
- 一个已经向上转型的子类对象，将父类引用转为子类引用，可以使用强制类型转换的格式，便是向下转型。
- 声明子类变量,保存父类声明对象变量，类似于java的强制类型转换，需要书写额外语法
- 向下转型成功的前提（曾经发生过向上转型并且与转型类型相同）
子类类型 变量名 = (子类类型) 父类变量名;
如:Cat c =(Cat) a;
//向上转型
Animal a=new Dog("大黄");
//向下转换
Dog d=(Dog)a;
2.5.3 转型的代码演示
- 测试类
public class Test {
public static void main(String[] args) {
// 向上转型
Animal a = new Cat();
a.eat(); // 调用的是 Cat 的 eat
// 向下转型
Cat c = (Cat)a;
c.catchMouse(); // 调用的是 Cat 的 catchMouse
}
}
- 定义类
abstract class Animal {
abstract void eat();
}
class Cat extends Animal {
public void eat() {
System.out.println("吃鱼");
}
public void catchMouse() {
System.out.println("抓老鼠"); }
}
class Dog extends Animal {
public void eat() {
System.out.println("吃骨头"); }
public void watchHouse() {
System.out.println("看家");
}
}
2.5.4 转型的异常
- 问题描述
转型的过程中，一不小心就会遇到这样的问题，请看如下代码：
public class Test {
public static void main(String[] args) {
// 向上转型
Animal a = new Cat();
a.eat(); // 调用的是 Cat 的 eat
// 向下转型
Dog d = (Dog)a;
d.watchHouse(); // 调用的是 Dog 的 watchHouse 【运行报错】 }
}
这段代码可以通过编译，但是运行时，却报出了ClassCastException类型转换异常！这是因为，明明创建了Cat类型对象，运行时，当然不能转换成Dog对象的。这两个类型并没有任何继承关系，不符合类型转换的定义。
为了避免 ClassCastException 的发生，Java提供了
instanceof关键字，给引用变量做类型的校验，格式如下：
public class Test {
public static void main(String[] args) {
// 向上转型
Animal a = new Cat();
a.eat(); // 调用的是 Cat 的 eat
// 向下转型
if (a instanceof Cat){
Cat c = (Cat)a;
c.catchMouse(); // 调用的是 Cat 的 catchMouse
} else if (a instanceof Dog){
Dog d = (Dog)a;
d.watchHouse(); // 调用的是 Dog 的 watchHouse
}
}
}
instanceof使用格式
变量名 instanceof 数据类型
如果变量属于该数据类型，返回true。
如果变量不属于该数据类型，返回false。
2.6 内存图解
2.7 多态的综合案例
请用所学知识分析，这个案例中有哪些具体类，哪些抽象类，哪些接口，并用代码实现。
代码实现：
- Person类
public abstract class Person {
private String name;
private int age;
public Person() {
}
public Person(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();
}
- 抽象运动员类(Player)
public abstract class Player extends Person {
public Player() {
}
public Player(String name, int age) {
super(name, age);
}
public abstract void study();
}
- 抽象教练类(Coach)
public abstract class Coach extends Person {
public Coach() {
}
public Coach(String name, int age) {
super(name, age);
}
public abstract void teach();
}
- 学英语接口(SpeakEnglish)
public interface SpeakEnglish {
public abstract void speak();
}
- 篮球教练(BasketballCoach)
public class BasketballCoach extends Coach {
public BasketballCoach() {
}
public BasketballCoach(String name, int age) {
super(name, age);
}
@Override
public void teach() {
System.out.println("篮球教练教如何运球和投篮");
}
@Override
public void eat() {
System.out.println("篮球教练吃羊肉，喝羊奶");
}
}
- 乒乓球教练(PingPangCoach)
public class PingPangCoach extends Coach implements SpeakEnglish {
public PingPangCoach() {
}
public PingPangCoach(String name, int age) {
super(name, age);
}
@Override
public void teach() {
System.out.println("乒乓球教练教如何发球和接球");
}
@Override
public void eat() {
System.out.println("乒乓球教练吃小白菜，喝大米粥");
}
@Override
public void speak() {
System.out.println("乒乓球教练说英语");
}
}
- 乒乓球运动员(PingPangPlayer)
public class PingPangPlayer extends Player implements SpeakEnglish {
public PingPangPlayer() {
}
public PingPangPlayer(String name, int age) {
super(name, age);
}
@Override
public void study() {
System.out.println("乒乓球运动员学习如何发球和接球");
}
@Override
public void eat() {
System.out.println("乒乓球运动员吃大白菜，喝小米粥");
}
@Override
public void speak() {
System.out.println("乒乓球运动员说英语");
}
}
- 篮球运动员(BasketballPlayer)
public class BasketballPlayer extends Player {
public BasketballPlayer() {
}
public BasketballPlayer(String name, int age) {
super(name, age);
}
@Override
public void study() {
System.out.println("篮球运动员学习如何运球和投篮");
}
@Override
public void eat() {
System.out.println("篮球运动员吃牛肉，喝牛奶");
}
}
每日一点点进步
不进则退
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
