面向对象（内部类）

内部类

内置类、嵌套类：一个类定义在另一个类的里面

 

外部类{

内部类{}

}

外部其他类{}

 

访问特点：

1.内部类可以直接访问外部类中的成员，包括私有成员

2.而外部类要访问内部类中的成员，必须建立内部类的对象

————————————————————————————

如图，外部类的method方法想访问内部类的function()方法

则在method方法中实例化内部类，调用function

——————————————————————————————

如何直接在main方法中访问内部类的成员呢（不常用）

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

//        in.function();

外部类名.内部类名 x = new 外部类().new 内部类();

——————————————————————————————

内部引用外部的原理：就是如果内部类没有x = 4, x = 6这两个变量，那么打印x,会输出外部类的x = 3

原因就是，前面加了隐式的Outer.this

this，指代这个类中的对象，那么Outer.this不就指代Outer类中的对象吗

如图，如何打印外部类的变量呢

在内部类的输出语句中，x——>6    this.x——>4    Outer.this.x——>3

______________________________________________________________________________

内部类可以被成员修饰符修饰 private class 内部类名{}

static class 内部类名{}：静态内部类

当内部类被static修饰后，访问外部类中的static成员

在外部其他类中，直接访问静态内部类

new Outer.Inner().function();

____________________________________________

当内部类中定义了静态成员，内部类必须是静态的

当外部类中的静态方法访问内部类时，内部类必须是静态的

————————————————————————————

当一个类(body)想要直接访问另一个类(heart)中的成员的时候，可以将这个类定义为内部类

并把内部类封装(private class heart),然后，外部类中定义方法(show)将内部类暴露出去访问

------------------------------------------------------------------------------------

上面定义的内部类都是在成员的位置上，还可以定义在局部的位置上

如图，这个内部类定义在了method方法里面

并且，局部内部类不可以有静态成员，

为什么呢，因为如果有静态成员，那么这个内部类也必须是静态，但是，静态是成员修饰符，不可以修饰局部

所以局部内部类不能被static修饰，所以，里面就不能定义静态成员

成员内部类就可以用static修饰

-----------------------------------------------------------------------------

局部内部类示例

---------------------------------------------------------

局部内部类1.不可以被成员修饰符修饰（static..）

可以方法外部类的成员，但不可以访问他所在的局部变量

只能访问被final修饰的局部变量 final int a  final int y = 4;

注意，final可是只能赋一次值哦

那这个怎么调用了一次7，一次8 呢，怎么没事

因为这里的a是一个局部变量，进的是栈内存，当out.method()方法执行结束后，

内存释放了，也就是说给a 赋的值没了，那再执行的时候，又在栈内存，然后赋一个8就没事

---------------------------------------------------------------------------------------

匿名内部类

1.其实就是内部类的简写格式

2.定义匿名内部类的前提：

内部类必须是继承一个类或者实现接口

--------------------------------------------------

如图，Outer类里面本身是有一个Inner内部类(该类继承了AbsDemo方法)

并在function里面new 内部类，调用show方法

这时，我把内部类部分注释掉，直接new AbsDemo(直接new父类)，后面带着方法体，里面重写show方法，并在后面调用show方法

这种形式，就是匿名内部类

 

匿名内部类有弊端，如果抽象类有多个抽象方法，那么我就要重写多个，就麻烦了

即，如果内部类有多个方法，那我就要多次new 父类(){}.show或者.add()

那很麻烦，但我如果非要起个名字的话，只能是AbsDemo ad = new AbsDemo(){

    复写方法show

    本类方法add

}

那么，当我调用add方法时，是不行的，因为我是父类new的，而父类不能调用子类特有的方法add

(不懂的话参考多态)

注：匿名内部类其实都是子类对象，要么继承了父类，要么实现了接口，而内部类里面的方法体，就是复写了父类的方法