匿名对象

何时创建：一次性使用时
格式：new 类名()； 例如：new Game().start()

栈：局部变量，对象的引用（等号左边的）
堆：对象的实例

垃圾处理机制

java有一种机制：垃圾处理机制
每new一次，就生成一个新的对象，新的地址，会占用内存。
当一个对象长期没有一个引用去指向它的时候，就会被回收掉，从而释放内存。
封装

面向对象三大特征：封装、继承、多态
封装：类的封装
1.首先把 成员属性 私有化( private ) （使用private修饰隐藏起来），除了本类之外，其他地方无法直接访问到
2.然后 对外 提供公共的访问方式，进行访问（要么修改set，要么获取get）
//获取 age 的方法 有返回值
public int getAge() {
        return age;
}

//修改 age 的方法 无返回值
public void setAge(int a ){
        //约束 if
        if(a<1 || a>100){
                age = 18;
        }else{
                age = a;
        }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
封装的作用：
1.提高了代码的安全性（数据的严谨）
2.保证后续框架的运行
public void setName(String name){
        //形式参数的名字和成员变量的名字一样的时候，如果直接赋值，是无用功
        //为了解决这个问题，必须使用this来区分本类还是其他参数
                this.name = name;
}
1
2
3
4
5
this:代表的是当前类的引用
1.区分本类属性与其他的参数，同名的情况
2.使用this 点出属性和方法

当参数列表有多个参数时，可用类当作数据类型来调用

public void check(Player p,Robot ro ){
        int pNum = p.num;//这里就可以直接用 p 点出Player类里的num
        int pName = p.name;
        int rName = ro.name;
        ...
}
1
2
3
4
5
6
static

static：静态的修饰符
方法区存放：类、静态的常量/参数
static 出现的时机：随着类的加载而出现，优先于对象的存在
可以直接使用类名去调用静态的元素
静态的参数是大家共享的，整个内存只有一个
快捷键

快速生成get/set 快捷键：alt + shift + s → Generate Getters and Setters…
练习

1.打地鼠(封装版)

1.将打地鼠游戏进行面向对象处理，分为：洞穴类，玩家类，地鼠类，裁判类，游戏运行类，main方法类。
2.洞穴类：参考属性：洞穴的类型O，方法：打印洞穴的方法
3.玩家类：属性：玩家输入的行与列，方法：玩家击打的方法
4.地鼠类：属性：地鼠出现的行与列，地鼠的价值分数，方法：地鼠出现的方法
5.裁判类：属性：游戏次数，得分，击中次数，未击中次数，方法：判断打中的方法
6.游戏运行的类： 写start（）方法
7.游戏循环10次，统计得分，击中，未击中
8.99-重新开始，88-退出游戏
--------- Drop 类-----------

package game_DiShu;
//洞穴类
public class Drop {
        // 成员属性
        private char dropName = 'o'; // 洞穴
        private int dropRow; // 行数
        private int dropColumn; // 列数

        // 获取洞穴名
        public char getDropName() {
                return dropName;
        }

        // 修改洞穴名
        public void setDropName(char dropName) {
                this.dropName = dropName;
        }

        // 获取洞穴行数
        public int getDropRow() {
                return dropRow;
        }

        // 修改洞穴行数
        public void setDropRow(int dropRow) {
                this.dropRow = dropRow;
        }

        // 获取洞穴列数
        public int getyDropColumn() {
                return dropColumn;
        }

        // 修改洞穴列数
        public void setDropColumn(int dropColumn) {
                this.dropColumn = dropColumn;
        }

        // 构造函数
        public Drop() {

        }

        // 成员方法

        //打印洞穴的方法
        public char[][] printDrop(Drop d) {
                //创建一个二维数组pDrop，值分别为洞穴的行数与列数
                char[][] pDrop = new char[d.getDropRow()][d.getyDropColumn()];
                //遍历这个数组，打印洞穴初始形态
                for (int i = 0; i < pDrop.length; i++) {
                        for (int j = 0; j < pDrop.length; j++) {
                                pDrop[j] = 'o';
                                System.out.print(pDrop[j] + " ");
                        }
                        System.out.println();
                }
                //返回这个二维数组，后期使用
                return pDrop;
        }
}
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
--------- Player 类-----------

package game_DiShu;

import java.util.Scanner;

//玩家类
public class Player {
        // 成员属性
        private int playerRow; // 玩家输入的行
        private int playerColumn; // 玩家输入的列

        // 获取玩家输入的行
        public int getPlayerRow() {
                return playerRow;
        }

        // 修改玩家输入的行
        public void setPlayerRow(int playerRow) {
                this.playerRow = playerRow;
        }

        // 获取玩家输入的列
        public int getPlayerColumn() {
                return playerColumn;
        }

        // 修改玩家输入的列
        public void setPlayerColumn(int playerColumn) {
                this.playerColumn = playerColumn;
        }

        // 构造方法
        public Player() {

        }

        // 成员方法
        // 玩家打击的方法(感觉放在外面更好判断特殊情况，于是就写在了外面)
        public void playerWrite(Judge ju) {
                System.out.println("----------------");
                // 打印第几次游戏
                System.out.println("第" + ju.getNum() + "次游戏");

                System.out.println("地鼠出现了,请打击(先行后列，回车确定      99-重新开始    88-结束游戏)");
        }

}
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
--------- Mouse 类-----------

package game_DiShu;

import java.util.Random;

//地鼠类
public class Mouse {
        private int mouseRow; // 地鼠出现的行
        private int mouseColumn; // 地鼠出现的列
        private int mouseScore = 2; // 地鼠的分数

        // 获取地鼠出现的行
        public int getMouseRow() {
                return mouseRow;
        }

        // 修改地鼠出现的行
        public void setMouseRow(int mouseRow) {
                this.mouseRow = mouseRow;
        }

        // 获取地鼠出现的列
        public int getMouseColumn() {
                return mouseColumn;
        }

        // 修改地鼠出现的列
        public void setMouseColumn(int mouseColumn) {
                this.mouseColumn = mouseColumn;
        }

        // 获取地鼠的分数
        public int getMouseScore() {
                return mouseScore;
        }

        // 修改地鼠的分数
        public void setMouseScore(int mouseScore) {
                this.mouseScore = mouseScore;
        }

        // 构造方法
        public Mouse() {

        }

        // 成员方法
        // 地鼠出现的方法
        public void mouseAppear(char[][] pDrop, Drop d, Mouse m) {
                // new随机对象
                Random r = new Random();
                // 地鼠随机出现位置的行与列（随机数为洞穴的行与列）
                m.mouseRow = r.nextInt(d.getDropRow());
                m.mouseColumn = r.nextInt(d.getyDropColumn());

                // 设置洞穴的 地鼠行 与 地鼠列 为"x"
                pDrop[m.mouseRow][m.mouseColumn] = 'x';
                // 遍历
                for (int i = 0; i < pDrop.length; i++) {
                        for (int j = 0; j < pDrop.length; j++) {
                                System.out.print(pDrop[j] + " ");
                        }
                        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
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
--------- Judge 类-----------

package game_DiShu;

//裁判类
public class Judge {

        private int num = 1; // 游戏次数
        private int score = 0; // 总得分
        private int hit; // 击中次数
        private int miss; // 未击中次数

        // 获取游戏次数
        public int getNum() {
                return num;
        }

        // 修改游戏次数
        public void setNum(int num) {
                this.num = num;
        }

        // 获取总得分
        public int getScore() {
                return score;
        }

        // 修改总得分
        public void setScore(int score) {
                this.score = score;
        }

        // 获取击中数
        public int getHit() {
                return hit;
        }

        // 修改击中数
        public void setHit(int hit) {
                this.hit = hit;
        }

        // 获取未击中数
        public int getMiss() {
                return miss;
        }

        // 修改未击中数
        public void setMiss(int miss) {
                this.miss = miss;
        }

        // 构造方法
        public Judge() {

        }

        // 成员方法
        //判断是否打中的方法
       
        public void whetherHit(char[][] pDrop, Player p, Mouse m) {
                //如果玩家输入的行数和地鼠出现的行数相同，并且玩家输入的列数和地鼠出现的列数相同，则为击中
                if (p.getPlayerRow() == m.getMouseRow() && p.getPlayerColumn() == m.getMouseColumn()) {
                        System.out.println("----------");
                        System.out.println("【恭喜你击中了】");
                        //总分数等于之前的得分加上地鼠的分数
                        score += m.getMouseScore();
                        //击中次数增加
                        hit++;

                } else {
                        System.out.println("----------");
                        System.out.println("【很遗憾，未击中地鼠】");
                        //未击中次数增加
                        miss++;
                }
                //游戏次数增加
                num++;
                //还原洞穴
                pDrop[m.getMouseRow()][m.getMouseColumn()] = 'o';
        }
}
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
--------- Game 类-----------

package game_DiShu;

import java.util.Random;
import java.util.Scanner;

//运行类
public class Game {
        public void start() {

                Drop d = new Drop();// 洞穴对象
                Player p = new Player();// 玩家对象
                Mouse mo = new Mouse();// 地鼠对象
                Judge ju = new Judge();// 裁判对象
                Random r = new Random();// 随机数对象
                Scanner s = new Scanner(System.in);// 键盘输入对象

                // 欢迎的方法
                welcome();
                System.out.println("请输入您想挑战的行数,回车确定");
                d.setDropRow(s.nextInt());
                System.out.println("请输入您想挑战的列数,回车确定");
                d.setDropColumn(s.nextInt());

                // 创建一个二维数组去获取洞穴
                char[][] pDrop = d.printDrop(d);

                System.out.println("--------------");
                System.out.println("请注意，地鼠出现了");
                System.out.println("↓↓↓↓↓↓↓↓↓↓↓↓↓↓");
                // 当游戏次数小于10时循环
                while (ju.getNum() <= 10) {
                        // 洞穴出现的方法
                        mo.mouseAppear(pDrop, d, mo);
                        // 玩家击打
                        p.playerWrite(ju);
                        // 玩家输入行数
                        p.setPlayerRow(s.nextInt() - 1);
                        // 如果玩家99重新开始
                        if (p.getPlayerRow() == 98) {
                                System.out.println("---------");
                                System.out.println("重新开始游戏");
                                pDrop[mo.getMouseRow()][mo.getMouseColumn()] = 'o';
                                ju.setNum(1);
                                ju.setScore(0);
                                ju.setHit(0);
                                ju.setMiss(0);
                                continue;
                        }
                        // 如果玩家88退出游戏
                        if (p.getPlayerRow() == 87) {
                                System.out.println("---------");
                                System.out.println("退出游戏");
                                return;
                        }
                        // 玩家输入列
                        p.setPlayerColumn(s.nextInt() - 1);
                        // 是否打中的方法
                        ju.whetherHit(pDrop, p, mo);

                }

                System.out.println("--------");
                System.out.println("游戏结束");
                System.out.println("最终得分：" + ju.getScore() + "分");
                System.out.println("击中" + ju.getHit() + "次");
                System.out.println("未击中" + ju.getMiss() + "次");

        }

        public void welcome() {
                System.out.println("欢迎来到打地鼠游戏");
                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
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
--------- Test 类-----------

package game_DiShu;
//测试类
public class Test {
        public static void main(String[] args) {
                new Game().start();
        }
}
---------------------
【转载】
作者：欧皇柯基
原文：https://blog.csdn.net/qq_42829628/article/details/84072618