JAVA基础之内部类

内部类：定义在类中的类叫内部类。

内部类的访问特点：

1.内部类可以直接访问外部类中的成员。

2.外部类要访问内部类，必须先创建内部类的对象。

内部类的使用：一般用于类的设计。

分析事物时，发现该事物描述中还有事物，而且这个事物还在访问描述事物的内容。

这时就可以将事物中的事物定义成内部类来描述。

比如：

class Love
{
private String love="随意";
private static  String like="随便";//因为静态只能访问静态，所以like变量也得是静态的。
class Like
{
void show()
{
System.out.println("show run..."+love);
}
}
static class love//这是一个静态的内部类，相当于一个外部类。
{
void show()
{
System.out.println("show run..."+like);
}
static void like()//如果内部类中定义了静态成员，那么该内部类也必须是静态的。
//因为静态成员是随着类的加载而存在的，当外部类开始加载的时候，内部类不是静态就无法存在
//更谈不上访问内部类中的静态成员。
{
System.out.println("遇见"+like);
}
}
public void getLove()
{
Like l =new Like();
l.show();
}
}

内部类直接访问外部类中的成员：

内部类需持有外部类的引用。格式为：外部类名.this

比如

class orange
{
String love="烦";
class apple
{
String love="迷茫";
void show()
{
String love="去";
System.out.println(love);//方法存在与栈内存中，当栈内存与堆内存存在相同变量时
//获取的是栈内存中的变量值，所以这个打印出来的是“茵茵”
System.out.println(this.love);//用了this关键字，输出的就是对象中的变量值。
//所以这句输出的是“迷茫”
System.out.println(orange.this.love);//用了外部类名就可以输出（调用）外部类的成员变量。
//所以这句输出的是“烦”
}
}
public void work()
{
new apple().show();//这是匿名对象调用。
}
}

内部类也可以存放在局部位置上。

内部类在局部位置上只能访问局部中被final修饰的局部变量。

比如：

class hello
{
String a="哈哈";
void show()
{
int b=8;//在JDK8版本以前，这个局部变量必须要加final关键字才能被内部类的方法所访问，否则就会报错。
//因为方法执行完后就弹栈了，内部类中的方法就访问不到这个局部变量。
//加final关键字的意思就是固定这个值。
//虽然JDK8以后不用加final关键字也能编译运行，但是这个变量值依然不可更改，更改即报错。
class world
{
void geta()
{
System.out.println(b);
}
}
new world().geta();
}
}

匿名内部类：

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

他的前提是：

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

匿名内部类：其实就是一个匿名子类对象。

格式：new 父类名or接口名(){子类内容}

比如：

abstract class Why
{
abstract void show();
}
class Who
{
int num=7;
class You extends Why//这是普通内部类继承外部类。
{
void show()
{
System.out.println(num);
}
}
void work()
{
new You().show();
new Why()//这是匿名内部类，直接用父类名创建子类对象，并覆盖父类中的方法。
{
void show()
{
System.out.println(num);
}
}.show();//.show();就是在调用匿名内部类中的方法。
}
}

匿名内部类的应用场景之一：

当函数参数是接口类型时，而且接口中的方法不超过三个。

可以用匿名内部类作为实际参数进行传递。

比如：

interface Inter
{
void show1();
void show2();
}
class Niming
{
class Inner implements Inter//这是一般方法。
{
public void show1()
{
System.out.println("真的爱你");
}
public void show2()
{
System.out.println("喜欢你");
}
}
void show3()
{
Inner in=new Inner();
in.show1();
in.show2();
System.out.println("---------");
Inter ia=new Inter()//这是匿名内部类的方法。当父类（接口）方法超过一个时可用多态形式命名新对象。
{//然后以父类类型命名匿名对象进行调用多个方法。
public void show1()
{
System.out.println("真的爱你");
}
public void show2()
{
System.out.println("喜欢你");
}
};
ia.show1();
ia.show2();
}
}
class TangYi
{
void show()
{
new Object()
{
void show1()
{
System.out.println("狂人山庄");
}
}.show1();//这个可以运行。
Object obj=new Object()
{
void show2()
{
System.out.println("乐与怒");
}
};
obj.show2();//这个会挂掉，编译失败。
/*因为虽然创建的是子类对象，但是类类型是父类的，也就是多态形式。
Object是没有定义任何方法的，所以show2()的方法就是子类特有的。
父类类型的子类对象当然访问不到子类的特有内容。
（匿名内部类这个子类对象被向上转型成了Object类型，这样就无法访问子类的特有方法）*/
}
}
class NeiBulei
{
public static void main(String[] args)
{
Love l= new Love();
l.getLove();
//还有一种不多见的访问形式，就是直接访问外部类中的内部类中的成员。比如：
Love.Like a=new Love().new Like();//所属关系一定要写对，否则无法访问。
a.show();
System.out.println("---------");
//如果内部类是静态的，这时就相当于一个外部类。
Love.love b=new Love.love();
b.show();
System.out.println("---------");
//如果内部类是静态的，而且内部类中的成员也是静态的。那我们可以直接类名调用。
Love.love.like();
System.out.println("---------");
new orange().work();//匿名对象调用。
System.out.println("---------");
new hello().show();
System.out.println("---------");
new Who().work();
System.out.println("---------");
new	Niming().show3();
System.out.println("---------");
show(new Inter()//这里可以看出，如果方法过多，阅读性就相当差了。
{//而且这里和内部类其实没什么关系了，只是一个匿名子类，也就是匿名对象。
public void show1()
{
System.out.println("情人");
}
public void show2()
{
System.out.println("海阔天空");
}
});
System.out.println("---------");
new TangYi().show();
}
public static void show(Inter in)
{
in.show1();
in.show2();
}
}