java 面向对象-内部类

内部类：

内部类：（当做类中的一个普通成员，只不过此成员变量是class的类型）
  一个java文件中可以包含多个class，但是只能有一个public class
  如果一个类定义个另一个类的内部，这个类可以被称为内部类。

   使用：
     创建内部类的时候，跟之前的方法不一样，需要在内部类的前面添加外部类的修饰。
       InnnerClassDemo.InnerClass innerClass =  new InnnerClassDemo().new InnerClass();

   特点：
      1 内部类可以方便的访问外部类的私有属性，
      2 外部类不能直接访问内部类的私有属性，但是可以通过创建内部类对象在外部类中来访问内部类私有属性
      3 内部类不能定义静态属性
      4 当内部类和外部类有相同的私有属性的时候，在内部类访问的时候，可以直接在内部类中访问内部类的属性，如果需要访问外部类的属性
         需要添加 外部类类名.this.属性

package com.yuzhu.Inner;

public class InnnerClassDemo {
    private int id;
    private String name;

    public int getId(){
        return this.id;
    }

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

    public String getName(){
        return name;
    }

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

    public void show(){
        System.out.println("show");
        new InnerClass().show();
    }

    class InnerClass{
        private int age;

        public void show(){
            System.out.println("Inner show");
            System.out.println(id);
            System.out.println(name);
        }
    }

}

public class Test {
    public static void main(String[] args) {
        InnnerClassDemo innnerClassDemo = new InnnerClassDemo();
        innnerClassDemo.show();
        System.out.println(innnerClassDemo.getName());

        InnnerClassDemo.InnerClass innerClass =  new InnnerClassDemo().new InnerClass();

        innerClass.show();
    }
}

分类：

匿名内部类： 当定义了一个类实现了某个接口的时候，在使用过程中只需要使用一次，没有其他用途
            此时考虑到代码编写的简介，可以考虑不创建具体的类，而采用new interface（）添加未实现的方法
            此种方法叫做匿名内部类

package com.yuzhu.Inner2;

public class Anonymous {
    public static void main(String[] args) {
        System.out.println("一万行代码");
        new Thread(new Runnable() {
            @Override
            public void run() {

            }
        });
        System.out.println("一万行代码");
    }

}

静态内部类： 在内部类中可以定定义静态内部类，使用static关键字修饰，
            使用规则：
              外部类.内部类 类的引用名称 = new 外部类.内部类();

package com.yuzhu.Inner2;

public class StaticClass {
    private int id;

    public  void test(){
        System.out.println("test");
    }
    static class InnerClass{
        private String name;
        public void show(){
            System.out.println("静态内部类");
        }
    }

    public static void main(String[] args) {
        InnerClass innerClass = new StaticClass.InnerClass();
    }
}

方法内部类： 在外部类的方法中也可以定义类，此时叫做方法内部类（了解即可）
            使用的时候注意只能在方法中创建对象，因为此class的作用域就是当前方法。
            方法内部类不能能使用访问控制符和static修饰符，因为作用域就在这个方法，在方法之外，并不能访问到该内部类，也即不需要private等访问控制符修饰
           
           static的变量实质上就是全局变量。所以static不能修饰局部变量。此外，局部变量是存放在栈中的，程序运行完立即释放。它只能在定义它的方法内部使用。所以不用static修饰符。

package com.yuzhu.Inner2;

public class MethodClass {
    public void show(){
        System.out.println("show");

        class InnerClass{
            private String name;
            public void test(int a){
                System.out.println("hahaha"+a);
            }
        }

        new InnerClass().test(12);
    }

    public static void main(String[] args) {
        MethodClass methodClass = new MethodClass();
        methodClass.show();
    }
}