上一篇是分享的是《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 面向对象之多态》的分享。
也欢迎大家交流探讨，该文章若有不正确的地方，希望大家多多包涵。
你们的支持就是我最大的动力，如果对大家有帮忙给个赞哦~~~