內部類分爲：成員內部類，局部內部類，靜態內部類，匿名內部類
下面分別介紹這幾種類的禁忌
成員內部類：
一個類中直接定義的內部類，成員內部類與普通類的成員沒什麼區別，可以與普通成員一樣進行修飾和限制。
不能的點：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的後面，用其實現一個接口或一個類。