overload与override的区别

overload与override的区别：

java多态之Override ：

Override（重写）是子类与父类的一种多态性体现。
Override允许子类改变父类的一些行为。
为什么需要Override：当父类不满足子类的一些要求时我们就需要子类对父类的一些行为进行重写。
例如：某公司里的员工的电话号码不允许对外公开，而销售人员（员工）的电话号码则需要对外公开。
这时我们就可以这样做：
Java代码 www.zzzyk.com
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

补充：软件开发 , Java ,