类变量和类方法、代码块、单例设计模式、final关键字、抽象类、接口、内部类
类变量和类方法
类变量-提出问题
说:有一群小孩在玩堆雪人,不时有新的小孩加入,请问如何知道现在共有多少人在玩?，编写程序解决。
传统的方法来解决
思路
- 在main方法中定义一个变量 count
- 当一个小孩加入游戏后 count+ +，最后个count 就记录有多少小孩玩游戏
小孩是一个类，有名字属性，“加入”方法。创建多个小孩对象，每执行一次“加入”方法count++.
问题分析:
- count 是一个独立于对象，很尴尬
- 以后我们访问 count 很麻烦，没有使用到OOP
- 因此，我们引出 类变量/静态变量
public class ChildGame {
public static void main(String[] args) {
Child child1 = new Child("蜘蛛精");
child1.join();
child1.count++;
Child child2 = new Child("白骨精");
child2.join();
child2.count++;
Child child3 = new Child("金角大王");
child3.join();
child3.count++;
System.out.println("共有" + Child.count + "个小孩加入了游戏");
}
}
class Child {
public static int count = 0;//声明类变量，是静态的
private String name;
public void join(){
System.out.println(name + "加入了游戏...");
}
public Child(String name) {
this.name = name;
}
}//类变量就是这个类下所有对象共享的一个变量。
类变量在类加载的时候就已经初始化了，所以可以不用通过实例对象来调用，可以直接通过类名调用
类变量的生命周期是随类的加载开始，随着类的消亡而销毁。
类方法
通过例子来解释
学生交学费，算出所有学生一共交了多少学费。
public class StaticMethod {
public static void main(String[] args) {
Stu stu1 = new Stu("张三");
stu1.payFee(100);
Stu stu2 = new Stu("李四");
stu1.payFee(200);
System.out.println("一共交了" + Stu.fee + "学费");
}
}
class Stu {
private String name;
public static int fee = 0;
public Stu(String name) {
this.name = name;
}
public static void payFee(int fee){//静态方法不能用this.fee+=fee，因为this指当前对象，而静态方法在对象创建之前就初始化了
Stu.fee += fee;
}
}
类方法使用场景
当方法中不涉及到任何和对象相关的成员，则可以将方法设计成静态方法,提高开发效率
比如: 工具类中的方法 utilsMath类、Arrays类、Collections 集合类看下源码
小结
在程序员实际开发，往往会将一些通用的方法，设计成静态方法，这样我们不需要创建对象就可以使用了，比如打印一维数组，冒泡排序,完成某个计算任务 等..[举例说明...]
一般当作工具来使用
类方法注意事项和细节讨论
-
类方法中无this的参数
类方法和普通方法都是随着类的加载而加载，将结构信息存储在方法区
普通方法中隐含着this的参数 -
类方法可以通过类名调用，也可以通过对象名调用
-
普通方法和对象有关，需要通过对象名调用，比如对象名.方法名(参数)，不能通过类名调用。
-
类方法中不允许使用和对象有关的关键字，比如this和super。普通方法(成员方法)可以
-
类方法(静态方法)中 只能访问 静态变量或静态方法
-
普通成员方法，既可以访问 普通变量(方法)，也可以访问静态变量(方法)
小结:静态方法，只能访问静态的成员，非静态的方法，可以访问静态成员和非静态成员
(必须遵守访问权限)
理解mian方法语法
解释main方法的形式:public static void main(String[] args){}
- main方法时虚拟机调用
- java虚拟机需要调用类的main0方法，所以该方法的访问权限必须是public
- java虚拟机在执行main()方法时不必创建对象，所以该方法必须是static
- 该方法接收String类型的数组参数，该数组中保存执行java命令时传递给所运行的类的参数,案例演示，接收参数.
- java 执行的程序 参数1 参数2 参数3[举例说明:]
代码块
基本介绍
代码化块又称为初始化块,属于类中的成员[即 是类的一部分]，类似于方法，将逻辑语句封装在方法体中，通过{}包围起来。
但和方法不同，没有方法名没有返回，没有参数，只有方法体，而且不用通过对象或类显式调用，而是加载类时或创建对象时隐式调用。
基本语法
[修饰符]{
\\代码
};
注意：
1)修饰符 可选，要写的话，也只能写 static
2)代码块分为两类，使用static 修饰的叫静态代码块，没有static修饰的，叫普通代码块.
3) 逻辑语句可以为任何逻辑语句 (输入、输出、方法调用、循环、判断等)
4); 号可以写上，也可以省略
代码块的好处
1)相当于另外一种形式的构造器(对构造器的补充机制)，可以做初始化的操作
2)场景: 如果多个构造器中都有重复的语句，可以抽取到初始化块中，提高代码的重用性
public class CodeBlock01 {
public static void main(String[] args) {
Movie movie = new Movie("功夫熊猫");
}
}
class Movie{
private String name;
private double price;
private String director;
//三个构造器->重载
//(1) 下面的三个构造器都有相同的语句
//(2) 这样代码看起来比较冗余
//(3) 这时我们可以把相同的语句，放入到一个代码块中，即可
//(4) 这样当我们不管调用哪个构造器，创建对象，都会先调用代码块的内容
//(5) 代码块调用的顺序优先于构造器
{
System.out.println("电影屏幕打开...");
System.out.println("广告开始...");
System.out.println("电影正式开始...");
}
public Movie(String name) {
// System.out.println("电影屏幕打开...");
// System.out.println("广告开始...");
// System.out.println("电影正式开始...");
System.out.println("Movie(String name)被调用。。。");
this.name = name;
}
public Movie(String name, double price) {
// System.out.println("电影屏幕打开...");
// System.out.println("广告开始...");
// System.out.println("电影正式开始...");
this.name = name;
this.price = price;
}
public Movie(String name, double price, String director) {
// System.out.println("电影屏幕打开...");
// System.out.println("广告开始...");
// System.out.println("电影正式开始...");
this.name = name;
this.price = price;
this.director = director;
}
}
代码块使用注意事项和细节讨论
- static代码块也叫静态代码块，作用就是对类进行初始化，而且它随着类的加载而执行，并且只会执行一次。如果是普通代码块， 每创建一个对象，就执行。
- 类什么时候被加载
1)创建对象实例时(new)
2)创建子类对象实例，父类也会被加载
3)使用类的静态成员时(静态属性，静态方法) - 普通的代码块，在创建对象实例时，会被隐式的调用。
被创建一次，就会调用一次。
如果只是使用类的静态成员时，普通代码块并不会执行 - 创建一个对象时，在一个类 调用顺序是:(重点，难点)
1）调用静态代码块和静态属性初始化(注意:静态代码块和静态属性初始化调用的优先级一样，如果有多个静态代码块和多个静态变量初始化，则按他们定义的顺序调用)
2）调用普通代码块和普通属性的初始化(注意:普通代码块和普通属性初始化调用的优先级一样，如果有多个普通代码块和多个普通属性初始化，则按定义顺序调用)
3）调用构造方法
public class CodeBlockDetail02 {
public static void main(String[] args) {
A a = new A();
}
}
class A{
//静态属性的初始化
public static int n1 = getN1();
private int n2 = getN2();//普通属性的初始化
{ //普通代码块
System.out.println("A 的普通代码块01");
}
//静态代码块
static{
System.out.println("静态代码块被调用...");
}
public static int getN1(){//静态方法
System.out.println("getN1()被调用...");
return 100;
}
public int getN2(){//普通方法/非静态方法
System.out.println("getN2()被调用...");
return 200;
}
public A (){
System.out.println("A 的无参构造器被调用...");
}
}
- 构造方法(构造器)的最前面其实隐含了 super()和 调用普通代码块,静态相关的代码块，属性初始化，在类加载时，就执行完毕因此是优先于 构造器和普通代码块执行的
public class CodeBlockDetail03 {
public static void main(String[] args) {
new BBB();
}
}
class AAA{
public AAA(){
//super();
System.out.println("AAA() 的无参构造器被调用...");
}
}
class BBB extends AAA{
{
System.out.println("BBB的普通代码块...");
}
public BBB(){
//(1)super();
//(2)调用本类的普通代码块
System.out.println("BBB() 的无参构造器被调用...");
}
}
6. 我们看一下创建一个子类时(继承关系)，他们的静态代码块，静态属性初始化普通代码块，普通属性初始化，构造方法的调用顺序如下:
- 父类的静态代码块和静态属性(优先级一样，按定义顺序执行)
- 子类的静态代码块和静态属性(优先级一样，按定义顺序执行)
- 父类的普通代码块和普通属性初始化(优先级一样，按定义顺序执行)
- 父类的构造方法
- 子类的普通代码块和普通属性初始化(优先级一样，按定义顺序执行)
- 子类的构造方法
静态代码块只能直接调用静态成员(静态属性和静态方法)，普通代码块可以调用任意成员。
练习
单例设计模式
什么是设计模式
- 静态方法和属性的经典使用
- 设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格以及解决问题的思考方式 。设计模式就像是经典的棋谱，不同的棋局，我们用不同的棋谱，免去我们自己再思考和摸索
什么是单例模式
单例（单个实例）
1） 所谓类的单例设计模式，就是采取一定的方法保证在整个的软件系统中，对某个类只能存在一个对象实例，并且该类只提供一个取得其对象实例的方法
2） 单例模式有两种方式:1)饿汉式 2)懒汉式
单例模式应用实例
饿汉式步骤如下
- 构造器私有化（防止直接new）
- 类的内部创建对象
- 向外暴露一个静态的公共方法 getInstance
- 代码实现
public class SingleTon01 {
public static void main(String[] args) {
GirlFriend instance = GirlFriend.getInstance();
System.out.println(instance);
}
}
//有一个类,GirlFriend
//只能有一个女朋友
class GirlFriend{
private String name;
private static GirlFriend gf = new GirlFriend("小王");
//如何保障我们只能创建一个 GirTFriend 对象
//步骤[单例模式-饿汉式]
//1. 将构造器私有化
//2. 在类的内部直接创建(该对象是static)
//3. 提供一个公共的static方法，返回 gf对象
private GirlFriend(String name){
this.name = name;
}
public static GirlFriend getInstance(){
return gf;
}
@Override
public String toString() {
return "GirlFriend{" +
"name='" + name + '\'' +
'}';
}
}
/**
* 演示懒汉式的单例模式
*/
public class SingleTon02 {
public static void main(String[] args) {
System.out.println(Cat.n1);
}
}
//希望程序在运行过程中，只能创建一个Cat对象
//使用单例模式
class Cat{
private String name;
public static int n1 = 999;
private static Cat cat;
//步骤
//1.仍然构造器私有化
//2.定义一个static静态属性对象
//3.定义一个public的static方法，可以返回一个Cat对象
//4.懒汉式，只有当用户使用getInstance时，才返回cat对象
private Cat(String name){
System.out.println("构造器被调用...");
this.name = name;
}
public static Cat getInstance(){
if (cat == null){
cat = new Cat("喵喵");
}
return cat;
}
}
饿汉式VS懒汉式
- 二者最主要的区别在于创建对象的时机不同:饿汉式是在类加载就创建了对象实例而懒汉式是在使用时才创建。
- 饿汉式不存在线程安全问题，懒汉式存在线程安全问题
- 饿汉式存在浪费资源的可能。因为如果程序员一个对象实例都没有使用，那么饿汉式创建的对象就浪费了，懒汉式是使用时才创建，就不存在这个问题。
- 在我们javaSE标准类中，java.lang.Runtime就是经典的单例模式
final关键字
基本介绍
- 当不希望类被继承时，可以用final修饰
- 当不希望父类的某个方法被子类重写/覆盖时，可以用final修饰
- 当不希望类的某个属性的值被修改时，可以用final修饰
- 当不希望某个局部变量被修改时，可以用final修饰
final使用细节
- final修饰的属性又叫常量,一般 用 XX_XX_XX 来命名
- final修饰的属性在定义时,必须赋初值,并且以后不能再修改，赋值可以在如下位置之一：(1)定义时: 如 public final double TAX RATE=0.08;(2)在构造器中;(3)在代码块中
- 如果final修饰的属性是静态的，则初始化的位置只能是（1）定义时（2）在静态代码块；不能在构造器中赋值
- final类不能继承，但是可以实例化对象
- 如果类不是final类，但是含有final方法，则该方法虽然不能重写，但是可以被继承。
- 般来说，如果一个类已经是final类了，就没有必要再将方法修饰成final方法
- final不能修饰构造方法(即构造器)
- final 和 static 往往搭配使用，效率更高，不会导致类加载.底层编译器做了优化处理。
- 包装类(Integer,Double,Float，Boolean等都是final),String也是final类
抽象类
有一个Animal类，里面有eat()方法，但是不知道具体该怎么实现eat(),可以把eat()方法声明为抽象类，不用写方法体，让子类去实现。这时，Animal类就变成了抽象类。
抽象类的介绍
- 用abstract 关键字来修饰一个类时,这个类就叫抽象类
访问修饰符 abstract 类名{
} - 用abstract 关键字来修饰一个方法时,这个方法就是抽象方法
访问修饰符 abstract 返回类型 方法名(参数列表);//没有方法体 - 抽象类的价值更多作用是在于设计，是设计者设计好后，让子类继承并实现抽象类()
- 抽象类，是考官比较爱问的知识点,在框架和设计模式使用较多
抽象类使用细节
- 抽象类不能被实例化
- 抽象类不一定要包含abstract方法。也就是说,抽象类可以没有abstract方法
- 一旦类包含了abstract方法,则这个类必须声明为abstract
- abstract 只能修饰类和方法，不能修饰属性和其它的
- 抽象类可以有任意成员[因为抽象类还是类]，比如: 非抽象方法、构造器、静态属性等等
- 抽象方法不能有主体，即不能实现
- 如果一个类继承了抽象类，则它必须实现抽象类的所有抽象方法，除非它自己也声明abstract类。
- 抽象方法不能使用private、final 和 static来修饰，因为这些关键字都是和重写相违背的
抽象类最佳实践-模板设计模式
需求
- 有多个类，完成不同的任务iob
- 要求能够统计得到各自完成任务的时间
- 请编程实现
public class AA {
//计算任务
//1+ ... + 700000
public void job(){
//得到开始时间
long start = System.currentTimeMillis();
long num = 0;
for (int i = 0; i <=700000 ; i++) {
num += i;
}
//得到结束时间
long end = System.currentTimeMillis();
System.out.println("执行时间：" + (end-start));
}
}
public class BB {
//计算任务
//1+ ... + 800000
public void job(){
//得到开始时间
long start = System.currentTimeMillis();
long num = 0;
for (int i = 0; i <=800000 ; i++) {
num += i;
}
//得到结束时间
long end = System.currentTimeMillis();
System.out.println("执行时间：" + (end-start));
}
}
public class TestTemplate {
public static void main(String[] args) {
AA aa = new AA();
aa.job();
BB bb = new BB();
bb.job();
}
}
可以看到代码重复度高
改进一
public class AA {
public void calculateTime(){
//得到开始时间
long start = System.currentTimeMillis();
job();
//得到结束时间
long end = System.currentTimeMillis();
System.out.println("执行时间：" + (end-start));
}
//计算任务
//1+ ... + 10000
public void job(){
long num = 0;
for (int i = 0; i <=700000 ; i++) {
num += i;
}
}
}
把计算时间和job分开，代码更容易分辨，另一个类同理。考虑到可能不止两个类，甚至更多，计算时间这一段代码冗余了。我们可以把这些类共有的“计算时间”的方法放到抽象类里面，然后把各自的job()方法写成抽象方法放进抽象类里。
- 最佳实践
设计一个抽象类(Template)，能完成如下功能:
- 编写方法calculateTime(,可以计算某段代码的耗时时间
- 编写抽象方法job()
- 编写一个子类Sub,继承抽象类Template，并实现job方法。
- 编写一个测试类TestTemplate,看看是否好用。
abstract public class Template {
public abstract void job();
public void calculateTime(){
//得到开始时间
long start = System.currentTimeMillis();
job();//动态绑定机制
//得到结束时间
long end = System.currentTimeMillis();
System.out.println("执行时间：" + (end-start));
}
}
public class AA extends Template{
public void job(){
long num = 0;
for (int i = 0; i <=700000 ; i++) {
num += i;
}
}
}
接口
基本介绍
接口就是给出一些没有实现的方法,封装到一起,到某个类要使用的时候,在根据具体情况把这些方法写出来。语法:
interface 接口名{
//属性
//方法(1.抽象方法 2 默认实现方法 3静态方法)
}
class 类名 implements 接口{
自己属性;
自己方法;
必须实现的接口的抽象方法
}
接口注意事项
- 接口不能被实例化
- 接口中所有的方法是 public方法，接口中抽象方法，可以不用abstract 修饰
- 一个普通类实现接口,就必须将该接口的所有方法都实现
- 抽象类实现接口，可以不用实现接口的方法
- 一个类同时可以实现多个接口
- 接口中的属性,只能是final的，而且是 public static final 修饰符。比如
int a=1; 实际上是 public static final int a=1; (必须初始化) - 接口中属性的访问形式: 接口名.属性名
- 接口的修饰符 只能是 public 和默认，这点和类的修饰符是一样的。
接口VS继承
当子类继承了父类，就自动的拥有父类的功能
如果子类需要扩展功能，可以通过实现接口的方式扩展
可以理解 实现接口 是 对java 单继承机制的一种补充。
- 接口和继承解决的问题不同
继承的价值主要在于:解决代码的复用性和可维护性
接口的价值主要在于:设计，设计好各种规范(方法)，让其它类去实现这些方法
- 接口比继承更加灵活
接口比继承更加灵活，继承是满足 is - a的关系，而接口只需满足 like - a的关系
- 接口在一定程度上实现代码解耦
接口多态特性
- 多态参数
- 多态数组
- 接口存在多态传递现象
练习
x会报错，摸棱两可，要么A.x,要么super.x
内部类
基本介绍
一个类的内部又完整的嵌套了另一个类结构。被嵌套的类称为内部类(inner class)嵌套其他类的类称为外部类(outer class)是我们类的第五大成员[思考:类的五大成员是哪些?[属性、方法、构造器、代码块、内部类]] ，内部类最大的特点就是可以直接访问私有属性，并且可以体现类与类之间的包含关系
基本语法
public class InnerClass01 { //其他类
public static void main(String[] args) {
}
}
class Outer{ //外部类
private int n = 10;
public void test(){
System.out.println("test");
}
{ //代码块
System.out.println("代码块...");
}
public Outer(int n){
this.n = n;
}
class Inner{ //内部类
}
}
内部类的分类
定义在外部类局部位置上 (比如方法内):
- 局部内部类(有名)
- 匿名内部类(没有类名，重点)
定义在外部类的成员位置上:
- 成员内部类(没用static修饰)
- 静态内部类(使用static修饰)
局部内部类
说明:局部内部类是定义在外部类的局部位置，比如方法中，并且有类名
- 可以直接访问外部类的所有成员，包含私有的
- 不能添加访问修饰符,因为它的地位就是一一个局部变量。局部变量是不能使用修饰符的。但是可以使用final 修饰，因为局部变量也可以使用final
- 作用域 : 仅仅在定义它的方法或代码块中。
- 局部内部类---访问---->外部类的成员[访问方式: 直接访问]
- 外部类---访问---->局部内部类的成员访问方式:创建对象，再访问(注意: 必须在作用域内)
- 外部其他类---不能访问----->局部内部类( 因为 局部内部类地位是一个局部变量)
- 如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员，则可以使用(外部类名.this.成员)去访问
/**
* 演示局部内部类的使用
*/
public class LocalInnerClass {
public static void main(String[] args) {
Outer01 outer01 = new Outer01();
outer01.m1();
System.out.println("Outer01.this hashcode= "+ outer01);
}
}
class Outer01{
private int n1 = 10;
private void f1(){
System.out.println("Outer f1()");
}
public void m1(){
class Inner01{
//7. 如果外部类和局部内部类的成员重名时，默认遵循就近原则，如果想访问外部类的成员，
// 使用(外部类名.this.成员)去访问
// Outer01.this 本质就是外部类的对象，即哪个对象调用了m1,Outer.this就是哪个对象
private int n1 = 100;
public void m2(){
System.out.println("n1= "+ n1 + "外部类的n1= "+ Outer01.this.n1);
//如果把Outer01去掉只留this，则this是对象Inner01而不是Outer01
System.out.println("Outer01.this hashcode= "+ Outer01.this);
f1();
}
}
Inner01 inner01 = new Inner01();
inner01.m2();
}
}
匿名内部类（重要！！）
（1）本质是类
（2）内部类
（3）该类没有名字
（4）同时还是一个对象
匿名内部类是定义在外部类的局部位置，比如方法中，且没有类名
语法
new 类或接口(参数列表){
类体
}
/**
* 演示匿名内部类的使用
*/
public class AnanymousInnerClass {
public static void main(String[] args) {
Outer04 outer04 = new Outer04();
outer04.method();
}
}
class Outer04{
private int n1 = 10;
public void method(){
//基于接口的匿名内部类
//1. 需求：想使用IA接口，并创建对象
//2. 传统方式：是一个类，实现该接口，并创建对象
//3. 需求是Tiger/Dog类只是使用一次，后面再不使用
//4. 可以使用匿名内部类来简化开发
IA tiger = new Tiger();
tiger.cry();
}
}
interface IA{
public void cry();
}
class Tiger implements IA{
@Override
public void cry() {
System.out.println("老虎叫唤...");
}
}
class Dog implements IA{
@Override
public void cry() {
System.out.println("小狗叫唤...");
}
}
class Outer04{
private int n1 = 10;
public void method(){
//基于接口的匿名内部类
//1. 需求：想使用IA接口，并创建对象
//2. 传统方式：是一个类，实现该接口，并创建对象
//3. 需求是Tiger/Dog类只是使用一次，后面再不使用
//4. 可以使用匿名内部类来简化开发
//5. tiger的编译类型？ IA
//6. tiger的运行类型？就是匿名内部类 Outer04$1
//7. jdk底层在创建匿名内部类Outer04$1时，立马创建了Outer04$1实例，并且把地址返回给tiger
//8. 匿名内部类使用一次后就不能再使用
/*
我们看底层 会分配 类名 Outer04$1
class Outer04$1 implements IA{
@Override
public void cry(){
System.out.println("老虎叫唤...");
}
}
*/
IA tiger = new IA() {
public void cry() {
System.out.println("老虎叫唤...");
}
};
tiger.cry();
}
}
匿名内部类的使用
- 匿名内部类的语法比较奇特，请大家注意，因为匿名内部类既是一个类的定义同时它本身也是一个对象，因此从语法上看，它既有定义类的特征，也有创建对象的特征，对前面代码分析可以看出这个特点，因此可以调用匿名内部类方法。
- 可以直接访问外部类的所有成员，包含私有的
- 不能添加访问修饰符,因为它的地位就是一个局部变量。
- 作用域: 仅仅在定义它的方法或代码块中
- 匿名内部类---访问---->外部类成员[访问方式: 直接访问]
- 外部其他类---不能访问>匿名内部类( 因为 匿名内部类地位是一个局部变量)
- 如果外部类和内部类的成员重名时，内部类访问的话，默认遵循就近原则，如果想访问外部类的成员，则可以使用 (外部类名.this.成员)去访问
匿名内部类的最佳实践
当做实参直接传递，简洁高效
public class InnerClassExercise01 {
public static void main(String[] args) {
//当作实参直接传递，简洁高效
f1(new IL() {
@Override
public void show() {
System.out.println("这是一副名画...");
}
});
//传统方法：先写一个类实现IL接口，在mian方法创建该对象，再传入f1方法。
}
//静态方法
public static void f1(IL il){
il.show();
}
}
//接口
interface IL{
void show();
}
练习
- 有一个铃声接口Bell，里面有个ring方法
- 有一个手机类Cellphone，具有闹钟功能alarmclock，参数是Bell类型
- 测试手机类的闹钟功能，通过匿名内部类(对象)作为参数，打印: 懒猪起床了
- 再传入另一个匿名内部类(对象)，打印:小伙伴上课了
public class InnerClassExercise02 {
public static void main(String[] args) {
Cellphone cellphone = new Cellphone();
//底层有
// class InnerClassExercise02$1 implements Bell{
// @Override
// public void ring() {
// System.out.println("懒猪起床啦");
// }
// }
cellphone.alarmclock(new Bell() {
@Override
public void ring() {
System.out.println("懒猪起床啦");
}
});
cellphone.alarmclock(new Bell() {
@Override
public void ring() {
System.out.println("小伙伴上课了");
}
});
}
}
interface Bell{
void ring();
}
class Cellphone {
public void alarmclock(Bell bell){ //闹钟功能
bell.ring();
}
}
成员内部类
成员内部类是定义在外部类的成员位置，并且没有static修饰
- 可以直接访问外部类的所有成员，包含私有的
- 可以添加任意访问修饰符(public、protected 、默认、private),因为它的地位就是一个成员。
- 作用域和外部类的其他成员一样，为整个类体比如前面案例，在外部类的成员方法中创建成员内部类对象，再调用方法
- 成员内部类---访问---->外部类(比如: 属性)[访问方式:直接访问]
- 外部类---访间------>内部类(说明)访问方式: 创建对象，再访问
- 外部其他类---访问---->成员内部类
静态内部类
静态内部类是定义在外部类的成员位置，并且有static修饰
- 可以直接访问外部类的所有静态成员，包含私有的，但不能直接访问非静态成员
- 可以添加任意访问修饰符(public、protected 、默认、private),因为它的地位就是一个成员
- 作用域 : 同其他的成员，为整个类体
- 静态内部类---访问---->外部类(比如: 静态属性)[访方式: 直接访问所有静态成员]
- 外部类---访问------>静态内部类 访问方式: 创建对象，再访问
