1. 内部类接上上
2. 成员内部类 419-420
说明:成员内部类是定义在外部类的成员位置，并且没有static修饰。
1.可以直接访问外部类的所有成员，包含私有的
2. 可以添加任意访问修饰符(public、 protected、默认、private),因为它的地位就是一个成员。
3.作用域和外部类的其他成员一样， 为整个类体比如前面案例，在外部类的成员方法中创建成员内部类对象，再调用方法。
4.成员内部类-访--- >外部类成员(比如:属性)访问方式:直接访问
5.外部类-- -----成员内部类(说明)访问方式创建对象， 再访问
6.外部其他类访---成员内部类
7.如果外部类和内部类的成员重名时，内部类访问的话，默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类名.this.成员) 去访问
代码在com.stulzl.member_innerclass01.包中
Member_InnerClass01
package com.stulzl.member_innerclass01;
//成员内部类419-420
public class Member_InnerClass01 {
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();
}
}
//写一个方法,调用成员内部类
//外部类-- -----成员内部类(说明)访问方式创建对象，再访问
public void t1(){
//使用成员内部类
//创建成员内部类的对象，然后使用相关的方法
Inner08 inner08 = new Inner08();
inner08.say();
System.out.println(inner08.sal);
}
//方法，返回一个 Inner08 实例
public Inner08 getInner08Instance(){
return new Inner08();
}
}3. 静态内部类 421-422
说明:静态内部类是定义在外部类的成员位置，并且有static修饰
1.可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员
2.可以添加任意访问修饰符(public、protected、默认、private),因为它的地位就是一个成员。
3.作用域:同其他的成员，为整个类体
4. 静态内部类-- -访问---->外部类(比如:静态属性[访向方式直接访问所有静态成员]
5. 外部类-- -访问-----静态内部类访问方式:创建对象，再访问
6.外部其他类---访向---->静态内部类
7.如果外部类和静态内部类的成员重名时，静态内部类访问的时，默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类名.成员) 去访问
代码在com.stulzl.static_innerclass01.包中
Static_InnerClass01
package com.stulzl.static_innerclass01;
//静态内部类421-422
public class Static_InnerClass01 {
public static void main(String[] args) {
Outer10 outer10 = new Outer10();
outer10.m1();
//外部其他类---访向---->静态内部类 外部其他类 使用静态内部类
//方式 1
//因为静态内部类，是可以通过类名直接访问(前提是满足访问权限)
Outer10.Inner10 inner10 = new Outer10.Inner10();
inner10.say();
//方式 2
//编写一个方法，可以返回静态内部类的对象实例
Outer10.Inner10 inner = outer10.getInner();
inner.say();
System.out.println("============");
//静态的
Outer10.Inner10 inner_ = Outer10.getInner_();
inner_.say();
}
}
class Outer10 { //外部类
private int n1 = 10;
private static String name = "张三";//静态的
private static void cry(){}
//Inner10 就是静态内部类
//1. 放在外部类的成员位置
//2. 使用 static 修饰
//4. 可以添加任意访问修饰符(public、protected 、默认、private),因为它的地位就是一个成员
//5. 作用域 ：同其他的成员，为整个类体
static class Inner10{
private static String name = "中国";
public void say(){
//3. 可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员
System.out.println(name);
cry();//静态内部类---访问---->外部类(比如:静态属性[访向方式直接访问所有静态成员]
//如果外部类和静态内部类的成员重名时，静态内部类访问的时，默认遵循就近原则，
// 如果想访问外部类的成员，则可以使用(外部类名.成员) 去访问
System.out.println(name+" 外部类name="+Outer10.name);
}
}
//5. 作用域 ：同其他的成员，为整个类体
// 外部其他类---访向---->静态内部类:创建对象，再访问
public void m1(){
Inner10 inner10 = new Inner10();
inner10.say();
}
//编写一个方法，返回new Inner10()实例
public Inner10 getInner(){
return new Inner10();
}
////编写一个静态方法，返回new Inner10()实例
public static Inner10 getInner_(){
return new Inner10();
}
}4. 内部类练习
4.1判断输出 423
代码在com.stulzl.innerclass01_exercise01.包中
InnerClass_Exercise01
package com.stulzl.innerclass01_exercise01;
//练习 判断输出423
public class InnerClass_Exercise01 {
public static void main(String[] args) {
Test t = new Test();//5
Test.Inner inner = t.new Inner();//这里是外部其他类，调用成员内部类
System.out.println(inner.a);//5
}
}
class Test {//外部类
public Test() {//构造器
Inner s1 = new Inner();//这里new一个成员内部类实例
s1.a = 10;//调用a变成10
Inner s2 = new Inner();//这里又new一个新的成员内部类实例，和前面那个实例没关系
System.out.println(s2.a);//5
}
class Inner { //内部类，成员内部类
public int a = 5;
}
}