Java 进阶，学习笔记-5 多态
Java 进阶-5 多态
面向对象的三大特征：封装性、继承性、多态性
extends 继承或者 implements 的实现，是多态的前提
多态：一个对象同时拥有多种对象，就是多态
多态性的体现：父类引用指向子类对象
对于继承
父类名称 对象名 = new 子类名称();
对于接口
接口名称 对象名 = new 实现类名称();
一个简单的多态的例子
// 定义父类
public class Human {
public void method() {
System.out.println("父类的方法");
}
public void methodHuman() {
System.out.println("父类特有的方法！");
}
}
// 定义子类
public class Student extends Human{
@Override
public void method () {
System.out.println("子类的方法！");
}
}
// 定义测试类
public class Test {
public static void main(String[] args) {
// 多态的写法创建对象
Human student = new Student();
student.method();
student.methodHuman();
}
}
输出：
子类的方法！
父类特有的方法！
多态中成员变量的访问特点
在之前，访问成员变量的两种方式：
1、直接通过对象进行访问，等号左边是谁，那么用的成员变量就是优先用谁的
2、间接通过成员方法访问，该方法属于谁，就优先用谁
在这里，规则还是如此
// 定义父类
public class Human {
String name = "charon";
}
// 定义子类
public class Student extends Human{
String name = "pluto";
}
// 定义测试类
public class Test {
public static void main(String[] args) {
Human student = new Student();
System.out.println(student.name);
}
}
输出：
charon
多态中成员方法的访问特点
之前学习中，了解到
1、new 的是谁，就优先用谁的方法，没有则往上找
成员变量：编译看左边，运行看左边
成员方法：编译看左边，运行看右边
// 定义父类
public class Human {
// 父类方法
public void method() {
System.out.println("父类特有方法！");
}
// 父类特有方法
public void methodHuman() {
System.out.println("父类特有的方法！");
}
}
// 定义子类
public class Student extends Human{
@Override
public void method() {
System.out.println("子类方法！");
}
// 子类特有方法
public void methodStudent() {
System.out.println("子类特有方法！");
}
}
public class Test {
public static void main(String[] args) {
Human student = new Student();
student.method();
student.methodHuman();
// 调用子类特有的方法
// student.methodStudent(); // 错误，不能调用子类特有的方法
}
}
输出：
子类方法！
父类特有的方法！
多态的使中，对象不能直接调用子类拥有的方法
对象的向上转型
向上转型其实就是多态的创建过程，即右侧创建一个子类对象，把它当做父类来看待，是一定安全的。小范围转向了大范围。
对象的向下转型
多态的弊端，就是通过多态创建的对象不能访问子类的特有内容，所以这里我们就可以向下转型，进行还原。
子类名称 对象名 = (子类名称)父类对象;
向下转型不能随意向下转型，只能转型为创建时 new 的对象
即：
Animal animal = new Cat();
Cat cat = (cat)animal; // 正确
Dog dog = (Dog)animal; // 错误
举例：
// 定义父类
public class Human {
// 父类方法
public void method() {
System.out.println("父类特有方法！");
}
// 父类特有方法
public void methodHuman() {
System.out.println("父类特有的方法！");
}
}
// 定义子类
public class Student extends Human{
@Override
public void method() {
System.out.println("子类方法！");
}
// 子类特有方法
public void methodStudent() {
System.out.println("子类特有方法！");
}
}
public class Test {
public static void main(String[] args) {
Human student = new Student();
student.method();
student.methodHuman();
// 调用子类特有的方法
// student.methodStudent(); // 错误，不能调用子类特有的方法
Student student1 = (Student)student;
student1.methodStudent();
}
}
输出：
子类方法！
父类特有的方法！
子类特有方法！
如何查看一个父类的引用对象，本来是什么类
可以用关键字 instanceof 来查看这个对象是否属于这个类
boolean bool = 对象 instance 类名称
案例：
定义 USB 接口、电脑类，鼠标类和键盘类，并描述使用关系
USB.java
// 定义 USB 接口类
public interface USB {
// 设备开启
public abstract void open();
// 设备关闭
public abstract void close();
}
Laptop.java
// 定义笔记本类
public class Laptop {
public void powerOn() {
System.out.println("开机");
}
public void powerOff() {
System.out.println("关机");
}
public void useDevice(USB usb) {
usb.open();
// 使用各类中的特有方法
if (usb instanceof Mouse) {
Mouse mouse = (Mouse)usb;
mouse.click();
}else if (usb instanceof Keyboard) {
Keyboard keyboard = (Keyboard)usb;
keyboard.type();
}
usb.close();
}
}
Mouse.java
// 定义鼠标类
public class Mouse implements USB {
@Override
public void open() {
System.out.println("开启鼠标");
}
@Override
public void close () {
System.out.println("关闭鼠标");
}
public void click() {
System.out.println("点击鼠标");
}
}
Keyboard.java
// 定义键盘类
public class Keyboard implements USB {
@Override
public void open() {
System.out.println("开启键盘");
}
@Override
public void close () {
System.out.println("关闭键盘");
}
public void type() {
System.out.println("敲击键盘");
}
}
Test.java
public class Test {
public static void main(String[] args) {
// 创建一个笔记本对象
Laptop laptop = new Laptop();
// 开启笔记本
laptop.powerOn();
// 多态创建一个鼠标
USB usbMouse = new Mouse();
// 笔记本使用鼠标
laptop.useDevice(usbMouse);
// 多态创建一个键盘
USB usbKeyboard = new Keyboard();
laptop.useDevice(usbKeyboard);
// 笔记本关机
laptop.powerOff();
}
}
输出：
开机
开启鼠标
点击鼠标
关闭鼠标
开启键盘
敲击键盘
关闭键盘
关机
本文章是 Java 学习过程中整理的学习笔记，如有错误，请留言