标签：顺序 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修饰的方法）
好了盲目分析完了，写点代码压压惊。
标签：顺序 int 规则 private 原则 类的方法 实现 修饰符 http
原文地址：http://www.cnblogs.com/zpoor/p/7609179.html
