サブクラスはプライベートフィールドを継承しますか？

これはインタビューの質問です。

サブクラスはプライベートフィールドを継承しますか？

「通常のOOP方法」ではアクセスできないため、「いいえ」と答えました。しかし、インタビュアーはそれらが継承されていると考えています。これは、そのようなフィールドに間接的にまたはリフレクションを使用してアクセスでき、それらはまだオブジェクトに存在しているためです。

私が戻ってきた後、私はjavadocで次の引用を見つけました：

スーパークラスのプライベートメンバー

サブクラスは、親クラスのプライベートメンバーを継承しません。

インタビュアーの意見について何か議論はありますか？

ここでの質問/回答の混乱のほとんどは、継承の定義を取り囲んでいます。

@DigitalRossが説明するように、サブクラスのOBJECTにはスーパークラスのプライベートフィールドが含まれている必要があります。彼が述べているように、プライベートメンバーへのアクセスがないことはそこに存在しないことを意味しません。

しかしながら。これは、クラスの継承の概念とは異なります。セマンティクスの問題があるJavaの世界の場合と同様に、アービターはJava言語仕様（現在は第3版）です。

JLSが述べるように（https://docs.oracle.com/javase/specs/jls/se8/html/jls-8.html#jls-8.2）：

プライベートとして宣言されたクラスのメンバーは、そのクラスのサブクラスによって継承されません。保護またはパブリックとして宣言されたクラスのメンバーのみが、クラスが宣言されているもの以外のパッケージで宣言されたサブクラスによって継承されます。

このアドレスは、正確な質問は、インタビュアーが提起：「サブんクラスは、プライベートフィールドを継承します」。（私が追加した強調）

答えは「いいえ」です。サブクラスのOBJECTSには、スーパークラスのプライベートフィールドが含まれています。サブクラス自体には、そのスーパークラスのプライベートフィールドはありません。

それは知識人の本質の意味論ですか？はい。面接で役立つ質問ですか？おそらく違います。しかし、JLSはJavaの世界の定義を確立し、（この場合は）明確に定義します。

編集済み（Bjarne Stroustrupからの並列引用を削除しました。これは、JavaとC ++の違いにより、おそらく混乱を増すだけです。私はJLSに答えを任せます:)

はい

クラスは 2つありますが、オブジェクトは1つしかないことを理解することが重要です。

つまり、もちろん、プライベートフィールドを継承しています。これらは、おそらく適切なオブジェクト機能に不可欠であり、親クラスのオブジェクトは派生クラスのオブジェクトではありませんが、派生クラスのインスタンスはほとんどの場合、親クラスのインスタンスです。すべてのフィールドがなければ、それは非常によくありません。

いいえ、直接アクセスすることはできません。はい、継承されます。彼らはする必要があります。

いい質問ですね！

更新：

エラー、「いいえ」

まあ、私たちはみんな何かを学んだと思います。以来JLSは、正確な文言「継承されていない」を発信し、答えるために正しい「ノー」。サブクラスはプライベートフィールドにアクセスまたは変更できないため、言い換えると、継承されません。しかし、実際には1つのオブジェクトしかなく、実際にはプライベートフィールドが含まれているため、誰かがJLSとチュートリアルで間違った言い方をした場合、OOP、Javaオブジェクト、そして実際に何が起こっているのかを理解するのは非常に困難です。

更新して更新：

ここでの論争には根本的な曖昧さが含まれています。正確に何が議論されているのですか？オブジェクト？ それとも、クラス自体について何らかの意味で話しているのですか？ オブジェクトとは対照的に、クラスを記述する場合は、かなりの自由度が許されます。したがって、サブクラスはプライベートフィールドを継承しませんが、サブクラスのインスタンスであるオブジェクトにはプライベートフィールドが含まれています。

いいえ。プライベートフィールドは継承されません...そのため、Protectedが発明されました。仕様によるものです。これは保護された修飾子の存在を正当化したと思います。

今コンテキストに来ています。継承とはどういう意味ですか？派生クラスから作成されたオブジェクトにある場合はどうでしょうか。はい、そうです。

もし意味があれば、派生クラスに役立つかもしれません。うーん、ダメ。

さて、関数型プログラミングになると、スーパークラスのプライベートフィールドは、サブクラスにとって意味のある方法で継承されません。サブクラスの場合、スーパークラスのプライベートフィールドは他のクラスのプライベートフィールドと同じです。

機能的には継承されません。しかし、理想的にはそうです。

OK、Javaチュートリアルを調べたところ、次のように引用されています。

スーパークラスのプライベートメンバー

サブクラスは、親クラスのプライベートメンバーを継承しません。ただし、スーパークラスにプライベートフィールドにアクセスするためのパブリックメソッドまたは保護メソッドがある場合、これらもサブクラスで使用できます。

参照：http : //download.oracle.com/javase/tutorial/java/IandI/subclasses.html

私はその分野がそこにあることに同意します。ただし、サブクラスはそのプライベートフィールドに対する権限を取得しません。サブクラスにとって、プライベートフィールドは他のクラスのプライベートフィールドと同じです。

純粋に視点の問題だと思います。あなたはどちらの側でも議論を形作ることができます。それは両方の方法を正当化する方が良いです。

「継承」の定義に依存します。サブクラスにはまだメモリ内のフィールドがありますか？間違いなく。それらに直接アクセスできますか？いいえ。定義の微妙な問題です。ポイントは、実際に何が起こっているのかを理解することです。

コードで概念を示します。サブクラスは実際にはスーパークラスのプライベート変数を継承します。唯一の問題は、スーパークラスのプライベート変数にパブリックゲッターとセッターを提供しない限り、子オブジェクトにアクセスできないことです。

パッケージDumpの2つのクラスを考えます。子は親を拡張します。

私の記憶が正しければ、メモリ内の子オブジェクトは2つの領域で構成されます。1つは親パーツのみで、もう1つは子パーツのみです。子は、親のパブリックメソッドを介してのみ、親のコードのプライベートセクションにアクセスできます。

このように考えてください。ボラットの父親であるボルトクには、10万ドルの金庫があります。彼は「プライベート」変数を安全に共有したくありません。したがって、彼は金庫の鍵を提供しません。ボラットは金庫を相続します。しかし、彼がそれを開くことさえできないならば、それはどんなに良いことですか？彼のお父さんだけが鍵を提供していたなら。

親-

package Dump;

public class Parent {

    private String reallyHidden;
    private String notReallyHidden;

    public String getNotReallyHidden() {
        return notReallyHidden;
    }

    public void setNotReallyHidden(String notReallyHidden) {
        this.notReallyHidden = notReallyHidden;
    }

}//Parent

子 -

package Dump;

public class Child extends Parent {

    private String childOnly;

    public String getChildOnly() {
        return childOnly;
    }

    public void setChildOnly(String childOnly) {
        this.childOnly = childOnly;
    }

    public static void main(String [] args){

        System.out.println("Testing...");
        Child c1 = new Child();
        c1.setChildOnly("childOnly");
        c1.setNotReallyHidden("notReallyHidden");

        //Attempting to access parent's reallyHidden
            c1.reallyHidden;//Does not even compile

    }//main

}//Child

いいえ、継承しません。

他のクラスがそれを間接的に使用するという事実は、継承については何も言わず、カプセル化についてです。

例えば：

class Some { 
   private int count; 
   public void increment() { 
      count++;
   }
   public String toString() { 
       return Integer.toString( count );
   }
}

class UseIt { 
    void useIt() { 
        Some s = new Some();
        s.increment();
        s.increment();
        s.increment();
        int v = Integer.parseInt( s.toString() );
        // hey, can you say you inherit it?
     }
}

また、リフレクションによってcount内部の値を取得することもできますUseIt。それは意味しません、あなたはそれを継承します。

更新

値は存在しますが、サブクラスには継承されません。

たとえば、次のように定義されたサブクラス：

class SomeOther extends Some { 
    private int count = 1000;
    @Override
    public void increment() { 
        super.increment();
        count *= 10000;
    }
}

class UseIt { 
    public static void main( String ... args ) { 
        s = new SomeOther();
        s.increment();
        s.increment();
        s.increment();
        v = Integer.parseInt( s.toString() );
        // what is the value of v?           
     }
}

これは最初の例とまったく同じ状況です。属性countは非表示になり、サブクラスにはまったく継承されません。それでも、DigitalRossが指摘するように、価値はありますが、継承に関するものではありません。

このようにしてください。もしあなたの父親が裕福でクレジットカードを渡したとしても、あなたは彼のお金で物を買うことができますが、あなたがそのすべてのお金を相続したということではありませんか？

その他のアップデート

ただし、属性が存在する理由を知ることは非常に興味深いことです。

率直に言って、正確な用語はありませんが、「継承されていない」親定義もロードするのはJVMとその動作方法です。

実際に親を変更しても、サブクラスは引き続き機能します。

例えば：

//A.java
class A {
   private int i;
   public String toString() { return ""+ i; }
}
// B.java
class B extends A {}
// Main.java
class Main {
   public static void main( String [] args ) {
      System.out.println( new B().toString() );
    }
}
// Compile all the files
javac A.java B.java Main.java
// Run Main
java Main
// Outout is 0 as expected as B is using the A 'toString' definition
0

// Change A.java
class A {
   public String toString() {
      return "Nothing here";
   }
}
// Recompile ONLY A.java
javac A.java
java Main
// B wasn't modified and yet it shows a different behaviour, this is not due to 
// inheritance but the way Java loads the class
Output: Nothing here

正確な用語はここにあると思います： JavaTM仮想マシン仕様

まあ、インタビュアーの質問への私の答えは- プライベートメンバーはサブクラスで継承されませんが、パブリックゲッターまたはセッターメソッドまたは元のクラスのそのような適切なメソッドを介してのみサブクラスまたはサブクラスのオブジェクトにアクセスできます。通常の方法では、メンバーをプライベートに保ち、パブリックなゲッターおよびセッターメソッドを使用してメンバーにアクセスします。では、それらが扱うプライベートメンバーがオブジェクトで使用できない場合に、getterメソッドとsetterメソッドのみを継承することの意味は何でしょうか。ここで「継承された」とは、サブクラスで新しく導入されたメソッドによって遊ぶために、サブクラスで直接利用できることを単に意味します。

以下のファイルをParentClass.javaとして保存し、自分で試してください->

public class ParentClass {
  private int x;

  public int getX() {
    return x;
  }

  public void setX(int x) {
    this.x = x;
  }
}

class SubClass extends ParentClass {
  private int y;

  public int getY() {
    return y;
  }

  public void setY(int y) {
    this.y = y;
  }

  public void setXofParent(int x) {
    setX(x); 
  }
}

class Main {
  public static void main(String[] args) {
    SubClass s = new SubClass();
    s.setX(10);
    s.setY(12);
    System.out.println("X is :"+s.getX());
    System.out.println("Y is :"+s.getY());
    s.setXofParent(13);
    System.out.println("Now X is :"+s.getX());
  }
}

Output:
X is :10
Y is :12
Now X is :13

SubClassのメソッドでParentClassのプライベート変数xを使用しようとすると、変更のために直接アクセスできません（つまり、継承されません）。ただし、xは、setXofParent（）メソッドで行われるように、元のクラスのsetX（）メソッドを介してSubClassで変更できます。または、setX（）メソッドまたは最終的にsetX（）を呼び出すsetXofParent（）メソッドを使用してChildClassオブジェクトを使用して変更できます したがって、ここでsetX（）およびgetX（）は、ParentClassのプライベートメンバーxへの一種のゲートです。

もう1つの簡単な例は、Clockスーパークラスが時間と分をプライベートメンバーとして持ち、適切なゲッターとセッターメソッドをパブリックとして持っていることです。次に、ClockのサブクラスとしてDigitalClockが登場します。ここで、DigitalClockのオブジェクトにhoursとminsのメンバーが含まれていない場合、問題が発生します。

わかりました。これは私がよく調べた非常に興味深い問題であり、スーパークラスのプライベートメンバーがサブクラスのオブジェクトで実際に使用可能（ただしアクセス不可能）であるという結論に達しました。これを証明するために、親クラスと子クラスのサンプルコードを以下に示します。子クラスオブジェクトをtxtファイルに書き込み、ファイル内の 'bhavesh'という名前のプライベートメンバーを読み取っているため、実際に子で使用できることがわかりますクラスですが、アクセス修飾子のためアクセスできません。

import java.io.Serializable;
public class ParentClass implements Serializable {
public ParentClass() {

}

public int a=32131,b,c;

private int bhavesh=5555,rr,weq,refw;
}

import java.io.*;
import java.io.Serializable;
public class ChildClass extends ParentClass{
public ChildClass() {
super();
}

public static void main(String[] args) {
ChildClass childObj = new ChildClass();
ObjectOutputStream oos;
try {
        oos = new ObjectOutputStream(new FileOutputStream("C:\\MyData1.txt"));
        oos.writeObject(childObj); //Writing child class object and not parent class object
        System.out.println("Writing complete !");
    } catch (IOException e) {
    }


}
}

MyData1.txtを開き、「bhavesh」というプライベートメンバーを検索します。皆さんの考えを教えてください。

サブクラスはプライベートフィールドを継承しているように見えます。これは、これらのフィールドがサブクラスの内部動作（哲学的に言えば）で使用されるためです。サブクラスは、そのコンストラクターでスーパークラスコンストラクターを呼び出します。スーパークラスコンストラクターがこれらのフィールドをコンストラクターで初期化した場合、スーパークラスプライベートフィールドは、スーパークラスコンストラクターを呼び出すサブクラスによって明らかに継承されます。これは単なる例です。しかしもちろん、アクセサメソッドがないと、サブクラスはスーパークラスのプライベートフィールドにアクセスできません（iPhoneのバックパネルをポップしてバッテリーを取り出して電話をリセットできないようなものですが、バッテリーはまだ残っています）。

PS私が遭遇した継承の多くの定義の1つ：「継承-派生クラスが基本クラスの機能を拡張し、そのSTATE（強調は私のもの）と動作をすべて継承できるようにするプログラミング手法。」

プライベートフィールドは、サブクラスからアクセスできない場合でも、スーパークラスの継承された状態です。

Javaのプライベートフィールドは継承されると私は答える必要があります。実演させてください：

public class Foo {

    private int x; // This is the private field.

    public Foo() {
        x = 0; // Sets int x to 0.
    }

    //The following methods are declared "final" so that they can't be overridden.
    public final void update() { x++; } // Increments x by 1.
    public final int getX() { return x; } // Returns the x value.

}


public class Bar extends Foo {

    public Bar() {

        super(); // Because this extends a class with a constructor, it is required to run before anything else.

        update(); //Runs the inherited update() method twice
        update();
        System.out.println(getX()); // Prints the inherited "x" int.

    }

}

プログラムBar bar = new Bar();で実行すると、出力ボックスに常に「2」という数字が表示されます。整数「x」はメソッドupdate()とgetX()でカプセル化されているため、整数が継承されていることが証明できます。

混乱は、整数 "x"に直接アクセスできないため、それは継承されないと主張することです。ただし、フィールドやメソッドなど、クラスの静的でないものはすべて継承されます。

ビット/アライメントの埋め込み、およびVTABLEへのオブジェクトクラスの組み込みは考慮されません。したがって、サブクラスのオブジェクトには、スーパークラスのプライベートメンバーのための場所があります。ただし、サブクラスのオブジェクトからはアクセスできません...

いいえ、プライベートフィールドは継承されません。唯一の理由は、サブクラスがそれらに直接アクセスできないことです。

答えは、質問された質問に完全に依存していると思います。つまり、質問が

サブクラスからスーパークラスのプライベートフィールドに直接アクセスできますか？

次に、答えは「いいえ」です。アクセス指定子の詳細を確認すると、プライベートメンバーはクラス自体の内部でのみアクセスできます。

しかし、質問が

サブクラスからスーパークラスのプライベートフィールドにアクセスできますか？

つまり、プライベートメンバーにアクセスするために何をするかは問題ではありません。その場合、スーパークラスでパブリックメソッドを作成し、プライベートメンバーにアクセスできます。したがって、この場合は、プライベートメンバーにアクセスするための1つのインターフェイス/ブリッジを作成しています。

C ++のような他のOOP言語には、friend function他のクラスのプライベートメンバーにアクセスできるという概念があります。

スーパークラスが継承されると、スーパークラスのプライベートメンバーは実際にはサブクラスのプライベートメンバーになり、さらに継承できないか、サブクラスのオブジェクトにアクセスできないと簡単に言えます。

プライベートクラスメンバーまたはコンストラクターは、メンバーまたはコンストラクターの宣言を囲む最上位クラス（§7.6）の本体内でのみアクセスできます。サブクラスには継承されません。https://docs.oracle.com/javase/specs/jls/se7/html/jls-6.html#jls-6.6

サブクラスは、親クラスのプライベートメンバーを継承しません。ただし、スーパークラスにプライベートフィールドにアクセスするためのパブリックメソッドまたは保護メソッドがある場合、これらもサブクラスで使用できます。

プライベートメンバー（状態と動作）は継承されます。これらは、クラスによってインスタンス化されたオブジェクトの動作とサイズに影響を与えることができます。言うまでもなく、これらは、利用可能なすべてのカプセル化解除メカニズムを介して、または実装者が想定できるサブクラスから非常によく見えます。

継承には「事実上の」定義がありますが、「いいえ」の回答によって想定される「可視性」の側面へのリンクはありません。

したがって、外交的である必要はありません。この時点でJLSは間違っています。

それらが「継承」されていないという想定は、安全でなく危険です。

したがって、2つの事実上の（部分的に）矛盾する定義（私は繰り返さない）のうち、従う必要があるのは、より安全な（または安全な）定義のみです。