Java 11深入解析：多态原理与实战应用-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_48755260/article/details/120968297

Java11--多态

1 多态
2 拓展

1 多态

1.1 概念

多态指同一个实体同时具有多种形式。它是面向对象程序设计（OOP）的一个重要特征。

主要是指同一个对象，在不同时刻，代表的对象不一样，指的是对象的多种形态。

好处是可以把不同的子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，统一调用标准。

例如：水，在不同时刻可以有多种形态，包括水蒸气，冰，水。

Java怎么体现多态呢？狗有两种形态：狗和小动物

class Animal

class Dog extends Animal

Dog d = new Dog();//狗是狗

Animal  a=new Dog();//狗是小动物，创建了狗的对象，赋值给动物对象，这就是多态

1.2 特点

1、多态的前提是继承

2、要有方法的重写

3、父类引用指向子类对象,如：Animal a = new Dog(); – 小到大，向上转型

4、多态中，编译看左边，运行看右边

1.3 入门案例

package cc;
public class p {
       public static void main(String[] args) {
              /*Animal  a = new Animal();
              a.eat();             
              Dog d = new Dog();
              d.kanjia();
              d.eat();*/
             
//父类引用指向子类对象--把右面的小的，给了左面大的。相当于从小到大的过程，向上造型。

              Animal an = new Dog();

              an.eat();//只可以用父类的功能，这就统一了调用的标准

              //狗吃肉,由于eat()发生了重写，所以父类方法被覆盖掉了

       }
}
class Animal{
       public void eat(){
              System.out.println("大小通吃");
       }
}
class Dog extends Animal{
       public void kanjia(){
              System.out.println("狗可以看家");
       }      
       public void eat(){
              System.out.println("狗吃肉");
       }
}

1.4 多态的好处

1、多态可以让我们不用关心某个对象到底是什么具体类型，就可以使用该对象的某些方法。

2、提高了程序的扩展性和可维护性

public class Q {
       public static void main(String[] args) {
              //多态--父类引用指向子类对象
              Dog a2=new Dog();
              Cat a2 = new Cat();
              Animal2 a2 = new Dog();
              eat(a2);//传入的参数满足条件就可以，运行右面的功能
       }      
//封装共性方法，不关心具体类型，只要传入的参数是子类就可以
       public static void eat(Animal2 a){
              a.eat();
       }
}

1.5 多态的使用

1.5.1 特点

1、成员变量：使用的是父类的

2、成员方法：由于存在重写现象所以使用的是子类的

3、静态成员：随着对象而存在，谁调用的就返回谁的

1.5.2 测试

package cc;

public class K {

       public static void main(String[] args) {

              Fu2 f = new Zi2();//多态，只能用父类的。。。

              //多态的成员变量，就是父类的

              System.out.println(f.num);//10
         
              //成员方法，因为存在重写，所以是子类的

              f.study();//Zi..study()
           
              //静态成员,谁调用就是谁的

              System.out.println(f.count);//10

              f.sleep();//Fu..sleep()

       }

}
class Fu2{

       int num=10;

       static int count=10;

       public void study(){

              System.out.println("Fu..study()");

       }     

       public static void sleep(){

              System.out.println("Fu..sleep()");
       }
}

class Zi2 extends Fu2{

       int num=20;

       static int count=20;

       public void study(){
              System.out.println("Zi..study()");
       }
       public static void sleep(){

              System.out.println("Zi..sleep()");
       }
}

2 拓展

2.1 静态代码块，构造代码块，局部代码块

！！！执行顺序：静态代码块—构造代码块—构造函数

7、静态代码块：在类加载时就加载，并且只被加载一次，一般用于项目的初始化

8、构造代码块：在创建对象时会自动调用，每次创建对象都会被调用

9、局部代码块：方法里的代码块

package cc;
public class haha {
       public static void main(String[] args) {

              //必须创建对象，不然静态代码块咋随着类的加载而加载。。

              Block m =  new Block();//静态1  静态2  构造1  构造2  局部1

              System.out.println();

              Block m2 =  new Block();//构造1  构造2  局部1,说明静态代码只被执行一次就是在类第一次初始化时

       }
}
class Block{
       {

              System.out.println("构造1");

       }

       static{

              System.out.println("静态1");

       }

       public Block(){

              {

                     System.out.println("局部1");

              }

       }
       {
              System.out.println("构造2");
       }

       static{
              System.out.println("静态2");
       }
}

2.2 静态变量和实例变量的区别

在语法定义上的区别：静态变量前要加static关键字，而实例变量前则不加。

在程序运行时的区别：实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量。静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。总之，实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。