目录
1 内容介绍
1. 接口(重点)
2. 多态(重点)
3. 引用类型的转换(掌握)
2 接口(重点)
2.1接口
2.1.1 概念理解
接口是一种约定规范,是多个抽象方法的集合。仅仅只是定义了应该有哪些功能,本身不实现功能,
至于每个功能具体怎么实现,就交给实现类完成。
接口中的方法是抽象方法,并不提供功能实现,体现了规范和实现相分离的思想,也体现了组件之间
低耦合的思想。
所谓耦合度,表示组件之间的依赖关系。依赖关系越多,耦合性越强,同时表明组件的独立性越差,
在开发中往往提倡降低耦合性,可提高其组件独立性,举一个低耦合的例子。
电脑的显卡分为集成显卡和独立显卡:
集成显卡:显卡和主板焊死在一起,显卡坏了,只能换主板
独立显卡:显卡和主板相分离,显卡插到主板上即可,显卡坏了,只换显卡,不用换主板
接口也体现的是这种低耦合思想,接口仅仅提供方法的定义,却不提供方法的代码实现。那么得专门
提供类并去实现接口,再覆盖接口中的方法,最后实现方法的功能,在多态案例中再说明。
2.1.2 接口申明&多继承性
接口可以认为是一种特殊的类,定义接口使用 interface 关键字。
public interface 接口名{
抽象方法 1();
抽象方法 2();
抽象方法 2();
}
接口表示具有某些功能的事物,接口名使用名词,有人也习惯以 I 打头如 IWalkable.java。
接口定义代码:
public interface IWalkable {
void walk();
}
接口中的方法都是公共的抽象方法,等价于:
public interface IWalkable {
public abstract void walk();
}
类可以继承类,但是只能单继承的,接口也可以继承接口,但是却可以继承多个接口,也就是说一个
接口可以同时继承多个接口,如两栖动物可以行走也可以拥有。
可行走规范:
public interface IWalkable {
void walk();
}
可游泳规范:
public interface ISwimable {
void swim();
}
两栖动物规范,即可以游泳,又可以行走。
public interface IAmphibiable extends IWalkable,ISwimable{
}
此时子接口能继承所有父接口的方法。
2.2 接口实现类
2.2.1 接口实现类概念
和抽象类一样,接口是不能创建对象的,此时必须定义一个类去实现接口,并覆盖接口中的方法,这
个类称之为实现类,类和接口之间的关系称之为实现关系(implements)。
public class 类名 implements 接口名 1,接口名 2{
覆盖接口中抽象方法
}
在类实现接口后,覆盖接口中的抽象方法,完成功能代码,此时接口和实现类之间的关系:
接口:定义多个抽象方法,仅仅定义有哪些功能,却不提供实现。
实现类:实现接口,覆盖接口中抽象方法,完成功能具体的实现。
2.2.2 接口与实现类案例
1 多态(polymorphic)
1.1 什么是多态?
简单理解 : 看成一种事物多种形态
示例 :
今天晚上大家请我吃大餐 : 龙虾 喝粥 思想大餐…
我准备买一辆车: 独轮车 自行车 拖拉机 布加迪模型…
Java 程序中的体现:
多态概念:
将子类对象装到父类的变量中保存(向上造型/向上转型),当父类变量调用方法的时候,如果子类重写了该方法,会直接执行子类重写之后的方法。(父类变量可以装任意类型的子类对象)。
多态案例1:
父类:
public class Animal {
int age = 1;
public void eat() {
System.out.println("吃....");
}
}
子类:
public class Person extends Animal{
int age = 2;
@Override
public void eat() {
System.out.println("吃肉...");
}
public void coding() {
System.out.println("撸代码...");
}
}
public class Pig extends Animal{
int age = 3;
@Override
public void eat() {
System.out.println("吃白菜");
}
public void gongBaiCai() {
System.out.println("拱白菜");
}
}
测试代码:
public class AnimalTest {
public static void main(String[] args) {
Animal animal = new Person();//多态的方式(向上造型/向上转型)
Animal animal2 = new Pig();//多态的方式(向上造型/向上转型)
//调用方法
animal.eat();//吃肉... 执行子类重写后的方法
animal2.eat();//吃白菜 执行子类重写后的方法
System.out.println(animal.age);//1 成员变量没有多态
// animal.gongBaiCai();//多态不能调用子类独有方法
}
}
1.2 多态作用:
可以屏蔽子类差异性,提高代码的扩展性
1.3 多态使用:(重点)
- 向上造型/向上转型:
语法:
父类类型 父类变量 = new 子类类型();
父类变量.方法();//子类若重写,则会执行子类重写后的方法
例如:
Animal animal = new Person();//多态的方式(向上造型/向上转型)
Animal animal2 = new Pig();//多态的方式(向上造型/向上转型)
//调用方法
animal.eat();//吃肉... 执行子类重写后的方法
animal2.eat();//吃白菜 执行子类重写后的方法
- 向下造型/向下转型: =>就是为了调用子类特有方法
例如:(接上面案例)
现在需要调用子类Person中特有的方法或者调用子类Pig中特有的方法,不能调用怎么办?
这个时候就需要强制转换(向下造型/向下转型):
强制转换(向下造型/向下转型)语法:
数据类型 变量 = (数据类型)值/变量;
在向下造型前,必须进行类型判断,需要判断当前父类变量中装的是哪一个子类类型的对象
类型判断方式1:
if(父类变量 instanceof 子类类型1){
//强制类型转换
子类类型1 子类变量 = (子类类型1)父类变量;
//现在就可以调用子类特有方法
子类变量.子类特有方法(...);
}else if(父类变量 instanceof 子类类型2){
//强制类型转换
子类类型2 子类变量 = (子类类型2)父类变量;
//现在就可以调用子类特有方法
子类变量.子类特有方法(...);
}...
类型判断方式2:
if(父类变量.getClass() == 子类类型1.class){
//强制类型转换
子类类型1 子类变量 = (子类类型1)父类变量;
//现在就可以调用子类特有方法
子类变量.子类特有方法(...);
}else if(父类变量.getClass() == 子类类型2.class){
//强制类型转换
子类类型2 子类变量 = (子类类型2)父类变量;
//现在就可以调用子类特有方法
子类变量.子类特有方法(...);
}...
如果不进行类型判断再强转,就有可能发生ClassCastException类造型异常
测试类代码如下:
public class AnimalTest {
public static void main(String[] args) {
Animal animal = new Person();//多态的方式(向上造型/向上转型)
Animal animal2 = new Pig();//多态的方式(向上造型/向上转型)
animal = new Pig();//多态的方式(向上造型/向上转型)
//调用方法
animal.eat();
animal2.eat();
System.out.println(animal.age);//1 成员变量没有多态
//如果这里需要调用Pig类中特有方法,就需要将animal强转为Pig类型
//类型判断的方式1
if (animal instanceof Pig) {//判断animal中是不是装的Pig对象,如果是才强转
Pig pig = (Pig)animal;
//调用Pig特有方法
pig.gongBaiCai();
} else if (animal instanceof Person) {
//如果这里需要调用Person类中特有方法,就需要将animal强转为Person类型
Person person = (Person)animal;
//调用Person特有方法
person.coding();
}
//类型判断的方式2
if (animal.getClass() == Pig.class) {//判断animal中是不是装的Pig对象,如果是才强转
Pig pig = (Pig)animal;
//调用Pig特有方法
pig.gongBaiCai();
} else if (animal.getClass() == Person.class) {
//如果这里需要调用Person类中特有方法,就需要将animal强转为Person类型
Person person = (Person)animal;
//调用Person特有方法
person.coding();
}
}
}
多态案例2:
父类:
public class Vip {
/**
* 会员特权
*/
public void privilege() {
System.out.println("我有特权...");
}
}
子类:
public class Vip1 extends Vip{
/**
* 会员特权
*/
public void privilege() {
System.out.println("我是5000元俱乐部会员");
}
public void low() {
System.out.println("我很low");
}
}
public class Vip2 extends Vip{
/**
* 会员特权
*/
public void privilege() {
System.out.println("我是500000元俱乐部会员");
}
public void normal() {
System.out.println("我很一般");
}
}
public class Vip3 extends Vip{
/**
* 会员特权
*/
public void privilege() {
System.out.println("我是500000000000元俱乐部会员");
}
public void great() {
System.out.println("我很NB....");
}
}
测试类:
public class VipTest {
public static void main(String[] args) {
/*
* 模拟会员登陆的时候特权展示
*
*/
Vip vip = new Vip2();//屏蔽子类差异性
//调用特权
vip.privilege();//调用特权方法,如果子类重写了,会执行对应子类重写后的方法
//判断当前VIP中装的子类是哪一个,展示对应的特权
if (vip instanceof Vip1) {//类型判断
//强制转换
Vip1 vip1 = (Vip1)vip;
//调用特有方法
vip1.low();
}else if (vip instanceof Vip2) {//类型判断
//强制转换
Vip2 vip2 = (Vip2)vip;
//调用特有方法
vip2.normal();
}else if (vip instanceof Vip3) {//类型判断
//强制转换
Vip3 vip3 = (Vip3)vip;
//调用特有方法
vip3.great();
}
}
}
多态案例3:
父类:
public class Dog {
public void eat() {
System.out.println("吃...");
}
}
public class Hasky extends Dog {
@Override
public void eat() {
System.out.println("狗粮..");
}
}
public class Teddy extends Dog {
@Override
public void eat() {
System.out.println("吃天吃地吃空气");
}
}
public class Tudog extends Dog {
@Override
public void eat() {
System.out.println("啃骨头。。。");
}
}
public class Person {
/*public void feedDog(Hasky dog) {
dog.eat();
}
public void feedDog(Teddy dog) {
dog.eat();
}
public void feedDog(Tudog dog) {
dog.eat();
}
如果有几万种狗,就需要写几万个方法喂狗,不可取
*/
public void feedDog(Dog dog) {//屏蔽子类差异性。写一个父类类型,所有的子类对象都可以接收
dog.eat();
}
}
测试类:
public class DogTest {
public static void main(String[] args) {
//测试喂狗案例
Hasky hasky = new Hasky();
Tudog tudog = new Tudog();
Teddy teddy = new Teddy();
Person person = new Person();
person.feedDog(hasky);
person.feedDog(tudog);
person.feedDog(teddy);
}
}
原理分析:
1.4 多态注意事项:
- 成员变量没有多态
- 不能调用子类特有的方法,如果需要调用子类特有的方法,必须进行强制类型转换(向下造型/向 下转型),向下造型需要进行子类类型判断
- 父类变量能点(调用)出哪些成员(成员变量和方法),是由当前类和其父类决定,优先从当前类 开始查找,直到找到Object了为止,如果Object中有没有,就不能调用
- 多态调用方法的优先级顺序为:(难度大)
该优先级为:this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。
1.5 多态扩展(了解)
代码如下:
public class A {
public String show(D obj) {
return ("A and D");
}
public String show(A obj) {
return ("A and A");
}
}
public class B extends A {
public String show(B obj) {
return ("B and B");
}
public String show(A obj) {
return ("B and A");
}
}
public class C extends B {
}
public class D extends B {
}
测试类:
public class Test {
public static void main(String[] args) {
A a1 = new A();
A a2 = new B();
B b = new B();
C c = new C();
D d = new D();
a1.show(b);// "A and A"
a1.show(c);// "A and A"
a1.show(d);// "A and D"
a2.show(b);// B and A
a2.show(c);// B and A
a2.show(d);// "A and D
b.show(b);// "B and B"
b.show(c);// "B and B"
b.show(d);// "A and D"
}
}
代码分析:
5.5. 继承关系的构造方法执行流程:(了解)
类加载流程:
从最高父类构造方法开始执行,逐级向下执行,直到当前类的构造方法结束
如图:
5.课程总结
5.1重点
多态
5.2难点
多态、组合关系
6.作业
- 人类有开车方法:
drive(Car car){
调用车的run方法
}:
车类:有run()方法
子类:
货车Truck的run()方法 跑80km/小时,并且有运输货物方法
牛车BullCar的run()方法跑10km/小时,并且有吃草的方法
军车的run()方法跑150km/小时,并且有放炮方法
测试类中:
人类分别开不同的车,并且调用每一个车的特有方法 - 总结+预习