overload与override的区别

overload与override的区别：

java多态之Override ：

Override（重写）是子类与父类的一种多态性体现。
Override允许子类改变父类的一些行为。
为什么需要Override：当父类不满足子类的一些要求时我们就需要子类对父类的一些行为进行重写。
例如：某公司里的员工的电话号码不允许对外公开，而销售人员（员工）的电话号码则需要对外公开。
这时我们就可以这样做：
Java代码 
1.public class Employee {  
2.      
3.    private String mobile;  
4.      
5.    public Employee(String mobile) {  
6.        this.mobile = mobile;  
7.    }  
8.      
9.    protected String showMess(){  
10.        return "电话号码："+mobile;  
11.    }  
12.} 
public class Employee {
       
        private String mobile;
       
        public Employee(String mobile) {
                this.mobile = mobile;
        }
       
        protected String showMess(){
                return "电话号码："+mobile;
        }
}

员工类的showMess方法是protected的，所以位于其他包的对象是访问不到的。

然后定义一个销售人员的类（Sales）,并继承Employee类

Java代码 
1.public class Sales extends Employee{  
2.      
3.        //子类除了具有父类的一些属性，也可以有自己的一些属性  
4.    private String msn;  
5. 
6.    public Sales(String mobile,String msn) {  
7.        super(mobile);  
8.        this.msn = msn;  
9.    }  
10. 
11.    @Override 
12.    public String showMess() {  
13.        return super.showMess()+"==msn:"+this.msn;  
14.    }  
15.} 
public class Sales extends Employee{
       
        //子类除了具有父类的一些属性，也可以有自己的一些属性
        private String msn;

        public Sales(String mobile,String msn) {
                super(mobile);
                this.msn = msn;
        }

        @Override
        public String showMess() {
                return super.showMess()+"==msn:"+this.msn;
        }
}

注意这时被覆盖的showMess方法的访问级别是public，可以被任何其他对象访问到。

关于Override有几点要注意的地方：
1.被覆盖方法的访问控制级别可以不一样。
例如上例父类的showMess方法的访问级别为protected的，而子类覆盖的showMess方法访问级别则为public的。

但子类的访问级别必须要高于父类被覆盖方法的访问级别，如果父类是public的而子类是protected的则是错误的。

2.方法被定义为private或static或final的则不能被覆盖。

3.方法的返回类型：子类的返回类型可以是更具体的对象，例如可以将Employee类的返回类型改为Object也正确。而倒过来则错误。

4.在方法调用时先会在子类中找覆盖的方法，如果子类中没有则会在父类中去找。

Java代码 
1.public class Parent {  
2.      
3.    private int num(int i,int j){  
4.        return i+j;  
5.    }  
6.      
7.    public static void main(String[] args) {  
8.        Parent p = new Child();  
9.        System.out.println(p.num(1, 2));  
10.    }  
11.}  
12.class Child extends Parent{  
13.      
14.    public int num(int x,int y){  
15.        return x-y;  
16.    }  
17.} 
public class Parent {
       
        private int num(int i,int j){
                return i+j;
        }
       
        public static void main(String[] args) {
                Parent p = new Child();
                System.out.println(p.num(1, 2));
        }
}
class Child extends Parent{
       
        public int num(int x,int y){
                return x-y;
        }
}

这段代码的执行结果为什么呢？如果你回答-1则错了，正确答案是3。
为什么呢？因为父类的num方法是private的，所以不能被覆盖，所以子类的num方法不是一种Override，因此在子类找不到被覆盖的num方法就会执行父类的num方法。所以结果输出为3.

Java代码 
1.public class Parent {  
2.      
3.    public int test(){  
4.                //执行子类的num方法  
5.        return num(1,2);  
6.    }  
7.      
8.    protected int num(int i,int j){  
9.        return i+j;  
10.    }  
11.      
12.    public static void main(String[] args) {  
13.        Parent p = new Child();  
14.        System.out.println(p.test());  
15.    }  
16. 
17.}  
18.class Child extends Parent{  
19.      
20.    public int num(int x,int y){  
21.        return x-y;  
22.    }  
23.} 
public class Parent {
       
        public int test(){
                //执行子类的num方法
                return num(1,2);
        }
       
        protected int num(int i,int j){
                return i+j;
        }
       
        public static void main(String[] args) {
                Parent p = new Child();
                System.out.println(p.test());
        }

}
class Child extends Parent{
       
        public int num(int x,int y){
                return x-y;
        }
}

那么这段代码的执行结果是-1，因为父类test方法调用的是子类的num方法。

 java overload的原则 :
在java中overload要遵循两个原则:准确性和唯一性

例一:

public class TestOverLoad
{
public static void main(String[] args)
{
   Test test = new Test();
   test.print(null); 
}
}

class Test
{

public void print(String some)
{
   System.out.println("String version print");
}

public void print(Object some)
{
   System.out.println("Object version print");
}

}

在这个程序中,   test.print(null)中的null即是String又是Object,那么要执行那个函数呢?结果是它执行了 public void print(String some),原因就是准确性原则,String继承自Object.在java看来,在这个例子中说null是String类型的比说null是Object类型的更为准确.

例二:

public class TestOverLoad
{
public static void main(String[] args)
{
   Test test = new Test();
   test.print(null); 
}
}

class Test
{

public void print(String some)
{
   System.out.println("String version print");
}

public void print(Object some)
{
   System.out.println("Object version print");
}

public void print(StringBuffer some)
{
   System.out.println("StringBuffer version print");
}
}
在该例中,Test类多了一个函数,然而在编译时出现了错误.原因是该例违反了overload的唯一性原则

.String和StringBuffer之间不存在继承关系,因此不能说null属于它们两个中的那个类更准确,于是程序在执行时就会不知道该调用public void print(String some),还是该调用 public void print(StringBuffer some).