如何理解java中重写，重载与多态（整理）

OVERRIDE(重写）

   OVERRIDE（只体现在具有继承关系）是重写（覆盖）了一个方法，以实现不同的功能。一般用于子类在继承父类是，重新实现父类中的方法。

规则：

1.重写方法的参数列表必须完全与被重写的方法相同

2.重写方法修饰符必须大于呗重写方法的访问修饰符（PUBLIC>PROTECTED>DEFAULT>PRIVATE)

3.重写方法的返回值和被重写方法的返回值必须一致

4.重写方法所抛出的异常必须与被重写方法抛出的异常一致，或为其子类

5.被重写方法不能为PRIVATE,否则只是在子类中重新定义一个新的方法。

   且父类中，被重写的方法一旦被FINAL, 无论为public，protected或default修饰，子类均不能重写。否则报错

例子

public class Father{
  public void speak(){
    System.out.println("FATHER");
	}
}

public class Son extends Father{
  public void speak(){
    System.out.println("SON");
	}
}

OVERLOAD(重载）

  OVERLOAD一般用于在一个类内实现若干重载的方法，这些方法名称相同而参数形式不同

规则：

1.在使用重载是只能通过相同的方法名，不同的参数形式实现。不同的参数类型，或不同的参数个数，或不同的参数顺序

2.可以有不同类型的返回类型,也可相同

3.可以抛出不同的异常

4.可以有不同的访问修饰符

5.不能通过防卫权限，返回类型，跑出异常的不同来进行重载

例子

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));
	}

}

POLYMORPHISM（多态）

1，接口和实现并覆盖接口的统一方法的几个不同类的体现

2，父类和继承父类中同一方法的几个不同子类的实现

多态性：发送消息给某个对象，让该对象自行决定相应何种行为。通过子类对象引用 赋值给 超类对象引用变量 来实现动态方法的调用

当超类对象引用变量引用子类对象是，被引用对象的类型（而不是引用变量的类型）决定调用谁的成员方法，但这个被调用的方法，必须是在超类

中定义过的，也就是说被子类覆盖的方法。

使用父类类型的引用指向子类的对象（比如 Animal a = new Cat(); )，该引用只能调用父类中定义的方法和变量，若子类中重写了父类中的一个方法，

那么在调用这个方法是，会调用子类的这个方法

如

class Father{ 
    public void func1(){ 
        func2(); 
    } 
    //这是父类中的func2()方法，因为下面的子类中重写了该方法 
    //所以在父类类型的引用中调用时，这个方法将不再有效 
    //取而代之的是将调用子类中重写的func2()方法 
    public void func2(){ 
        System.out.println("AAA"); 
    } 
} 
  
class Child extends Father{ 
    //func1(int i)是对func1()方法的一个重载 
    //由于在父类中没有定义这个方法，所以它不能被父类类型的引用调用 
    //所以在下面的main方法中child.func1(68)是不对的 
    public void func1(int i){ 
        System.out.println("BBB"); 
    } 
    //func2()重写了父类Father中的func2()方法 
    //如果父类类型的引用中调用了func2()方法，那么必然是子类中重写的这个方法 
    public void func2(){ 
        System.out.println("CCC"); 
    } 
} 
  
public class PolymorphismTest { 
    public static void main(String[] args) { 
        Father child = new Child(); 
        child.func1();//打印结果将会是什么？    
    } 
}

上面的程序是个很典型的多态的例子。子类Child继承了父类Father，并重载了父类的func1()方法，重写了父类的func2()方法。

重载后的func1(int i)和func1()不再是同一个方法，由于父类中没有func1(int i)，那么，父类类型的引用child就不能调用func1(int i)方法。

而子类重写了func2()方法，那么父类类型的引用child在调用该方法时将会调用子类中重写的func2()。 那么该程序将会打印出什么样的结果呢？ 

 很显然，应该是“CCC”。

//父类 
public class Father{ 
    //父类有一个打孩子方法 
    public void hitChild(){ 
    } 
} 
//子类1 
public class Son1 extends Father{ 
    //重写父类打孩子方法 
    public void hitChild(){ 
       System.out.println("为什么打我？我做错什么了！"); 
    } 
} 
//子类2 
public class Son2 extends Father{ 
    //重写父类打孩子方法 
    public void hitChild(){ 
       System.out.println("我知道错了，别打了！"); 
    } 
} 
//子类3 
public class Son3 extends Father{ 
    //重写父类打孩子方法 
    public void hitChild(){ 
       System.out.println("我跑，你打不着！"); 
    } 
} 

//测试类 
public class Test{ 
    public static void main(String args[]){ 
       Father father; 

       father = new Son1(); 
       father.hitChild(); 

       father = new Son2(); 
       father.hitChild(); 

       father = new Son3(); 
       father.hitChild(); 
    } 
} 

都调用了相同的方法，出现了不同的结果！这就是多态的表现！