码迷,mamicode.com
首页 > 编程语言 > 详细

Java-重载、重写(冷静分析)

时间:2017-10-04 15:18:19      阅读:215      评论:0      收藏:0      [点我收藏+]

标签:顺序   int   规则   private   原则   类的方法   实现   修饰符   http   

一、方法的重载

  重载就是根据不同的数据类型,自动匹配对应的方法。重载在编译的时候就决定调用哪个方法了,和重写不一样。(常见,构造函数重载)。

 

举个栗子:

1、基本数据类型的重载:

 

 1 /**
 2  * @author 薛定谔的猫
 3  * 基本数据类型的重载
 4  * */
 5 public class Main {
 6     
 7     static void methed( byte b) {
 8         System.out.println("byte:method");
 9     }
10     
11     static void method(double d) {
12         System.out.println("double:method");
13     }
14     
15     static void method(int i) {
16         System.out.println("int:method");
17     }
18     
19     static void method(String s) {
20         System.out.println("String:method");
21     }
22     
23     public static void main(String[] args) {
24         methed((byte)1);
25         method(2.0);
26         method(1);
27         method("zpoor");
28     }
29 }
30 
31 /*
32  * 结果:
33  *         byte:method
34  *        double:method
35  *        int:method
36  *        String:method
37 */

 

 

 

2、带对象引用参数的重载

 

 1 /**
 2  * @author 薛定谔的猫
 3  * 带有对象引用参数的重载*/
 4 class Animal {
 5     
 6 }
 7 
 8 class Pig extends Test{
 9     
10 }
11 
12 class Test {
13     static void method(Test a) {
14         System.out.println("Animal");
15     }
16     
17     static void method(Pig p) {
18         System.out.println("Pig");
19     }
20     
21     public static void main(String[] args) {
22         Test a = new Test();
23         Pig p = new Pig();
24         Test b = new Pig();
25         
26         method(a);
27         method(p);
28         method(b);//为啥不是Pig,而是Animal
29         /*
30          * 盲目分析:看的是引用类型而不是对象类型,重载在编译时候就决定了,
31          *             引用类型决定了哪个重载方法。
32          * */
33         
34     }
35 }
36 
37 /**
38  * 结果:
39  *     Animal
40     Pig
41     Animal
42 */

 

 

 

总结:重载的规则

1、重载的方法必须改变参数列表,参数必须不同(参数的个数,参数的类型,参数的顺序)

2、被重载的方法与返回值没有关系,不是通过返回值类型来判断方法是不是重载了。

3、重载的方法可以改变访问修饰符。

4、重载的方法可以声明新的或者更广的建厂异常。

5、方法能够在一个类或者一个子类中被重载。

 

二、方法的重写

 

重写只能出现在继承关系中,只要父类的方法不是final修饰的,都可以重写父类的方法。重写的有点:能够定义某个子类特有的特征。

 

举个栗子:

 

 

 1 /**
 2  * @author 薛定谔的猫
 3  * 重载例子*/
 4 class Animal {
 5     public void eat() {
 6         System.out.println("吃点东西");
 7     } 
 8 }
 9 
10 class Horse extends Animal {
11     public void eat() {
12         System.out.println("吃点草");//实现重载
13         }
14 }

 

 

技术分享 

对于父类继承的抽象方法,要么子类是重写该方法,要么把子类也设为抽象子类。所以抽象方法可以说是必须重写的方法。

 

重写的意义:

  重写可以实现多态,用父类的引用来指向子类对象。

 

举个栗子:

 

 1 /**
 2  * @author 薛定谔的猫
 3  * 重写例子*/
 4 public class Test {
 5     public static void main(String[] args) {
 6         Animal p = new Pig();
 7         p.eat();
 8     }
 9 }
10 
11 
12 class Animal {
13     public void eat() {
14         System.out.println("吃点东西吧");
15     }
16 }
17 
18 class Pig extends Animal {
19     public void eat() {
20         System.out.println("吃点猪食beautiful");
21     }
22 }

 

 

重载原则:(盲目分析):

  使用了什么引用,编译器只会调用引用类所拥有的方法。如果调用子类特有的方法就会报错。也就是说,编译器只看引用;类型,不看对象类型。

 

 

重写方法的规则:

1、重写方法不能比被重写方法限制有更要个的访问限权。(但是可以更加宽泛,父类是包访问,子类的重写方法可以使public访问权限,特别留意toSting())

2、参数列表必须与被重写的方法相同(重写和重载的区别)

3、重写返回类型必须与被重写方法的返回类型相同

4、重写方法不能抛出新的异常,或者比被重载方法声明的检查异常更广的检查异常。但是可以抛出更少,更有限或者不抛出异常

5、final修饰的方法不能被重写

6、一个方法不能被继承,则不能重写他(比如被final修饰的类的方法,还有就是父类的private修饰的方法)

 

好了盲目分析完了,写点代码压压惊。

 

Java-重载、重写(冷静分析)

标签:顺序   int   规则   private   原则   类的方法   实现   修饰符   http   

原文地址:http://www.cnblogs.com/zpoor/p/7609179.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!