內部類

原文鏈接http://zhhll.icu/2020/05/10/java%E5%9F%BA%E7%A1%80/java%E5%9F%BA%E7%A1%80%E4%B9%8B%E5%86%85%E9%83%A8%E7%B1%BB/

定義在另一個類中的類，叫做內部類，可以把一些邏輯相關的類組織在一起，并控制位于內部的類的可見性，

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

標籤：其他

上一篇：【譯】Java 14 Hotspot 虛擬機垃圾回收調優指南

下一篇：volatile關鍵字詳解