多态思想
接口
接口概述
我们要完成一个工程,需要一个插座
思考1:去市场买个回来!=> 市场上有公牛、小米... => 小米和公牛认识吗?
什么原因导致公牛和小米的插座我都可以用?
接口是一种约定的规范,是多个抽象方法的集合。仅仅只是定义了应该有哪些功能,本身不实现功 能,至于每个功能具体怎么实现,就交给实现类完成。
接口中的方法是抽象方法,并不提供功能实现,体现了规范和实现相分离的思想,也体现了组件之 间低耦合的思想。
所谓耦合度,表示组件之间的依赖关系。依赖关系越多,耦合性越强,同时表明组件的独立性越 差,在开发中往往提倡降低耦合性,可提高其组件独立性,举一个低耦合的例子。
电脑的显卡分为集成显卡和独立显卡:
集成显卡:显卡和主板焊死在一起,显卡坏了,只能换主板
独立显卡:显卡和主板相分离,显卡插到主板上即可,显卡坏了,只换显卡,不用换主板
接口也体现的是这种低耦合思想,接口仅仅提供方法的定义,却不提供方法的代码实现。那么得专 门提供类并去实现接口,再覆盖接口中的方法,最后实现方法的功能,在多态案例中再说明。
接口定义和多继承性
接口可以认为是一种特殊的类,但是定义类的时候使用class关键字,定义接口使用interface关键字。
public interface 接口名{
//抽象方法1();
//抽象方法2();
//抽象方法2();
}
接口表示具有某些功能的事物,接口名使用名词,有人也习惯以I开头。 接口定义代码:
public interface IWalkable {
void walk();
}
接口中的方法都是公共的抽象方法,等价于:
public interface IWalkable {
public abstract void walk();
}
从Java8开始, Java支持在接口中定义有实现的方法, 如:
public interface IWalkable {
public abstract void walk();//抽象方法
default void defaultMethod(){
System.out.println("有默认实现的方法, 属于对象");
}
static void defaultMethod(){
System.out.println("有默认实现的方法, 属于类");
}
}
在java中,接口也可以继承,一个接口可以继承多个接口,也就是说一个接口可以同时继承多个接口, 如两栖动物可以行走也可以拥有。
可行走规范:
public interface IWalkable {
void walk();
}
可游泳规范:
public interface ISwimable {
void swim();
}
两栖动物规范,即可以游泳,又可以行走:
public interface IAmphibiable extends IWalkable,ISwimable{
}
此时子接口能继承所有父接口的方法。
接口实现类
(1)因为接口中的方法时抽象的,没有方法体,所以接口是不能创建对象的,此时必须定义一个类去实现接口,并覆盖接口中的方法,这个类称之为实现类,实现类和接口之间的关系称之为实现关系(implements)。
public class 类名 implements 接口名{
//覆盖接口中抽象方法
}
实现类实现接口后,必须实现接口中的所有抽象方法,完成功能代码,此时接口和实现类之间的关系:
接口:定义多个抽象方法,仅仅定义有哪些功能,却不提供实现。
实现类:实现接口,实现接口中抽象方法,完成功能具体的实现。
如果实现类没有全部实现接口中的方法,要么报错,要么把实现类设置为抽象类(下图)。
定义一个猫类(Cat)实现IWalkable接口,并创建对象调用方法。
public class Cat implements IWalkable{
public void walk() {
System.out.println("走猫步...");
}
}
根据方法覆盖原则:子类方法的访问修饰符必须大于等于父类方法的访问修饰符,接口中的方法都是public修饰的,所以实现类中的方法只能使用public修饰。
定义一个人类,实现ISwimable,IWalkable接口
public class Person implements ISwimable, IWalkable {
@Override
public void walk() {
System.out.println("人类步行...");
}
@Override
public void swim() {
System.out.println("人类游泳...");
}
}
实现类实现了接口,一定具备接口中定义的能力。
(2)实现类可以继承父类,但可以同时实现一个或多个接口,继承在前,实现在后。
定义一个青蛙类(Frog)继承于动物类(Animal),同时实现于会走路(IWalkable),会游泳(ISwimable)的接口,语法如下:
public class Frog extends Animal implements ISwimable,IWalkable{
public void walk() {
System.out.println("跳啊跳...");
}
public void swim() {
System.out.println("游啊游..");
}
}
(3)接口是一种引用数据类型,可以用来声明变量,并接收(引用)所有该接口的实现类对象。如果要创 建实现类对象,语法如下:
接口 变量 = new 实现类();
测试类:
public static void main(String[] args) {
/**
* 学生找房子,由于条件不足,所以委托中介帮忙找房子,但又不想强依赖于中介
*/
// 使用接口声明变量的意义在于?
IRentable rentable = null;
// 使用rentable可以引用其实现类
rentable = new Agent("链家");
/**
* rentable 引用实现类更在乎实现类啊,你具不具备我接口约定的能力,而不关心你到底是谁
*/
Student student = new Student("二狗");
// student.setRentable(rentable);
rentable = new Teacher(); student.setRentable(rentable);
student.findHouse();
}
接口总结
(1)接口表示一种规约(规范、标准),它里面定义了一些列抽象方法(功能),它可以被多个类实现。
(2)实现类实现接口,必须实现接口中的所有抽象方法。我们经常说:接口约定了实现类应该具备的能力。
(3)面向接口编程。
多态
多态概念
多态是面向对象三大特征之一:封装、继承、多态。
在继承关系,是一种 is A 的关系,也即什么是什么 ,也就说子类是父类的一种特殊情况,有如下代码:
public class Animal{}
public class Dog extends Animal{} // Dog is a Animal
public class Cat extends Animal{} // Cat is a Animal
那么我们可以认为狗和猫都是一种特殊的动物,那么可以使用动物类型来表示狗或猫。
Dog d = new Dog(); //创建一只狗对象,赋给子类类型变量
Animal a = ne Cat() //创建一只猫对象,赋给父类类型变量
此时对象(a)具有两种类型:
编译时类型:声明对象变量的类型——>Animal
运行时类型:对象的真实类型 ——>Dog
当编译类型和运行类型不一致的时候,此时多态就产生了。
注意:编译类型必须是运行类型的父类或接口。
所谓多态,表示一个对象具有多种形态。
说的具体点就是同一引用类型变量调用同一方法时,由于引用实例不同,方法产生的结果不同。
Animal a = null;
a = new Dog(); //a此时表示Dog类型的形态
a = new Cat(); //a此时表示Cat类型的形态
多态的前提,可以是继承关系(类和类),也可以是实现关系(接口和实现类),在开发中,一般都指 接口和实现类之间的关系。
一言以蔽之:父类引用变量指向于子类对象,调用方法时实际调用的是子类的方法。
我家有一种动物,你猜它的叫声是怎么样的,猜不到,因为这个动物有多种形态。
如果该动物是狗,叫声是:旺旺旺...
如果该动物是猫,叫声是:妙妙妙...
多态操作有两种定义格式和操作语法:
操作继承关系:
父类 变量名 = new 子类();
变量名.方法();
操作实现关系:
接口 变量名 = new 实现类();
变量名.方法();
操作继承关系
父类 变量名 = new 实现类();
变量名.方法();
Animal类:
public class Animal {
public void shut() {
System.out.println("Animal...shout...");
}
}
Cat类:
public class Cat extends Animal{
public void shut() {
System.out.println("妙妙妙...");
}
}
Dog类:
public class Dog extends Animal{
public void shut() {
System.out.println("旺旺旺...");
}
}
测试类:
public class AnimalDemo {
public static void main(String[] args) {
// 创建Cat对象
Animal a = new Cat(); a.shout();
// 创建Dog对象
a = new Dog();
a.shout();
}
}
控制台输出:
妙妙妙...
旺旺旺...
父类引用变量指向于子类对象,调用方法时实际调用的是子类的方法。
操作实现关系
接口 变量名 = new 实现类();
变量名.方法();
ISwimable 接口:
public interface ISwimable {
void swim();
}
Fish类:
public class Fish implements ISwimable{
public void swim() {
System.out.println("游啊游...");
}
}
测试类:
public class FishDemo {
public static void main(String[] args) {
// 创建Fish对象
ISwimable fish = new Fish();
fish = new Dog();//Dog也是实现了ISwimable接口的
Fish f = new Fish();
fish.swim();
}
}
控制台输出:
游啊游...
接口引用变量指向实现类对象,调用方法时实际调用的是实现类实现接口的方法。
多态时方法调用问题
把子类对象赋给父类变量,此时调用方法:
Animal a = new Cat();
a.shut();
那么a对象调用的shut方法,是来自于Animal中还是Cat中?
判断规则如下:
先判断shout方法是否在父类Animal类中:
找不到:编译报错
找 到:再看shout方法是否在子类Cat类中
找不到:运行父类方法
找 到:运行子类方法(这个才是真正的多态方法调用)
多态小结
// Dog d = new Dog();
// Cat c = new Cat();
Animal a = new Cat();
a.xxx();
a.ooo();
IEmployeeService service = new EmployeeServiceImpl2();
service.save();
service.delete();
所谓多态,就是一个对象的多种形态,这个对象一般都比较抽象,当通过同一引用类型,由于引用的实例不同,对同一行为产生的结果不同。
多态中的类型转换
类型转换
自动类型转换:把子类对象赋给父类变量(多态)
Animal a = new Dog();
Object obj = new Dog(); //Object是所有类的根类
强制类型转换:把父类类型对象赋给子类类型变量。
子类类型 变量 = (子类类型)父类对象;
Animal a = new Dog();
Dog d = (Dog) a;//正确
Cat c = (Cat) a;//错误
instanceOf
instanceof 运算符:判断该对象是否是某一个类/接口的实例。
语法格式:
boolean b = 对象A instanceof 类B; //判断 A对象是否是 B类的实例?如果是,返回true
代码如下:
Animal a = new Dog();
System.out.println(a instanceof Animal); //true
System.out.println(a instanceof Dog); //true
System.out.println(a instanceof Cat); //false
USB案例
模拟在主板上安装鼠标、键盘等,比较没有规范和有规范的区别。
没有统一规范:
鼠标类:
public class Mouse {
//鼠标工作的方法
public void work1() {
System.out.println("鼠标在移动");
}
}
键盘类:
public class Keyboard {
//键盘工作的方法
public void work2() {
System.out.println("鼠标在移动");
}
}
主板类:
public class MotherBoard {
//在主板上安装鼠标对象
public void plugin(Mouse m) {
m.work1(); //调用鼠标工作的方法
}
//在主板上安装键盘对象
public void plugin(Keyboard k) {
k.work2(); //调用键盘工作的方法
}
}
上述代码是没有统一规范的,我们能发现其中的问题:
不同设备中工作的方法名称是不一致的
每次需要安装新设备,都需要在主板类上新增一个方法
有统一规范:
USB规范接口:
//定义一种规范,用来约束所有的USB设备应该具有的功能
public interface IUSB {
//USB设备工作的方法
void swapData();
}
在Mouse和Keyboard类遵循于USB规范——工作的方法名称也就相同了。
public class Mouse implements IUSB{
public void swapData() {
System.out.println("鼠标在移动");
}
}
public class Keyboard implements IUSB{
public void swapData() {
System.out.println("用键盘打字");
}
}
主板类,在安装方法plugin上也体现出了多态的特征:
public class MotherBoard {
//IUSB类型可以接受实现类对象
public void plugin(IUSB usb) {
usb.swapData();
}
}
面向接口编程,体现的就是多态,其好处:把实现类对象赋给接口类型变量,屏蔽了不同实现类之间的实现差异,从而可以做到通用编程。
测试类:
public class USBDemo {
public static void main(String[] args) {
// 创建主板对象
MotherBoard board = new MotherBoard();
// 创建鼠标对象
Mouse m = new Mouse();
// 创建键盘对象
Keyboard k = new Keyboard();
//在主板上安装鼠标
board.plugin(m);
//在主板上安装键盘
board.plugin(k);
}
}
以上就是Java入门第九天的全部内容了。
资料文档地址:Java开发零基础篇:day09面向对象(三).pdf