上一篇是分享的是《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.定义子类Dog2class 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 面向对象之多态》的分享。
- 也欢送大家交换探讨，该文章若有不正确的中央，心愿大家多多包涵。
- 你们的反对就是我最大的能源，如果对大家有帮忙给个赞哦~~~