内部类
(一) 概述
把类定义在另一个类的内部，该类就被称为内部类。
举例：把类Inner定义在类Outer中，类Inner就被称为内部类。
class Outer {
class Inner {
}
}
(二) 内部类的访问规则
A:可以直接访问外部类的成员，包括私有
B:外部类要想访问内部类成员，必须创建对象
- 内部类被static修饰：可以直接new,没有外部类的关联引用，不必创建外部类后才能去创建内部类
Inner in = new Inner();
- 内部类没有被static修饰:得先new出来外部类的实例，再new内部类的，内部类有一个外部类的引用，内部类的第二篇文章会解释这部分
Inner in = new Outer().new Inner();
(三) 内部类的分类
A：成员内部类
B：局部内部类
C：静态内部类
D：匿名内部类
(1) 成员内部类
成员内部类——就是位于外部类成员位置的类
特点：可以使用外部类中所有的成员变量和成员方法（包括private的）
1.没有使用static修饰的内部类。
2.在成员内部类中不允许出现静态变量和静态方法的声明。
static只能用在静态常量的声明上。
3.成员内部类中可以访问外部类中所有的成员(变量，方法)，包含私有成员，如果在内部类中定义有和外部类同名的实例变量，访问方法：
OuterClass.this.outerMember;
4.构建内部类的实例，要求必须外部类的实例先存在
外部类的外部/外部类的静态方法：new Outer().new Inner();
外部类的实例方法：
new Inner();
this.new Inner();
A：格式：
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();
}
}
B：创建对象时：
//成员内部类不是静态的：
外部类名.内部类名 对象名 = new 外部类名().new 内部类名();
//成员内部类是静态的：
外部类名.内部类名 对象名 = new 外部类名.内部类名();
C：成员内部类常见修饰符：
A：private
如果我们的内部类不想轻易被任何人访问，可以选择使用private修饰内部类，这样我们就无法通过创建对象的方法来访问，想要访问只需要在外部类中定义一个public修饰的方法，间接调用。这样做的好处就是，我们可以在这个public方法中增加一些判断语句，起到数据安全的作用。
class Outer {
private class Inner {
public void show() {
System.out.println(“密码备份文件”);
}
}
public void method() {
if(你是管理员){
Inner i = new Inner();
i.show();
}else {
System.out.println(“你没有权限访问”);
}
}
}
下面我们给出一个更加规范的写法
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();
}
}
B：static
这种被 static 所修饰的内部类，按位置分，属于成员内部类，但也可以称作静态内部类，也常叫做嵌套内部类。具体内容我们在下面详细讲解。
D：成员内部类经典题(填空)
请在三个println 后括号中填空使得输出25,20,18
class Outer {
public int age = 18;
class Inner {
public int age = 20;
public viod showAge() {
int age = 25;
System.out.println(age);//空1
System.out.println(this.age);//空2
System.out.println(Outer.this.age);//空3
}
}
}
(2) 局部内部类
局部内部类——就是定义在一个方法或者一个作用域里面的类
1.定义在方法体，甚至比方法体更小的代码块中
2.类比局部变量。
3.局部内部类是所有内部类中最少使用的一种形式。
4.局部内部类可以访问的外部类的成员根据所在方法体不同。
- 如果在静态方法中：
可以访问外部类中所有静态成员，包含私有
- 如果在实例方法中：
可以访问外部类中所有的成员，包含私有。
5.局部内部类可以访问所在方法中定义的局部变量，但是要求局部变量必须使用final修饰。
A 格式：
class Outer {
public void method(){
class Inner {
}
}
}
B：访问时：
//在局部位置，可以创建内部类对象，通过对象调用和内部类方法
class Outer {
private int age = 20;
public void method() {
final int age2 = 30;
class Inner {
public void show() {
System.out.println(age);
//从内部类中访问方法内变量age2，需要将变量声明为最终类型。
System.out.println(age2);
}
}
Inner i = new Inner();
i.show();
}
}
C: 为什么局部内部类访问局部变量必须加final修饰呢？
因为局部变量是随着方法的调用而调用，使用完毕就消失，而堆内存的数据并不会立即消失。
所以，堆内存还是用该变量，而该变量已经没有了。为了让该值还存在，就加final修饰。
原因是，当我们使用final修饰变量后，堆内存直接存储的是值，而不是变量名。
（即上例 age2 的位置存储着常量30 而不是 age2 这个变量名）
(3) 静态内部类
我们所知道static是不能用来修饰类的,但是成员内部类可以看做外部类中的一个成员,所以可以用static修饰,这种用static修饰的内部类我们称作静态内部类,也称作嵌套内部类.
特点：不能使用外部类的非static成员变量和成员方法
1.声明在类体部，方法体外，并且使用static修饰的内部类
2.访问特点可以类比静态变量和静态方法
3.脱离外部类的实例独立创建
在外部类的外部构建内部类的实例
new Outer.Inner();
在外部类的内部构建内部类的实例
new Inner();
4.静态内部类体部可以直接访问外部类中所有的静态成员，包含私有
解释：非静态内部类编译后会默认的保存一个指向外部类的引用，而静态类却没有。
简单理解：
即使没有外部类对象，也可以创建静态内部类对象，而外部类的非static成员必须依赖于对象的调用，静态成员则可以直接使用类调用，不必依赖于外部类的对象，所以静态内部类只能访问静态的外部属性和方法。
class Outter {
int age = 10;
static age2 = 20;
public Outter() {
}
static class Inner {
public 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();
}
}
(4) 匿名内部类
正所谓匿名内部类，正如它的字面意思一样，也就是没有名字的内部类(没有类名)。也是因为没有名字所以匿名内部类只能执行一次，想应该也能想到这一点吧，匿名内部类通常用简化代码编写。
一般都是有一个接口或者一个抽象类，按照常规逻辑，我们写一个子类例如 public xxName class extends xx...这样子，但是有时候可能这个子类只用了一次，我们如果使用时还是先创建一个子类，然后在代码中去创建子类的对象，就显得繁琐，那我们不去创建子类这个类，直接new 父类或接口，省去了创建子类的过程，new出来的这个父类或接口是没有类名字的，故叫做匿名内部类。
因为匿名内部类用的比较多，为了让大家彻底明白匿名内部类，以及使用它的好处，给大家来2个有味道的代码对比下：
public interface Father {
void say();
}
class Son implements Father {
@Override
public void say() {
System.out.println("小可爱：爸爸，我想拉粑粑，你一会给我擦擦");
}
public static void main(String[] args) {
Father father = new Son();
father.say();
}
}
public interface Father {
void say();
public static void main(String[] args) {
new Father() {
@Override
public void say() {
System.out.println("小可爱：爸爸，我想拉粑粑，你一会给我擦擦");
}
}.say();
}
}
//同样实现了上面的功能，但是我们并没有创建中间类son,而是用了new Father{...},创建了一个对象，省去了中间类的定义，我们对象是根据类来创建的，类就像模板，模板有个名字，类名，这里没有模板自然就没有类名，也就是匿名类哈，我好啰嗦呀，哈哈哈。希望大家不要嫌弃，我就是这么的婆婆妈妈西喜爱
- 1.没有名字的局部内部类。
- 2.没有class,interface,implements,extends关键字
- 3.没有构造器。
- 4.一般隐式的继承某一个父类或者实现某一个接口
A 格式：
new 类名或者接口名() {
重写方法();
}
本质：其实是继承该类或者实现接口的子类匿名对象
这也就是下例中，可以直接使用 new Inner() {}.show(); 的原因 == 子类对象.show();
interface Inner {
public abstract void show();
}
class Outer {
public void method(){
new Inner() {
public void show() {
System.out.println("HelloWorld");
}
}.show();
}
}
class Test {
public static void main(String[] args) {
Outer o = new Outer();
o.method();
}
}
如果匿名内部类中有多个方法又该如何调用呢？
Inter i = new Inner() { //多态，因为new Inner(){}代表的是接口的子类对象
public void show() {
System.out.println("HelloWorld");
}
};
B：匿名内部类在开发中的使用
我们在开发的时候，会看到抽象类，或者接口作为参数。
而这个时候，实际需要的是一个子类对象。
如果该方法仅仅调用一次，我们就可以使用匿名内部类的格式简化。
-----------------------------------------------------------------------------
2019-8-17更新补充
使用内部类的原因
(一) 封装性
作为一个类的编写者，我们很显然需要对这个类的使用访问者的访问权限做出一定的限制，我们需要将一些我们不愿意让别人看到的操作隐藏起来，
如果我们的内部类不想轻易被任何人访问，可以选择使用private修饰内部类，这样我们就无法通过创建对象的方法来访问，想要访问只需要在外部类中定义一个public修饰的方法，间接调用。
public interface Demo {
void show();
}
class Outer {
private class test implements Demo {
public void show() {
System.out.println("密码备份文件");
}
}
public Demo getInner() {
return new test();
}
}
我们来看其测试
public static void main(String[] args) {
Outer outer = new Outer();
Demo d = outer.getInner();
i.show();
}
//运行结果
密码备份文件
这样做的好处之一就是，我们可以在这个public方法中增加一些判断语句，起到数据安全的作用。
其次呢，我们的对外可见的只是getInner()这个方法，它返回了一个Demo接口的一个实例，而我们真正的内部类的名称就被隐藏起来了
(二) 实现多继承 ※
我们之前的学习知道，java是不可以实现多继承的，一次只能继承一个类，我们学习接口的时候，有提到可以用接口来实现多继承的效果，即一个接口有多个实现，但是这里也是有一点弊端的，那就是，一旦实现一个接口就必须实现里面的所有方法，有时候就会出现一些累赘，但是使用内部类可以很好的解决这些问题
public class Demo1 {
public String name() {
return "BWH_Steven";
}
}
public class Demo2 {
public String email() {
return "xxx.@163.com";
}
}
public class MyDemo {
private class test1 extends Demo1 {
public String name() {
return super.name();
}
}
private class test2 extends Demo2 {
public String email() {
return super.email();
}
}
public String name() {
return new test1().name();
}
public String email() {
return new test2().email();
}
public static void main(String args[]) {
MyDemo md = new MyDemo();
System.out.println("我的姓名:" + md.name());
System.out.println("我的邮箱:" + md.email());
}
}
我们编写了两个待继承的类Demo1和Demo2，在MyDemo类中书写了两个内部类，test1和test2 两者分别继承了Demo1和Demo2类，这样MyDemo中就间接的实现了多继承
(三) 用匿名内部类实现回调功能
我们用通俗讲解就是说在Java中，通常就是编写一个接口，然后你来实现这个接口，然后把这个接口的一个对象作以参数的形式传到另一个程序方法中， 然后通过接口调用你的方法，匿名内部类就可以很好的展现了这一种回调功能
public interface Demo {
void demoMethod();
}
public class MyDemo{
public test(Demo demo){
System.out.println("test method");
}
public static void main(String[] args) {
MyDemo md = new MyDemo();
//这里我们使用匿名内部类的方式将接口对象作为参数传递到test方法中去了
md.test(new Demo){
public void demoMethod(){
System.out.println("具体实现接口")
}
}
}
}
(四) 解决继承及实现接口出现同名方法的问题
编写一个接口 Demo
public interface Demo {
void test();
}
编写一个类 MyDemo
public class MyDemo {
public void test() {
System.out.println("父类的test方法");
}
}
编写一个测试类
public class DemoTest extends MyDemo implements Demo {
public void test() {
}
}
这样的话我就有点懵了，这样如何区分这个方法是接口的还是继承的，所以我们使用内部类解决这个问题
public class DemoTest extends MyDemo {
private class inner implements Demo {
public void test() {
System.out.println("接口的test方法");
}
}
public Demo getIn() {
return new inner();
}
public static void main(String[] args) {
//调用接口而来的test()方法
DemoTest dt = new DemoTest();
Demo d = dt.getIn();
d.test();
//调用继承而来的test()方法
dt.test();
}
}
//运行结果
接口的test方法
父类的test方法
同时可以参考下这篇文章中的例子，多思考下为什么有这些特点，怎么解释，怎么让自己信服。内部类