JAVA基础笔记 10 内部类

创建内部类

// 创建内部类
public class Pracel2 {
    // 内部类
    class Contents {
        private int i = 11;
        public int value() {
            return i;
        }
    }
    public Contents contents() {
        return new Contents();
    }
    public static void main(String[] args) {
        Pracel2 p = new Pracel2();
    // 通过调用外部类对象的方法来生成内部类对象
        Pracel2.Contents c = p.new Contents();
    }
}

内部类拥有外部类的所有元素的访问权

interface Selector {
    boolean end();
    Object current();
    void next();
}
// Sequence只是一个固定大小的Object的数组，已类来封装起来
public class Sequence {
    private Object[] items;
    private int next = 0;

    public Sequence(int size) {
        items = new Object[size];
    }

    public void add(Object x) {
        if (next < items.length)
            items[next++] = x;
    }
    /* 内部类  通过实现接口的selector功能
    *  方法end(),current(),next()都用到了object对象，这都是外部类的字段
    */
    private class SequenceSelector implements Selector {
        private int i = 0;
        @Override
        public boolean end() {
            return i == items.length;
        }
        @Override
        public Object current() {
            return items[i];
        }
        @Override
        public void next() {
            if (i < items.length)
                i++;
        }
    }
    /* 通过外部类的方法来返回内部类的对象
     * 当某个外部类的对象创建了一个内部类对象时，内部类对象会捕获一个指向那个外部类独享的引用，这一切编译器都是自动处理。
    */
    public Selector selector() {
        return new SequenceSelector();
    }

    public static void main(String[] args) {
        Sequence sequence = new Sequence(10);

        for (int i = 0; i < 10; i++) {
            sequence.add(new Strings("zheng"));
        }

        Selector selector = sequence.selector();
        while (!selector.end()) {
            System.out.println(selector.current() + " ");
            selector.next();
        }
    }
}

使用.this与.new

public class DotNew{
    public class Inner{}
    public static void main(String [] args){
        DotNew dn = new DotNew();
        //创建某个内部类的对象  （.new语法）
        DotNew.Inner dni = dn.new Inner();
    }
}

匿名类

public class Parcel9{
// 在匿名内部类中使用一个外部定义的对象，参数引用是final的
    public Destination destination(final String dest){
        return new Destination(){
            private String label = dest;
            public String readLabel(){
                return label;
            }
        }
    }
}

//匿名类的工厂模式
// 接口1
interface Service {
    void methond1();
    void methond2();
}
// 接口2
interface ServiceFactory {
    Service getService();
}

class Impletional1 implements Service {
    @Override
    public void methond1() {
        System.out.println("Implement method1");
    }

    @Override
    public void methond2() {
        System.out.println("Implement method2");
    }
    匿名类 
    public static ServiceFactory factory = new ServiceFactory() {
        @Override
        public Service getService() {
            return new Impletional1();
        }
    };
}
public class Factory {
    public static void serviceConsumer(ServiceFactory fact) {
        Service s = fact.getService();
        s.methond1();
        s.methond2();
    }

    public static void main(String[] args) {
        serviceConsumer(Impletional2.factory);
    }

}

嵌套类

普通的内部类对象隐式地保存了一个引用，指向创建他的外部类对象。但是当内部类为static的时候。
1.如果创建嵌套类的对象，并不需要其外部类的对象
2.不能从嵌套类的对象中访问非静态的外部类的对象