内部类

【内部类】

• 定义： 在面向对象程序设计中，可以在一个类的内部定义另一个类，即内部类；

• 内部类两种： 静态内部类（在初学者开发很少用到） 非静态内部类（普通内部类，使用相对更多一些）

• 作用 ： 可以隐藏实现细节，也可以让代码更加简洁。

• 1）普通内部类

  • 内部类几乎可以处于内部的任意位置，可以与实例变量处于同一级,或处于方法之内，甚至是一个表达式的一部分。 普通内部类可以访问外部类的属性和方法。
  • 举一个例子：

    public class Forest {
        private int sum_tree=1000; //树的总数
        private int type_tree=100; //树的类型

    //成员方法
        public int getTreeType() {
        return type_tree;
        }


        //定义一个动物内部类
        class MagicalAnimal{
            private String name;  //动物名称

            public void setName(String name) {
            this.name=name;
            }
            //内部类访问外部类的属性
            public int getTreeSum() {           
                return Forest.this.sum_tree; 
            }
            //内部类访问外部类的方法
            public int getTreeType() {
                return Forest.this.getTreeType(); 
            }
    }

对 return Forest.this.getTreeType()存在疑惑，可以这么理解， this代表当前对象的引用，森林类 是一个外部类，MagicAnimal是一个内部类，若想访问到外部类的成员变量或方法，那么肯定不能直接去访问(属于越级访问），那么就得通这样的语法（父类名.this.方法名）访问，这里的 “.” 可以理解为“的”。

public static void main(String[] args) {
        //Forest f=new Forest();
        //Forest.MagicalAnimal man=f.new MagicalAnimal();
        //以上两行代码可以用下面这一行代码代替，语法原理是一样的
        Forest.MagicalAnimal man=new Forest().new MagicalAnimal();


        man.setName("Monkey"); //普通内部类的成员方法
        System.out.println(man.getTreeSum());//普通内部类的成员方法
        System.out.println(man.getTreeType());//普通内部类的成员方法
    }

---

2）静态内部类
定义：相比于普通内部类来它的最大区别在于多加一个关键字static 和 对外部类的访问权限以及访问语法不同。
* 举一个例子

public class Forest {
            //成员变量
        private int sum_tree=1000; //树的总数
        private int type_tree=100; //树的类型

        //成员方法
        public int getTreeType() {
            return type_tree;
        }
        //静态变量
        private static int staticValue=10000;
        //静态方法
        public static int getTreeSum() {
            return 1000;
        }


        //定义一个静态内部类
        static class A{
            private int i=1;

            public int getStaticValue() {
                return Forest.staticValue;   
            //静态内部类能访问外部类的静态变量

            public int getTreeSum() {
                return Forest.getTreeSum();
             //静态内部类能访问外部类的静态方法
                }
            }

    }

我们需要在此注意：静态内部类不能访问外部类的成员变量，而且/静态内部类也不能去访问外部类的成员方法。

public static void main(String[] args) {


    Forest.A  a=new Forest.A();
    //静态内部类的创建方法，不需要外部类的实例。
    //这里的语法类同于对静态方法的调用（通过类名.)去调用
    //不同于一般类的实例化和访问方式，我们需要理解，把它当做是一种语法就好。
    System.out.println(Forest.A.getStaticValue());

    }

3）匿名内部类
定义：匿名内部类没有名字，只能使用一次，它必须继承一个父类或者实现一个接口，但最多只能一个父类或实现一个接口，创建匿名内部类时会立即创建一个类的实例。
* 格式：

new 类名或者接口名(){
        重写方法;
    }

    public  class Dog {
         private String name ;

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

        System.out.println("我的名字是"+name);
    }
}

public class InnerClass {
    public static void main(String args[])
    {
         new  Dog( "er ha")  {      // 实现匿名内部类
             public void bark() {

                System.out.println("我在玩，我的名字是" +name
            }
        }

        new Dog.bark();//调用方法
}