Java のオーバーロード、書き換え、コンストラクターの詳細な説明

この記事では、主に Java のオーバーロード、書き換え、およびコンストラクターの例の詳細な説明に関する関連情報を紹介します。この記事を通じて、Java オブジェクト指向のメソッドを理解して習得できることを願っています。オーバーロードと書き換え 書き方とコンストラクターの例を詳しく解説

メソッドのオーバーライド

1. オーバーライドは継承関係でのみ使用できます。クラスが親クラスからメソッドを継承する場合、親クラスのメソッドをオーバーライドする機会があります。特殊なケースは、親クラスのメソッドが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.");
    }
  }

2. 親クラスから継承された抽象メソッドの場合は、サブクラスでオーバーライドしてメソッドを設計するか、サブクラスを抽象としてマークします。したがって、抽象メソッドは書き換える必要があるメソッドであると言えます。

3.書き換えの意味。

オーバーライドメソッドはポリモーフィズムを達成し、親クラスからの参照を使用してサブクラスオブジェクトを操作できますが、実際の操作ではオブジェクトは独自の一意のメソッドを実行します。

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(){
    }
  }

原則の 1 つは、どのような参照が使用されるかに関係なく、コンパイラーは参照クラスが所有するメソッドのみを呼び出すということです。上記の例の h.buck() などのサブクラス固有のメソッドを呼び出すと、コンパイラはエラーを返します (コンパイル エラー)。つまり、コンパイラはオブジェクト型ではなく参照型のみを調べます。

4. メソッドの書き換えに関するルール。

オーバーロードではなく修飾された書き換えメソッドを実装したい場合は、次の要件を同時に満たす必要があります。

A. 書き換えルールの 1 つ: オーバーライドするメソッドは、オーバーライドされるメソッドよりも制限的なアクセス レベルを持つことはできません。

(ただし、より広範囲になる可能性があります。たとえば、親クラスのメソッドにはパッケージのアクセス権があり、サブクラスのオーバーライドされたメソッドにはパブリックのアクセス権があります。)

例: Object クラスには toString() メソッドがあります。これは常にそうです。このメソッドのオーバーライドを開始するのは簡単です。 public 修飾子を忘れてください。もちろん、コンパイラーは教訓を与える機会を逃しません。エラーの理由は、アクセス修飾子のないメソッドにはパッケージへのアクセス権があるため、パッケージへのアクセス権はパブリックよりも厳しいため、コンパイラはエラーを報告します。

B. 書き換えルール 2: パラメーター リストはオーバーライドされたメソッドのリストと同じである必要があります。

Rewriteには、後で登場するオーバーロードという双子の兄弟がいます。サブクラスのメソッドのパラメータが親クラスの対応するメソッドと異なる場合、それはオーバーライドではなくオーバーロードです。

C. ルール 3 の書き換え: **戻り値の型は、オーバーライドされたメソッドの戻り値の型と同じである必要があります。

親クラスのメソッド A: void Eat(){} サブクラスのメソッド B: int Eat(){} パラメータは同じですが、戻り値の型が異なるため、オーバーライドされません。 **

親クラスのメソッド A: int Eat(){} サブクラスのメソッド B: long Eat(){} 戻り値の型は親クラスと互換性がありますが、違いが異なるためオーバーライドではありません。

D. オーバーライド ルール 4: オーバーライドするメソッドは、新しい例外や、オーバーライドされるメソッドによって宣言されたチェック例外よりも広いチェック例外をスローできません。ただし、スローする例外の数を減らしたり、より限定したり、あるいは例外をスローしないようにすることも可能です。

import java.io.*;
  /**
  * Java学习交流QQ群：589809992 我们一起学Java！
  */
  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 をスローし、サブクラスがより広範な例外をスローした場合、そのクラスはコンパイルされません。
注: この制限は、ランタイム例外 RuntimeException およびそのサブクラスにのみ適用されます。

E. 書き換えルール 5: Final としてマークされたメソッドはオーバーライドできません。

F. 書き換えルール 6: メソッドを継承できない場合は、オーバーライドできません。

代表的なものは親クラスの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.");
    }
  }

このコードはコンパイルできます。表面的にはルール 6 に違反しているように見えますが、実際にはちょっとした偶然でした。 Animal クラスの Eat() メソッドは継承できないため、Horse クラスの Eat() メソッドは、書き換えやオーバーロードではなく、Horse クラスにのみ属するまったく新しいメソッドです。これは多くの人を混乱させますが、理解するのはそれほど難しいことではありません。

main() メソッドが次のような場合:

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

コンパイラーはエラーを報告します。なぜですか? Horse クラスの Eat() メソッドが公開されました。呼び出せるはずですよ！ポリモーフィズムは、サブクラス オブジェクトのメソッドではなく、親クラスによって参照されるメソッドのみを参照することに注意してください。

メソッドのオーバーロード

オーバーロードはフレンドリーであり、メソッドを呼び出す前にデータ型を変換する必要はなく、一致するメソッドが自動的に検索されます。メソッドのオーバーロードは、オーバーライドとは異なり、コンパイル時に呼び出すメソッドを決定します。最も一般的に使用されるのは、コンストラクターのオーバーロードです。

1. 基本的なデータ型パラメーターのオーバーロード。

/**
 * Java学习交流QQ群：589809992 我们一起学Java！
 */
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位的。

2、重载方法的规则。

A、被重载的方法必须改变参数列表。

参数必须不同，这是最重要的！不同有两个方面，参数的个数，参数的类型，参数的顺序。

B、被重载的方法与返回类型无关。

也就是说，不能通过返回类型来区分重载方法。

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

没有重写方法那样严格的限制。

D、被重载的方法可以声明新的或者更广的检查异常。

没有重写方法那样严格的限制。

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

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

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.”呢？还是那句老话，要看引用类型而不是对象类型，方法重载是在编译时刻就决定的了，引用类型决定了调用哪个版本的重载方法。

4、重载和重写方法区别的小结。

如果能彻底弄明白下面的例子，说明你对重载和重写非常了解了，可以结束这节的复习了。

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)方法。因此不能通过编译。

小结一下：多态不决定调用哪个重载版本；多态只有在决定哪个重写版本时才起作用。

重载对应编译时，重写对应运行时。够简洁的了吧！

构造方法

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

1、构造方法的规则。

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、抽象类有构造方法。

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

1、静态方法是不能被覆盖的。可以分两种情况讨论：

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

从这个结果可以看出，并没有实现多态。

但是这种形式很迷惑人，貌似多态，实际编程中千万不要这样搞，会把大家搞懵的！

它不符合覆盖表现出来的特性，不应该算是覆盖！

总而言之，静态方法不能被覆盖。

2、静态方法可以和非静态方法一样被重载。

这样的例子太多了，我不想写例程了。看看java类库中很多这样的例子。

如java.util.Arrays类的一堆重载的binarySearch方法。

在这里提一下是因为查资料时看到这样的话“sun的SL275课程说，静态方法只能控制静态变量（他们本身没有），静态方法不能被重载和覆盖……”

大家不要相信啊！可以重载的。而且静态与非静态方法可以重载。

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

以上がJava のオーバーロード、書き換え、コンストラクターの詳細な説明の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。