面向对象-------方法重写与方法重载

1.方法重载

Java允许同一个类中定义多个同名方法，只要它们的形参列表不同即可。如果同一个类中包含了两个或两个以上方法名相同的方法，但形参列表不同，这种情况被称为方法重载（overload）。

在类中定义了重载方法后，对重载方法的调用与一般的调用方法相同。

例如：

public class OverloadDemo{

    public void display(int a){
        System.out.println("a= "+a);
}
    public void display(double d){
        System.out.println("d= "+d);
}
    public void display(){
        System.out.println("无参数方法")；
}
public void display(int a,int b){
        System.out.println("a= "+a+",b= "+b);
}
public static void main(String[] args){
    OverloadDemo obj=new OverloadDemo();
    obj.diaplay();
    obj.diaplay(10);
    obj.display(50,60);
    obj.display(100.0);
    }
}
//运行结果
无参数方法
a=10
a=50,b=60
d=100.0

重载是在一个类中，有相同的函数名称，但形参不同的函。重载的结果，可以让一个程序段尽量减少代码和方法的种类。

参数列表不同包括：个数不同、顺序不同、类型不同。
跟成员方法一样，构造方法也可以重载。
声明为final的方法不能被重载。
声明为static的方法不能被重载，但是能够被在此声明。

2.方法重写

    在子类中可以定义与父类中的名字、参数列表、返回值类型都相同的方法，这时子类的方法就叫作覆盖或重写了父类的方法.

假设要在Employee类中也定义一个sayHelloO方法，用它来输出员工信息，定义如下：

public void sayHello{
    System.out.println("hello.i am "+name);
    System.out.println("i am "+age);
}

  该方法就是对Person类的sayHelloo方法的覆盖。如果子类覆盖了超类的方法，在调用相同的方法时，调用的是子类的方法。
  为了遭免在覆盖方法时写错方法头，可以使用@Override注解语法，即在要覆盖的方法前面添加@Override。例如，假设一个Employee类要覆盖Object类的toStringO方法，代码如下：          

@Override
public String toString{
    return "姓名： "+name+"年龄： "+age;
}

   @Override注解表示其后的方法必须是覆盖父类的一个方法。如果具有该注解的方法没有覆盖父类的方法，编译器将报告一个错误。例如，toString如果被错误地写成tosrting,将报告一个编译错误。如果没有使用注解，编译器不会报告错误。使用注解可以避免错误。的关于方法覆盖，有下面两点值得注意：
(l)private方法不能覆盖。只有非private的实例方法才可以覆盖，如果在子类中定义了一个方法在父类中是private的，则这两个方法无关。
(2)父类中static方法可以被继承，但不能被覆盖。如果子类中定义了与父类中的static方法完全一样的方法，那么父类中的方法被隐藏。父类中被隐藏的static方法仍然可以使用“类名.方法名（）”形式调用。

   方法重载是在一个类中定义多个名称相同但参数不同的方法。而方法覆盖是在子类中为父类中的同名方法提供一个不同的实现。要在子类中定义一个覆盖的方法，方法的参数和返回值类型都必须与父类中的方法相同。请看下面例子，

//定义一个Parent类
public class Parent{
    public void display(double i){
        System.out.println(i);
    }
}
//定义Parent类的子类child
public class child extends Parent{
   public void display(double i){
     System.out.println(2*i);
    }
}
//测试
public class Demo{
    public static void main (String[] args){
        Child obj=new Child();
        obj.display(10);
        obj.display(10.0);

    }
}
//运行结果
20.0
20.0

 3.super关键字

在子类中可以使用super关键字，用来引用当前对象的父类对象，它可用于下面三种情况：

①在子类中调用父类中被覆盖的方法，格式为：

                          super.methodName([paramlist])

②在之类中调用父类的构造方法，格式为：

                          supper([paramlist])

③ 在子类中访问父类中被隐藏的成员变量，格式为：

                         super.variableName                                                      

这里，methodName表示要用调用父类中被覆盖的方法名；paramlist表示为方法传递的参数；variableName表示要访问的父类中被隐藏的变量名。                                                                         

package com.demo;
    class super{
        int x,y;
        public super(){
            System.out.println("创建父类对象");
            setXY(5,5);
        }
    public void diaplay setXY(int x,int y){
        this.x=x;
        this.y=y;
    }
    public void display(){
        System.out.println("x= " +x+ ",y= " +y);
    }
    class Sub extends Super{
        int x,z;
        public Sub(){
            this(10,10);
            System.out.println("创建子类对象");
        }
    }
    public Sub(int x,int z){
     super();
     public Sub(){
     this.x=x;
     this.z=z;
        }
    }
    public void diaplay(){
        super.display();
        System.out.println("x- "+x+",y="+y);
        System.out.println("super.x= "+super.x+",super.y="+super.y);
        }
    }
    public class SuperDemo{
        public static void mian(String[] args){
            Sub b=new Snb();
            b.display();
        }
    }
//运行结果
创建父类对象
创建子类对象
x=5,y=5
x=10,y=5
super.x=5,super.y=5