继承&关键字

# 1. 继承

# 1.1 继承的实现（掌握）

# 1.1.1 继承的概念

继承是面向对象三大特征之一，可以使得子类具有父类的属性和方法，还可以在子类中重新定义，以及追加属性和方法

# 1.1.2 实现继承的格式

继承通过extends实现
格式：class 子类 extends 父类 { }

举例：class Dog extends Animal { }

示例代码

public class Fu {
	public void show() {
		System.out.println("show方法被调用");
	}
}

public class Zi extends Fu {
	public void method() {
		System.out.println("method方法被调用");
	}
}

public class Demo {
	public static void main(String[] args) {
		//创建对象，调用方法
		Fu f = new Fu();
		f.show();

		Zi z = new Zi();
		z.method();
		z.show();
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# 1.2 继承的优点缺点

继承可以让类与类之间产生关系，子父类关系，产生子父类后，子类可以使用父类中非私有的成员。

继承的优点
- 提高了代码的复用性(多个类相同的成员可以放到同一个类中)
- 提高了代码的可维护性(如果方法的代码需要修改，修改一处即可)
继承的缺点
- 继承让类与类之间产生了关系，类的耦合性增强了，当父类发生变化时子类实现也不得不跟着变化，削弱了子类的独立性
继承的应用场景
- 不能盲目使用继承，需要考虑类与类之间是否存在is..a的关系
- 假设法：我有两个类A和B，如果他们满足A是B的一种，或者B是A的一种，就说明他们存在继承关系，这个时候就可以考虑使用继承来体现，否则不能滥用继承
- 举例：苹果和水果，猫和动物

# 2. 继承中的成员访问特点

# 2.1 继承中变量的访问特点（掌握）

在子类方法中访问一个变量，采用的是就近原则。

子类局部范围找
子类成员范围找
父类成员范围找
如果都没有就报错(不考虑父亲的父亲…)

示例代码：

class Fu {
	int num = 10;
}

class Zi {
	int num = 20;
	public void show(){
		int num = 30;
		System.out.println(num);
	}
}

public class Demo1 {
	public static void main(String[] args) {
		Zi z = new Zi();
		z.show(); // 输出show方法中的局部变量30
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# 2.2 super（掌握）

# 2.2.1 this&super关键字

this：代表本类对象的引用
super：代表父类存储空间的标识(可以理解为父类对象引用)

# 2.2.2 this和super的使用分别

关键字	访问成员变量	访问成员方法	访问构造方法
this	this.成员变量 —— 访问本类成员变量	this.成员方法 —— 访问本类成员方法	this(…) —— 访问本类构造方法
super	super.成员变量 —— 访问父类成员变量	super.成员方法 —— 访问父类成员方法	super(…) —— 访问父类构造方法

# 2.2.3 示例代码

# 2.3 继承中构造方法的访问特点（理解）

# 2.3.1 特点

子类中所有的构造方法默认都会访问父类中无参的构造方法

# 2.3.2 原因

子类会继承父类中的数据，可能还会使用父类的数据。所以，子类初始化之前，一定要先完成父类数据的初始化
每一个子类构造方法的第一条语句默认都是：super()

问题：如果父类中没有无参构造方法，只有带参构造方法，该怎么办呢？

通过使用super关键字去显示的调用父类的带参构造方法
在父类中自己提供一个无参构造方法

推荐方案：自己给出无参构造方法

# 2.3.3 示例代码

public class Fu {

    //public Fu() {
    //    System.out.println("Fu中无参构造方法被调用");
    //}
    public Fu() {}

    public Fu(int age) {
        System.out.println("Fu中带参构造方法被调用");
    }
}

public class Zi extends Fu {

    public Zi() {
//        super();
        super(20);
        System.out.println("Zi中无参构造方法被调用");
    }

    public Zi(int age) {
//        super();
        super(20);
        System.out.println("Zi中带参构造方法被调用");
    }
}

public class Demo {
    public static void main(String[] args) {
        //创建对象
        Zi z = new Zi();

        Zi z2 = new Zi(20);
    }
}

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

# 2.4 继承中成员方法的访问特点（掌握）

通过子类对象访问一个方法

子类成员范围找
父类成员范围找
如果都没有就报错(不考虑父亲的父亲…)

# 2.5 super内存图（理解）

对象在堆内存中，会单独存在一块super区域，用来存放父类的数据

# 2.6 方法重写（掌握）

# 2.6.1 方法重写概念

子类出现了和父类中一模一样的方法声明（方法名一样，参数列表也必须一样）

# 2.6.2 方法重写的应用场景

当子类需要父类的功能，而功能主体子类有自己特有内容时，可以重写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容

# 2.6.3 Override注解

用来检测当前的方法，是否是重写的方法，起到校验的作用。如果不是重写的方法，注解处会报错。

# 2.6.4 示例代码

public class Phone {
    public void call(String name) {
        System.out.println("给" + name + "打电话");
    }
}

public class NewPhone extends Phone {

    @Override
    public void call(String name) {
        System.out.println("开启视频功能");
//        System.out.println("给" + name + "打电话");
        super.call(name);
    }
}

public class PhoneDemo {
    public static void main(String[] args) {
        //创建对象，调用方法
        Phone p = new Phone();
        p.call("林青霞");
        System.out.println("--------");

        NewPhone np = new NewPhone();
        np.call("林青霞");
    }
}

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

# 2.7 方法重写的注意事项（掌握）

方法名和形参列表不能改变。
私有方法和静态方法不能被重写(父类私有成员子类是不能继承的)
子类方法访问权限不能更低，可以更高(public > protected 默认 > 私有)
如果返回值是引用类型，重写后的方法返回值可以是父类方法返回值的子类

示例代码：

public class Fu {
	private void show() {
		System.out.println("Fu中show()方法被调用");
	}
	
	void method() {
		System.out.println("Fu中method()方法被调用");
	}
}

public class Zi extends Fu {
	/* 编译【出错】，子类不能重写父类私有的方法*/
	@Override
	private void show() {
		System.out.println("Zi中show()方法被调用");
	}
	
	/* 编译【出错】，子类重写父类方法的时候，访问权限需要大于等于父类 */
	@Override
	private void method() {
		System.out.println("Zi中method()方法被调用");
	}

	/* 编译【通过】，子类重写父类方法的时候，访问权限需要大于等于父类 */
	@Override
	public void method() {
		System.out.println("Zi中method()方法被调用");
	}
}

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

# 2.8. Java中继承的注意事项（掌握）

Java中类只支持单继承，不支持多继承（只能继承一个类）
- 错误范例：class A extends B, C { }
Java中类支持多层继承

多层继承示例代码：

public class Granddad {
	
	public void drink() {
		System.out.println("爷爷爱喝酒");
	}
}

public class Father extends Granddad {
	public void smoke() {
		System.out.println("爸爸爱抽烟");
	}
}

public class Mother {
	public void dance() {
		System.out.println("妈妈爱跳舞");
	}
}

public class Son extends Father {
	// 此时，Son类中就同时拥有drink方法以及smoke方法
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

# 3. 继承练习

# 3.1 老师和学生（应用）

# 3.1.1 需求

定义老师类和学生类，然后写代码测试；最后找到老师类和学生类当中的共性内容，抽取出一个父类，用继承的方式改写代码，并进行测试

# 3.1.2 步骤

①定义老师类(姓名，年龄，教书())

②定义学生类(姓名，年龄，学习())

③定义测试类，写代码测试

④共性抽取父类，定义人类(姓名，年龄)

⑤定义老师类，继承人类，并给出自己特有方法：教书()

⑥定义学生类，继承人类，并给出自己特有方法：学习()

⑦定义测试类，写代码测试

# 3.1.3 示例代码：

class Person {
	private String name;
	private int age;
	
	public Person() {
	}

	public Person(String name, int age) {
		this.name = name;
		this.age = age;
	}

	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;
	}
}

class Teacher extends Person {
	public Teacher() {}

	public Teacher(String name,int age) {
		super(name,age);
	}

	public void teach() {
		System.out.println("用爱成就每一位学员");
	}
}

class Student extends Person{
	public Student() {}
	
	public Student(String name, int age) {
		super(name,age);
	}

	public void study(){
		System.out.println("好好学习，天天向上");
	}
}

class PersonDemo {
	public static void main(String[] args){
		//创建老师类对象并进行测试
		Teacher t1 = new Teacher();
		t1.setName("林青霞");
		t1.setAge(30);
		System.out.println(t1.getName() + "," + t1.getAge());
		t1.teach();

		Teacher t2 = new Teacher("张曼玉", 25);
		System.out.println(t2.getName() + "," + t2.getAge());
		t2.teach();
		
		// 创建学生类对象测试
		Student s = new Student("星子"，20)；
		System.out.println(s.getName() + "," + s.getAge());
		s.study();
	}
}

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

# 3.2 猫和狗（应用）

# 3.2.1 需求

请采用继承的思想实现猫和狗的案例，并在测试类中进行测试

# 3.2.2 分析

①猫：

成员变量：姓名，年龄
构造方法：无参，带参
成员方法：get/set方法，抓老鼠()

②狗：

成员变量：姓名，年龄
构造方法：无参，带参
成员方法：get/set方法，看门()

③共性：

成员变量：姓名，年龄
构造方法：无参，带参
成员方法：get/set方法

# 3.2.3 步骤：

1、定义动物类(Animal)

【成员变量：姓名，年龄】【构造方法：无参，带参】【成员方法：get/set方法】

2、定义猫类(Cat)，继承动物类【构造方法：无参，带参】【成员方法：抓老鼠() 】

3、定义狗类(Dog)，继承动物类【构造方法：无参，带参】【成员方法：看门() 】

4、定义测试类(AnimalDemo)，写代码测试

# 3.2.4 示例代码：

class Animal {
	private String name;
	private int age;

	public Animal() {
	}

	public Animal(String name, int age) {
		this.name = name;
		this.age = age;
	}

	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;
	}
}

class Cat extends Animal {
	public Cat() {
	}

	public Cat(String name, int age) {
		super(name, age);
	}

	public void catchMouse() {
		System.out.println("猫抓老鼠");
	}
}

class Dog extends Animal {
	public Dog() {
	}
	
	public Dog(String name, int age) {
		super(name, age);
	}

	public void lookDoor() {
		System.out.println("狗看门");
	}
}

/*
测试类
*/
public class AnimalDemo {
	public static void main(String[] args) {
		//创建猫类对象并进行测试
		Cat c1 = new Cat();
		c1.setName("加菲猫");
		c1.setAge(5);
		System.out.println(c1.getName() + "," + c1.getAge());
		c1.catchMouse();
		
		Cat c2 = new Cat("加菲猫", 5);
		System.out.println(c2.getName() + "," + c2.getAge());
		c2.catchMouse();
	}
}

# 4. final和static关键字

# 4.1 final（应用）

fianl关键字的作用

final代表最终的意思，可以修饰成员方法，成员变量，类
final修饰类、方法、变量的效果
- fianl修饰类：该类不能被继承（不能有子类，但是可以有父类）
- final修饰方法：该方法不能被重写
- final修饰变量：表明该变量是一个常量，不能再次赋值

示例代码：

Fu：

package day10.demo12;

//public final class Fu {
//
//    public final void method() {
//        System.out.println("Fu method");
//    }
//}

public class Fu {

    public final void method() {
        System.out.println("Fu method");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

Zi：

package day10.demo12;

public class Zi extends Fu{

//    @Override
//    public void method() {
//        System.out.println("Zi method");
//    }

    public final int age = 20;

    public void show() {
//        age = 100;
        System.out.println(age);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

Demo：

package day10.demo12;

public class Demo {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.method();
        z.show();
    }
}

1
2
3
4
5
6
7
8
9

# 4.2 final修饰局部变量（理解）

fianl修饰基本数据类型变量

final 修饰指的是基本类型的数据值不能发生改变
final修饰引用数据类型变量
- final 修饰指的是引用类型的地址值不能发生改变，但是地址里面的内容是可以发生改变的
- 举例：
```
public static void main(String[] args){
	final Student s = new Student(23);
	s = new Student(24); // 错误
	s.setAge(24); // 正确
}
```
  1
  2
  3
  4
  5

# 4.3 static（应用）

static的概念

static关键字是静态的意思，可以修饰【成员方法】，【成员变量】
static修饰的特点
1. 被类的所有对象共享，这也是我们判断是否使用静态关键字的条件
2. 可以通过类名调用，也可以通过对象名调用【推荐使用类名调用】
什么时候使用static定义方法
- 如果是定义在封装类的方法，就定义成员方法 -> 没有static的方法
- 如果是定义在测试类的方法，就定义静态方法 -> 有static修饰的方法

示例代码：

public class Student {
	public String name; //姓名
	public int age; //年龄
	public static String university; //学校 共享数据！所以设计为静态！

	public void show() {
		System.out.println(name + "," + age + "," + university);
	}
}

public class StaticDemo {
    public static void main(String[] args) {
        // 为对象的共享数据赋值(s)
        Student.university = "B站大学";

        Student s1 = new Student();
        s1.name = "林青霞";
        s1.age = 30;
//        s1.university = "B站大学";
        s1.show();

        Student s2 = new Student();
        s2.name = "林青霞";
        s2.age = 30;
//        s2.university = "B站大学";
        s2.show();
    }
}

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

# 4.4 static 访问特点（掌握）

# 4.4.1 成员变量

静态变量和实例变量的区别：

	内存特点	访问方式
静态变量（static）	随着类的加载而存在，在内存中只有一份，被所有对象共享。	使用类名或对象名访问（推荐类名访问）
实例变量（无static）	随着对象的创建而存在，每个对象各自维护一份数据。	只能使用对象名访问

# 4.4.2 成员方法

非静态的成员方法
- 能访问静态的成员变量
- 能访问非静态的成员变量
- 能访问静态的成员方法
- 能访问非静态的成员方法
静态的成员方法
- 能访问静态的成员变量
- 能访问静态的成员方法
总结：静态成员方法只能访问静态成员
- 原因：在内存中，静态修饰的成员和方法先出现（静态修饰成员或方法在程序加载时就出现），此时成员的实例变量和方法还未产生，不能访问成员变量或方法。

示例代码：

/*
    static访问特点
 */
public class Student {
    //非静态成员变量
    private String name = "林青霞";
    //静态成员变量
    private static String university = "B站大学";

    //非静态成员方法
    public void show1() {

    }

    //非静态成员方法
    public void show2() {
        System.out.println(name);
        System.out.println(university);
        show1();
        show3();
    }

    //静态成员方法
    public static void show3() {

    }

    //静态成员方法
    public static void show4() {
		//System.out.println(name);
        System.out.println(university);
		//show1();
        show3();
        //通过创建对象调用静态对象和方法
        Student s = new Student();
        System.out.println(s.name);
        s.show1();
    }
}

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

# 4.5 static关键字的应用-在线人数统计

# 4.5.1 需求：

统计在线人数（创建的对象的个数）

# 4.5.2 代码实现：

User：

public class User {
    private String name; //姓名
    //为了在线人数能够多个对象共享，需要设计成静态的
    private static int total; //当前在线人数

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

    //登录方法：登录成功后，更新在线人数
    public void login() {
        System.out.println(name + "上线了");
        total++;
        System.out.println("当前在线人数" + total);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

UserDemo：

public class UserDemo {
    public static void main(String[] args) {
        User u1 = new User("蔡徐坤");
        u1.login();

        User u2 = new User("坤坤");
        u2.login();
    }
}

1
2
3
4
5
6
7
8
9

# 4.6 工具类的设计

# 4.6.1 工具类的概念

将多处地方相同的代码，提取到工具类中，在其他地方直接调用

# 4.6.2 工具类的特点

方法通常是静态方法（调用方便）
构造方法是私有的（不让创建对象）

# 4.6.3 示例代码

设计验证码

CodeUtil：

import java.util.Random;

/*
工具类：将多处地方相同的代码，提取到工具类中，在其他地方直接调用
工具类的特点：
    1.方法通常是静态方法（调用方便）
    2.构造方法是私有的（不让创建对象）
 */
public class CodeUtil {

    //私有构造方法，不让外界创建对象
    private CodeUtil() {

    }

    //为了调用方便，可以将方法设计为静态
    public static void randomCode(int length) {
        //生成4位长度的数字验证码
        //如果生成1000-9999，第一位不能为0，不够随机
        //使用StringBuilder拼接4个0-9的随机数
        StringBuilder sb = new StringBuilder();
        Random r = new Random();
        for (int i = 0; i < length; i++) {
            int a = r.nextInt(10);
            sb.append(a);
        }
        String code = sb.toString();
        System.out.println(code);
    }
}

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 Login {
    public static void main(String[] args) {

        //通过类名调用方法,生成5位的验证码
        CodeUtil.randomCode(5);

        //禁止使用对象调用
        //CodeUtil c = new CodeUtil();
        //c.randomCode(5);
    }
}

1
2
3
4
5
6
7
8
9
10
11

public class Register {
    public static void main(String[] args) {

        //通过类名调用方法，生成4位的验证码
        CodeUtil.randomCode(4);
    }
}

1
2
3
4
5
6
7

# 5. 综合案例-超级玛丽游戏

# 5.1 业务角色要求

在开发超级玛丽游戏时，系统需要定义角色类然后创建对象来代表不同角色展示在界面上。分析角色信息有超级玛丽、蘑菇怪、啪嗒鬼（分红绿乌龟）等角色。它们的属性和行为需求如下：

角色信息内容如下
- 超级玛丽（属性：名称，图片名称，总得分；行为：移动，发射，踩踏）
- 蘑菇怪（属性：名称，图片名称，分值；行为：移动，碰撞）
- 啪嗒鬼（属性：名称，图片名称，颜色；行为：移动）
请用优雅方式设计出以上三种角色类（使用继承优化设计）

角色名称：

超级玛丽：SuperMario

蘑菇怪：Mushroom

啪嗒龟：Tortoise

# 5.2 代码实现

Character类：

public class Character {
    private String name;
    private String photoName;

    public Character() {
    }

    public Character(String name, String photoName) {
        this.name = name;
        this.photoName = photoName;
    }

    public String getName() {
        return name;
    }

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

    public String getPhotoName() {
        return photoName;
    }

    public void setPhotoName(String photoName) {
        this.photoName = photoName;
    }

    public void move() {
        System.out.println(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
31
32

SuperMario类：

public class SuperMario extends Character{
    private int totalScore;

    public SuperMario() {

    }

    public SuperMario(String name, String photoName, int totalScore) {
        super(name, photoName);
        this.totalScore = totalScore;
    }

    public int getTotalScore() {
        return totalScore;
    }

    public void setTotalScore(int totalScore) {
        this.totalScore = totalScore;
    }

    public void shoot() {
        System.out.println( getName() + "正在发射子弹");
    }

    public void Tread() {
        totalScore++;
        System.out.println( getName() + "正在踩踏，得分为" + totalScore);
    }
}

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

Mushroom类：

public class Mushroom extends Character{
    private int score;

    public Mushroom(int score) {
        this.score = score;
    }

    public Mushroom(String name, String photoName, int score) {
        super(name, photoName);
        this.score = score;
    }

    public int getScore() {
        return score;
    }

    public void setScore(int score) {
        this.score = score;
    }

    public void hit() {
        System.out.println( getName() + "正在碰撞");
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

Tortoise类：

public class Tortoise extends Character {
    private String color;

    public Tortoise() {
    }

    public Tortoise(String name, String photoName, String color) {
        super(name, photoName);
        this.color = color;
    }

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

Test类：

/*
    目标：能够应用继承完成游戏角色设计

    父类Role

    角色信息内容如下：
        超级玛丽 SuperMario
            属性：名称name，图片名称imageName，总得分totalScore
            行为：移动move，发射shoot，踩踏stepOn

        蘑菇怪物 Mushroom
            属性：名称name，图片名称imageName，分值score
            行为：移动move，碰撞crash

        啪嗒龟 Tortoise
            属性：名称name，图片名称imageName，颜色color
            行为: 移动move
 */

public class Test {
    public static void main(String[] args) {
        SuperMario mario = new SuperMario("超级玛丽", "mario.jpg", 0);
        mario.move();
        mario.shoot();
        mario.Tread();

        Mushroom m = new Mushroom("蘑菇怪", "mushroom.jpg", 100);
        m.move();
        m.hit();

        Tortoise t = new Tortoise("啪嗒龟", "tortoise.jpg", "绿色");
        t.move();
    }
}

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

在Github中编辑

上次更新: 2022/04/20, 21:54:58

← ArrayList集合&学生管理系统权限修饰符&代码块→

继承&关键字

# 1. 继承

# 1.1 继承的实现（掌握）

# 1.1.1 继承的概念

# 1.1.2 实现继承的格式

# 1.2 继承的优点缺点

# 2. 继承中的成员访问特点

# 2.1 继承中变量的访问特点（掌握）

# 2.2 super（掌握）

# 2.2.1 this&super关键字

# 2.2.2 this和super的使用分别

# 2.2.3 示例代码

# 2.3 继承中构造方法的访问特点（理解）

# 2.3.1 特点

# 2.3.2 原因

# 2.3.3 示例代码

# 2.4 继承中成员方法的访问特点（掌握）

# 2.5 super内存图（理解）

# 2.6 方法重写（掌握）

# 2.6.1 方法重写概念

# 2.6.2 方法重写的应用场景

# 2.6.3 Override注解

# 2.6.4 示例代码

# 2.7 方法重写的注意事项（掌握）

# 2.8. Java中继承的注意事项（掌握）

# 3. 继承练习

# 3.1 老师和学生（应用）

# 3.1.1 需求

# 3.1.2 步骤

# 3.1.3 示例代码：

# 3.2 猫和狗（ 应用）

# 3.2.1 需求

# 3.2.2 分析

# 3.2.3 步骤：

# 3.2.4 示例代码：

# 4. final和static关键字

# 4.1 final（应用）

# 4.2 final修饰局部变量（理解）

# 4.3 static（应用）

# 4.4 static 访问特点（掌握）

# 4.4.1 成员变量

# 4.4.2 成员方法

# 4.5 static关键字的应用-在线人数统计

# 4.5.1 需求：

# 4.5.2 代码实现：

# 4.6 工具类的设计

# 4.6.1 工具类的概念

# 4.6.2 工具类的特点

# 4.6.3 示例代码

# 5. 综合案例-超级玛丽游戏

# 5.1 业务角色要求

# 5.2 代码实现

# 3.2 猫和狗（应用）