上一篇是分享的是《Spring Security》，这篇给大家分享《JAVA 面向对象之多态》。
接下来开始进行分享：
多态
1. 概念
多态是面向对象程序设计（OOP）的一个重要特色，指同一个实体同时具备多种形式，即同一个对象，在不同时刻，代表的对象不一样，指的是对象的多种状态。
能够把不同的子类对象都当作父类来看，进而屏蔽不同子类对象之间的差别，写出通用的代码，做出通用的编程，对立调用规范。
比方，你的女朋友让你买点水果回来，不论买回来的是苹果还是西瓜，只有是水果就行，这个就是生存中多态的体现
再比方，小猫、小狗、小猪咱们能够把他们都演绎成小动物，然而每种小动物爱吃的货色不一样，具体的小动物有具体的食物，如下代码所示：
class Animal{//1. 定义父类 Animal
....eat(){syso("吃啥都行")}
}
class Cat extends Animal{//2.1 定义子类 Cat
....eat(){syso("吃小鱼干")}
}
class Dog extends Animal{//2.2 定义子类 Dog
....eat(){syso("吃肉骨头")}
}
class Pig extends Animal{//2.3 定义子类 Pig
....eat(){syso("吃菜叶子")}
}
main(){
//3. 创立子类对象
Cat c = new Cat();// 小猫是小猫
Dog d = new Dog();// 小狗是小狗
Pig p = new Pig();// 小猪是小猪
//4. 创立多态对象(父类援用指向子类对象 / 编译看右边, 运行看左边)
Animal a1 = new Cat();// 小猫是小动物
Animal a2 = new Dog();// 小狗是小动物
Animal a3 = new Pig();// 小猪是小动物}
2 . 特点
多态的前提 1：是继承
多态的前提 2：要有办法的重写
父类援用指向子类对象, 如：Animal a = new Cat();
多态中，编译看右边，运行看左边
3. 练习：多态入门案例
创立包: cn.tedu.oop
创立类: TestDemo.java
package cn.tedu.oop;
/** 本类用于测试多态 */
public class TestDemo{public static void main(String[] args) {
//5. 创立父类对象进行测试 \
Animal a = new Animal();
a.eat();// 小动物 Animal 吃啥都行~~~
//a.jump();// 父类无奈应用子类的特有办法
//6. 创立子类对象进行测试
Cat c = new Cat();
c.eat();// 小猫 Cat 爱吃小鱼干!!!-- 调用的是重写当前的性能
c.jump();
//8. 创立多态对象进行测试
/** 口诀 1: 父类援用 指向子类对象 */
/** 口诀 2: 编译 (保留) 看右边, 运行 (测试) 看左边 */
Animal a2 = new Cat();
Animal a3 = new Dog();
a2.eat();//eat()应用的是父类的申明, 但应用的是子类的实现形式
a3.eat();
/** 多态的呈现是为了对立调用规范, 向父类看齐
* 父类提供的性能能力用, 子类特有的性能用不了 */
}
}
//1. 创立父类
class Animal{//3. 创立父类中的一般办法 eat()
public void eat() {System.out.println("小动物 Animal 吃啥都行~~~");
}
}
//2. 创立子类
class Cat extends Animal{
//4. 重写父类中的办法 -- 对父类中的代码性能批改
// 重写: 办法签名保持一致(返回值类型 办法名(参数列表) )
// & 权限修饰符 >= 父类权限修饰符
public void eat() {System.out.println("小猫 Cat 爱吃小鱼干!!!");
}
//7. 定义了子类特有的办法
public void jump() {System.out.println("小猫 Cat 跳的老高啦");
}
}
class Dog extends Animal{public void eat() {System.out.println("小狗爱吃肉骨头!!!");
}
}4. 多态的益处
多态能够让咱们不必关怀某个对象到底具体是什么类型, 就能够应用该对象的某些办法
进步了程序的可扩展性和可维护性
5. 多态的应用
成员变量: 应用的是父类的
成员办法: 因为存在重写景象, 所以应用的是子类的
动态成员: 随着类的加载而加载, 谁调用就返回谁的
6. 练习：多态成员应用测试
创立包: cn.tedu.oop
创立类: TestDemo2.java
package cn.tedu.oopstatic;
/** 本类用于多态中的元素测试 */
public class TestDemo2 {public static void main(String[] args) {
//7. 创立子类对象进行测试
Dog2 d = new Dog2();
System.out.println(d.sum);//20
d.eat();// 小狗要吃肉骨头
d.play();// 小狗爱打滚儿~~~
//10. 创立多态对象进行测试
/** 口诀 1: 父类援用指向子类对象 */
/** 口诀 2: 编译 (保留) 看右边, 运行 (测试) 看左边 */
Animal2 a = new Dog2();
/**2. 多态中, 成员变量应用的都是父类的 */
System.out.println(a.sum);//10
/**3. 多态中, 成员办法应用的是父类的申明, 子类的实现 */
a.eat();
/**4. 多态中, 如果父子类都有静态方法, 应用的是父类的 */
a.play();// 玩啥都行}
}
//1. 创立父类
class Animal2{
//2. 创立成员变量
int sum = 10;
//3. 创立成员办法
public void eat() {System.out.println("吃啥都行");
}
//8. 父类中定义静态方法 play()
public static void play() {System.out.println("玩啥都行");
}
}
/**1. 多态的前提: 继承 + 重写 */
//4. 定义子类 Dog2
class Dog2 extends Animal2{
//5. 定义子类的成员变量
int sum = 20;
//6. 重写父类的 eat()
/**@Override 这个注解加在办法上, 示意这是一个重写的办法 */
@Override // 注解 -- 标签
public void eat() {System.out.println("小狗要吃肉骨头");
}
//9. 定义子类的静态方法 play()
//@Override -- 不是重写, 不能加这个注解
public static void play() {System.out.println("小狗爱打滚儿~~~");
}
}
/** 留神!!! 动态资源属于类, 不存在重写景象, 只是两个类中有同样申明的办法而已, 不属于重写 */
7 拓展
7.1 设计汽车综合案例
创立包: cn.tedu.oopexec
创立类: DesignCar.java
package cn.tedu.oopexec;
/** 本类用于实现 OOP 汽车设计综合案例 */
/**
* 1. 剖析事物, 得出它的属性和性能
* 2. 提取类中的共同点, 向上抽取, 造成父类 Car
* 3. 子类继承父类后, 就领有的父类的性能
* 4. 如果对父类的性能不称心, 能够重写
* 5. 能够封装某些类的属性, 如果封装了, 就要提供对应的 get()/set()
*/
public class DesignCar {
//3. 创立入口函数 main
public static void main(String[] args) {
//4. 创立父类对象进行测试
Car c = new Car();
System.out.println(c.getColor());// 通过 get 办法查看封装后的 color 值
c.start();
c.stop();
//5. 创立宝马类对象进行测试
BMW b = new BMW();
System.out.println(b.color);
System.out.println("*********");
b.start();
b.stop();
//6. 创立保时捷类对象进行测试
BSJ j = new BSJ();
System.out.println(j.color);
j.start();
j.stop();}
}
//0. 创立一个汽车类
class Car{
//0.1 定义 Car 类的属性
//0.3 通过 private 对 Car 类的属性进行封装
private String brand;// 品牌
private String color;// 色彩
//0.4 属性封装后, 对外提供公共的 get()与 set()便于外界对属性进行操作
// 右键 -->Source-->Generate Getters and Setters -->Select All -->Generate
public String getBrand() {return brand;}
public void setBrand(String brand) {this.brand = brand;}
public String getColor() {return color;}
public void setColor(String color) {this.color = color;}
//0.2 定义 Car 类的启动与进行办法
public void start() {System.out.println("我的车车启动啦~~~");
}
public void stop() {System.out.println("哎呀呀, 我的车车熄火了~");
}
}
//1. 创立一个宝马类并且继承 Car 类
class BMW extends Car{
String color = "五彩斑斓的黑";
@Override
public void start() {super.start();
System.out.println("宝马启动加速度~~~UPUP");
}
}
//2. 创立一个保时捷并且继承 Car 类
class BSJ extends Car{
String color = "黑不溜秋的白";
@Override
public void stop() {System.out.println("保时捷想停得稳当些~");
}
}7.2 动态变量和实例变量的区别
在语法定义上的区别：动态变量前要加 static 关键字，而实例变量前则不加。
在程序运行时的区别：实例变量属于某个对象的属性，必须创立了实例对象，其中的实例变量才会被调配空间，能力应用这个实例变量。动态变量不属于某个实例对象，而是属于类，所以也称为类变量，只有程序加载了类的字节码，不必创立任何实例对象，动态变量就会被调配空间，动态变量就能够被应用了。总之，实例变量必须创建对象后才能够通过这个对象来应用，动态变量则能够间接应用类名来援用。
7.3 向上转型和向下转型
在 JAVA 中，继承是一个重要的特色，通过 extends 关键字，子类能够复用父类的性能，如果父类不能满足以后子类的需要，则子类能够重写父类中的办法来加以扩大。
在利用中就存在着两种转型形式，别离是：向上转型和向下转型。
比方：父类 Parent, 子类 Child
向上转型：父类的援用指向子类对象 Parent p=new Child();
阐明：向上转型时，子类对象当成父类对象，只能调用父类的性能，如果子类重写了父类的办法就依据这个援用指向调用子类重写办法。
向下转型(较少)：子类的援用的指向子类对象，过程中必须要采取到强制转型。
Parent p = new Child();// 向上转型，此时，p 是 Parent 类型
Child c = (Child)p;// 此时，把 Parent 类型的 p 转成小类型 Child
// 其实，相当于创立了一个子类对象一样，能够用父类的，也能够用本人的
阐明：向下转型时，是为了方便使用子类的非凡办法，也就是说当子类办法做了性能拓展，就能够间接应用子类性能。
- 以上就是《JAVA 面向对象之多态》的分享。
- 也欢送大家交换探讨，该文章若有不正确的中央，心愿大家多多包涵。
- 你们的反对就是我最大的能源，如果对大家有帮忙给个赞哦~~~