java基础【内部类（普通内部类，嵌套类，普通局部内部类，匿名内部类）】

package com.hike.javase.innerclass;

/**
 * 内部类：把一个类定义在另一个类的内部，后面的类称为外部类
 *
 * 内部又分为：
 *      成员内部类：声明在类中方法外
 *          没有被static修饰的称为普通内部类
 *              适用于内部类与外部类频繁交互，比对相关联更方便，但对象关联更安全，所以用的多一些
 *          被static修饰的内部类称为嵌套类
 *      局部内部内：声明在方法中
 *          普通用法，普通局部内部类
 *          匿名内部类（重点），主要和接口配合使用
 */

class Outer{
    private int id = 10;

    //普通内部类，隶属于外部类的对象，创建和使用会受到外部类对象的限制。
    public class inner1{
        private int id = 100;

        public void inner1Test(){
            System.out.println(id); //就近原则，100
            System.out.println(inner1.this.id);//内部类的id
            System.out.println(Outer.this.id);//外部类的id

            outerTest2();//在内部类中可以随意使用外部类的成员，因为都是类的成员,这也是内部类与外部类的关系
        }
    }

    public void outerTest1(){
        inner1 inner1 = this.new inner1();
        inner1.inner1Test();
    }

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

    //嵌套类，与外部类是平级的关系
    static class Inner2{

        public static String name = "Inner2";

        public static void staticTest(){
            System.out.println("inner static test");
        }

        private  int age;

        public Inner2(int age){
            this.age = age;
        }

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

//匿名内部类通常和接口配合
interface I1{
    void test1();
}


public class InnerClassTest {

    public static void main(String[] args) {
        //匿名内部类：因为没有类名，所以需要在声明的同时创建对象
        I1 i1 = new I1(){   //只能创建一个对象，并且不能本态调用
            //类体部分就相当于接口的实现子类的类体
            @Override
            public void test1() {
                System.out.println("匿名内部类的实现方法体");
            }
        };
        i1.test1();

        new I1(){

            @Override
            public void test1() {
                System.out.println("第二个匿名内部类的实现");
            }
        }.test1(); //匿名类的匿名对象，仅适用于一次性调用
    }

    public static void main3(String[] args) {
        //普通局部内部类：在方法中声明的内部类。不可以加修饰符，可以有属性，get、set方法
        class LocalClass1{
            private int id;
            private String name;

            public int getId() {
                return id;
            }

            public void setId(int id) {
                this.id = id;
            }

            public String getName() {
                return name;
            }

            public void setName(String name) {
                this.name = name;
            }

            @Override
            public String toString() {
                return "LocalClass1{" +
                        "id=" + id +
                        ", name='" + name + '\'' +
                        '}';
            }
        };

        LocalClass1 localClass1 = new LocalClass1();
        System.out.println(localClass1.getId());
        System.out.println(localClass1.getName());
    }

    public static void main2(String[] args) {
        Outer.Inner2.staticTest();

        Outer.Inner2 oi2 = new Outer.Inner2(15);
        oi2.inner2Test();
    }

    public static void main1(String[] args) {
        Outer outer = new Outer();
//        outer.outerTest1(); //100
        //直接创建内部类对象,需要使用外部类对象.new
        Outer.inner1 inner1 = outer.new inner1();
        inner1.inner1Test();
    }
}