成員內部類：
1.可以直接訪問外部類的所有成員，包含私有的
class Outer01{//外部類
private int n1 = 10;
public String name = "張三";
class Innter01{
public void say0(){
System.out.println("Outer01 的n1 =" + n1 +" outer01 的 name ="+ name );
}}}2.可以添加任意訪問修飾符(public、protected、默認、private),因為它的地位就是一個成員。
3.作用域 和外部類的其他成員一樣，為整個類體比如前面案例，在外部類的成員方法中創建成員內部類對象，再調用方法.
4.成員內部類---訪問---->外部類成員（比如屬性）[訪問方式：直接訪問]（說明）
5.外部類---訪問--->成員內部類（說明）訪問方式：創建對象，再訪問
6.外部其他類---訪問---->成員內部類
7.如果外部類和內部類的成員重名時，內部類訪問的話，默認遵循就近原則，如果想訪問外部類的成員，則可以使用（外部類名.this.成員）去訪問
package com.hspedu.innerclass;
public class MemberInnerClass01 {
public static void main(String[] args) {
Outer08 outer08 = new Outer08();
outer08.t1();
//外部其他類，使用成員內部類的三種方式
//解讀
// 第一種方式
// outer08.new Inner08(); 相當于把 new Inner08()當做是 outer08 成員
// 這就是一個語法，不要特別的糾結. Outer08.Inner08 inner08 = outer08.new Inner08();
inner08.say();
// 第二方式 在外部類中，編寫一個方法，可以返回 Inner08 對象
Outer08.Inner08 inner08Instance = outer08.getInner08Instance();
inner08Instance.say();
}
}
class Outer08 { //外部類
private int n1 = 10;
public String name = "張三";
private void hi() {
System.out.println("hi()方法...");
}
//1.注意: 成員內部類，是定義在外部內的成員位置上
//2.可以添加任意訪問修飾符(public、protected 、默認、private),因為它的地位就是一個成員
public class Inner08 {//成員內部類
private double sal = 99.8;
private int n1 = 66;
public void say() {
//可以直接訪問外部類的所有成員，包含私有的
//如果成員內部類的成員和外部類的成員重名，會遵守就近原則. //，可以通過 外部類名.this.屬性 來訪問外部類的成員
System.out.println("n1 = " + n1 + " name = " + name + " 外部類的 n1=" + Outer08.this.n1);
hi();
}
}
//方法，返回一個 Inner08 實例
public Inner08 getInner08Instance(){
return new Inner08();
}
//寫方法
public void t1() {
//使用成員內部類
//創建成員內部類的對象，然后使用相關的方法
Inner08 inner08 = new Inner08();
inner08.say();
System.out.println(inner08.sal);
}
}靜態內部類：
說明：靜態內部類是定義在外部類的成員位置，并且有static修飾
1.可以直接訪問外部類的所有靜態成員，包含私有的，但不能直接訪問非靜態成員
2.可以添加任意訪問修飾符(public、protected、默認、private),因為它的地位就是一個成員。
3.作用域：同其他的成員，為整個類體
4.靜態內部類---訪問---->外部類（比如：靜態屬性）[訪問方式：直接訪問所有靜態成員]
5.外部類---訪問-->靜態內部類訪問方式：創建對象，再訪問
6.外部其他類---訪問--->靜態內部類7.如果外部類和靜態內部類的成員重名時，靜態內部類訪問的時，默認遵循就近原則，如果想訪問外部類的成員，則可以使用（外部類名.成員）去訪問
package com.hspedu.innerclass;
public class StaticInnerClass01 {
public static void main(String[] args) {
Outer10 outer10 = new Outer10();
outer10.m1();
//外部其他類 使用靜態內部類
//方式 1
//因為靜態內部類，是可以通過類名直接訪問(前提是滿足訪問權限)
Outer10.Inner10 inner10 = new Outer10.Inner10();
inner10.say();
//方式 2
//編寫一個方法，可以返回靜態內部類的對象實例. Outer10.Inner10 inner101 = outer10.getInner10();
System.out.println("============");
inner101.say();
Outer10.Inner10 inner10_ = Outer10.getInner10_();
System.out.println("************");
inner10_.say();
}
}
class Outer10 { //外部類
private int n1 = 10;
private static String name = "張三";
private static void cry() {}
//Inner10 就是靜態內部類
//1. 放在外部類的成員位置
//2. 使用 static 修飾
//3. 可以直接訪問外部類的所有靜態成員，包含私有的，但不能直接訪問非靜態成員
//4. 可以添加任意訪問修飾符(public、protected 、默認、private),因為它的地位就是一個成員
//5. 作用域 ：同其他的成員，為整個類體
static class Inner10 {
private static String name = "韓順平教育";
public void say() {
//如果外部類和靜態內部類的成員重名時，靜態內部類訪問的時，
//默認遵循就近原則，如果想訪問外部類的成員，則可以使用 （外部類名.成員）
System.out.println(name + " 外部類 name= " + Outer10.name);
cry();
}
}
public void m1() { //外部類---訪問------>靜態內部類 訪問方式：創建對象，再訪問
Inner10 inner10 = new Inner10();
inner10.say();
}
public Inner10 getInner10() {
return new Inner10();
}
public static Inner10 getInner10_() {
return new Inner10();
}
}
