允许一个类的定义出现在另一个类中，将处于另一个类中的“寄生类”称为“内部类”（inner class），也称为“类属类”

这样的一组类在逻辑上是一个整体，内部类和外层封装它的类之间存在逻辑上的从属关系

内部类对其封装类的内部成员有访问权限

举例1：

public class Outer1 { 
                  private int size; 
                  /* 定义一个内部类，名为 "Inner" */ 
                  public class Inner { 
                      public void doStuff() { 
                        // 内部类可以访问外部类的私有属性 
                        size++; 
                     } 
                 } 
                 public void testTheInner() { 
                    Inner i = new Inner(); 
                    i.doStuff(); 
                  } 
        }

实例化内部类的两种方法：

---法一：

Outer.Inner in=new Outer().new Inner();

---法二：

Outer o=new Outer();

Outer.Inner I=o.new Inner();

如果内部类是static的，也可以用下面方法：

Outer.Inner in=new Outer.Inner();

举例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

举例3：静态内部类

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();
                }
        }

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

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

实例4：私有内部类

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(); 
                } 
        }

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

上面的代码中，我们必须在Out类里面生成In类的对象进行操作，而无法再使用Out.In in = new Out().new In() 生成内部类的对象

也就是说，此时的内部类只有外部类可控制。