浅谈Java多态

浅谈Java多态

多态

多态是同一个行为具有多个不同表现形式或形态的能力。

多态就是同一个接口，使用不同的实例而执行不同操作。

那么怎么理解这句话呢？

我们假设有基类Animal，两个Animal的派生类Cat和Dog。

我现在有块广告牌，想要输入什么动物就放什么动物的照片？如果没有多态，我是不是需要不断地进行判断？

那么有了多态，我们可以如下实现：

// 创建Animal类
class Animal{
	protected String name;	// 可被子类访问的name
	public Animal() {
		this.name = "Animal";
	}
	// 封装
	public String getName() {
		return this.name;
	}
}

class Cat extends Animal{
	Cat(){
		name = "Cat";
	}
}

class Dog extends Animal{
	Dog(){
		name = "Dog";
	}
}

public class Test {
	static public void board(Animal s) {		
		System.out.println(s.getName());
	}
	
	public static void main(String[] args) {
		Animal animal = new Animal();	//创建Animal对象
		Animal cat = new Cat();			//创建Cat对象
		Animal dog = new Dog();			//创建Dog对象
		// 三块广告牌
		board(animal);
		board(cat);
		board(dog);
		
	}
}

// output
// Animal
// Cat
// Dog

从这个代码和结果，我们就已经可以看出，多态有什么用了！那么，要怎么实现多态呢！

多态存在的三个必要条件

• 继承
• 重写
• 基类引用指向派生类对象（引用还是指向基类）

比如

Parent p = new Child();

​ 当使用多态方式调用方法时，首先检查基类中是否有该方法，如果没有，则编译错误；如果有，再去调用派生类的同名方法。

重载(Overload)与重写(Override)

多态中重写的基本规则

1. 参数必须要一样，且返回类型必须兼容

   重写是派生类对基类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！

   基类定义出其他的程序代码要如何使用方法。不管基类使用了哪种参数，覆盖此方法的派生类也一定要使用相同的参数。同样，不论基类声明的返回类型是什么，派生类必须要声明返回一样的类型或该类型的派生类。要记得，派生类对象必须保证可以执行基类的一切。

2. 不能降低方法存取的极限

   简而言之，方法和变量的存取权必须相同或者更为开放。

   例如不能把public的方法降低为private。

3. 基类的成员方法只能被它的派生类重写。

4. 声明为 final 的方法不能被重写。

5. 声明为 static 的方法不能被重写，但是能够被再次声明。

6. 构造方法不能被重写。

7. 如果不能继承一个方法，那么它一定不能被重写

8. 当需要在派生类中调用基类的被重写方法时，要使用 super 关键字。

   class Animal{
      public void move(){
         System.out.println("动物可以移动");
      }
   }
    
   class Dog extends Animal{
      public void move(){
         super.move(); // 应用super类的方法
         System.out.println("狗可以跑和走");
      }
   }
    
   public class TestDog{
      public static void main(String args[]){
    
         Animal b = new Dog(); // Dog 对象
         b.move(); //执行 Dog类的方法
    
      }
   }
   
   
   //编译结果如下
   >>>动物可以移动
   >>>狗可以跑和走
   

重载

重载的意义时同一个类里，两个方法的名称相同，但参数不同。

所以，重载和多态没有半毛钱关系！

重载可以有同一方法的多个不同参数版本以便调用。比如某个方法需要int，调用方就需要把double转成int然后才能调用。如果有个重载版的方法取用double参数，这样调用就简单多了。

因为重载方法不需要满足定义在基类的多态合约，所以扩展起来比较方便。

重载最常用的地方就是构造器的重载。

原则

1. 返回类型可以不同

   可以任意改变重载方法的返回类型，只要所有的覆盖使用不同参数即可。

2. 不能只改变返回类型

   如果只有返回类型改变但参数一样，编译器不会通过编译。也就是说，被重载的方法必须改变参数列表(参数个数或类型不一样)；

   结合前两条，无法以返回值类型作为重载函数的区分标准。

3. 可以更改存储权限

   可以任意地设定重载方法的存储权限。

4. 方法能够在同一个类中或者在一个派生类中被重载。

public class Overloading {
    public int test(){
        System.out.println("test1");
        return 1;
    }
 
    public void test(int a){
        System.out.println("test2");
    }   
 
    //以下两个参数类型顺序不同
    public String test(int a,String s){
        System.out.println("test3");
        return "returntest3";
    }   
 
    public String test(String s,int a){
        System.out.println("test4");
        return "returntest4";
    }   
 
    public static void main(String[] args){
        Overloading o = new Overloading();
        System.out.println(o.test());
        o.test(1);
        System.out.println(o.test(1,"test3"));
        System.out.println(o.test("test4",1));
    }
}

重写与重载之间的区别

区别点	重载方法	重写方法
参数列表	必须修改	一定不能修改
返回类型	可以修改	一定不能修改
异常	可以修改	可以减少或删除，一定不能抛出新的或者更广的异常
访问	可以修改	一定不能做更严格的限制（可以降低限制）

总结

方法的重写(Overriding)和重载(Overloading)是java多态性的不同表现，重写是基类与派生类之间多态性的一种表现，重载可以理解成多态的具体表现形式。

• (1)方法重载是一个类中定义了多个方法名相同,而他们的参数的数量不同或数量相同而类型和次序不同,则称为方法的重载(Overloading)。
• (2)方法重写是在派生类存在方法与基类的方法的名字相同,而且参数的个数与类型一样,返回值也一样的方法,就称为重写(Overriding)。
• (3)方法重载是一个类的多态性表现,而方法重写是派生类与基类的一种多态性表现。

附一张网图

多态成员访问的特点

Parent p = new Child();

成员变量

编译看左边（基类），运行看左边（基类）；无论如何都是访问基类的成员变量。

成员方法

编译看左边（基类），运行看右边（派生类），动态绑定。

Static方法

编译看左边（基类），运行看左边（基类）。

只有非静态的成员方法,编译看左边,运行看右边。

这样，我们也可以得出多态的局限：

不能使用派生类特有的成员属性和派生类特有的成员方法。