在普通類中使用內部結構

不多說，先上個代碼

Outer類里面有個內部類Inner

public class Outer {
    private String msg = "哈哈";   //只能在類內部訪問
    public void fun(){
        Inner in = new Inner();    //實例化內部類的對象
        in.print();
    }
 
    //在Outer類中的內部類
    class Inner{
        public void print(){
            System.out.println(Outer.this.msg);   //msg是Outer類里面的屬性
        }
    }
}

測試類

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

創建外部類的實例調用外部類的方法卻執行了內部類的方法，打印出“哈哈”。

從整體的代碼結構來講，內部類的結構并不合理，所以內部類本身最大的缺陷在于破壞了程序的結構，但是破壞需要有目的的破壞，那么它也一定會有其優勢，如果要想更好的觀察出內部類的優勢，就可以將內部類拿到外面來。我將上面的代碼Inner拿出來

public class Outer {
    private String msg = "哈哈";   //只能在類內部訪問
    public void fun(){
        Inner in = new Inner(this);    //實例化內部類的對象
        in.print();
    }
    public String getMsg(){
        return this.msg;
    }
}

public class Inner {
    private Outer out;
    public Inner(Outer out){
        this.out = out;
    }
    public void print(){
        System.out.println(this.out.getMsg());   //msg是Outer類里面的屬性
    }
}

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

如果不是對引用知識掌握的比較扎實，會有點懵。我們折騰了半天主要的目的就是為了讓Inner這個內部類可以訪問Outer這個類中的私有屬性，如果不用內部類的時候整體代碼會非常的麻煩，所以可以得出內部類的優點： 輕松的訪問外部類中的私有屬性 。

需要注意的是， 內部類雖然可以方便的訪問外部類中的私有成員或私有方法 ，同理， 外部類也可以輕松訪問內部類中的私有成員或私有方法 。如下

public class Outer {
    private String msg = "哈哈";   
    public void fun(){
        Inner in = new Inner();
        in.print();
        System.out.println(in.info);        //訪問內部類的私有屬性
    }
    class Inner{
        private String info = "今天天氣不好";
        public void print(){
            System.out.println(Outer.this.msg);
        }
    }
}

使用了內部類之后，內部類與外部類之間的私有操作的訪問就不再需要通過setter,getter以及其他的間接方式完成了，可以直接進行操作，但是需要注意的是，內部類本身也屬于一個類，雖然在大部分情況下內部類往往是被外部類包裹的，但是外部依然可以產生內部類的實例化對象，而此時，內部類實例化對象的格式如下：

外部類.內部類 內部類對象 = new 外部類（）.new 內部類（） ；

在內部類編譯完成之后會自動形成一個“Outer”這個符號換到程序中就變為“.”，所以 內部類的全稱：“外部類.內部類” 。內部類與外部類之間可以直接進行私有成員的訪問，這樣一來內部類如果要是提供有實例化對象了，一定要先保證外部類實例化了。

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

如果此時Inner類只允許Outer類來使用，那么在這樣的情況下就可以使用private進行私有定義 。

這樣，此時的Inner類就無法再外部使用， 即在test中的這條語句 Outer.Inner in = new Outer().new Inner()就失效 。

2. 在抽象類和接口中使用內部結構

在我們的java之中，類作為最基礎的結構體實際上還有與之類似的抽象類或者是接口，抽象類和接口中都可以定義內部結構。

2.1 接口中定義內部接口

我們現在定義 內部接口 ：

public interface IChannel {
    public void send(IMessage msg);
    //內部接口
    interface IMessage{
        public String getContent();
    }
}

public class ChannelImpl implements IChannel {
    @Override
    public void send(IMessage msg) {
        System.out.println(msg.getContent());
    }
 
    class MessageImpl implements IMessage{
        @Override
        public String getContent() {
            return "haha";
        }
    }
}

public class Test {
    public static void main(String[] args) {
        IChannel channel = new ChannelImpl();
        channel.send(((ChannelImpl)channel).new MessageImpl());
    }
}

最后打印出結果 “哈哈”

2.2 接口中定義內部抽象類

下面我們繼續觀察一個 內部抽象類 ，內部抽象類可以定義在普通類，抽象類，接口內部都可以

public interface IChannel {
    public void send();
    abstract class AbstractMessage{
        public abstract String getContent();
    }
}

public class ChannelImpl implements IChannel {
 
    @Override
    public void send() {
        AbstractMessage msg = new MessageImpl() ;
        System.out.println(msg.getContent());
 
    }
 
    class MessageImpl extends AbstractMessage {
        public String getContent() {
            return "哈哈";
        }
    }
}

public class Test {
    public static void main(String[] args) {
        IChannel channel = new ChannelImpl();
        channel.send();
    }
}

結果打印出來的是“哈哈”。

2.3 用內部類實現外部接口

內部類還有一些更為有意思的結構，即：如果現在 定義了一個接口，那么可以在內部利用類實現該接口 ，在JDK1.8之后，接口中追加了static方法可以不受到實例化對象的控制，現在就可以利用此特性來完成功能。

接口內部進行接口實現

public interface IChannel {
    public void send();
 
    class ChannelImpl implements IChannel{
        public void send(){
            System.out.println("哈哈");
        }
    }
    
    public static IChannel getInstance(){
        return new ChannelImpl();
    }
}

public class Test {
    public static void main(String[] args) {
        IChannel channel = IChannel.getInstance();
        channel.send();
    }
}

輸出的結果為“哈哈”

從上面可以看到，內部類是非常靈活的結構，只要你的語法滿足了，各種需求都可以幫你實現！

3. 總結：

方法，類，抽象類，接口，代碼塊中都可以定義內部結構-------類，抽象類，接口。今天主要講了如何在內部類中使用內部類和接口中使用內部類。