面向对象_内部类

package Interface;

/**
 * 内部类：把一个类定义在另一个类的内部称为内部类
 *     使用：创建内部类的对象的时候，需要在内部类的前面加外部类来进行修饰
 *     1.内部类可以直接访问外部类的属性和方法
 *     2.外部类要想访问内部类，则需创建内部类的对象才可访问
 *     3.内部类中不能定义静态属性(静态当然可以)
 *     4.当内部类和外部类有相同的（属性或者方法）的时候，在内部类中可以直接访问内部类的（属性或方法）
 *     如果想访问外部类的（属性或者方法）就得用 外部类类名.this.（属性或者方法）
 *
 *     分类：
 *        1.成员内部类
 *    实例化格式：
 *     外部类.内部类 对象 = new 外部类（）.new 内部类（）;
 *        2.静态内部类：
 *     实例化格式：
 *     外部类.内部类 对象 = new 外部类.内部类（）;
 *        3.匿名内部类：适合一个类在使用过程中只是用一次的时候
 *     格式：new 对象（）{添加未实现的方法}
 *     4.方法内部类：定义在外部类中方法里的类就称为方法内部类
 *     注意：
 *     1.方法内部类中的属性是被final修饰的（只是现在JDK版本高了，不需要显示声明）
 */
public class NeibuTest {
    private int age = 200;

    //成员内部类
    public class DE {
        //属性
        private String name;
        private int age = 10;

        public void a() {
            System.out.println(age);
            System.out.println(NeibuTest.this.age);
            b();
        }
    }
    public void b(){
        DE de =new DE();
        System.out.println(de.name);
        de.a();
    }
    //静态内部类
    static class J {
       private  static String info = "HelloWorld!";
        public void shuchu(){
            System.out.println(info);
        }
    }

    public Comparable mother() {
        //匿名内部类
      return new Comparable() {

          @Override
          public int compareTo(Object o) {
              return 100;
          }
      };
    }
    //方法内部类
    public void head(){
        /*final*/ int num = 10;
        class You{
            public void print(){
                //num = 20;无法改变
                System.out.println(num);
            }
        }
    }
}
class Demo{
    public static void main(String[] args) {
        //静态内部类实例化
        NeibuTest.J j = new NeibuTest.J();
        j.shuchu();
        //成员内部类实例化
        NeibuTest.DE de =new NeibuTest().new DE();
    }
}