Java 内部类

人来的本质是什么？复读鸡啊~~

人来的本质是什么？复读鸡啊~~

人来的本质是什么？复读鸡啊~~

内部类

内部类是定义在另一个类中的类。

1、内部类优点与特性

优点

内部类可以随意使用外部类的成员变量（包括私有）而不用生成外部类的对象。

• 内部类方法可以访问该类定义所在的作用域中的数据， 包括私有的数据。
• 内部类可以对同一个包中的其他类隐藏起来。
• 当想要定义一个回调函数且不想编写大量代码时，使用匿名(anonymous) 内部类比较便捷。

特性

• 内部类的对象总有一个隐式引用， 它指向了创建它的外部类对象

2、内部类基本结构

//外部类
class Out {
    private int age = 12;
     
    //内部类
    class In {
        public void print() {
            System.out.println(age);
        }
    }
}
 
public class Demo {
    public static void main(String[] args) {
        Out.In in = new Out().new In();
        in.print();
        //或者采用下种方式访问
        /*
        Out out = new Out();
        Out.In in = out.new In();
        in.print();
        */
    }
}

程序编译过后会产生两个 .class 文件，分别是 Out.class 和 Out$In.class。

其中 $ 代表了上面程序中 Out.In 中的那个。

生成内部类的对象

Out.In in = new Out().new In() 可以用来生成内部类的对象，这种方法需要注意：

• 1.开头的 Out 是为了标明需要生成的内部类对象在哪个外部类当中。
• 2.必须先有外部类的对象才能生成内部类的对象，因为内部类的作用就是为了访问外部类中的成员变量。

访问内外部类变量

class Out {
    private int age = 12;
     
    class In {
        private int age = 13;
        public void print() {
            int age = 14;
            System.out.println("局部变量：" + age);
            System.out.println("内部类变量：" + this.age);
            System.out.println("外部类变量：" + Out.this.age);
        }
    }
}
 
public class Demo {
    public static void main(String[] args) {
        Out.In in = new Out().new In();
        in.print();
    }
}

局部变量：14
内部类变量：13
外部类变量：12

• 内部类在没有同名成员变量和局部变量的情况下，内部类会直接访问外部类的成员变量，而无需指定Out.this.属性名。否则，内部类中的局部变量会覆盖外部类的成员变量。
• 访问内部类本身的成员变量可用 this.属性名，访问外部类的成员变量需要使用 Out.this.属性名。

3、成员内部类

成员内部类是最普通的内部类，它的定义为位于另一个类的内部。

//外部类
class Out {
    private int age = 12;
     
    //内部类
    class In {
        public void print() {
            System.out.println(age);
        }
    }
}
 
public class Demo {
    public static void main(String[] args) {
        Out.In in = new Out().new In();
        in.print();
        //或者采用下种方式访问
        /*
        Out out = new Out();
        Out.In in = out.new In();
        in.print();
        */
    }
}

4、局部内部类

局部内部类是定义在一个方法或者一个作用域里面的类，它和成员内部类的区别在于局部内部类的访问仅限于方法内或者该作用域内。

局部内部类就像是方法里面的一个局部变量一样，是不能有 public、protected、private 以及 static 修饰符的。

class People{
    public People() {
         
    }
}
 
class Man{
    public Man(){
         
    }
     
    public People getWoman(){
        class Woman extends People{   //局部内部类
            int age =0;
        }
        return new Woman();
    }
}

方法内部类

将内部类移到了外部类的方法中，然后在外部类的方法中再生成一个内部类对象去调用内部类方法。

class Out {
    private int age = 12;
 
    public void Print(final int x) {
        class In {
            public void inPrint() {
                System.out.println(x);
                System.out.println(age);
            }
        }
        new In().inPrint();
    }
}
 
public class Demo {
    public static void main(String[] args) {
        Out out = new Out();
        out.Print(3);
    }
}


3
12

5、静态内部类

如果用 static 将内部内静态化，那么内部类就只能访问外部类的静态成员变量，具有局限性。

因为内部类被静态化，因此 Out.In 可以当做一个整体看，可以直接 new 出内部类的对象（通过类名访问 static，生不生成外部类对象都没关系）

class Out {
    private static int age = 12;
     
    static class In {
        public void print() {
            System.out.println(age);
        }
    }
}
 
public class Demo {
    public static void main(String[] args) {
        Out.In in = new Out.In();
        in.print();
    }
}

运行结果：12

6、匿名内部类

匿名内部类也是不能有访问修饰符和 static 修饰符的。

bt.setOnClickListener(new OnClickListener() {
    @Override
    public void onClick(View v) {
        // TODO Auto-generated method stub
         
    }
});

内部类为以下代码，直接new的，不给他生成对象：

new OnClickListener() {
    @Override
    public void onClick(View v) {
        // TODO Auto-generated method stub
         
    }
}

7、私有内部类

如果一个内部类只希望被外部类中的方法操作，那么可以使用 private 声明内部类。

class Out {
    private int age = 12;
     
    private class In {
        public void print() {
            System.out.println(age);
        }
    }
    public void outPrint() {
        new In().print();
    }
}
 
public class Demo {
    public static void main(String[] args) {
        //此方法无效
        /*
        Out.In in = new Out().new In();
        in.print();
        */
        Out out = new Out();
        out.outPrint();
    }
}

运行结果：12

8、为什么局部内部类和匿名内部类只能访问 final 的局部变量?

原因：生命周期不同步

当外部类的方法结束时，局部变量就会被销毁了，但是内部类对象可能还存在(只有没有人再引用它时，才会死亡)。

当局部变量死亡后，内部类仍可以访问它，实际访问的是局部变量的"copy"。

将局部变量复制为内部类的成员变量时，必须保证这两个变量是一样的，也就是如果在内部类中修改了成员变量，方法中的局部变量也得跟着改变，怎么解决问题呢？

就只有将局部变量设置为final，保证内部类的成员变量和方法的局部变量的一致性。

若变量是final时：

• 若是基本类型，其值是不能改变的，就保证了copy与原始的局部变量的值是一样的；
• 若是引用类型，其引用是不能改变的，保证了copy与原始的变量引用的是同一个对象。