1. 函数重载(OverLoding)

概念：同名函数具有不同的参数列表。

作用：实现单个类内部的多态性，是静态多态。

注意点： 

(1) 参数类型、个数、顺序至少有一个不相同。

(2) 不能通过访问权限、返回类型、抛出的异常进行重载。

2. 函数重写(OverRideing)

概念：在子类中定义某个方法与其父类有相同的名称和参数；子类对象引用或者子类对象的父类引用使用这个方法时，将调用子类中的定义。


作用：在继承中实现多态性，是父类与子类之间多态性的表现。


注意点：

(1) 方法名、参数、返回值必须相同。

(2) 子类方法不能缩小父类方法的访问权限。

(3) 子类方法不能抛出比父类更多的异常(子类可以不抛出异常)。

(4) 被定义为final的方法不能被重写。

例子：

class Father {
	private int money;	

	public int getMoney() {return money; }
	public void setMoney(int money) {this.money = money; }

	public void printInfo() {System.out.println("This is Father");}

	private void printInfo2() {System.out.println("This is Father");}
}

class Son extends Father{
/*重写了父类中的printInfo()函数，但是该函数的权限不能变小*/
	public void printInfo() {System.out.println("This is son");}
/*虽然父类中也有printInfo2()函数，但是该函数不是父类函数的重写，是子类自己定义申明的，
因为父类中printInfo2()是私有函数，子类继承后对齐不可见，故。。。*/
	public void printInfo2() {System.out.println("This is Father");}
	
}

public class Ext5 {
	public static void main (String args[]) {
		Son son = new Son();
		son.setMoney(100);
		//son.printInfo();
	}
}



3. 判断对象引用能否调用一个方法的原则

(1) 向上转型：子类转型成父类型。

(2) 子类对象引用：方法存在子类定义中则可以调用，否则不可以调用。

(3) 父类对象引用：方法存在父类定义中则可以调用，调用结果根据多态性原则；否则不可以调用。

// Animal类
public class Animal {
public void introduce(){
System.out.println("I am an animal!");
}
}  

// Cat类
public class Cat extends Animal {
//重写了父类的introduce，实现了overriding
public void introduce(){
System.out.println("I am a cat!");
}
//实现了Overloading
public void introduce(String name){
System.out.println("I am a cat, My name is : " + name); 
}
}

// Dog类
public class Dog extends Animal {
//重写了父类的introduce，实现了overriding
public void introduce(){
System.out.println("I am a dog!");
}

//实现了Overloading
public void introduce(String name){
System.out.println("I am a dog, My name is : " + name);
}
}

// 测试类
public class Test {
    public static void main(String[] args) {
//Overriding是父类与子类之间多态性的一个表现
Animal animal1 = new Animal();
Animal animal2 = new Cat();
Animal animal3 = new Dog();
animal1.introduce();
animal2.introduce();
animal3.introduce();
// animal2.introduce("JACK");  是错误的用法
// animal3.introduce("JACK");  是错误的用法
//Overloading是在一个类中多态性的体现
Cat cat = new Cat();
cat.introduce();
cat.introduce("JACK");
}
}






1. 函数重载(OverLoding)

概念：同名函数具有不同的参数列表。


作用：实现单个类内部的多态性，是静态多态。


注意点： 

(1) 参数类型、个数、顺序至少有一个不相同。

(2) 不能通过访问权限、返回类型、抛出的异常进行重载。


2. 函数重写(OverRideing)

概念：在子类中定义某个方法与其父类有相同的名称和参数；子类对象引用或者子类对象的父类引用使用这个方法时，将调用子类中的定义。

作用：在继承中实现多态性，是父类与子类之间多态性的表现。

注意点：

(1) 方法名、参数、返回值必须相同。

(2) 子类方法不能缩小父类方法的访问权限。

(3) 子类方法不能抛出比父类更多的异常(子类可以不抛出异常)。

(4) 被定义为final的方法不能被重写。

例子：

class Father {
	private int money;	

	public int getMoney() {return money; }
	public void setMoney(int money) {this.money = money; }

	public void printInfo() {System.out.println("This is Father");}

	private void printInfo2() {System.out.println("This is Father");}
}

class Son extends Father{
/*重写了父类中的printInfo()函数，但是该函数的权限不能变小*/
	public void printInfo() {System.out.println("This is son");}
/*虽然父类中也有printInfo2()函数，但是该函数不是父类函数的重写，是子类自己定义申明的，
因为父类中printInfo2()是私有函数，子类继承后对齐不可见，故。。。*/
	public void printInfo2() {System.out.println("This is Father");}
	
}

public class Ext5 {
	public static void main (String args[]) {
		Son son = new Son();
		son.setMoney(100);
		//son.printInfo();
	}
}



3. 判断对象引用能否调用一个方法的原则

(1) 向上转型：子类转型成父类型。

(2) 子类对象引用：方法存在子类定义中则可以调用，否则不可以调用。

(3) 父类对象引用：方法存在父类定义中则可以调用，调用结果根据多态性原则；否则不可以调用。

// Animal类
public class Animal {
public void introduce(){
System.out.println("I am an animal!");
}
}  

// Cat类
public class Cat extends Animal {
//重写了父类的introduce，实现了overriding
public void introduce(){
System.out.println("I am a cat!");
}
//实现了Overloading
public void introduce(String name){
System.out.println("I am a cat, My name is : " + name); 
}
}

// Dog类
public class Dog extends Animal {
//重写了父类的introduce，实现了overriding
public void introduce(){
System.out.println("I am a dog!");
}

//实现了Overloading
public void introduce(String name){
System.out.println("I am a dog, My name is : " + name);
}
}

// 测试类
public class Test {
    public static void main(String[] args) {
//Overriding是父类与子类之间多态性的一个表现
Animal animal1 = new Animal();
Animal animal2 = new Cat();
Animal animal3 = new Dog();
animal1.introduce();
animal2.introduce();
animal3.introduce();
// animal2.introduce("JACK");  是错误的用法
// animal3.introduce("JACK");  是错误的用法
//Overloading是在一个类中多态性的体现
Cat cat = new Cat();
cat.introduce();
cat.introduce("JACK");
}
}