JAVA初级(十三)方法的重写和重载

方法的重写(Override)

1, 什么是方法的重写?
就是将子类从父类继承下来的方法重新编写的过程.其中参数和返回值,名称不能修改.
2,如何来实现重写？

public class Teacher extends Human {
    @Override
    public void fun(String msg){//子类重写父类的方法
        System.out.println("我是老师类会教书,会说话"+msg);
    }
}
public class Human {
    public void fun(String msg){
        System.out.println("我是人类会说话"+msg);
    }
}

重写就这么写,首先要有继承关系,然后子类重写父类方法时.方法名称,参数和返回值都要一样.
观察以上两个类.子类Teacher继承Human类.
然后子类重写了父类的fun()方法.
这里表示的意义是什么?
人类会说话但不一定会教书.但是它有一个子类Teacher会教书.然后这个子类就继承了人类的fun()方法并给它扩大了功能.–>这是多态的一种体现.一个行为多种不同的表现方式.
接着执行以下语句

 public static void main(String[] args) {
        Human father = new Human();
        Teacher teacher = new Teacher();
        father.fun("人类");//调用的人类的fun
        teacher.fun("老师类");//调用的Teacher的fun
    }

结果输出:
我是父类人类
我是子类老师类

这样就把父类的方法重写了.
你回头看下发现Teacher类的fun()方法上面有一个 @Override,这个叫做注解.这个的意思就是表明了我是要重写fun()方法.因此这时候你如何修改了fun()的参数,或者返回值以及名称都将会报错

public class Teacher{
  @Override
    public String fun(double msg){
        System.out.println("我是子类"+msg);
        return "";//这样会报错,会说你和父类的方法不匹配
    }
    }

但是你去掉 @Override就不会报错了,.但此时并不能说它就是重写父类的方法了,因为返回值和参数都变了,.变成真正意义上属于Teacher()它自己的方法了

1,所以可以说添加上@Override它一定是重写,不加@Override它不一定是重写.
2,修改了参数,和返回值会报错.

public class Teacher extends Human{
@Override
  protected void fun(String msg){
        System.out.println("我是人类会说话"+msg); 
    }
    //会报错,protected会出现编译错误,原因是权限太小.
}

3,子类重写父类方法时,权限不能比父类小.也就是父类是public那么子类重写时就必须时public而不能是protected或者更小的权限.

public class Human {
    public final void fun(String msg){//添加了final
        System.out.println("我是父类"+msg);
    }
}
public class Teacher extends Human {
    @Override
    public void fun(String msg){
        System.out.println("我是子类"+msg);
    }
    //结果报错,提示不能重写被final修饰的方法
}

4,子类重写父类方法时,不能重写被final修饰的方法

public class Human {
    public static void fun(String msg){//添加了static
        System.out.println("我是父类"+msg);
    }
}
public class Teacher extends Human {
    @Override
    public void fun(String msg){
        System.out.println("我是子类"+msg);
    }
    //结果报错,提示不能重写被static修饰的方法
}

5,子类重写父类方法时,不能重写被static修饰的方法

总结:
重写的规则
1,参数不变，返回值不变
2,权限不能更低
3,只有子类能重写父类的方法.别的类不能重写
4,声明为final的方法不能被重写。
5,声明为static的方法不能被重写
6,子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为private和final的方法。
7,子类和父类不在同一个包中，那么子类只能够重写父类的声明为public和protected的非final方法。
8,重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。
9,构造方法不能被重写。
10,如果不能继承一个方法，则不能重写这个方法。
后面5点可以自行去证明.后面5点来自菜鸟教程,前面5点参考菜鸟教程http://www.runoob.com/java/java-override-overload.html

方法的重载(Overload)

1,什么方法的重载？
重载的表现是在同一个类里面,方法名称相同,参数不同的方法.

public class TestDemo{
	public String fun(){
		return "原始方法"
	}
	public double fun(double num){//重载fun方法,参数不同,返回值相同
		return num;
	}
	public String fun(double num,String num2){//重载fun方法,参数不同,返回值不同
		return num+num2;
	}
}

这就是重载,方法名称相同,参数一定不同,返回值可相同可不同.
这样你在调用这个类的fun()方法时,就可以根据参数来选择调用哪一个fun()方法
类似这样的操作在构造方法上面最常用.

 public static void main(String[] args) {
        TestDemo testDemo= new TestDemo();
        testDemo.fun();//调用没有参数的那个fun
        testDemo.fun(3.0);//调用参数只有一个的那个fun
        testDemo.fun(3.5,"fun");//调用参数有两个的那个fun
    }

当然参数不同指的并不是数量要不同,而是在那个参数的位置上的类型要不同.
比如

public double fun(double num,String num1){
		return num;
	}
public double fun(String num,double num1){
		return 0.0;
	}

它们的参数数量一样,但是在相同位置的参数类型不一样.这也是重载.因为我们能够根据参数来选择调用哪一个fun();

重载和重写的区别.

区别	重载方法	重写方法
参数	不同	相同
返回值	可同可不同	相同
访问权限	任意修改	权限不能更小
异常	任意修改	可减少,不能加切不能抛出更大的异常

关于异常后面介绍异常的时候在说

拓展:重写是父类与子类之间的一种多态体现,重载是类的一种多态体现