7.面向对象(高级)

一、类变量和类方法

1. 类变量

类变量（静态变量/静态属性）：是该类所有对象共享的变量，该类所有的对象都可以对齐进行修改或引用。

语法：static ： 表示静态

1
2
3
访问修饰符 static 数据类型 变量名；（推荐该写法）

static 访问修饰符 数据类型 变量名；

引用语法：

1
2
3
类名.类变量名；（推荐使用）

对象名.类变量名；
  1. 类变量是随着类的加载而创建的，即使没有创建对象，也可以访问；
  2. 类变量的访问，也要遵守访问修饰符的访问权限；
  3. 没有加 static 则表示为实例变量，不共享，加上则表示为 类变量，是共享的；
  4. 类变量的生命周期时随着类的加载而加载，随着类的消亡而消亡；

2.类方法

类方法，也叫静态方法；

语法：

1
访问修饰符 static 返回数据类型 方法名（）{};(推荐写法)

调用：

1
类名.类方法名();
  1. 静态方法既可以通过类调用，也可以通过类调用；
  2. 非静态方法不能通过类调用，只能通过对象调用；
  3. 类方法中不允许使用和对象有关的关键字
    1. 如： this，super
  4. 静态方法中，只能访问静态变量或静态方法
    1. 普通成员方法 都可以访问；

静态方法，只能访问静态的成员； > 普通方法，静态与非静态的成员都可以访问；

使用场景：

  1. 用来编写不涉及对象的方法，比如：工具类

二、代码块

代码块（初始化块）：属于类中的成员，类似于方法，将逻辑语句封装在方法体中，通过{}包围起来；
与方法不同，没有方法名，没有返回，没有参数，只有方法体，不能通过对象或类显式调用，在加载类或创建对象时隐式调用

语法：

1
[修饰符]{代码}；
  1. 修饰符 可选，要写只能写 static
  2. 没有修饰符的叫普通代码块，有修饰符的叫静态代码块
  3. “；” 可以省略
  4. 代码块的调用顺序优先于构造器

类什么时候加载：

  1. 创建实例对象时
  2. 创建子类对象实例时，父类也会加载（父类先加载，子类后加载）；
  3. 使用类的静态成员时

细节：

  1. 静态代码块只会执行一次，普通代码块 每创建一个对象，就会执行一次
    1. 如果只使用静态成员时，普通成员不会执行
  2. 创建对象时，类 调用顺序：
    1. 调用静态代码块和静态属性初始化（优先级一样，多个时按定义顺序调用）
    2. 调用普通代码块和普通属性的初始化（同上）
    3. 调用构造器方法
  3. 构造器的前面隐含了 super（）和 调用普通代码块，静态相关的代码块和属性初始化在类加载时就执行完成了，因此是优先于 构造器和普通代码块执行的。
  4. 有继承关系的子类对象在创建时的调用顺序：
    1. 父类静态代码块、静态属性（优先级一样，按定义顺序执行）
    2. 子类静态代码块、静态属性（优先级一样，按定义顺序执行）
    3. 父类普通代码块、普通属性（优先级一样，按定义顺序执行）
    4. 父类的构造方法
    5. 子类普通代码块、普通属性（优先级一样，按定义顺序执行）
    6. 子类的构造方法
  5. 静态代码块只能调用静态成员，普通代码块可以调用任意成员
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
public class StaticDemo01 {
    public static void main(String[] args) {
        StaticDemo01.demo1();
        System.out.println("======================");
        new StaticDemo01().demo2();
    }

    private static String name1 = getName1();
    private String name2 = getName2();

    public static String getName1() {
        System.out.println("静态属性 被执行~~~");
        return name1;
    }

    public String getName2() {
        System.out.println("普通属性 被执行~~~");
        return name2;
    }

    {
        System.out.println("普通代码块 被执行~~~");
    }
    static {
        System.out.println("静态代码块 被执行~~~");
    }
    public static void demo1(){
        System.out.println("静态方法 被执行~~~");
    }
    public void demo2(){
        System.out.println("普通方法 被执行~~~");
    }

    public StaticDemo01() {
        System.out.println("构造函数 被执行~~~");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public class StaticDemo02 {
    public static void main(String[] args) {
        Test a = new Test();
    }
}

class Sample{
    Sample(String s){
        System.out.println(s);
    }
    Sample(){
        System.out.println("Sample 默认构造器函数被调用");
    }
}
class Test{
    Sample sam1 = new Sample("sam1 成员初始化");
    static Sample sam = new Sample("静态成员 sam 初始化");
    static {
        System.out.println("static 快执行");
        if (sam == null){
            System.out.println("sam is null");
        }
    }
    Test(){
        System.out.println("Test 默认构造器函数被调用");
    }
}

三、单例设计模式

单例模式： 采取一定的方法，使某个类只存在一个对象实例，并且该类只提供一个获取对象实例的方法。
单例模式：
①。饿汉式： 类在加载时直接创建一个对象，不管后续有没有使用；
②。懒汉式： 只有当使用时，类才会加载一个对象；

饿汉式 和 懒汉式 设计模式的实现：

  1. 构造器私有化（防止直接 new 对象）
  2. 类的内部创建对象
  3. 向外暴露一个静态的公共方法
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
// 单例模式 - 饿汉式 案例
public class SingleTon01 {
    public static void main(String[] args) {
        GirlFriend friend = GirlFriend.getInstance();
        System.out.println(friend);
    }
}

class GirlFriend{
    private String name;
    // 构造方法私有化
    private GirlFriend(String name) {
        this.name = name;
    }
    // 类的内部创建对象，因需要一个静态方法返回，所以创建对象也需要静态化
    private static GirlFriend gf = new GirlFriend("小汪");
    // 暴露给外部的方法
    public static GirlFriend getInstance(){
        return gf;
    }

    @Override
    public String toString() {
        return "GirlFriend{" +
                "name='" + name + '\'' +
                '}';
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
// 单例模式 - 懒汉式
public class SingleTon02 {
    public static void main(String[] args) {
        Cat c = Cat.getInstance();
        System.out.println(c);
    }
}

class Cat{
    private String name;
    private static Cat cat;

    private Cat(String name) {
        this.name = name;
    }
    // 如果已经创建了一个对象，则不在创建，如果没有创建对象，则会创建一个对象
    public static Cat getInstance(){
        if (cat == null){
            cat = new Cat("你老子");
        }
        return cat;
    }

    @Override
    public String toString() {
        return "Cat{" +
                "name='" + name + '\'' +
                '}';
    }
}

四、final 关键字

final ： 表示最后的、最终的
final 可以用于修饰类、属性、方法、局部变量等

使用场景：

  1. 当不希望类被继承时，可以使用 final 修饰
  2. 当不希望父类的某个方法被子类覆盖、重写时，可以使用 final 关键字修饰
  3. 当不希望某个属性的值被修改时，可以使用 final 修饰
  4. 当不希望某个是不变量被修改时，可以使用 final 修饰

注意事项：

  1. final 修饰的属性又叫常量，一般用 全大写字母 和 下划线 来命名
    1. NUM_TEST
  2. final 修饰的属性在定义时，必须赋初始值，并且以后不能再修改
    1. 定义时：如：public final double TAX_RATE = 0.08;
    2. 在构造器中赋值；
    3. 在代码块中赋值；
  3. 如果 final 修饰的是静态属性，则初始化的位置只能
    1. 在定义时
    2. 在静态代码块中
    3. 不能在构造器中赋值
  4. final 类不能继承，但是可以实例化对象
  5. 如果类不是 final 类，但是含有 final 方法，则该方法虽然不能重写，但是可以被继承
  6. 如果一个类 被 final 修饰了，那么他的方法就没有必要再用 final 修饰
  7. final 不能修饰构造器
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
// final 关键字
public class Final01 {
    public static void main(String[] args) {
        System.out.println(new AA("小王"));
        CC cc = new CC();
        // 方法被 final 修饰后，子类可以继承但是不能重写
        cc.prints();
    }
}

class AA{
    // 定义时赋值
    public final double TAX_RATE = 0.08;
    private final String name;
    private final int age;

    {   // 代码块中赋值
        age = 18;
    }
    // 构造器中赋值
    public AA(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "AA{" +
                "TAX_RATE=" + TAX_RATE +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

class BB{
    // 静态方法只能在 定义时 或 静态代码块中初始化
    private static final String name;
    private static final int age = 18;
    static {
        name = "小明";
    }
    public final void prints(){
        System.out.printf("name=%s,age=%d",name,age);
    }
}

class CC extends BB{ }

五、抽象类（abstract）

抽象类： 当类中的某些方法不确定时，就可以使用 abstract 关键字将方法修饰为抽象方法，用 abstract 修饰类成为抽象类，一般都会由子类继承，由子类来实现抽象方法。

语法：

1
2
3
4
// 抽象类及抽象方法
abstract class Demo{
    public abstract String demo();
}

注意事项：

  1. 抽象类和抽象方法必须使用 abstract 修饰；
  2. 抽象方法没有方法体；
  3. 抽象类一般都会被继承，由子类重写抽象方法；
  4. 抽象类不能实例化；
  5. 抽象类不一定有抽象方法，但是有抽象方法，则必须是抽象类；
  6. abstract 只能修饰 类 或 方法；
  7. 如果继承了抽象类，则必须实现抽象方法，或者自己也申明为抽象类
  8. 抽象方法不能用 final、static、private 来修饰，与抽象方法规则相违背；
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
// 抽象类
abstract public class Employee {
    private String name;
    private int age;
    private double salary;

    public Employee(String name, int age, double salary) {
        this.name = name;
        this.age = age;
        this.salary = salary;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    abstract public void work();
}

class CommonEmployee extends Employee{
    public CommonEmployee(String name, int age, double salary) {
        super(name, age, salary);
    }


    @Override
    public void work() {
        System.out.printf("普通员工 %s 工作中~~~\n",getName());
    }
}

class Manager extends Employee{
    private double bonus;

    public Manager(String name, int age, double salary, double bonus) {
        super(name, age, salary);
        this.bonus = bonus;
    }

    public double getBonus() {
        return bonus;
    }

    public void setBonus(double bonus) {
        this.bonus = bonus;
    }

    @Override
    public void work() {
        System.out.printf("经理 %s 工作中……\n",getName());
    }
}

class Test{
    public static void main(String[] args) {
        CommonEmployee ce = new CommonEmployee("小李", 25, 3000);
        ce.work();
        Manager mg = new Manager("老王", 40, 5000, 1000);
        mg.work();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
// 抽象 - 模板模式
public class AbstractTime {
    public static void main(String[] args) {
        AA aa = new AA();
        aa.calculateTime();
    }
}

abstract class Template{
    public abstract void job();
    // 抽象类 计算任务执行所需的时间
    public void calculateTime(){
        long startTime = System.currentTimeMillis();
        job();
        long endTime = System.currentTimeMillis();
        System.out.printf("执行时间为：%d",(endTime-startTime));
    }
}

class AA extends Template{
    // 重写父类的抽象方法
    @Override
    public void job() {
        for (int i = 1; i <= 8000000 ; i++) {
            i++;
        }
    }
}

六、接口

接口： 就是给出一些没有实现的方法封装到一起，到某个类要使用的时候，再根据具体情况把这些方法写出来
使用 interface 来定义接口
使用 implement 来实现接口

语法：

1
2
3
4
5
6
7
8
interface 接口名{
    属性或方法；
}

class 类名 implement 接口名{
    自己的属性或方法；
    必须实现抽象方法；
}

注意事项：

  1. 接口不能被实例化；
  2. 接口中所有的方法都是 public 方法，接口中的抽象方法 可以不用 abstract 修饰
  3. 一个普通类实现接口，就必须将该接口的所有方法都实现
  4. 抽象类实现接口，可以不用实现接口的方法
  5. 一个类同时可以实现多个接口
  6. 接口中的属性，只能是 final 的，而且是 public static final 修饰符
    1. 如： int a =1; 实际上是 public static final int a = 1;(必须初始化）
  7. 接口中属性的访问形式： 接口名.属性名
  8. 一个接口不能继承其他的类，但是可以继承多个接口
    1. 如： interface A extends B，C{}
  9. 接口的修饰符只能是 public 和 默认，这点和 类的修饰符一样

当子类继承类父类，就自动拥有父类的功能，如果子类需要扩展功能，则可以通过实现接口的方式扩展
实现接口 是对 java 单继承的一个补充

继承 与 接口实现的区别：

  1. 继承时，会自动拥有父类的所有功能；
    1. 接口是对 单继承的一种补充，用于扩展子类功能
  2. 继承主要解决代码的复用性和可维护性
    1. 接口主要用于设计各种规范，让其他类去实现这些方法
  3. 接口相较于继承更加灵活
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
// 接口与继承
public class ExtendsVsInterface {
    public static void main(String[] args) {
        LittleMonkey wk = new LittleMonkey("悟空");
        wk.work();
        wk.flying();
        wk.swimming();
    }
}

class Monkey{
    private String name;

    public Monkey(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void work(){
        System.out.println(String.format("%s 会爬树",name));
    }
}

class LittleMonkey extends Monkey implements FishAble,BirdAble{
    public LittleMonkey(String name) {
        super(name);
    }

    @Override
    public void swimming() {
        System.out.printf("%s 通过学习，可以像鱼一样游泳~\n",getName());
    }

    @Override
    public void flying() {
        System.out.printf("%s 通过学习，可以像鸟一样飞翔~\n",getName());
    }
}

interface FishAble{
    void swimming();
}

interface BirdAble{
    void flying();
}

接口的多态特性：

  1. 多态参数（一个接口有多个方法实现时，通过参数判断实现对象）
  2. 多态数组
  3. 多态传递（一个接口继承了另一个接口）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
// 接口 - 多态数组
public class InterfacePoly {
    public static void main(String[] args) {
        Usb[] usbs = new Usb[2];
        usbs[0] = new Phone_();
        usbs[1] = new Camera_();
        for (int i = 0; i < usbs.length; i++) {
            if (usbs[i] instanceof Phone_){
                ((Phone_) usbs[i]).call();
            }
            usbs[i].work();
        }
    }
}

interface Usb{
    void work();
}

class Phone_ implements Usb{
    public void call(){
        System.out.println("用手机打电话");
    }
    @Override
    public void work() {
        System.out.println("手机工作中");
    }
}

class Camera_ implements Usb{
    @Override
    public void work() {
        System.out.println("相机工作中");
    }
}

七、内部类

内部类 ： 一个类的内部又完整的嵌套了另一个类结构，

类的五大成员： 属性、代码块、构造器、方法、内部类
语法：

1
2
3
4
class Outer{	// 外部类
    class Inner{	// 内部类
    }
}

内部类的分类：

  1. 根据定义在外部类的位置：
    1. 局部内部类（有类名）
    2. 匿名内部类（没有类名）
  2. 根据定义在外部类的成员位置：
    1. 成员内部类（没有 static 修饰）
    2. 静态内部类（有 static 修饰）

1. 局部内部类

说明：

  1. 通常定义在方法中；
  2. 可以直接访问外部类的所有成员，包括私有的属性或方法；
  3. 不能添加访问修饰符，但是可以使用 final 修饰符
  4. 作用域：只在定义他的方法或代码块中使用``
  5. 局部内部类访问外部类时，可以直接访问
  6. 外部类访问局部内部类时，需要先创建对象，在进行访问
  7. 外部其他类不能访问局部内部类
  8. 如果外部类和内部类的成员重名，则默认采取就近原则，
    1. 如果要访问外部类成员，可以使用 外部类.this.成员
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
// 局部内部类
public class LocalClass {
    public static void main(String[] args) {
        AA aa = new AA("老王");
        aa.method1();

    }
}

class AA{
    private String name;

    public AA(String name) {
        this.name = name;
    }

    public void method1(){
        // 不能使用访问修饰符，但是可以使用 final，使用后不能被其他类继承
        final class BB{
            private String name;

            public BB(String name) {
                this.name = name;
            }
            public void method1(){
                // 内部类属性与外部类属性同名时，默认访问的是内部类属性，可以通过 类名.this.属性 获取外部类
                System.out.printf("局部内部类，内部类 name= %s，外部类 name= %s\n",name,AA.this.name);
            }

            public String getName() {
                return name;
            }

            public void setName(String name) {
                this.name = name;
            }
        }
        // 外部类访问内部类时，需要先创建对象，然后在访问
        BB bb = new BB("张三");
        bb.method1();
        System.out.println("访问类外部类方法");
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

2.匿名内部类

语法：

1
2
3
new 类或接口（形参）{
    类体；
}

注意事项：

  1. 调用匿名内部类的方法：
    1. new A(){}.cry();
    2. A a = new A(){}; a.cry();
  2. 可以直接访问外部类的所有成员，包括私有属性
  3. 不能添加访问修饰符，因为它就是一个局部变量
  4. 作用域：仅定义在他的方法或代码块中
  5. 外部其他类，不能访问匿名内部类
  6. 外部类和内部类的成员重名时，默认遵守就近原则；
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
// 匿名内部类 - 案例 1
public class LocalClass2 {
    public static void main(String[] args) {
        Cellphone cellphone = new Cellphone();
        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();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
// 匿名内部类 - 案例 2
public class AnonymousInnerClass {
    public static void main(String[] args) {
        Other01 other01 = new Other01();
        other01.method1();
    }
}

class Other01{
    public void method1(){
        // 基于 接口 的匿名内部类
        // 匿名内部类 只能被调用一次，但是对象可以调用多次（tiger 为对象）
        IA tiger = new IA() {
            @Override
            public void cry() {
                System.out.println("老虎叫~~~");
            }
        };
        // 匿名内部类调用
        tiger.cry();

        // 基于 类 的匿名内部类
        // 不加 {},则为普通的创建对象，加上 {} 则表示匿名内部类
        Father father = new Father("张三"){
            @Override
            public void test() {
                System.out.println("匿名内部类重写类 test 方法");
            }
        };
        father.test();

        // 基于 抽象类 的匿名内部函数
        Animal animal = new Animal(){
            @Override
            void eat() {
                System.out.println("实现抽象类的抽象方法");
            }
        };
        animal.eat();
    }
}

interface IA{
    void cry();
}

class Father{
    String name;
    public Father(String name){
        this.name = name;
    };
    public void test(){
        System.out.println(name);
    };
}

abstract class Animal{
    abstract void eat();
}

3.成员内部类

成员内部类定义在外部类的成员位置，并且没有 static 修饰

  1. 可以直接访问外部类的所有成员，包括私有成员
  2. 可以添加任意访问修饰符（public、protected、默认、private），他的定位时成员；
  3. 作用域：和外部类的成员方法一样
  4. 成员内部类 可以直接访问 外部类
  5. 外部类 访问 成员内部类时，需要先创建内部类对象，再访问
  6. 外部其他类 可以访问 内部成员类
  7. 如果外部类和内部类的成员重名，则默认遵守就近原则
    1. 如果要访问外部类成员，则 通过（外部类名.this.成员名）访问
1
2
3
4
5
6
7
8
9
10
11
// 外部其他类访问 成员内部类的方法

// 方法 1
Outer1 outer1 = new Outer1();
Innter1 innter1 = outer1.new Innter1();

// 方式 2
Innter2 innter2 = new Outer2().new Innter2();

// 方式 3(使用一个方法来获取)
Innter3 innter3d = new Outer3().getInnter3();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
// 成员内部类 - 案例
public class LocalClass3 {
    public static void main(String[] args) {
        Outer1 outer1 = new Outer1();
        outer1.t1();

        // 外部其他类 访问成员内部类
        // 通过外部类对象，创建成员内部类实例对象
        Outer1.Inner1 inner1 = outer1.new Inner1();
        inner1.say();
        // 通过 成员方法调用 成员内部类
        Outer1.Inner1 inner1 = outer1.getInner1();
        inner1.say();
    }
}

class Outer1 {
    private int n1 = 10;
    private String name = "张三";
    // 成员内部类
    // 成员内部类可以使用任何 访问修饰符
    public class Inner1{
        public void say(){
            // 内部类 可以直接访问外部类成员方法或属性，包括私有属性
            System.out.printf("n1= %d,name= %s",n1,name);
        }
    }

    public void t1(){
        // 外部类访问成员内部类时，需要先创建内部类对象，再进行访问
        Inner1 inner1 = new Inner1();
        inner1.say();
    }

    // 编写一个方法，返回 成员内部类的实例对象
    public Inner1 getInner1(){
        return new Inner1();
    }
}

4.静态内部类

静态内部类定义在 外部类的成员位置， 并且有 static 修饰符

  1. 可以直接访问外部类的所有静态成员，包括私有的，但不能直接访问非静态成员
  2. 可以添加任意访问修饰符，因为它定位为成员
  3. 作用域： 和其他成员相同
  4. 静态内部类可以直接访问外部类的静态成员
  5. 外部类访问静态内部类时，需要先创建对象，再进行访问
  6. 外部其他类 可以访问 静态内部类
  7. 如果外部类和静态内部类的成员重名，则默认遵守就近原则
    1. 如果要访问外部类成员，则 通过（外部类名.成员名）访问
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
// 静态内部类 - 案例
public class LocalClass3 {
    public static void main(String[] args) {
        Outer1 outer1 = new Outer1();
        outer1.m1();

        // 外部其他类 访问 静态内部类
        // 1. 通过外部类的类名访问
        Outer1.Inner1 inner1 = new Outer1.Inner1();
        inner1.say();

        // 2. 通过方法 返回一个内部类对象
        Outer1.Inner1 inner11 = outer1.getInner1();
        inner11.say();

        // 通过静态方法返回
        Outer1.Inner1 inner2 = Outer1.getInner2();
        inner2.say();
    }
}

class Outer1 {
    private int n1 = 10;
    private static String name = "张三";

    public static void cry(){
        System.out.println("静态方法");
    };

    public static class Inner1{
        public void say(){
            System.out.println(name);
            cry();
        }
    }

    public void m1(){
        Inner1 inner1 = new Inner1();
        inner1.say();
    }

    // 普通方法，返回静态内部类对象
    public Inner1 getInner1(){
        return new Inner1();
    }

    // 静态方法，返回静态内部类对象
    public static Inner1 getInner2(){
        return new Inner1();
    }
}