如何在普通類中使用內(nèi)部結構

在普通類中使用內(nèi)部結構

不多說，先上個代碼

Outer類里面有個內(nèi)部類Inner

public class Outer {
    private String msg = "哈哈";   //只能在類內(nèi)部訪問
    public void fun(){
        Inner in = new Inner();    //實例化內(nèi)部類的對象
        in.print();
    }
 
    //在Outer類中的內(nèi)部類
    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();
    }
}

創(chuàng)建外部類的實例調(diào)用外部類的方法卻執(zhí)行了內(nèi)部類的方法，打印出“哈哈”。

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

public class Outer {
    private String msg = "哈哈";   //只能在類內(nèi)部訪問
    public void fun(){
        Inner in = new Inner(this);    //實例化內(nèi)部類的對象
        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這個內(nèi)部類可以訪問Outer這個類中的私有屬性，如果不用內(nèi)部類的時候整體代碼會非常的麻煩，所以可以得出內(nèi)部類的優(yōu)點： 輕松的訪問外部類中的私有屬性 。

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

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

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

外部類.內(nèi)部類 內(nèi)部類對象 = new 外部類（）.new 內(nèi)部類（） ；

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

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. 在抽象類和接口中使用內(nèi)部結構

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

2.1 接口中定義內(nèi)部接口

我們現(xiàn)在定義 內(nèi)部接口 ：

public interface IChannel {
    public void send(IMessage msg);
    //內(nèi)部接口
    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 接口中定義內(nèi)部抽象類

下面我們繼續(xù)觀察一個 內(nèi)部抽象類 ，內(nèi)部抽象類可以定義在普通類，抽象類，接口內(nèi)部都可以

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 用內(nèi)部類實現(xiàn)外部接口

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

接口內(nèi)部進行接口實現(xiàn)

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();
    }
}

輸出的結果為“哈哈”

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

3. 總結：

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