Java学习路线-11：内部类

第28 章 ： 内部类

126 内部类基本概念

内部类：类的内部定义其他的类

// 外部类
class Outer{
    private String message = "私有属性" ;

    // 普通方法
    public void fun(){  
        // 实例化内部类并调用内部类方法
        Inner in = new Inner();
        in.printInfo();
    }

    // 内部类
    class Inner{
        public void printInfo(){
            // 内部类使用外部类中的属性
            System.out.println(Outer.this.message);
        }
    }

}

class Demo{
    public static void main(String[] args) {
        // 实例化外部类
        Outer outer = new Outer();
        outer.fun();
        // 私有属性
    }
}

不使用内部类实现上面代码

// 外部类
class Outer{
    private String message = "私有属性" ;

    // 普通方法
    public void fun(){  
        // 实例化内部类并调用内部类方法
        Inner inner = new Inner(this);
        inner.printInfo();
    }

    public String getMessage(){
        return this.message;
    }
}

// 内部类
class Inner{
    private Outer outer;

    public Inner(Outer outer){
        this.outer = outer; 
    }

    public void printInfo(){
        // 内部类使用外部类中的属性
        System.out.println(this.outer.getMessage());
    }
}

class Demo{
    public static void main(String[] args) {
        // 实例化外部类
        Outer outer = new Outer();
        outer.fun();
        // 私有属性
    }
}

缺点：从整体代码结构上来讲，内部类的结构并不合理，破坏了类结构
优势：轻松访问外部类中的私有属性

127 内部类相关说明

内部类实例化格式：

外部类.内部类 内部类对象 = new 外部类().new 内部类();

上面实例编译后出现文件

Demo.java  

Demo.class      
Outer.class
Outer$Inner.class

其中的$ 换到程序之中就是.

内部类可以使用private私有化

抽象类和接口中也可以定义内部结构

示例：内部接口

interface Ichannel{
    public void send(IMessage message);
    
    interface IMessage{
        public String getContent();
    }
}

class ChannelImpl implements Ichannel{
    public void send(IMessage message){
        System.out.println(message.getContent());
    }
    
    class MessageImpl implements IMessage{
        public String getContent(){
            return "内部消息" ;
        }
    }
}

class Demo{
    public static void main(String[] args) {
        Ichannel channel = new ChannelImpl();
        channel.send(((ChannelImpl)channel).new MessageImpl());
        // 内部消息
    }
}

示例：内部抽象类

// 定义接口
interface Ichannel{
    public void send();
    
    // 内部抽象类
    abstract class AbstractMessage{
        public abstract String getContent();
    }
}

class ChannelImpl implements Ichannel{
    public void send(){
        AbstractMessage message = new MessageImpl();
        System.out.println(message.getContent());
    }
    
    class MessageImpl extends AbstractMessage{
        public String getContent(){
            return "内部消息" ;
        }
    }
}

class Demo{
    public static void main(String[] args) {
        Ichannel channel = new ChannelImpl();
        channel.send();
        // 内部消息
    }

}

示例：内部类实现接口

// 定义接口
interface Ichannel{
    public void send();
    
    class ChannelImpl implements Ichannel{
        public void send(){
            System.out.println("hello");
        }
    }

    public static Ichannel getInstance(){
        return new ChannelImpl();
    }
}


class Demo{
    public static void main(String[] args) {
        Ichannel channel = Ichannel.getInstance();
        channel.send();
        // hello
    }

}

128 static定义内部类

如果内部类使用了static，那么这个内部类就变成了外部类

static内部类实例化格式：

外部类.内部类 内部类对象 = new 外部类.内部类();

class Outer{
    private static final String MESSAGE = "静态消息" ;

    static class Inner{
        public void print(){
            System.out.println(Outer.MESSAGE);
        }
    }
}


class Demo{
    public static void main(String[] args) {
        Outer.Inner Inner = new Outer.Inner();
        Inner.print();
        // 静态消息
    }

}

static定义一组相关内部接口

interface IMessageWrap{
    static interface IMessage{
        public String getContent();
    }

    static interface IChannel{
        public boolean connect();
    }

    public static void send(IMessage message, IChannel channel){
        if(channel.connect()){
            System.out.println(message.getContent());
        } else {
            System.out.println("无法连接通道");
        }

    }
}

class MessageImpl implements IMessageWrap.IMessage{
    public String getContent(){
        return "消息内容" ;
    }
}

class ChannelImpl implements IMessageWrap.IChannel{
    public boolean connect(){
        return true ;
    }
}

class Demo{
    public static void main(String[] args) {
        IMessageWrap.send(new MessageImpl(), new ChannelImpl()) ; 
        // 消息内容
    }
}

129 方法中定义内部类

内部类可以在任意结构中定义
包括：类，方法，代码块

方法中定义内部类
JDK >= 1.8 内部类直接访问方法中的参数

JDK < 1.8 需要加关键字final

public void fun(final long time)

class Outer{
    private String msg = "私有消息";

    public void fun(long time){
        // 方法中定义内部类
        class Inner{
            public void print(){
                System.out.println(Outer.this.msg);
                System.out.println(time);
            }
        }

        // 方法中直接实例化内部类
        new Inner().print();
    }
}

class Demo{
    public static void main(String[] args) {
        new Outer().fun(1234567890L);
        // 私有消息
        // 1234567890
    }
}

130 匿名内部类

匿名内部类是一种简化的内部类处理形式
主要在抽象类和接口的子类上使用

interface IMessage{
    public void send();
}

class MessageImpl implements IMessage{
    public void send(){
        System.out.println("Hello Java");
    }
}

class Demo{
    public static void main(String[] args) {
        IMessage message = new MessageImpl();
        message.send();
        // Hello Java
    }
}

如果 MessageImpl 实现只使用一次，可以使用匿名内部类

interface IMessage{
    public void send();
}

class Demo{
    public static void main(String[] args) {
        IMessage message = new IMessage() {
            public void send(){
                System.out.println("Hello Java");
            }
        };
        message.send();
        // Hello Java
    }
}

接口中定义匿名内部类

interface IMessage{
    public void send();

    public static IMessage getInstance(){
        return new IMessage() {
            public void send() {
                System.out.println("Hello Java");
            }
        };
    }
}

class Demo{
    public static void main(String[] args) {
        IMessage.getInstance().send();
        // Hello Java
    }
}