一、內部類

1.1.1、成員內部類

一個類定義在另一個類的內部,那麽該類就叫作成員內部類

1.1.2、成員內部類訪問方式

方式一：在外部類中提供一個方法創建內部類的對象進行訪問
方式二：在其他類中創建內部類的對象: 格式:外部類.內部類 變量名=new 外部類().new 內部類();

註意：如果是一個靜態的內部類,那麽其他內的創建的格式
外部類.內部類 變量名 = new 外部類.內部類();

方式一：

 1 /* 方式一 */
 2 
 3 //外部類
 4 class Outer{
 5　　　　int 1 = 100;
 6       //成員
 
外部類
 7       class Inner{
 8　　　　　 int i = 10;
 9         public void print(){
10             System.out.println("這是內部類的的print方法!..."+i);
11         }
12     }
13     //在外部的方法中創建內部類的對象,然後調用內部方法
14     public void instance(){
15         Inner inner=new Inner();
16             inner.print();
17     }
18 }
19
 
 class Demo3 {
20     public static void main(String[] args) {
21         Outer o=new Outer();
22             o.instance();
23     }
24 }

方式二：

 1 /* 方式二 */
 2 
 3 //外部類
 4 class Outer{
 5　　　　int i = 100;
 6       //成員外部類
 7       class Inner{
 8　　　　　 int i = 10;
 9         public void print(){
10             System.out.println("這是內部類的的print方法!..."+i);
 
11         }
12     }
13 }
14 class Demo3 {
15     public static void main(String[] args) {
16         Outer.Inner inner = new Outer().new Inner();
17         inner.print();
18     }
19 }

註意：靜態內部類的調用方法

 1 //外部類
 2 class Outer{
 3      int i = 100;
 4      //成員內部類
 5      static class Inner{
 6         static int i = 10;
 7         public void print(){
 8             System.out.println("這是內部類的的print方法!..."+t);
 9         }
10         11     }
12 }
13 class Demo3 {
14     public static void main(String[] args) {
15         Outer.Inner inner=new Outer.Inner();//靜態的內部類
16             inner.print();
17     }
18 }

1.1.3、內部類應用的場景

我們描述A事物的時候,發現描述A事物還存在另外一個比較復雜事物B的時候,而且這個比較復雜的事物B還需要訪問A事物的屬性等數據,那麽這個時候我們就可以使用內部類描述B事物

比如: 人-------->心臟 等等。

class 人{ //外部類
    血液
    氧氣
    等....
    class 心臟{ //內部類
    　　....

    }
}

1.1.4、內部類的好處

　　內部類可以直接訪問外部類的所有成員

1.1.5、內部內需要註意的細節:
　　1.如果內部類和外部類存在同名的成員時,在內部類中默認訪問的是內部類的成員變量,可以通過"外部類.this.成員變量名"指定訪問外部類的成員
　　2.私有的成員內部類只能在外部類中類中提供一個方法創建內部類對象進行訪問,不能在其他類中創建對象了.
　　3.成員內部類一旦出現靜態成員,那麽該類必須用static修飾

//外部類
class Outer{
    int i=100;//outer.class文件被加載到內存時存在內中.靜態的成員數據是不需要對象存在才能訪問的
    public int test(){
        System.out.println("hello,你好");
        return 1;
    }
    //成員內部類
    class Inner{
    　　int t=i;
    　　public void print(){
            System.out.println("這是內部類的的print方法!..."+t);
        }
        int c=test();
    }
    //在外部的方法中創建內部類的對象,然後調用內部方法
    public void instance(){
        Inner inner=new Inner();
            inner.print();
    }
}
class Demo3 {
    public static void main(String[] args) {
        Outer.Inner inner=new Outer().new Inner();
        //Outer.Inner inner=new Outer.Inner();//靜態的內部類
        inner.print();
        //System.out.println(Outer.Inner.i);
        Outer o=new Outer();
        o.instance();
    }
}

1.2.1、局部內部類

在一個類的方法內定義另一個類,那麽另一個類就稱作為局部內部類.

1.2.2、局部內部類需要註意的細節

1.如果局部內部類訪問一個局部變量,那麽該局部變量必須使用final修飾

 1 //外部類
 2 class Outer{
 3     private String name="外部類的name";
 4     public void eat(){ //外部類的方法
 5         final int i=10;         
 6         //局部內部類
 7         class Inner{
 8             //int i;
 9             public void print(){
10                 System.out.println("這是局部內部類的方法......"+i);
11             }
12         }
13         //實例化局部內部類
14         Inner inner=new Inner();
15         inner.print();
16     }
17 }
18 class Demo4 {
19     public static void main(String[] args) {
20         Outer o=new Outer();
21         o.eat();
22     }
23 }

二、匿名內部類

2.1、匿名內部類

沒有名字的類名稱作為匿名內部類

2.2、匿名內部類的好處

簡化書寫

2.3、匿名內部類的使用前提

必須存在繼承或者實現關系才能使用

繼承關系下的匿名內部類

 1 //繼承關系下的匿名內部類
 2 abstract class Animal{
 3     public abstract Animal run();
 4     public abstract void sleep();
 5 }
 6 
 7 class Outher{
 8     public void print(){
 9     //匿名內部類:只是沒有類名,其他的一概成員都具備的
10     //匿名內部類與Animal是繼承關系,目前是Animal子類的對象
11     Animal a = new Animal(){ //多態     new Animal()：是一個子類對象
12         //匿名內部的成員
13         public Animal run(){
14             System.out.println("狗在跑.....");
15             return this;
16         }
17         public void sleep(){
18             System.out.println("狗趴著睜著眼睛睡......");
19         }
20     };
21     a.run();
22     a.sleep();
23     
24     }
25 }
26 class Demo6 {
27     public static void main(String[] args) {
28         Outher o=new Outher();
29         o.print();
30     }
31 }

或者

 1 //繼承關系下的匿名內部類
 2 abstract class Animal{
 3     public abstract Animal run();
 4     public abstract void sleep();
 5 }
 6 
 7 class Outher{
 8     public void print(){
 9     //匿名內部類:只是沒有類名,其他的一概成員都具備的
10     //匿名內部類與Animal是繼承關系,目前是Animal子類的對象
11     new Animal(){ //多態     new Animal()：是一個子類對象
12         //匿名內部的成員
13         public Animal run(){
14             System.out.println("狗在跑.....");
15             return this;
16         }
17         public void sleep(){
18             System.out.println("狗趴著睜著眼睛睡......");
19         }
20     }.run().sleep();
21     }
22 }
23 class Demo6 {
24     public static void main(String[] args) {
25         Outher o=new Outher();
26         o.print();
27     }
28 }

實現關系下的匿名內部類

 1 //實現關系下的匿名內部類
 2 interface Dao{ //接口
 3     public void add();
 4 }
 5 //接口的實現
 6 class t implements Dao{
 7     public void add(){
 8     
 9     }
10 }
11 //外部類
12 class Outer{
13     public void print(){ //外部類的方法           
14         //創建一個匿名的內部類的對象
15         new Dao(){//不是說好的接口不能實例話嗎?現在咋又實例化了啊!   其實：(匿名內部類實現了Dao)，實現關系
16             public void add(){
17                 System.out.println("添加成功");
18             }    
19         }.add();
20     }
21 }
22 
23 class  Demo7{
24     public static void main(String[] args) {
25         Outer o = new Outer();
26         o.print();
27     }
28 }

或者

//實現關系下的匿名內部類
interface Dao{
    public void add();
}

class t implements Dao{
    public void add(){
    
    }
}
/*
class Outer{
    public void print(){            
        //創建一個匿名的內部類的對象
        new Dao(){//不是說好的接口不能實例話嗎?現在咋又實例化了啊!  (匿名內部類實現了Dao)實現關系
            public void add(){
                System.out.println("添加成功");
            }    
        }.add();
    }
}
*/
class  Demo7{
    public static void main(String[] args) {
        test(new Dao(){//Dao的一個匿名實現類
            public void add(){
                System.out.println("添加成功");
            }
        });
    }
    //調用這個方法
    public static void test(Dao d){//形參類型是一個接口引用.....(多態)
        d.add();
    }
}

java基礎15 內部類(成員內部類、局部內部類)和匿名內部類