内部类

定义在另一个类中的类，叫做内部类，可以把一些逻辑相关的类组织在一起，并控制位于内部的类的可见性。

public class Outter {

    class Inner {
        public void print(String s) {
            System.out.println(s);
        }
    }

    public Inner buildInner() {
        return new Inner();
    }

    public static void main(String[] args) {
        Outter outter = new Outter();
        Inner inner = outter.buildInner();
        inner.print("输出");
    }
}

内部类与外部类联系

内部类可以使用外部类的所有成员，而且不需要任何特殊条件，且拥有其对与外部类所有元素的访问权。

public class Sequence {

    private Object[] items;

    private int next;

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

    /**
     * 添加元素
     *
     * @param obj
     */
    public void add(Object obj) {
        if (next < items.length) {
            items[next] = obj;
            next++;
        }
    }

    public SequenceSelector selector() {
        return new SequenceSelector();
    }

    public static void main(String[] args) {
        Sequence sequence = new Sequence(10);
        for (int i = 0; i < 10; i++) {
            sequence.add(i);
        }
        SequenceSelector selector = sequence.selector();
        while (!selector.end()) {

            System.out.print(selector.current() + " ");
            selector.next();
        }
    }

    private class SequenceSelector {

        private int current = 0;

        public boolean end() {
            return current == size();
        }

        public int size() {
            return items.length;
        }

        public Object current() {
            return items[current];
        }

        public void previous() {
            if (current > 0) {
                current--;
            }
        }

        public void next() {
            if (current < items.length) {
                current++;
            }
        }
    }
}

使用.this和.new

在内部类如何生成外部类对象的引用，使用外部类名.this

public class DoThis {
    class Inner{
        public DoThis outer(){
            return DoThis.this;
        }
    }

    public void f(){
        System.out.println("DoThis.f()");
    }

    public Inner inner(){
        return new Inner();
    }

    public static void main(String[] args) {
        DoThis doThis = new DoThis();
        Inner inner = doThis.inner();
        inner.outer().f();
    }
}

外部类如何创建内部类的对象，需要使用外部类名.new

public class DoNew {

    class Inner {
        public void f(){
            System.out.println("Inner.f()");
        }
    }

    public static void main(String[] args) {
        DoNew doNew = new DoNew();
        Inner inner = doNew.new Inner();
        inner.f();
    }
}

在拥有外部类对象之前是不可能创建内部类对象的，内部类对象会连接到创建它的外部类对象上，静态内部类不需要外部类对象的引用。

对于私有的内部类，外部类是可以访问到它的，其他的类无法访问到，如下

public class DoNew {

    private class Inner {
        public void f(){
            System.out.println("Inner.f()");
        }
    }

    public static void main(String[] args) {
        DoNew doNew = new DoNew();
        // 外部类中可以访问到
        Inner inner = doNew.new Inner();
        inner.f();
    }
}

public class Test {
    public static void main(String[] args) {
        DoNew doNew = new DoNew();
        // 其他类无法访问
        // 'DoNew.Inner' has private access in 'DoNew'
        //doNew.new Inner();
    }
}

内部类分类

局部内部类

在方法作用域内创建的类，称为局部内部类

public class MethodOuter {

    public Destination desc(String s){
        // 局部内部类
        class Inner implements Destination{
            @Override
            public void f(){
                System.out.println("Inner.f()传入参数"+s);
            }
        }
        return new Inner();
    }

    public static void main(String[] args) {
        MethodOuter methodOuter = new MethodOuter();
        methodOuter.desc("test").f();
    }
}

Inner是desc()方法的一部分，在方法之外访问不到

匿名内部类

public class Outer1 {
    public Contents contents(){
        return new Contents(){
            @Override
            public void f() {
                System.out.println("Contents匿名内部类.f()");
            }
        };
    }

    public static void main(String[] args) {
        Outer1 outer1 = new Outer1();
        outer1.contents().f();
    }
}

嵌套类

嵌套类就是静态内部类，内部类对象与外部类对象之间没有联系，将内部类声明为static，普通的内部类对象隐式的保存了一个引用，指向创建它的外部类对象，当内部类是static的时候，意味着

• 要创建嵌套类的对象，并不需要其外部类的对象

• 不能从嵌套类的对象中访问非静态的外围对象

  普通内部类不能有static数据和static字段，也不能包含嵌套类，但是嵌套类可以。

  public class Outer2 {
      private static class Inner2{
          private static int i = 0;
          private static void f(){
              System.out.println("Inner2.f()");
          }
      }
  
      public static void main(String[] args) {
          Inner2.f();
      }
  }
  

  接口内部类

  嵌套类可以作为接口的一部分，放到接口中任何类都是public static的

由于本身的博客百度没有收录，博客地址http://zhhll.icu