3、クラスと対象の抽象クラス、インタフェース、内部クラス

抽象クラスとインタフェース:
この2つの概念はいつも一緒に議論されています.彼らには似たようなところがたくさんあるので、インタフェース自体が完全に抽象的だと言えます.抽象クラスよりも「抽象的」です.なぜそう言いますか.抽象クラスは一種で、中には抽象的な方法のほかに、具体的な方法もありますが、インタフェースの中には抽象的な方法(インタフェースでクラスを定義できる場合もありますが、後で話します)でなければなりません.abstractキーワードで宣言されていない場合もあります.ここでは抽象的な方法についてお話しします.Javaでは、abstract void function()のような方法で宣言されています.すべて抽象的な方法で、抽象的な方法を含むクラスは抽象的なクラスで、このようにまとめることができます:抽象的なクラスの中ですべて実体的な方法です;抽象的な方法ばかりでもいいです.抽象的な方法のあるクラスは抽象的なクラスでなければならない.
 
抽象クラスを継承する場合は、その抽象メソッドを書き直さなければならないので、抽象クラスはfinalタイプとして宣言できません.finalキーワードを付けたクラスは継承できないことを保証しているので、抽象クラスは継承され、インスタンス化されません(abstract宣言のクラスであれば).
インタフェースとして宣言されたクラスはインタフェースであり、抽象クラスよりも抽象的なメカニズムである.インタフェースでは、abstractキーワードを追加することなく、すべてのメソッドが抽象的でなければなりませんが、コンパイラはインタフェース内のメソッドに対して、直接抽象的なメソッドで処理されます.私たちはimplementsを通じてインタフェースを実現します.インタフェースを実装する場合は、すべての方法を書き直さなければなりません.
 
Javaマルチインタフェース実装
 
interfaceは抽象的な方法とエンティティの方法を分離する構造を提供してくれたが、interfaceの役割はそれだけではなく、Javaではインタフェースが非常に重要な問題を解決した:マルチ継承.C++では多重継承を実現するのは比較的簡単なことであるが,Java継承メカニズムでは多重継承は許されないため,異なるクラスの機能を統合するにはインタフェースを使用する必要がある.
インタフェースを使用するメリットをまとめます.
1、インタフェースは上への転換を実現することができ、複数の共通属性を持つクラスはそれらの共通点を抽出し、抽象化することができ、このように階層がはっきりし、統一的に管理する.
 

class A implements interA,interB,interC{
       @overide 
        somemethod(){... ...}
}
class B{
       method(interA a){a.fun1()};
       method(interB a){a.fun2()};
       method(interC a){a.fun3()};
       main(){method(new A);}
}
                  ，           ；

 
 
 
2、インタフェースにはエンティティメソッドがなく、ベースクラスに最適です.
 
抽象クラスとインタフェースの違いと関連をまとめます.
 
a)抽象クラスはクラスであり,実体メソッドがある.
 
b)抽象クラスはマルチ継承を実現できないが,インタフェースは可能である.
 
c)メソッド定義およびメンバー変数を持たないベースクラスを作成する必要がある場合は、インタフェースを使用し、クラスに特定の実装の一部が必要な場合は抽象クラスを使用します.
 
d)事前にクラスをベースクラスとして設計したい場合は、インタフェースが優先される.
インタフェースは、インタフェースを継承することによって機能を拡張することができる.
インタフェースの変数(ドメイン)のデフォルトはpublic final staticなのでinterfaceで宣言された変数は大文字を推奨し、宣言時に初期化しなければならず、使用時に明示的に宣言されたpublic final static String NAMEを変更することはできません.暗黙的に宣言されたString NAME;
 
内部クラス
 
内部クラスとは、クラスの定義を別のクラスの内部に置くことを意味します.合理的な内部クラスの使用により、コードがより簡潔になり、プログラムがより巧みになることがあります.外部クラスのメンバーとして、内部クラスは外部クラスのプライベートメンバー変数にアクセスできます.まず、内部クラスの作成を見てみましょう.
1.外部クラスの非静的メソッドで内部クラスインスタンスを作成します.

class InnerClass {  
    class A{  
        int a = 10;  
        void b(){  
            System.out.println("this is A.b()!");  
        }  
    }  
    A getA(){
     A a=new A();       
    return a;         //                 ，    a     ；
    }
}
public class Extends {	
  public static void main(String[] args){	  
	  new InnerClass().getA().b();
  }
} 

 
2.外部クラスの静的メソッドで内部クラスのインスタンスを作成します.
外部クラスの静的メソッドで内部クラスを作成する場合は、static class A{}などの内部クラスも静的でなければなりません.
ここでなぜclass Aにstaticを付けなければならないのですか?

public class InnerClass {  
	static class A{  
        int a = 10;  
        void b(){  
            System.out.println("this is A.b()!");  
        }  
    }  
    public static void main(String[] args) {  
        InnerClass.build().b();  
    }  
    static A build(){    //             ，       
        A a =new A();     
        return a;
    }  
} 

内部クラスが非静的である場合:
 

public class InnerClass {  
    class A{  
        int a = 10;  
        void b(){  
            System.out.println("this is A.b()!");  
        }  
    }     
    public static void main(String[] args) {  
        InnerClass ic = new InnerClass();  
        InnerClass.A aa = ic.new A();  
        aa.b();  
    }  
}  

、内部クラスの非静的メソッドで外部クラスのインスタンスを作成します.(外部クラス.thisを使用して外部クラスのインスタンスを作成)
 
ここで、内部クラスが外部クラスを作成できるのはなぜですか?Jvmメカニズムと関係があるはずで、後の章で詳しく説明します.
 

public class InnerClass {  
    class A{  
        int a = 10;  
        void build(){  
            InnerClass ic = InnerClass.this;   //  this     
            ic.a();  
        }  
    }  
    void a(){  
        System.out.println("this is InnerClass.a()!");  
    }  
}  

、内部クラスの静的メソッドで外部クラスのインスタンスを作成します.(直接newで作成)
 
 

public class InnerClass {  
    static class A{  
        int a = 10;  
        static void build(){  
            InnerClass ic = new InnerClass();  
            ic.a();  
        }  
    }      
    void a(){  
        System.out.println("this is InnerClass.a()!");  
    }  
} 

、その他のクラスにおける内部クラスインスタンスの作成
 
 

class B {  
    class A{  
        void a(){  
            System.out.println("this is A.a()!");  
        }  
    }  
    static class C{  
        void c(){  
            System.out.println("this is C.c()!");  
        }  
    }  
}  
 public class AKL{  
    public static void main(String[] args){  
        /*        */  
        B ic = new B();  
        B.A a = ic.new A();  
        a.a();  
          
        /*       */  
        B.C c = new B.C();  
        c.c();  
    }  
}  

深層ネストを見てください.
 
 

public class ABC {  
    void a() {  
        System.out.println("this is A.a()!");  
    }  
  
    class B {  
        void b() {  
            System.out.println("this is B.b()!");  
        }  
        class C {  
            void c() {  
                a();  
                b();  
                System.out.println("this is C.c()!");  
            }  
        }  
    }  
    public static void main(String[] args) {  
        ABC abc = new ABC();  
        ABC.B b = abc.new B();  
        ABC.B.C c = b.new C();  
        c.c();  
    }  
}  

&&:ここで最も重要なのはこれです」.newオペレータ.また、クラスCの内部でa()とb()を呼び出すのは簡単です.内部クラスはprivate権限でも同じクラスにあるため、一般的な変数に相当します.
 
匿名の内部クラスの作成:
 

interface A {  
    void a();  
}  
  
public class InnerClass_NoName {  
    public A test() {   //      A    (     )
        return new A() {  
            public void a() {  
                System.out.println("");  
            }  
        };  
    }  
  
    public static void main(String[] args) {  
        InnerClass_NoName icn = new InnerClass_NoName();  
        A a = icn.test();  
        a.a();    //a         ，           
    }  
}  

は、典型的には、内部クラスがクラスから継承されるか、インタフェースが実装され、内部クラスのコード操作によってその周辺クラスのオブジェクトが作成される.内部クラスは、その周辺クラスに入るウィンドウを提供していると考えられます.内部クラスを使用する最も魅力的な理由は、各内部クラスが1つの(インタフェースの)実装から独立して継承できるため、周辺クラスが1つの(インタフェースの)実装を継承しているかどうかにかかわらず、(インタフェースの)実装は、内部クラスには影響しません.内部クラスが提供する複数の具体的または抽象的なクラスを継承できる能力がなければ、いくつかの設計とプログラミングの問題は解決しにくいです.この観点から、内部クラスは
多重継承のソリューションが完全になりました.インタフェースは一部の問題を解決し、内部クラスは効果的に実現した.
多重継承 ”.一般的に、内部類は長すぎるべきではありません.そうしないと、頭が重くて足が軽いように見えます.
 
匿名の内部クラスを使用するには、次の点に注意してください.
a)匿名内部クラスは構築方法にならない
b)匿名内部クラスは、静的メンバー、メソッド、クラスを定義することはできません.
c)匿名内部クラスはpublic,protected,private,staticではない.
d)匿名内部クラスのインスタンスは1つしか作成できません.
e)匿名の内部クラスは、newの後ろにあり、インタフェースを暗黙的に実装したり、クラスを実装したりするに違いない.
 
f)匿名内部クラスはローカル内部クラスであるため,ローカル内部クラスのすべての制限が有効となる.
 
 
内部クラスには、メンバー内部クラス、静的ネストクラス、メソッド内部クラス、匿名内部クラスがあります.いくつかの内部クラスの共通性:A、内部クラスは依然として独立したクラスであり、コンパイル後に内部クラスが独立してコンパイルされる.classファイルですが、前に外部クラスのクラス名と$記号が冠されています.B、内部クラスは普通の方法でアクセスできません.内部クラスは外部クラスのメンバーであるため、privateの有無にかかわらず、内部クラスは外部クラスのメンバー変数に自由にアクセスできます.

1、     ：    
    class Outer {
        class Inner{}
    }       
             ：Outer.class Outer$Inner.class。
                ！          。
    class Inner{
        static int a = 10;
    } 

技術的には、静的ネストクラスは内部クラスに属しません.内部クラスは外部クラスと特殊な関係を共有するため、より正確にはインスタンスの共有関係である.静的ネストクラスには上記の関係はありません.別のクラスの内部に位置するだけなので、トップクラスのネストクラスとも呼ばれます.静的とは、内部クラスが他の静的メンバーのように、外部クラスオブジェクトがない場合にもアクセスできることを意味します.静的ネストされたクラスは、外部クラスのメンバーおよびメソッドにアクセスできません.

public class InnerClass {  
    static class A{  
        static int a = 10;  
        static void a(){  
            System.out.println("this is A.a()!");  
        }  
    }  
}  

インタフェースの内部クラス:

public interface Interface_Class {  
    void say();  
    class IC implements Interface_Class{  
        @Override  
        public void say() {  
            System.out.println("hello");  
        }  
        
    }  
}  

このインタフェースを実装したすべてのクラスで使用できる共通コードの作成に適しています.
内部クラスの継承は、内部クラスが外部クラスへの参照を持っていると述べています.したがって、継承するときは、この「隠された」参照を初期化する必要があります.次のコードを参照してください.

class AAA {  
    class BBB {   
    }  
}  
public class InnerClass_Extends extends AAA.BBB {  
    public InnerClass_Extends(AAA aaa) {  
        aaa.super();  
    }  
    public static void main(String[] args) {  
        AAA aaa = new AAA();  
        InnerClass_Extends ice = new InnerClass_Extends(aaa);  
    }  
} 

最後に、内部クラスを使用する理由をまとめます.各内部クラスは、外部クラスがインタフェースを実装しているかどうかにかかわらず、1つのインタフェースから独立して継承できるためです.
もっと簡単に言えば、内部クラスはJavaマルチ継承メカニズムの完璧な補完であり、現在抽象クラスでマルチ継承を実現しなければならない場合は、明らかに不可能であり、ここでは内部クラスを使用しなければならない.
 

   
public abstract class Pencil {
  public abstract void write();
}
    
public abstract class Eraser {
  public abstract void erase();
} 
        :
public class PencilWithEraser {     
    private MyPencil pencil = new MyPencil();   
    private MyEraser eraser = new MyEraser();   
    private class MyPencil extends Pencil {   
        public void write() {   
            System.out.println("Use to write");   
        }   
    }   
    private class MyEraser extends Eraser {   
        public void erase() {   
            System.out.println("Use to erase");   
        }   
    }   
    public void write() {   
        pencil.write();   
    }   
    public void erase() {   
        eraser.erase();   
  

 
もしあなたが達人なら、366437263、もしあなたが菜鳥なら、私たちと一緒に進歩しましょう.
勉強を続けてください.