Java内部类:把类定义在另一个类的内部，该类就被称为内部类。

目录

1.什么是内部类

2.内部类的分类

1）成员内部类

2)静态内部类

3)局部内部类

4）匿名内部类

3.内部类的特点

4.内部类的意义

1)封装性

2)实现多继承

---

1.什么是内部类

把类定义在另一个类的内部，该类就被称为内部类。

如果在类 Outer 的内部再定义一个类 Inner，此时类 Inner 就称为内部类（或称为嵌套类），而类 Outer 则称为外部类（或称为宿主类）。

2.内部类的分类

内部类一般来说包括这四种：

成员内部类

静态内部类

局部内部类

匿名内部类

1）成员内部类

成员内部类——就是位于外部类成员位置的类

特点：可以使用外部类中所有的成员变量和成员方法（包括private的）

class Outer {
    private int age = 20;
    class Inner {
        public void show() {
         System.out.println(age);
    }
   }
}

class Test {
    public static void main(String[] ages) {
        Outer.Inner oi = new Outer().new Inner();
        oi.show();
    }
}

private修饰内部类

如果我们的内部类不想轻易被任何人访问，可以选择使用private修饰内部类，这

样我们就无法通过创建对象的方法来访问，想要访问只需要在外部类中定义一个

public修饰的方法，间接调用。这样做的好处就是，我们可以在这个public方法

中增加一些判断语句，起到数据安全的作用。

class Outer {
    private class Inner {
    public void show() {
    System.out.println(“密码备份文件”);
    }
}
//使用getXxx()获取成员内部类，可以增加校验语句（文中省略）
    public Inner getInner() {
    return new Inner();
        }
    }
    public static void main(String[] args) {
    Outer outer = new Outer();
    Outer.Inner inner = outer.getInner();
    inner.show();
}

2)静态内部类

这种被 static 所修饰的内部类，按位置分，属于成员内部类，但也可以称作静态内部类，也常叫做嵌套内部类.不能使用外部类的非static成员变量和成员方法

public class Outter {
    int age = 10;
    static int age2 = 20;
    public Outter() {
    }
    static class Inner {
    public void method() {
    System.out.println(age);//错误
    System.out.println(age2);//正确
    }
    }
}   
    public class Test {
    public static void main(String[] args) {
    Outter.Inner inner = new Outter.Inner();
    inner.method();
    }
}

3)局部内部类

局部内部类——就是定义在一个方法或者一个作用域里面的类

特点：主要是作用域发生了变化，只能在自身所在方法和属性中被使用

public class Demo2 {
    //局部内部类，定义在一个方法或者一个作用域里面的类
    private int n=10;
 
    public int sumN(){
        for (int i = 0; i < 10; i++) {
            n++;
            //局部内部类，只能在自身所在方法和属性中被使用
            class Demo1Inner{
                public void AddN(){
                    if (n%2==0){
                        n--;
                    }
                }
            }
        }
        return n;
    }
}

4）匿名内部类

一个没有名字的类，是内部类的简化写法

interface Inner {
    public abstract void show();
}
class Outer {
public void method(){
    new Inner() {
    public void show() {
    System.out.println("Hel loWorld");
    }
        }. show();
    }
}
class Test {
    public static void main(String[] args) {
    Outer o = new Outer();
    o.method();
    }
}

3.内部类的特点

内部类仍然是一个独立的类，在编译之后内部类会被编译成独立

的.class文件，但是前面冠以外部类的类名和$符号。

内部类不能用普通的方式访问。内部类是外部类的一个成员，因此内部

类可以自由地访问外部类的成员变量，无论是否为 private 的。

内部类声明成静态的，就不能随便访问外部类的成员变量，仍然是只能

访问外部类的静态成员变量。

4.内部类的意义

1)封装性

作为一个类的编写者，我们很显然需要对这个类的使用访问者的访问权限做出一

定的限制，我们需要将一些我们不愿意让别人看到的操作隐藏起来.

2)实现多继承

public class Father{
    public String powerFul = "市长";
}
public class Mother{
    public String wealthy = "一百万";
}

public class Son{
    class Extends_Father extends Father{
    }
    class Extends_Mother extends Mother{
    }
    public voidsayHello(){
    String father = new Extends_Father().powerFul;
    String mother = new Extends_Mother().wealthy;
    System.out.println("my father is:"+father + "my mother has:"+mother);
    }
}