Java内部类

内部类

分为实例内部类、静态内部类、匿名内部类、本地内部类

实例内部类

1、实例内部类不能有静态的数据成员
2、如何拿到内部类的对象
3、面试问题：实例内部类是否拥有外层对象/是否有额外的开销

静态内部类

在内部类名前面加了一个static就是静态内部类
不能直接访问在外部类中的非静态数据成员，不能直接外部类点上内部类，因为静态内部类不依赖于对象，但是可以间接访问

看下面的代码：

/**
 * 内部类：
 * 实例内部类
 * 静态内部类
 * 匿名内部类
 * 本地内部类
 */
class OuterClass {
    public int data1 = 10;
    public static int data2 = 20;
    //实例内部类->实例方法-》实例数据
    *//**
     * 1、实例内部类不能有静态的数据成员
     * 2、如何拿到内部类的对象
     * OuterClass o = new OuterClass();
     * OuterClass.InnerClass in  = o.new InnerClass();
     * 3、面试问题：
     *     实例内部类是否拥有外层类对象/是否有额外的开销？
     *//*
    class InnerClass {
        public int data1 = 100;
        //public static int data2 = 300;
        public int data2 = 999;
        public InnerClass() {
            System.out.println("InnerClass()");
        }
        public void func() {
            System.out.println("data2："+data2);
            System.out.println("data1："+this.data1);
            System.out.println("data1："+OuterClass.this.data1);
        }
    }
}


class OuterClass {
    public int data1 = 10;
    public static int data2 = 20;

    /**
     * 静态内部类：
     * 1、OuterClass.InnerClass in =
     *          new OuterClass.InnerClass(outerClass);
     * 2、静态内部类 不能直接访问外部内部类的非静态数据成员
     * 但是可以间接访问的。
     */
    static class InnerClass {
        public int data1 = 999;
        public static int  data2 = 888;
        OuterClass o2 = null;
        public InnerClass() {
        }
        public InnerClass(OuterClass o) {
            o2 = o;
        }
        public void func() {
            System.out.println("data1: "+data1);
            System.out.println("data2: "+data2);
            System.out.println("data2: "+OuterClass.data2);
            System.out.println("data1: "+o2.data1);
        }
    }
}
/**
     * 匿名内部类：在多线程中用的多
*/
class MyThread {
    public void func(){
        System.out.println("func!");
    }
}
public class TestDemo4 {
    public static void main(String[] args) {
        new MyThread(){
            @Override
            public void func() {
                System.out.println("hello");
            }
        }.func();
    }

    public static void main1(String[] args) {
        OuterClass outerClass = new OuterClass();
        //System.out.println(outerClass.data1);

        OuterClass.InnerClass in = new OuterClass.InnerClass(outerClass);
        in.func();

        /*实例内部类
        OuterClass o = new OuterClass();
        OuterClass.InnerClass in  = o.new InnerClass();
        in.func();*/
    }
}

用内部类实现单链表的头插尾插：

import java.util.LinkedList;
class MyLinkedList {
     static class Node {
        public int data;
        public Node next;
        public Node(int data) {
            this.data = data;
        }
    }
    public Node head;
    public void insert(int data) {
         Node node = new Node(data);
         if(this.head == null) {
             this.head = node;
         }else {
             node.next = this.head;
             this.head = node;
         }
    }
    public void insertTail(int data) {
        Node node = new Node(data);
        if(this.head == null) {
            this.head = node;
        }else {
            Node cur = this.head;
            while (cur.next != null) {
                cur = cur.next;
            }
            cur.next = node;
        }
    }
    public void display( ) {
        Node cur = this.head;
        while (cur != null) {
            System.out.print(cur.data+" ");
            cur = cur.next;
        }
        System.out.println();
    }
    public void display2(Node newHead) {
        Node cur = newHead;
        while (cur != null) {
            System.out.print(cur.data+" ");
            cur = cur.next;
        }
        System.out.println();
    }
}




public class TestDemo5 {
    public static MyLinkedList.Node mergeList(MyLinkedList.Node headA
            ,MyLinkedList.Node headB) {
        /*MyLinkedList myLinkedList = new MyLinkedList();
        MyLinkedList.Node newHead = myLinkedList.new Node(-1);*/
        MyLinkedList.Node newHead =
                new MyLinkedList.Node(-1);
        MyLinkedList.Node tmp = newHead;
        while (headA != null && headB != null) {
            if(headA.data < headB.data) {
                tmp.next = headA;
                headA = headA.next;
                tmp = tmp.next;
            }else {
                tmp.next = headB;
                headB = headB.next;
                tmp = tmp.next;
            }
        }
        if(headA != null) {
            tmp.next = headA;
        }
        if(headB != null) {
            tmp.next = headB;
        }
        return newHead.next;
    }

    public static void main(String[] args) {
        MyLinkedList myLinkedList = new MyLinkedList();
        myLinkedList.insertTail(1);
        myLinkedList.insertTail(2);
        myLinkedList.insertTail(3);
        myLinkedList.insertTail(4);
        myLinkedList.display();
        MyLinkedList myLinkedList2 = new MyLinkedList();
        myLinkedList2.insertTail(1);
        myLinkedList2.insertTail(2);
        myLinkedList2.insertTail(3);
        myLinkedList2.insertTail(4);
        myLinkedList2.display();

        MyLinkedList.Node ret =
                mergeList(myLinkedList.head,myLinkedList2.head);
        myLinkedList.display2(ret);

    }
}