1. static定義內部類

1.1 static定義內部類

如果說現在內部類上使用了static定義，那么這個內部類就變成了“外部類”，static定義的都是獨立于類的結構，所以該類結構就相當于是一個獨立的程序類了。需要注意，static定義的不管是類還是方法只能夠訪問static成員， 所以static定義的內部類只能夠訪問外部內中的static屬性和方法 ；

public class Outer {
    private static final String MSG = "哈哈";
    static class Inner{
        public void print(){
            System.out.println(Outer.MSG);
        }
    }
}

這個時候的Inner類是一個獨立類 ，如果此時要想實例化Inner類對象，只需要根據“ 外部類.內部類 ”的結構實例化對象即可

格式如下 外部類.內部類 內部類對象 = new 外部類.內部類（） ；

這個時候類名稱帶有“.”

我們現在實例化static內部類對象

public class Test {
    public static void main(String[] args) {
       Outer.Inner in = new Outer.Inner();
       in.print();
    }
}

輸出結果是“haha”

所以以后如果發現類名稱上提供有“.”，首先應該立刻想到這是一個內部類的結構，如果可以直接進行實例化，則應該立刻認識到這是一個static定義的內部類，但是static定義內部類的形式來講并不常用， static定義內部接口的形式最為常用 。

1.2 static定義內部接口

上代碼，注意內部接口IMessage和IChannel

public interface IMessageWarp {
    static interface  IMessage{
        public String getContent();
    }
 
    static interface IChannel{
        public boolean connect();  //消息的發送通道
    }
 
 
    //消息發送
    public static void send(IMessage msg,IChannel channel){
        if(channel.connect()){
            System.out.println(msg.getContent());
        }else{
            System.out.println("消息通道無法建立");
        }
    };   
}

public class DefaultMessage implements IMessageWarp.IMessage {
    @Override
    public String getContent() {
        return "哈哈";
    }
}

public class NetChannel implements IMessageWarp.IChannel{
    @Override
    public boolean connect() {
        return true;
    }
}

public class Test {
    public static void main(String[] args) {
        IMessageWarp.send(new DefaultMessage() , new NetChannel());
    }
}

之所以使用static定義的內部接口，主要是因為這些操作時屬于一組相關的定義，有了外部接口之后可以更加明確的表述出這些接口的主要目的

2.方法中定義內部類

內部類可以在任意的結構中定義，這就包括了：類中、方法中、代碼塊中。但在方法中定義內部類的情況比較多。

public class Outer {
    private String msg = "haha";
    public void fun (long time){
        class Inner {    //內部類
            public void print(){
                System.out.println(Outer.this.msg);
                System.out.println(time);
            }
        }
        new Inner().print();    //方法中直接實例化內部類對象
    }
}

public class Test {
    public static void main(String[] args) {
        new Outer().fun(2390239023L);
    }
}

輸出：haha 和 2390239023

此時在fun()方法內部提供有Inner內部類的定義，并且發現內部類可以直接訪問外部類中的私有屬性也可以直接訪問方法中的參數，但對于方法中的參數直接訪問時從JDK1.8開始支持的。而在JDK1.8之前**，如果方法中定義的內部類要想訪問方法中的參數則參數前必須追加final。**

之所以取消這樣的限制是為了擴展函數式編程準備的

3.匿名內部類

匿名類是一種簡化的內部類的處理形式，其主要是在抽象類和接口的子類上使用的。

接口和抽象類是一樣的

public interface IMessage {
    public void send(String str);
}

public class MessageImpl implements IMessage {
    @Override
    public void send(String str) {
        System.out.println(str);
    }
}

public class Test {
    public static void main(String[] args) {
        IMessage msg = new MessageImpl();
        msg.send("哈哈");
 
    }
}

如果說現在IMessage接口中的MessageImpl子類只使用唯一的一次，那么是否還有必要將其定義為單獨的類？那么在這樣的要求下就發現這個時候定義的子類是有些多余了，所以就可以利用內部類的形式來解決此問題

public interface IMessage {
    public void send(String str);
}

public class Test {
    public static void main(String[] args) {
        IMessage msg = new IMessage() {
           @Override
            public void send(String str) {    //匿名內部類
                System.out.println(str);
            }
        };
        msg.send("哈哈");
    }
}

匿名內部類不一定要在抽象類或接口上，但只有在抽象類和接口上才有意義。有些時候為了更加方的體現出匿名內部類的使用，往往可以利用靜態方法做一個內部類的匿名內部類實現

在接口中直接定義匿名內部類

public interface IMessage {
    public void send(String str);
}

public interface IMessage {
    public void send(String str);
 
    public static IMessage getInstance(){
        return new IMessage() {
            @Override
            public void send(String str) {
                System.out.println(str);
            }
        };
    }
}

public class Test {
    public static void main(String[] args) {
        IMessage.getInstance().send("哈哈");
    }
}

與內部類相比匿名內部類只是一個沒有名字的只能夠使用一次的，并且結構固定的一個子類。

4.總結：

好了，內部類的使用就介紹完了，大家可以收藏起來，工作中肯定用得到。