java 重载、重写、构造函数详解

时间 2019-11-17

标签 java 重载重写构造函数详解栏目 Java 繁體版

原文原文链接

方法重写java

一、重写 只能出如今继承关系之中。当一个类继承它的父类方法时，都有机会重写该父类的方法。一个特例是父类的方法被标识为final。重写的主要优势是可以定义某个子类型特有的行为。

 class Animal {
       public void eat(){
           System.out.println ("Animal is eating.");
       }
   }
  
   class Horse extends Animal{
       public void eat(){
           System.out.println ("Horse is eating.");
       }
   }

二、对于从父类继承来的抽象方法，要么在子类用重写的方式设计该方法，要么把子类也标识为抽象的。因此抽象方法能够说是必需要被重写的方法。

三、重写的意义。
重写方法能够实现多态，用父类的引用来操纵子类对象，可是在实际运行中对象将运行其本身特有的方法。

   public class Test {
       public static void main (String[] args) {
           Animal h = new Horse();
           h.eat();  
       }
   }

   class Animal {
       public void eat(){
           System.out.println ("Animal is eating.");
       }
   }
  
   class Horse extends Animal{
       public void eat(){
           System.out.println ("Horse is eating.");
       }
       public void buck(){
       }
   }

　　一个原则是：使用了什么引用，编译器就会只调用引用类所拥有的方法。若是调用子类特有的方法，如上例的h.buck(); 编译器会抱怨的（编译错误）。也就是说，编译器只看引用类型，而不是对象类型。

四、重写方法的规则。
　　若想实现一个合格重写方法，而不是重载，那么必须同时知足下面的要求！

A、重写规则之一： 重写方法不能比被重写方法限制有更严格的访问级别。
（可是能够更普遍，好比父类方法是包访问权限，子类的重写方法是public访问权限。）
　　好比：Object类有个toString()方法，开始重写这个方法的时候咱们总容易忘记public修饰符，编译器固然不会放过任何教训咱们的机会。出错的缘由就是：没有加任何访问修饰符的方法具备包访问权限，包访问权限比public固然要严格了，因此编译器会报错的。

B、重写规则之二： 参数列表必须与被重写方法的相同。
　　重写有个孪生的弟弟叫重载，也就是后面要出场的。若是子类方法的参数与父类对应的方法不一样，那么就是你认错人了，那是重载，不是重写。

C、重写规则之三： 返回类型必须与被重写方法的返回类型相同。
　　父类方法A：void eat(){} 子类方法B：int eat(){} 二者虽然参数相同，但是返回类型不一样，因此 不是重写。
　　父类方法A：int eat(){} 子类方法B：long eat(){} 返回类型虽然兼容父类，可是不一样就是不一样，因此 不是重写。

D、重写规则之四： 重写方法不能抛出新的异常或者比被重写方法声明的检查异常更广的检查异常。可是能够抛出更少，更有限或者不抛出异常。

   import java.io.*;
   public class Test {
       public static void main (String[] args) {
           Animal h = new Horse();
           try {
               h.eat();  
           }
           catch (Exception e) {
           }
       }
   }

   class Animal {
       public void eat() throws Exception{
           System.out.println ("Animal is eating.");
           throw new Exception();
       }
   }
  
   class Horse extends Animal{
       public void eat() throws IOException{
           System.out.println ("Horse is eating.");
           throw new IOException();
       }
   }

　　这个例子中，父类抛出了检查异常Exception，子类抛出的IOException是Exception的子类，也便是比被重写的方法抛出了更有限的异常，这是能够的。若是反过来，父类抛出IOException，子类抛出更为宽泛的Exception，那么不会经过编译的。
注意：这种限制只是针对检查异常，至于运行时异常RuntimeException及其子类再也不这个限制之中。

E、重写规则之五： 不能重写被标识为final的方法。

F、重写规则之六： 若是一个方法不能被继承，则不能重写它。
　　比较典型的就是父类的private方法。下例会产生一个有趣的现象。

   public class Test {
       public static void main (String[] args) {
           //Animal h = new Horse();
           Horse h = new Horse();
           h.eat();
       }
   }

   class Animal {
       private void eat(){
           System.out.println ("Animal is eating.");
       }
   }
  
   class Horse extends Animal{
       public void eat(){
           System.out.println ("Horse is eating.");
       }
   }

　　这段代码是能经过编译的。表面上看来违反了第六条规则，但实际上那是一点巧合。Animal类的eat()方法不能被继承，所以 Horse类中的 eat()方法是一个全新的方法，不是重写也不是重载，只是一个只属于Horse类的全新的方法！这点让不少人迷惑了，可是也不是那么难以理解。
　　main()方法若是是这样：

   Animal h = new Horse();
   //Horse h = new Horse();
   h.eat();

　　编译器会报错，为何呢？Horse类的eat()方法是public的啊！应该能够调用啊！请牢记，多态只看父类引用的方法，而不看子类对象的方法！

方法的重载编程

　　重载是友好的，它不要求你在调用一个方法以前转换数据类型，它会自动地寻找匹配的方法。方法的重载是在编译时刻就决定调用哪一个方法了，和重写不一样。最最经常使用的地方就是构造器的重载。

一、基本数据类型参数的重载。app

   public class Test {
       static void method(byte b){
           System.out.println ("method:byte");
       }
       static void method(short s){
           System.out.println ("method:short");
       }
       static void method(int i){
           System.out.println ("method:int");
       }
       static void method(float f){
           System.out.println ("method:float");
       }
       static void method(double d){
           System.out.println ("method:double");
       }
       public static void main (String[] args) {
           method((byte)1);
           method('c');
           method(1);
           method(1L);
           method(1.1);
           method(1.1f);
       }
   }

输出结果：函数

method:byte
method:int
method:int
method:float
method:double
method:float

　　能够看出：首先要寻找的是数据类型正好匹配方法。若是找不到，那么就提高为表达能力更强的数据类型，如上例没有正好容纳long的整数类型，那么就转换为 float类型的。若是经过提高也不能找到合适的兼容类型，那么编译器就会报错。反正是不会自动转换为较小的数据类型的，必须本身强制转换，本身来承担转变后果。

　　char类型比较特殊，若是找不到正好匹配的类型，它会转化为int而不是short，虽然char是16位的。

二、重载方法的规则。

A、被重载的方法必须改变参数列表。
参数必须不一样，这是最重要的！不一样有两个方面，参数的个数，参数的类型，参数的顺序。

B、被重载的方法与返回类型无关。
也就是说，不能经过返回类型来区分重载方法。

C、被重载的方法能够改变访问修饰符。
没有重写方法那样严格的限制。

D、被重载的方法能够声明新的或者更广的检查异常。
没有重写方法那样严格的限制。

E、方法可以在一个类中或者在一个子类中被重载。

三、带对象引用参数的方法重载。this

   class Animal {}
   class Horse extends Animal{}
  
   public class Test {
       static void method(Animal a){
           System.out.println ("Animal is called.");
       }
       static void method(Horse h){
           System.out.println ("Horse is called.");
       }
       public static void main (String[] args) {
           Animal a = new Animal();
           Horse h = new Horse();
           Animal ah = new Horse();
          
           method(a);
           method(h);
           method(ah);
        }
   }

输出结果是：编码

Animal is called.
Horse is called.
Animal is called.

　　前两个输出没有任何问题。第三个方法为何不是输出“Horse is called.”呢？仍是那句老话，要看引用类型而不是对象类型，方法重载是在编译时刻就决定的了，引用类型决定了调用哪一个版本的重载方法。

四、重载和重写方法区别的小结。
　　若是能完全弄明白下面的例子，说明你对重载和重写很是了解了，能够结束这节的复习了。spa

   class Animal {
       public void eat(){
           System.out.println ("Animal is eating.");  
       }
   }
   class Horse extends Animal{
       public void eat(){
           System.out.println ("Horse is eating.");  
       }
       public void eat(String food){
           System.out.println ("Horse is eating " + food);
       }
   }
  
   public class Test {
       public static void main (String[] args) {
           Animal a = new Animal();
           Horse h = new Horse();
           Animal ah = new Horse();
          
           a.eat();
           h.eat();
           h.eat("apple");
           ah.eat();
           //a.eat("apple");
           //ah.eat("apple");
        }
   }

四个输出分别是什么？被注释的两条语句为何不能经过编译？
第一条：a.eat(); 普通的方法调用，没有多态，没什么技术含量。调用了Animal类的eat()方法，输出：Animal is eating.
第二条：h.eat(); 普通的方法调用，也没什么技术含量。调用了Horse类的eat()方法，输出：Horse is eating.
第三条：h.eat("apple"); 重载。Horse类的两个eat()方法重载。调用了Horse类的eat(String food)方法，输出：Horse is eating apple
第四条：ah.eat(); 多态。前面有例子了，不难理解。输出：Horse is eating.
第五条：a.eat("apple"); 低级的错误，Animal类中没有eat(String food)方法。所以不能经过编译。
第六条：ah.eat("apple"); 关键点就在这里。解决的方法仍是那句老话，不能看对象类型，要看引用类型。Animal类中没有eat(String food)方法。所以不能经过编译。

小结一下：多态不决定调用哪一个重载版本；多态只有在决定哪一个重写版本时才起做用。
重载对应编译时，重写对应运行时。够简洁的了吧！

设计

构造方法code

　　构造方法是一种特殊的方法，没有构造方法就不能建立一个新对象。实际上，不只要调用对象实际类型的构造方法，还要调用其父类的构造方法，向上追溯，直到 Object类。构造方法没必要显式地调用，当使用new关键字时，相应的构造方法会自动被调用。

一、构造方法的规则。
A、构造方法能使用任何访问修饰符。包括private，事实上java类库有不少都是这样的，设计者不但愿使用者建立该类的对象。

B、构造方法的名称必须与类名相同。这样使得构造方法不同凡响，若是咱们遵照sun的编码规范，彷佛只有构造方法的首字母是大写的。

C、构造方法不能有返回类型。
反过来讲，有返回类型的不是构造方法对象

   public class Test {
       int Test(){
           return 1;
       }
   }

　　这个方法是什么东西？一个冒充李逵的李鬼而已，int Test()和其余任何普通方法没什么两样，就是普通的方法！只不过看起来很恶心，相似恶心的东西在考试卷子里比较多。

D、如果不在类中建立本身的构造方法，编译器会自动生成默认的不带参数的构造函数。
　　这点很容易验证！写一个这样简单的类，编译。

class Test {
}

对生成的Test.class文件反编译：javap Test，能够看到：

D:"JavaCode"bin>javap Test
Compiled from "Test.java"
class Test extends java.lang.Object{
    Test();
}

　　看到编译器自动添加的默认构造函数了吧！

E、若是只建立了带参数的构造方法，那么编译器不会自动添加无参的构造方法的！

F、在每一个构造方法中，若是使用了重载构造函数this()方法，或者父类的构造方法super()方法，那么this()方法或者super()方法必须放在第一行。并且这两个方法只能选择一个，所以它们之间没有顺序问题。

G、除了编译器生成的构造方法，并且没有显式地调用super()方法，那么编译器会插入一个super()无参调用。

H、抽象类有构造方法。

静态方法的重载与重写（覆盖）

一、静态方法是不能被覆盖的。能够分两种状况讨论：

A、子类的非静态方法“覆盖”父类的静态方法。
　　这种状况下，是不能经过编译的。

class Father{
     static void print(){
         System.out.println ( " in father   method " );
     }
}
class Child extends Father{
     void print(){
         System.out.println ( " in child method " );
     }
}

　　static方法表示该方法不关联具体的类的对象，能够经过类名直接调用，也就是编译的前期就绑定了，不存在后期动态绑定，也就是不能实现多态。子类的非静态方法是与具体的对象绑定的，二者有着不一样的含义。

B、子类的静态方法“覆盖”父类静态方法。
　　这个覆盖依然是带引号的。事实上把上面那个例子Child类的print方法前面加上static修饰符，确实能经过编译！可是不要觉得这就是多态！多态的特色是动态绑定，看下面的例子：

class Father{
     static void print(){
         System.out.println ( " in father   method " );
     }
}
class Child extends Father{
     static void print(){
         System.out.println ( " in child method " );
     }
}

class Test{
     public static void main (String[] args) {
         Father f = new Child();
         f.print();
     }
}

　　输出结果是：in father method
　　从这个结果能够看出，并无实现多态。
　　可是这种形式很迷惑人，貌似多态，实际编程中千万不要这样搞，会把你们搞懵的！
　　它不符合覆盖表现出来的特性，不该该算是覆盖！
　　总而言之，静态方法不能被覆盖。

二、静态方法能够和非静态方法同样被重载。
这样的例子太多了，我不想写例程了。看看java类库中不少这样的例子。
如java.util.Arrays类的一堆重载的binarySearch方法。
在这里提一下是由于查资料时看到这样的话“sun的SL275课程说，静态方法只能控制静态变量（他们自己没有），静态方法不能被重载和覆盖……”
你们不要相信啊！能够重载的。并且静态与非静态方法能够重载。

从重载的机制很容易就理解了，重载是在编译时刻就决定的了，非静态方法均可以，静态方法怎么可能不会呢？

　　致谢：感谢您的耐心阅读！