1、接口
1.1 接口基本概述及格式
1.1.1 接口概述
接口，是Java语言中一种引用类型，是方法的集合，如果说类的内部封装了成员变量、构造方法和成员方法，那么
接口的内部主要就是封装了方法（功能），包含抽象方法 (JDK7及以前) , 默认方法和静态方法（JDK8）私有方法（JDK9）。
-
总结
接口就是一种公共的规范标准，只要符合规范标准，大家都可以通用。
Java中的接口更多的体现在对行为的抽象！
1.1.2 接口定义格式
接口用关键字interface修饰
public interface 接口名 {}
1.1.3 接口的使用
接口是不能创建对象，必须有实现类才能使用，类实现接口用implements表示
public class 类名 implements 接口名 {}
注意: 接口的实现类必须重写接口中的所有的抽象方法，要么该类是一个抽象类
1.2 接口成员的特点
1.2.1 成员变量
只能是常量，默认修饰符：public static final
1.2.2 成员方法
只能是抽象方法，默认修饰符：public abstract
1.2.3 构造方法
没有，因为接口主要是扩展功能的，而没有具体存在
1.4 代码演示
-
接口
public interface Inter { public int num = 10; public final int num2 = 20; // public static final int num3 = 30; int num3 = 30; //public Inter() {} //public void show() {} public abstract void method(); void show(); } -
实现类
public class InterImpl implements Inter { public InterImpl() { super(); } @Override public void method() { System.out.println("method"); } @Override public void show() { System.out.println("show"); } } -
测试类
public class InterfaceDemo { public static void main(String[] args) { Inter i = new InterImpl(); // i.num = 20; System.out.println(i.num); // i.num2 = 40; System.out.println(i.num2); System.out.println(Inter.num); } }
1.3 类和接口的关系
-
类与类的关系
继承关系，只能单继承，但是可以多层继承
-
类与接口的关系
实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口
-
接口与接口的关系
继承关系，可以单继承，也可以多继承
1.4 抽象类和接口的区别
-
成员区别
-
抽象类
变量,常量；有构造方法；有抽象方法,也有非抽象方法
-
接口
常量；抽象方法
-
-
关系区别
-
类与类
继承，单继承
-
类与接口
实现，可以单实现，也可以多实现
-
接口与接口
继承，单继承，多继承
-
-
设计理念区别
-
抽象类
为了继承而来,让子类强制重写父类中的抽象方法
-
接口
对行为抽象，主要是行为
-
1.5 继承父类并实现多个接口
之前学过，在继承体系中，一个类只能继承一个父类。而对于接口而言，一个类是可以实现多个接口的，这叫做接
口的多实现。并且，一个类能继承一个父类，同时实现多个接口。
1.5.1 多实现格式
class 类名 [extends 父类名] implements 接口名1,接口名2,接口名3... {
// 重写接口中抽象方法【必须】
// 重写接口中默认方法【不重名时可选】
}
1.5.2 代码演示
-
定义接口
interface A { public abstract void showA(); public abstract void show(); } interface B { public abstract void showB(); public abstract void show(); } -
定义父类
public class Fu{} -
定义实现类
public class C extends Fu implements A,B{ @Override public void showA() { System.out.println("showA"); } @Override public void showB() { System.out.println("showB"); } @Override public void show() { System.out.println("show"); } } -
注意事项
接口中，有多个抽象方法时，实现类必须重写所有抽象方法。如果抽象方法有重名的，只需要重写一次即可！ 如果实现类继承了父类，这个父类是一个抽象类时，我们还需要再重写抽象类中的所有抽象方法。
1.6 接口之间的多继承
一个接口能继承另一个或者多个接口，这和类之间的继承比较相似。接口的继承使用extends关键字，子接口继承父接口的方法。如果父接口中的默认方法有重名的，那么子接口需要重写一次。
-
定义父接口
interface A { public void method1(); } interface B { public void method2(); } -
定义子接口
interface D extends A,B{ public void method2(); } -
注意
接口多继承之后，如果想使用，我们还必须定义实现类，才能使用
1.7 接口小结
-
接口中只有常量和抽象方法
-
接口是没有静态代码块和构造方法的。
-
一个类的直接父类是唯一的，但是一个类可以同时实现多个接口。 单继承多实现
public class MyInterfaceImpl implements MyInterfaceA, MyInterfaceB { // 覆盖重写所有抽象方法 } -
如果实现类所实现的多个接口当中，存在重复的抽象方法，那么只需要覆盖重写一次即可。
-
如果实现类没有覆盖重写所有接口当中的所有抽象方法，那么实现类就必须是一个抽象类。
1.8 接口案例
-
需求
对猫和狗进行训练，他们就可以跳高了，这里加入跳高功能。
请采用抽象类和接口来实现猫狗案例，并在测试类中进行测试。
-
代码实现
-
Animal类
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(); } -
跳高接口Jumping
public interface Jumpping { public abstract void jump(); } -
猫类(Cat)
public class Cat extends Animal implements Jumpping { public Cat() { } public Cat(String name, int age) { super(name, age); } @Override public void eat() { System.out.println("猫吃鱼"); } @Override public void jump() { System.out.println("猫可以跳高了"); } } -
测试类
public class AnimalDemo { public static void main(String[] args) { Cat c = new Cat(); c.setName("加菲"); c.setAge(5); System.out.println(c.getName()+","+c.getAge()); c.eat(); c.jump(); } }
-
2、多态
2.1 什么是多态
多态是继封装、继承之后，面向对象的第三大特性。
生活中，比如跑的动作，小猫、小狗和大象，跑起来是不一样的。再比如飞的动作，昆虫、鸟类和飞机，飞起来也
是不一样的。可见，同一行为，通过不同的事物，可以体现出来的不同的形态。多态，描述的就是这样的状态。
定义：同一个对象，在不同时刻表现出来的形态是不同的
2.2 多态的前提
- 要有继承或实现关系 - 要有方法的重写 - 要有父类引用指向子类对象
2.3 多态格式
-
普通类多态的格式
父类 对象 = new 子类();
-
抽象类多态的格式
抽象类 对象名 = new 抽象类子类();
-
接口多态的格式
接口 对象名 = new 接口实现类();
2.4 多态中的成员访问特点
2.4.1 成员变量
编译看父类，运行看父类
2.4.2 成员方法
编译看父类，运行看子类
2.4.3 代码演示
-
动物类(Animal)
public class Animal { public int age = 40; public void eat() { System.out.println("动物吃东西"); } } -
猫类(Cat)
public class Cat extends Animal { public int age = 20; public int weight = 10; @Override public void eat() { System.out.println("猫吃鱼"); } public void playGame() { System.out.println("猫捉迷藏"); } } -
测试类
public class AnimalDemo { public static void main(String[] args) { //有父类引用指向子类对象 Animal a = new Cat(); System.out.println(a.age); // System.out.println(a.weight); a.eat(); // a.playGame(); } }
2.5 多态的好处和弊端
2.5.1 多态的好处
提高程序的扩展性。定义方法时候，使用父类型作为参数，在使用的时候，使用具体的子类型参与操作
2.5.2 多态的弊端
不能使用子类的特有成员
2.5.3 多态的好处代码演示
实际开发的过程中，父类类型作为方法形式参数，传递子类对象给方法，进行方法的调用，更能体现出多态的扩展性与便利
-
定义父类
public abstract class Animal { public abstract void eat(); } -
定义子类
class Cat extends Animal { public void eat() { System.out.println("吃鱼"); } } class Dog extends Animal { public void eat() { System.out.println("吃骨头"); } } -
定义测试类
public class Test { public static void main(String[] args) { // 多态形式，创建对象 Cat c = new Cat(); Dog d = new Dog(); // 调用showCatEat showCatEat(c); // 调用showDogEat showDogEat(d); /* 以上两个方法, 均可以被showAnimalEat(Animal a)方法所替代 而执行效果一致 */ showAnimalEat(c); showAnimalEat(d); } public static void showCatEat (Cat c){ c.eat(); } public static void showDogEat (Dog d){ d.eat(); } public static void showAnimalEat (Animal a){ a.eat(); } }
2.5.4 多态的好处小结
由于多态特性的支持，showAnimalEat方法的Animal类型，是Cat和Dog的父类类型，父类类型接收子类对象，当然可以把Cat对象和Dog对象，传递给方法。当eat方法执行时，多态规定，执行的是子类重写的方法，那么效果自然与showCatEat、showDogEat方法一致，所以showAnimalEat完全可以替代以上两方法。
不仅仅是替代，在扩展性方面，无论之后再多的子类出现，我们都不需要编写showXxxEat方法了，直接使用
showAnimalEat都可以完成。 所以，多态的好处，体现在，可以使程序编写的更简单，并有良好的扩展。
2.6 多态中的转型
2.6.1 为什么要用转型
当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误。也就是说，不能调用子类拥有，而父类没有的方法。编译都错误，更别说运行了。这也是多态给我们带来的一点
"小麻烦"。所以，想要调用子类特有的方法，必须做向下转型。
2.6.2 向上转型
多态本身是子类类型向父类类型向上转换的过程，这个过程是默认的。
-
使用格式
父类类型 变量名 = new 子类类型(); 如：Animal a = new Cat();
2.6.3 向下转型
父类类型向子类类型向下转换的过程，这个过程是强制的。
一个已经向上转型的子类对象，将父类引用转为子类引用，可以使用强制类型转换的格式，便是向下转型。
-
使用格式
子类类型 变量名 = (子类类型) 父类变量名; 如:Cat c =(Cat) a;
2.6.4 代码演示
-
定义类
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("看家"); } } -
测试类
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 } }
2.7 转型的异常
2.7.1 问题描述
转型的过程中，一不小心就会遇到这样的问题，请看如下代码：
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关键字，给引用变量做类型的校验，格式如下：
2.7.2 instanceof使用格式
变量名 instanceof 数据类型
如果变量属于该数据类型，返回true。
如果变量不属于该数据类型，返回false。
2.7.3 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
}
}
}
3、综合案例
3.1 案例需求
我们现在有乒乓球运动员和篮球运动员，乒乓球教练和篮球教练。
为了出国交流，跟乒乓球相关的人员都需要学习英语。
请用所学知识分析，这个案例中有哪些具体类，哪些抽象类，哪些接口，并用代码实现。
3.2 代码实现
-
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("篮球运动员吃牛肉，喝牛奶"); } }
207
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
