重载与重写的区别

重载：是指一个类中定义多个方法名相同，参数列表不同的方法，在编译时，根据参数的个数，类型，顺序来决定绑定哪个方法。

重写：是指在子类中定义和父类完全相同的方法，在程序运行时，根据对象的类型（而不是引用类型）调用不同的方法。

/**
 * 方法重载:指的是方法名相同的完全不同的方法。（参数类型,参数个数和参数顺序不同）
 * 在调用重载方法时，根据方法名和参数列表确定调用哪个方法。与返回值无关。
 * 私有方法只能被重载，不能被重写
 * @author hezhi
 *
 */
public class OverloadDemo {
	public static void main(String[] args) {
		A a = new A() ;
		a.test(1 , 2) ;
		a.test(1.0 , 2) ;
		a.test(1 , 2.0) ;
		a.test() ;
	}
}

class A {
	public void test() {
		System.out.println("空") ;
	}
	public void test(int i , int j) {
		System.out.println(i + j); ;
	}
	public void test(int i , double j) {
		System.out.println("int , double " + i + "," + j) ;
	}
	public void test(double i , int j) {
		System.out.println("double , int " + i + "," + j) ;
 	}
}

/**
 * 方法重写：在子类中重写和父类一样的方法，构造函数，静态方法，私有方不能被重写
 * 子类重写父类方法的规则：返回值要兼容，修饰词要更加开放，异常要更加具体
 * @author hezhi
 *
 */
public class OverrideDemo {
	public static void main(String[] args) {
		Foo foo = new Foo(5) ;
		Goo goo = new Goo() ;
		//向上造型：父类型变量引用子类型对象，造型以后，父类型变量只能访问父类中声明的方法和属性。
		//如果仍要访问子类型方法和属性，必须将父类型变量强制转换为子类型变量，然后在访问。
		foo = goo ;
		foo.test() ;    
		/* 运行结果:
		 * Foo的构造函数
		 * Foo的构造函数
		 * Goo的构造函数
		 * Goo_Method                //根据对象的类型来决定调用哪个方法。
		 */
	}
}

class Foo {
//	public Foo() {
//		System.out.println("Foo的构造函数") ;
//	}
	public Foo(int a) {
		System.out.println("Foo" + a) ;
	}
	protected void test() throws RuntimeException{
		System.out.println("Foo_Method");
	}
}

class Goo extends Foo {
	//子类在调用自己的构造函数之前，一定会先调用父类的构造函数。
	public Goo() {
		super(3) ;          //如果写super()，默认调用父类的无参构造函数，如果父类没有无参构造函数，需要
							//显示调用super(value,...),否则就会出现编译错误。建议都在父类中添加无参构造函数。
		System.out.println("Goo的构造函数") ;
	}
	public void test() throws NullPointerException{     //不能是Exception
		System.out.println("Goo_Method") ;
	}
}