java 继承中的重写、重载、多态

java 在继承当中，可以使用父类引用指向子类的对象，而子类对象引用则不能指向父类对象。

Father fs=new Son();

当父类与子类具有同名的成员变量时，如都有同名的String s时，尽管创建的是Son对象，fs.s调用的却是Father的s；

当父类与子类具有同名的方法时，构成了重写，如具有同名的show()方法，与成员变量不同，fs.show调用的是Son中的show()方法。

但如果是静态的方法，当父类与子类具有同名静态方法时，不会被重写。静态方法不会被重写，只能被继承或者隐藏。

java重写的规则，要求方法名相同，返回类型相同，或者返回对象派生自被重写的方法的返回对象，重写方法的限制符号不能比被重写的更宽。

重写是基于继承，方法没有被继承就不会被重写，父类中private的方法是不会被继承的，所以也不可能被重写。

package array;

class Father{
	String s="这是父类的String成员";
	public void show(){
		System.out.println("这是父类的show方法");
	}
	
	public static void showStatic(){
		System.out.println("这是父类的静态方法");
	}
			
}
class Son extends Father{
	String s="这是子类的String成员";
	public void show(){
		//
		super.show();//这是可以的
		System.out.println("这是子类的show方法");
	}
	public static void showStatic(){
		//super.showStatic();//这是不可以的
		System.out.println("这是子类的静态方法");
	}
}
public class FatherAndSon {
	public static void main(String[] args){
		Father f=new Father();
		Son s=new Son();
		Father fs=new Son();  //父类引用可以引用子类对象
		//Son sf=new Father();//报错，子类引用不能引用父类对象
		
		System.out.println("fs中的s成员是："+fs.s); //应该引用的是父类的S
		fs.show();  //和成员变量不同，方法调用的是子类的方法
		fs.showStatic();//静态方法不会被重写，依然调用的是父类的静态方法
		fs=s;
		s.showStatic();  //把父类引用指向子类对象，就调用子类的静态方法
	}
}

方法的重载

重载是指在一个类里面具有，相同方法名不同参数的方法，返回值可以相同也可以不同。

如果重载的参数是引用，且有继承关系，则重载哪个方法是由传入参数的引用类型决定的。

package array;

class A{}
class B extends A{}
class C extends B{}

class Commons{
	public void show(A a){
		System.out.println("this is show A");
	}
	public void show(B b){
		System.out.println("this is show B");
	}
	public void show(C c){
		System.out.println("this is show C");
	}
}

public class Reload {
	

	public static void main(String[] args) {
		// TODO Auto-generated method stub
	A a=new A();
	B b=new B();
	C c=new C();
	A ab=new B();
	A ac=new C();
	B bc=new C();
	
	Commons con=new Commons();
	con.show(a);
	con.show(b);
	con.show(c);
	con.show(ab);
	con.show(ac);
	con.show(bc);
	//output is A B C A A B 	
	}

}

final类不能被继承，final方法不能被重写

与final想对的关键字是abstract，abstract用于修饰抽象类，抽象类不可被实例化，只可以被继承，抽象类中用abstract修饰的方法称为抽象方法，抽象方法在继承的时候通过重写来实现。抽象类的第一个子类，必须实现它和它所继承来的所有抽象方法。 非抽象类中不能有抽象方法。

基于继承的多态：在java中基于继承的多态是指对象功能的调用者用超类的引用来进行方法调用。

用超类的引用调用不同子类的实现，使用超类当中的方法，而不用关心具体子类当中的实现方法，就是多态。

package array;
abstract class Car{
	abstract void start();
}
class Truck extends Car{
	public void start(){
		System.out.println("卡车启动了");
	}
}
class Mini extends Car{
	public void start(){
		System.out.println("面包车启动了");
	}
}
public class DuoTaai {

	public static void main(String[] args){
		//定义父类的引用
		Car car=new Truck();
		//调用父类的抽象方法，这个方法已经被子类重写了
		car.start();
		//父类引用指向另一个子类
		car=new Mini();
		//调用的是另一个子类重写的抽象方法
		car.start();
	}
}