内部类分为：成员内部类，局部内部类，静态内部类，匿名内部类
下面分别介绍这几种类的禁忌
成员内部类：
一个类中直接定义的内部类，成员内部类与普通类的成员没什么区别，可以与普通成员一样进行修饰和限制。
不能的点：1.不能含有static的变量和方法
2.可以访问外部类的所有成员
3.内部类和外部类的实例变量可以共存
package com.test;
public class Outer {
private static int number = 100;
private int j= 20;//共存的变量
private String name = "Java";
public static void outer_funOne(){
System.out.println("外部类Outer的静态方法:outer_funOne");
}
public void outer_funTwo(){
System.out.println("外部类的普通方法：outer_funTwo");
}
//成员内部类，可以访问外部类的所有成员
class Demo{
//内部类不允许定义静态变量
//static int demo_i = 100;
//内部类和外部类的实例变量可以共存
int j =50;
//成员内部类中的方法定义
public void demo_funOne(){
//内部类中访问内部类自己的变量直接用变量名
//也可以用 this.j
System.out.println(j);
//内部类中访问外部类的成员变量语法：外部类类名.this.变量名
System.out.println("内部类访问外部类变量："+Outer.this.j);
//如果内部类中没有与外部类中有相同的变量，则可以直接用变量名使用
System.out.println(name);
//内部类调用外部类方法
outer_funOne(); //静态方法
outer_funTwo(); //非静态方法
}
}
public static void outer_funThree(){
//外部类静态方法访问成员内部类
// 1、建立外部类对象
Outer out = new Outer();
// 2、根据外部类建立内部类对象
Demo demo = out.new Demo();
// 访问内部类方法
demo.demo_funOne();
//访问内部类字段
System.out.println("内部类成员字段："+demo.j);
}
public static void main(String[] args) {
//调用内部类的方法
// 1、创建外部类对象
Outer out = new Outer();
// 2、通过外部类对象创建内部类对象
Outer.Demo demo = out.new Demo();
// 1、2步简写
// Outer.Demo demo1 = new Outer().new Demo();
//方法调用
demo.demo_funOne();
}
}
局部内部类：
在方法中定义的内部类，称为局部内部类。
禁忌点：
1.不能有访问说明符（public，protected，private）
2.只能在定义该内部类的方法内实例化。
3.局部内部类对象不能用该内部类所在的方法的final局部变量。
package com.test;
public class Outer {
private static int number = 100;
private int j = 20;
private String name = "Java";
//定义外部类方法
public void outer_funOne(int k){
final int number = 100;
int j = 50;
//方法内部的类（局部内部类）
class Demo{
public Demo(int k){
demo_funOne(k);
}
//可以定义与外部类同名的变量
int number = 300;
//不可以定义静态变量
// static int j = 10;
//内部类的方法
public void demo_funOne(int k){
System.out.println("内部类方法：demo_funOne");
//访问外部类的变量，如果没有与内部类同名的变量，则可直接用变量名
System.out.println(name);
//访问外部类与内部类同名的变量
System.out.println(Outer.this.number);
System.out.println("内部类方法传入的参数是："+k);
}
}
new Demo(k);
}
public static void main(String[] args) {
//访问内部类必须要先有外部类对象
Outer out = new Outer();
out.outer_funOne(11);
}
}
静态内部类：
顾名思义，在内部类加上static。不需要内部类对象与外围类对象之间有联系，则用静态内部类。
禁忌点：
1.不用外围类的对象
2.不可访问非静态的外围类对象。
package com.test;
public class Outer {
private static int number = 100;
private int j = 20;
private String name = "Java";
public static void outer_funOne(){
System.out.println("外部类静态方法:outer_funOne");
}
public void outer_funTwo(){
}
//静态内部类可以用public、protected、private修饰
//静态内部类可以定义静态类或非静态内部类
private static class Demo{
static int j = 100;
String name = "C#";
//静态内部类里的静态方法
static void demo_funOne(){
//静态内部类只能访问外部类的静态成员（静态变量、静态方法）
System.out.println("静态内部类访问外部类静态变量："+number);
//访问外部类静态方法
outer_funOne();
}
//静态内部类非静态方法
void demo_funTwo(){
}
}
public void outer_funThree(){
//外部类访问内部类静态成员：内部类.静态成员
System.out.println(Demo.j);
//访问静态方法
Demo.demo_funOne();
//访问静态内部类的非静态成员，实例化内部类即可
Demo demo = new Demo();
//访问非静态变量
System.out.println(demo.name);
//访问非静态方法
demo.demo_funTwo();
}
public static void main(String[] args) {
new Outer().outer_funThree();
}
}
匿名内部类：
没有名字的内部类就叫匿名内部类。
适用条件：
1.只用到类的一个实例。
2.类在定义后马上用到
3.类很小
禁忌点：
1.匿名内部类中不能有构造方法
2.不能定义任何静态成员/方法/类
3.匿名内部类不能是 public，protected，private，static
4.只能创建匿名内部类的一个实例。
5.局部内部类的限制都对其有效
6.匿名内部类一定是在new的后面，用其实现一个接口或一个类。