重载和重写

重载：

1. 同一个文件中可以包含多个类
2. public修饰的类只能有一个
3. public修饰的类只能与文件名相同

public static void main(String[] args) {
		Aoo o=new Aoo();
		o.sayHi();
		o.sayHi(25);
		o.sayHi("zhangsan");
		o.sayHi(25, "zhangsan");
		o.sayHi("zhangsan", 25);
	}
}
class Aoo{
	void sayHi(){}
	void sayHi(String name){}
	void sayHi(int age){}
	void sayHi(String name,int age){}
	void sayHi(int age,String name){}//以上都是重载
	//int sayHi(){return 1;}//编译错误，与返回值无关
	//void sayHi(String address){}//编译错误，与参数名称无关	
}

重写：

1. 发生在父子类中，方法名相同，参数列表相同，方法体不同
2. 重写方法在被调用时，看对象的类型–【区分向上造型，向上造型是看引用】
3. 注意事项：重写需要遵循“两同两小一大”原则：一般都是一模一样

• 两同：方法名称相同，参数列表相同
• 两小：
  1） 子类方法的返回值类型小于或等于父类的
  void 和基本类型时，必须相同
  引用类型时，小于或等于
  2）子类抛出的异常小于或等于父类的—异常
• 一大：子类方法的访问权限大于或等于父类的–访问修饰符

重写与重载的区别—常见面试题

1. 重写：

• 父子类中，方法名相同，参数列表相同，方法体不同
• 遵循“运行期”绑定，根据对象的类型调用方法 ·

2. 重载：

• 一个类中，方法名相同，参数列表不同，方法体一般也不同
• 遵循“编译期”绑定，根据引用的类型来绑定方法（参数的个数和类型就是引用的个数和 类型）

	public static void main(String[] args) {
		/*Aoo o1=new Aoo();
		o1.show();
		
		Boo o2=new Boo();
		o2.show();
	
		Aoo o3=new Boo();
		o3.show();*/
		
		Boo o4=new Boo();
		o4.show();
	
		//重载看引用，重写看对象
		/*Goo goo=new Goo();
		Eoo o=new Foo();//向上造型
		goo.test(o);//父型参数 子类show---首先看test，test发生了重载，重载看引用（参数），引用（o）的类型是Eoo，所以输出
			//“父型参数”，接着到o.show 这个show发生了重写，重写看对象，此时o所处的对象是Foo,所以输出“子类show”
		
		Goo goo=new Goo();
		Foo o=new Foo();//引用和对象都是Foo
		goo.test(o);//子型参数 子类show
		*/
		
		/*
		Goo goo=new Goo();
		Eoo o  =new Eoo();//引用和对象都是Eoo
		goo.test(o);//父型参数 父类show
		*/
	}
}
class Aoo{
	void show(){
		System.out.println("父类show");
	}
}
class Boo extends Aoo{
	void show(){
		super.show();//调用父类的show方法
		System.out.println("子类show");
	}
}
//父类大，子类小
class Coo{
	void sayHi(){}//返回值为void
	double show(){return 0.0;}
	Coo test(){return null;}
	Doo say(){return null;}
}
class Doo extends Coo{
	void sayHi(){}//void时必须相同
	double show(){return 1.0;}//基本类型时必须相同
	Doo test(){return null;}//小于父类
	Doo say(){return null;}//和父类相同，正确
	//Coo say(){return null;} //编译错误，引用类型时，子类的返回值类型必须小于或等于父类
}
//Goo演示重载
class Goo{
	void test(Eoo o){
		System.out.println("父型参数");
		o.show();
	}
	void test(Foo o){
		System.out.println("子型参数");
		o.show();
	}
}
//Eoo和Foo演示重写
class Eoo{
	void show(){
		System.out.println("父类show");
	}
}
class Foo extends Eoo{
	void show(){
		System.out.println("子类show");
	}