java内部类和匿名内部类的作用是什么？
有四种类型:成员内部类、局部内部类、静态内部类和匿名内部类。
1.成员内部类:即作为外部类的成员存在，与外部类的属性和方法并列。
注意:静态变量不能在成员的内部类中定义，但是外部类的所有成员都可以被访问。
公共类外部{
私有静态int I = 1；
private int j = 10；
private int k = 20
public static void outer _ f 1(){
//做更多的事情
}
public void out_f2(){
//做更多的事情
}
//成员内部类
内部类{
//static int inner _ I = 100；//不允许在内部类中定义静态变量
int j = 100；//内部类中外部类的实例变量可以保存在* * *
int inner _ I = 1；
void inner_f1(){
system . out . println(I)；//如果外部类的变量和内部类的变量没有重名，可以用变量名直接访问外部类的变量。
system . out . println(j)；//在内部类中访问内部类自己的变量，直接使用变量名。
system . out . println(this . j)；//也可以用“这个。变量名”来访问内部类变量。
//要在外部类中访问与内部类同名的实例变量，可以使用“外部类名。这个。变量名”。
system . out . println(k)；//如果外部类的变量和内部类的变量没有重名，可以用变量名直接访问外部类的变量。
outer _ f 1()；
outer _ F2()；
}
}
//外部类的非静态方法访问成员的内部类。
public void outer_f3(){
Inner Inner = new Inner()；
inner . inner _ f 1()；
}
//外部类的静态方法访问成员内部类，就像在外部类之外访问成员内部类一样。
public static void outer_f4(){
//step1创建外部类对象
Outer out = new Outer()；
//* * *第二步根据外部类对象建立内部类对象* * *
Inner Inner = out . new Inner()；
//step3访问内部类的方法
inner . inner _ f 1()；
}
公共静态void main(String[] args){
outer _ F4()；
}
}
成员内部类的优点:
(1)作为外部类的成员，内部类可以访问外部类的私有成员或属性。(即使外部类被声明为私有，它对内部类仍然是可见的。)
⑵使用内部类定义外部类中不可访问的属性。这样，外部类中的访问权限就小于外部类的私有。
注意:内部类是编译时的一个概念。一旦编译成功，就会变成两个完全不同的类。对于名为outer的外部类及其内部定义的名为inner的内部类。编译后有两个类别:outer.class和outer$inner.class
2.局部内部类:在方法中定义的内部类，类似于局部变量，局部内部类前没有修饰符public或private，其作用域是定义它的代码块。
注意:不能在局部内部类中定义静态变量，可以访问外部类的局部变量(即方法中的变量)，但变量必须是final。
公共类外部{
private int s = 100；
private int out _ I = 1；
public void f(final int k){
最终int s = 200
int I = 1；
final int j = 10；
类Inner{ //是在方法内部定义的。
int s = 300//可以定义一个与外部类同名的变量。
//static int m = 20；//不能定义静态变量。
Inner(int k){
inner _ f(k)；
}
int inner _ I = 100；
void inner_f(int k){
system . out . println(out _ I)；//如果内部类没有与外部类同名的变量，则可以在内部类中直接访问外部类的实例变量。
system . out . println(k)；//* * * *可以访问外部类的局部变量(即方法内的变量)，但变量必须是final的* * * *。
//system . out . println(I)；
system . out . println(s)；//如果内部类中存在与外部类同名的变量，则直接用变量名访问的是内部类的变量。
system . out . println(this . s)；//使用“这个。变量名”来访问内部类变量。
system . out . println(outer . this . s)；//使用外部“外部类名”访问外部类变量。这个。变量名"
}
}
新内心(k)；
}
公共静态void main(String[] args) {
//对本地内部类的访问必须先有外部类对象。
Outer out = new Outer()；
out . f(3)；
}
}
注意:
局部内部类不能直接在类外部生成(以确保局部内部类对外界不可见)。如果要使用局部内部类，需要生成一个对象，对象调用方法，然后可以在方法中调用它的局部内部类。内部类和接口之间实现强制弱耦合，接口由局部内部类实现，方法中返回接口类型，使得局部内部类不可见，实现类的可见性被屏蔽。
3.静态内部类:静态内部类是在类中定义的，除了任何方法，都是由static定义的。
注意:静态或非静态成员可以在静态内部类中定义。
公共类外部{
私有静态int I = 1；
private int j = 10；
public static void outer _ f 1(){
}
public void outer_f2(){
}
//静态内部类可以用public、protected、private和private来修饰。
//静态或非静态成员可以在静态内部类中定义。
静态类内部{
static int inner _ I = 100；
int inner _ j = 200
静态void inner_f1(){
system . out . println(" outer . I "+I)；//静态内部类只能访问外部类的静态成员。
outer _ f 1()；//包括静态变量和静态方法
}
void inner_f2(){
//system . out . println(" outer . I "+j)；//静态内部类不能访问外部类的非静态成员。
//outer _ F2()；//包括非静态变量和非静态方法
}
}
public void outer_f3(){
//外部类访问内部类的静态成员:内部类。静态成员
system . out . println(inner . inner _ I)；
inner . inner _ f 1()；
//外部类访问内部类的非静态成员:实例化内部类即可。
Inner Inner = new Inner()；
inner . inner _ F2()；
}
公共静态void main(String[] args) {
新的外部()。outer _ F3()；
}
}
注意:* * * * * *生成(新的)静态内部类不需要外部类成员:这就是静态内部类和成员内部类的区别。静态内部类的对象可以直接生成:
外部。内in =新外。inner()；
而不生成外部类对象。这实际上使静态内部类成为了顶级类。静态内部类不能由private定义。*******
示例:
对两个类使用相同的方法:
阶级人士
{
run()；
}
机器类{
run()；
}
此时有一个机器人类:
类机器人扩展人器机。
此时无法直接实现Run()。
注意:当类和接口(或接口和接口)之间存在方法命名冲突时，必须使用内部类来实现。多重继承不能完全用接口实现，但是用接口和内部类，可以实现真正的多重继承。
4.匿名内部类
匿名内部类是一种特殊的局部内部类，通过匿名类实现接口。
IA被定义为一个接口。
IA I = new IA(){ }；
匿名内部类的特征:
1，一个类用来继承其他类或者实现接口，不需要增加额外的方法，只是继承方法提前或者覆盖。
2，只是获取一个对象实例，不需要知道它的实际类型。
3，类名没有意义，就是不需要。
公共类外部{
私有静态int I = 1；
private int j = 10；
public static void outer _ f 1(){
}
public void outer_f2(){
}
//静态内部类可以用public、protected、private和private来修饰。
//静态或非静态成员可以在静态内部类中定义。
静态类内部{
static int inner _ I = 100；
int inner _ j = 200
静态void inner_f1(){
system . out . println(" outer . I "+I)；//静态内部类只能访问外部类的静态成员。
outer _ f 1()；//包括静态变量和静态方法
}
void inner_f2(){
//system . out . println(" outer . I "+j)；//静态内部类不能访问外部类的非静态成员。
//outer _ F2()；//包括非静态变量和非静态方法
}
}
public void outer_f3(){
//外部类访问内部类的静态成员:内部类。静态成员
system . out . println(inner . inner _ I)；
inner . inner _ f 1()；
//外部类访问内部类的非静态成员:实例化内部类即可。
Inner Inner = new Inner()；
inner . inner _ F2()；
}
公共静态void main(String[] args) {
新的外部()。outer _ F3()；
}
}
注意:匿名内部类必须在new后面，它隐式地实现了一个接口或类。没有类名。根据多态性，我们使用它的父类名。因为是局部内部类，所以局部内部类的所有限制都会对其生效。匿名内部类是唯一没有构造函数的类。大多数匿名内部类用于接口回调。匿名内部类在编译时被系统自动命名为$1.class。如果一个对象被编译成一个接口，那么它就作为一个实现这个接口的类来运行。因为匿名内部类没有构造函数，所以用途非常有限。需要多个对象时使用局部内部类，所以局部内部类的应用相对更多。构造函数不能在匿名内部类中定义。如果一个对象被编译成一个接口，那么它就作为一个实现这个接口的类来运行。
________________________________________________________________________________
内部课程摘要:
1.首先，内部类被视为外部类的特殊成员，所以它有封闭的类成员级别:私有、受保护、友好)、公共。
它有针对类成员的修饰符:static、final、abstract。
2.非静态内部类嵌套内部类，隐含指向外部类的指针，所以可以访问外部类的所有资源(当然包括私有)。
当外部类访问内部类的成员时，它必须首先获得内部类的对象，这取决于内部类成员的封装级别。
非静态内部类不能包含任何静态成员。
3.静态内部类:静态内部类，不再包含外部类的这个指针，在外部类加载时初始化。
静态内部类可以包含静态或非静态成员。
静态内部类只能访问外部类的静态成员。
外部类访问静态内部类的成员，遵循一般的类规则。对于静态成员，可以用类名来访问它们。成员，而对于非静态成员，您只能
用对象访问。成员
4.对于方法或块中的内部类，只能访问块或方法中的最终变量。
类成员有静态和非静态两种，内部类也是如此。
非静态内部类的实例必须在外部类的方法中或通过外部类的实例(outerclassinsistancename)创建。新的内部类名(构造函数参数))，并且可以直接访问外部类的信息，通过OuterClassName.this可以引用外部类对象。
静态内部类的实例可以直接创建，不需要引用外部类实例。
静态和非静态内部类都有对外部类的引用。
非静态内部类不允许有静态成员。
方法中的内部类只允许访问方法中的最终局部变量和方法的最终参数列表，所以内部类和方法中的内部类没有区别。但是，不能在方法外部访问方法中的内部类，并且方法中不能有静态内部类。
如果匿名内部类从某个接口继承，它必须实现指定接口的方法，并且不带任何参数。
如果匿名内部类从类继承，则参数必须作为父类的构造函数的参数传递。