day7.Java面向对象编程技术——多态

概述：同一操作作用于不同的对象，可以有不同的解释，产生不同的执行结果，这就是多态性。
简单的说：就是用基类的引用指向子类的对象。
实例：

abstract class Animal {
	public abstract void shout(); // 定义抽象shout()方法
}
 
//定义Cat类继承Animal
class Cat extends Animal {
	// 实现shout()方法
	public void shout() {
		System.out.println("喵喵...");
		
	}
}
 
//定义Dog类继承Animal
class Dog extends Animal {
	// 实现shout()方法
	public void shout() {
		System.out.println("汪汪...");
		
	}
}
 
public class Duotai {
	public static void main(String[] args) {
		Animal cat = new Cat();
		Animal dog = new Dog();
		
		animalShout(dog);
		animalShout(cat);
//		运行结果：
//				汪汪...
//				喵喵...
	
	}
	
	// 定义一个静态的animalShout()方法,接收一个Animal类型的对象
	public static void animalShout(Animal animal) {
		animal.shout();// 调用实际参数的shout()方法
	}
}

1.重载

重载的三个条件：
1.在同一个类中
2.方法名必须相同
3.方法的参数类不同 (和返回值类型没有关系)

public class TestOverLoad{
 public void mOl(int i){
  System.out.println(i*i);
 }
 public void mOl(int i , int j){
  System.out.println(i+2);
 }
 public int mOl(String str){
  System.out.print(str);
  return 0;
 }
}

重载的时候，方法名要一样，但是形参类型和个数不一样，返回值类型可以相同也可以不相同。

说明：参数列表不同包括：个数不同、类型不同和顺序不同。 仅仅参数变量名称不同是不可以的。 跟成员方法一样，构造方法（构造器）也可以重载。
声明为final的方法不能被重载。 声明为static的方法不能被重载，但是能够被再次声明。

方法的重载的规则：

方法名称必须相同。
参数列表必须不同（个数不同、或类型不同、参数排列顺序不同等）。
方法的返回类型可以相同也可以不相同。
仅仅返回类型不同不足以成为方法的重载。

实例：

public class OverLoading {
    public void max(int a, int b) {
        // 含有两个int类型参数的方法
        System.out.println(a > b ? a : b);
    }

    public void max(double a, double b) {
        // 含有两个double类型参数的方法
        System.out.println(a > b ? a : b);
    }

    public void max(double a, double b, int c) {
        // 含有两个double类型参数和一个int类型参数的方法
        double max = (double) (a > b ? a : b);
        System.out.println(c > max ? c : max);
    }

    public static void main(String[] args) {
        OverLoading ol = new OverLoading();
        System.out.println("1 与 9 比较，较大的是：");
        ol.max(1, 5);
        System.out.println("5.205 与 5.8 比较，较大的是：");
        ol.max(5.205, 5.8);
        System.out.println("2.15、0.05、58 中，较大的是：");
        ol.max(2.15, 0.05, 58);
    }
}

运行结果：

1 与 9 比较，较大的是：
9
5.205 与 5.8 比较，较大的是：
5.8
2.15、0.05、58 中，较大的是：
58.0

2.覆盖

覆盖是在类派生体系中，子类中直接定义和父类同样的属性和方法（重新编写方法体）。
属性覆盖条件:只要属性名相同，就可以实现覆盖，修饰符可以不同。

方法覆盖的条件：

1.成员名称相同。
2.方法的参数列表完全相同（参数的个数，类型，顺序都相同）
3.返回值必须相同
4.静态方法只能覆盖静态方法

访问属性的要求：

覆盖的方法必须提供与被覆盖方法一样的访问权限。若父类的访问属性是public，则子类的覆盖方法必须是public。若父类的访问属性是protected，则子类的覆盖方法必须是public和protected。若父类的访问属性是默认类型，则子类的覆盖方法和访问类型一定不能是private，其他都可以。
实例：

class A{
void f(){
Systemout.println("调用A.f()");
}
void h(){
Systemout.println("调用A.h()");
}
}
class B extends A{
void f(){
Systemout.println("调用B.f()");
}
}
public class Test(){
public static void main(String args[])
{
A a=new A();
B b=new B();
a.f();
a.h();
b.f();
}
}

运行结果：

调用A.f()
调用A.h()
调用B.f()

重载与覆盖的区别

1.方法覆盖是子类与父类之间的关系，是垂直关系；方法重载是同一个类中方法之间的关系，是水平关系。
2.覆盖只能有一个方法或只能有一对方法产生关系；方法的重载是多个方法之间的关系。
3.覆盖要求参数列表相同；重载要求参数列表不同；
4.在覆盖关系中具体调用那个方法体，是根据对象的类型来决定；重载关系是根据调用的实参表与形参表来选择方法体。