一、类与对象

1. 引出类与对象

  • 由于现有技术不利于数据的管理，效率低，不能完美的解决新的需求，Java设计者引入类与对象(OOP)

2. 类与对象

  1. 类是一个模板，是数据类型。比如Cat
  2. 对象是类的一个具体实例，有属性和行为。例如，一条狗是一个对象，它的属性有：颜色、名字、品种；行为有：摇尾巴、叫、吃等

3. 类与对象入门案例

  • 使用面向对象的方式来解决养猫问题 ```java // 猫类 class Cat { // 属性/成员变量 String name; // 名字 int age; // 年龄 String color; // 颜色 }

// 主类 public class Hello {

  1. public static void main(String[] args) {
  2.     // 使用OOP面向对象解决
  3.     // 实例化一只猫(创建一只猫对象)
  5.     // 1. new Cat() 创建一只猫对象
  6.     // 2. 把创建的猫赋给 cat1
  7.     // 3. cat1 是一个对象名(对象引用)，new Cat()创建的对象空间(数据)才是真正的对象
  8.     Cat cat1 = new Cat();
  9.     cat1.name = "小白";
  10.     cat1.age = 3;
  11.     cat1.color = "白色";
  13.     Cat cat2 = new Cat();
  14.     cat2.name = "小花";
  15.     cat2.age = 100;
  16.     cat2.color = "花色";
  18.     // 访问对象的属性
  19.     System.out.println("第一只猫：" + cat1.name
  20.             + " " + cat1.age + " " + cat1.color);
  22.     System.out.println("第二只猫：" + cat2.name
  23.             + " " + cat2.age + " " + cat2.color);
  24. }

}

  3. <a name="CfdU0"></a>
  4. #### 4. 类与对象的区别和联系
  6. 1. 类是抽象的，概念的，代表一类事物。比如人类、猫类...，是数据类型
  7. 1. 对象是具体的，实际的，代表一个具体事物，是实例
  8. 1. 类是对象的模板，对象是类的一个个体，对应一个实例
  10. <a name="HgGUr"></a>
  11. #### 5. 对象在内存中存在形式(重要)
  12. ![mk-2022-04-20-16-51.png](https://cdn.nlark.com/yuque/0/2022/png/2828304/1651853109398-9f1c0cb6-06bd-4265-9dd5-e6e17e82dbfb.png#clientId=ucc169495-961e-4&crop=0&crop=0&crop=1&crop=1&from=ui&id=uab9f65fc&name=mk-2022-04-20-16-51.png&originHeight=670&originWidth=1575&originalType=binary&ratio=1&rotation=0&showTitle=true&size=426843&status=done&style=none&taskId=ud2f444a6-42b0-419d-a38b-cb88bcb55bf&title=%E5%AF%B9%E8%B1%A1%E5%9C%A8%E5%86%85%E5%AD%98%E4%B8%AD%E5%AD%98%E5%9C%A8%E5%BD%A2%E5%BC%8F "对象在内存中存在形式")
  14. <a name="uysjY"></a>
  15. #### 6. 属性/成员变量
  17. 1.  从概念或叫法上看：成员变量 = 属性 = field(字段) 
  18. ```java
  19. class Car() {
  20.     String name; // 属性/成员变量/field
  21.     String color;
  22.     double price;
  23.     String[] master; // 属性可以是引用类型
  24. }
  1. 属性是类的一个组成部分，一般是基本数据类型，也可以是引用类型(对象，数组)

7. 类与对象注意事项

  1. 属性的定义语法同变量，示例：访问修饰符 属性类型 属性名;
    • 访问修饰符：控制属性的访问范围，有四种访问修饰符。public, proctected, default, private
  2. 属性的定义类型可以为任意类型，包含基本类型或引用类型
  3. 属性如果不赋值，有默认值，规则和数组一致
    • int 0, short 0, byte 0, long 0, float 0.0, double 0.0, char \u0000, boolean false, String null

8. 如何创建对象

  1. 先声明再创建 
    1. Cat cat; // 声明对象 cat
    2. cat = new Cat(); // 创建
  1. 直接创建 
    1. Cat cat= new Cat();
  1. 访问属性 
    1. // 对象名.属性名;
    2. cat.name;
    3. cat.age;
    4. cat.color;

9. 类与对象的内存分配机制(重要)

mk-2022-04-21-11-29.png

  1. Java内存的结构分析
    1. 栈：一般存放基本数据类型(局部变量)
    2. 堆：存放对象(Cat cat, 数组等)
    3. 方法区：常量池(常量，比如字符串)，类加载信息

  2. Java创建对象的流程简单分析

    1. Person p = new Person();
    2. p.name = "jack";
    3. p.age = 10;

  3. 先加载Person类信息(属性和方法信息，只会加载一次)

  4. 在堆中分配空间，进行默认初始化(默认值)
  5. 把地址赋给p，p就指向对象
  6. 进行指定初始化赋值，比如 p.name = "jack"
  7. p是对象引用/对象名，堆中的才是真正的对象

二、成员方法

1. 成员方法基本介绍

在某些情况下，我们要需要定义成员方法(简称方法)。比如人类：除了有一些属性外(年龄，姓名…)，我们人类还有一些行为比如可以说话、跑步，通过学习，还可以做算术题。这时就
要用成员方法才能完成。现在要求对Person类完善。

2. 成员方法案例演示

  1. public class Method01 {
  2.     /*
  3.      * 1. 创建Person类
  4.      * 2. 添加speak成员方法，输出 我是一个好人
  5.      * 3. 添加cal01成员方法，可以计算 1+...+1000的结果
  6.      * 4. 添加cal02成员方法，可以接收一个数n，计算从1+...+n的结果
  7.      * 5. 添加getSum成员方法，可以计算两个数的和
  8.      */
  9.     public static void main(String[] args) {
  10.         Person p = new Person(); // 创建对象
  11.         p.speak(); // 调用speak成员方法
  12.         p.cal01(); // cal01成员方法
  13.         p.cal02(10); //cal01成员方法
  15.         // 把 方法getSum()返回的值，赋给变量sum
  16.         int sum = p.getSum(10, 20); // 调用getSum a01 = 10, b = 20
  17.         System.out.println(sum);
  18.     }
  19. }
  21. // Person类
  22. class Person {
  23.     // 属性
  24.     String name;
  25.     int age;
  27.     // 1. public表示方法是公开的
  28.     // 2. void：没有返回值
  29.     // 3. speak：方法名
  30.     // 4. ()：形参列表
  31.     // 5. {}：方法体
  32.     public void speak() { // 输出"我是一个好人"
  33.         System.out.println("我是一个好人");
  34.     }
  36.     public void cal01() { // 计算 1+...+1000的结果
  37.         int sum = 0;
  38.         for (int sum = 1; sum <= 1000; sum++) {
  39.             sum += sum;
  40.         }
  41.         System.out.println("cal01: " + sum);
  42.     }
  44.     public void cal02(int n) { // 接收一个数n，计算从1+...+n的结果
  45.         int sum = 0;
  46.         for (int sum = 1; sum <= n; sum++) {
  47.             sum += sum;
  48.         }
  49.         System.out.println("cal01: " + sum);
  50.     }
  52.     // int：表示方法执行后，返回一个int值
  53.     // (int a01, int b)：形参列表，可以接收用户传入的两个数
  54.     // return：返回a+b的值
  55.     public int getSum(int a01, int b) {                 // 计算两个数的和
  56.         int res = a01 + b;
  57.         return res;
  58.     }
  59. }

3. 方法的调用机制原理(重要)

方法的调用机制.svg

4. 方法的优点

  1. 提高代码的复用性
  2. 可以将实现的细节封装起来，然后供其他用户来调用

5. 成员方法的定义

  1. 参数列表：表示成员方法输入
  2. 返回数据类型(返回类型)：表示成员方法输出，void表示没有返回值
  3. 方法主体：表示为了实现某一功能的代码块
  4. return语句不是必须的
  1. 访问修饰符 返回数据类型 方法名 (形参列表) {
  2.     // 方法体
  3.     语句;
  4.     return 返回值;
  5. }

6. 方法的注意事项和使用细节

  1. 访问修饰符
    1. 控制方法的适用范围，可选，如果不写默认访问
    2. 访问修饰符共有四种：public, protected, default, private
  2. 返回值
    1. 一个方法最多有一个返回值
    2. 返回类型可以为任意类型，包含基本类型或引用类型(数组，对象等)
    3. 如果方法要求有返回数据类型，则方法体中最后的执行语句必须为return值；而且要求返回值类型必须和return的值类型一致或兼容
    4. 如果方法是void，则方法体中可以没有return语句，或者只写return
  3. 方法名
    • 遵循驼峰命名法，最好见名知义，表达出该功能的意思即可
  4. 形参列表
    1. 一个方法可以有0个参数，也可以有多个参数，中间用逗号隔开
    2. 参数类型可以为任意类型，包含基本类型或引用类型
    3. 调用带参数的方法时，一定对应着参数列表传入相同类型或兼容类型的参数
    4. 方法定义时的参数称为形式参数，简称形参；方法调用时的参数称为实际参数，简称实参，实参和形参的类型要一致或兼容，个数、顺序必须一致
  5. 方法体
    • 里面写完成功能的具体语句，可以为输入、输出、变量、运算、分支、循环、方法调用，但是方法体内不能再定义方法。即：方法不能嵌套定义
  6. 方法调用
    1. 同一个类中的方法直接调用即可。比如：方法名(参数)
    2. 跨类中的方法：A类调用B类的方法，需要创建B类对象，然后通过对象名调用。比如：对象名.方法名(参数)
    3. 跨类的方法调用和方法的访问修饰符相关

7. 课后练习

  1. 编写类AA，方法：判断一个数是奇数odd还是偶数，返回boolean ```java /*

      1. 方法的返回类型 boolean
      1. 方法的名字 isOdd
      1. 方法的形参 int num
      1. 方法体 判断 */ public class MethodExercise01 {

    public static void main(String[] args) {

    1. AA a01 = new AA();
    2. if (a01.isOdd(2)) { // T
    3.     System.out.println("是奇数");
    4. } else {
    5.     System.out.println("是偶数");
    6. }

    } }

class AA { public boolean isOdd(int num) { // return num % 2 != 0 ? true : false; return num % 2 != 0; } }

  3. 2.  根据行、列、字符打印对应行数和列数的字符，比如：行：4, 列：4, 字符#，则打印相应效果 
  4. ```java
  5. /* 
  6.  * 根据行、列、字符打印对应行数和列数的字符
  7.  * 比如，[行：4, 列：4, 字符：#]，则打印相应效果：
  8.  * ####
  9.  * ####
  10.  * ####
  11.  * ####
  12.  * 1. 方法的返回类型 void
  13.  * 2. 方法的名字 print
  14.  * 3. 方法的形参 int row, int column, char c 
  15.  * 4. 方法体 for循环打印输出
  16.  */
  17. public class MethodParameter01 {
  19.     public static void main(String[] args) {
  20.         AA a01 = new AA();
  21.         a01.print(4, 4, '#');
  22.     }
  23. }
  25. class AA {
  26.     public void print(int row, int col, char c) {
  27.         for (int i = 0; i < col; i++) {
  28.             for (int j = 0; j < row; j++) {
  29.                 System.out.print(c);
  30.             }
  31.             System.out.println();
  32.         }
  33.     }
  34. }

8. 成员方法传参机制(重要)

  1. 对于基本数据类型，传递的是值(值拷贝)，形参的任何改变不影响实参
  2. 对于引用数据类型(包括类)，传递的是地址值，可以通过形参影响实参

成员方法传参机制.svg

  • 案例演示

    1. 编写MyTools类，编写一个方法可以打印二维数组的数据

    2. 编写一个方法copyPerson可以复制一个Person对象，返回复制的对象。克隆对象，注意要求得到新对象和原来的对象是两个独立的对象，只是他们的属性相同 ```java public class Hello {

      public static void main(String[] args) { int[][] arr = { { 1, 1, 1 }, { 2, 2, 2 }, { 3, 3, 3 } }; MyTools tools = new MyTools(); tools.printArr(arr); // 打印二维数组

      Person p = new Person(); p.name = “jack”; p.age = 10;

      Person p2 = tools.copyPerson(p); // 克隆对象

      // p 和 p2 是两个独立的Person对象，属性相同 System.out.println(“p：” + p.age + “ “ + p.name); System.out.println(“p2：” + p2.age + “ “ + p2.name);

      // 通过比较查看是否为同一个对象 System.out.println(p == p2); // false } }

class Person { // Person类 String name; int age; }

class MyTools { // MyTools类 public void printArr(int[][] arr) { // 打印二维数组的数据 for (int i = 0; i < arr.length; i++) { for (int j = 0; j < arr[i].length; j++) { System.out.print(arr[i][j] + “ “); } System.out.println(); } }

  1. public Person copyPerson(Person p) {
  2.     Person p2 = new Person();
  3.     p2.name = p.name;
  4.     p2.age = p.age;
  5.     return p2;
  6. }

}

  2. <a name="Tef68"></a>
  3. ### 三、方法递归调用
  4. <a name="hgSmc"></a>
  5. #### 1. 递归基本介绍
  7. - 递归是指在函数的定义中使用函数自身的方法，每次调用时传入不同的变量
  8. - 递归有助于编程者解决复杂问题，同时可以让代码变得简洁
  10. <a name="ZT0F6"></a>
  11. #### 2. 递归能解决什么问题
  13. 1. 各种数学问题，如：八皇后、汉诺塔、阶乘、迷宫、球和篮子(Google编程大赛)等
  14. 1. 各种算法中也会使用到递归，比如：快排、归并排序、二分查找、分治算法等
  15. 1. 将用栈解决的问题，递归代码比较简洁
  17. <a name="NnkDF"></a>
  18. #### 3. 递归案例演示
  20. 1. 打印问题
  21. 1. 阶乘问题
  23. ```java
  24. public class recursion01 {
  25.     public static void main(String[] args) {
  26.         A a01 = new A();
  27.         a01.test(4); // 打印输出 2
  28.         int res = a01.factorial(5);
  29.         System
  30.     }
  31. }
  33. class A {
  34.     public void test(int n) {
  35.         // 打印问题
  36.         if (n > 2) {
  37.             test(n - 1);
  38.         }
  39.         System.out.println("n = " + n);
  40.     }
  42.     public int factorial(int n) {
  43.         // 阶乘问题
  44.         if (n == 1) {
  45.             return 1;
  46.         } else {
  47.             return factorial(n-1) * n;
  48.         }
  49.     }
  50. }

方法的递归调用.svg

4. 递归的重要规则

  1. 执行一个方法时，就创建一个新的受保护的独立空间(栈空间)
  2. 方法的局部变量是独立的，不会相互影响
  3. 如果方法中使用的是引用类型变量(比如数组、对象)，就会共享该引用类型的数据
  4. 递归必须向退出递归的条件逼近，否则就是无限递归，出现StackOverflowError，死龟了:)
  5. 当一个方法执行完毕，或者遇到return，就会返回，遵守谁调用，就将结果返回给谁，同时当发法执行完毕或者返回时，该方法也就执行完毕

5. 课堂练习

  1. 请使用递归的方式求出斐波那契数列1,1,2,3,5,8,13...求第n个数的值
  2. 猴子吃桃问题：有一堆桃子，猴子第一天吃了其中的一半，并再多吃了一个。以后每天猴子都吃其中的一半，然后再多吃一个。当到第10天时，想再吃时发现只有一个桃子了。问题：最初共有多少个桃子？
  1. public class maze {
  3.     public static void main(String[] args) {
  4.         T t1 = new T();
  5.         System.out.println("=========斐波那契数=========");
  6.         int n = 7;
  7.         int res = t1.fibNum(7);
  8.         System.out.println("当n = " + n + "时，斐波那契数为：" + res);
  10.         System.out.println("\n=========猴子吃桃子=========");
  11.         int day = 1;
  12.         int peachNum = t1.peach(1);
  13.         System.out.println("第" + day + "天的桃子数为：" + peachNum); // 1534
  14.     }
  15. }
  17. class T {
  18.     /*
  19.     * 请使用递归的方式求出斐波那契数
  20.     * 1,1,2,3,5,8,13...求第n个数的值
  21.     * 
  22.     * 思路分析：
  23.     * 1. 当 n = 1 时，斐波那契数 是 1
  24.     * 2. 当 n = 2 时，斐波那契数 是 1
  25.     * 3. 当 n >= 3 时，斐波那契数 是 前两个数的和
  26.     * 4. 递归思路
  27.     */
  28.     public int fibNum(int n) {
  29.         if (n >= 3) {
  30.             return fibNum(n - 1) + fibNum(n - 2);
  31.         } else {
  32.             return 1;
  33.         }
  34.     }
  36.     /*
  37.     * 2. 猴子吃桃问题：
  38.     * 有一堆桃子，猴子第一天吃了其中的一半，并再多吃了一个。
  39.     * 以后每天猴子都吃其中的一半，然后再多吃一个。
  40.     * 当到第10天时，想再吃(还没吃)时发现只有一个桃子了。
  41.     * 问题：最初共有多少个桃子？
  42.     * 
  43.     * 思路分析：(逆推)
  44.     * 1. day = 10 时，有1个桃子
  45.     * 2. day = 9 时，有(day10+1)*2=4个桃子
  46.     * 3. day = 8 时，有(day9+1)*2=10个桃子
  47.     * 4. 前一天的桃子 = (后一天的桃子 + 1 ) * 2
  48.     * 5. 递归算法
  49.     */
  50.     public int peach(int day) {
  51.         if (day == 10) { // 第10天，只有一个桃子
  52.             return 1;
  53.         } else if (day >= 1 && day <= 9) {
  54.             return (peach(day + 1) + 1) * 2;
  55.         } else {
  56.             System.out.println("day的范围是：1-10");
  57.             return -1;
  58.         }
  59.     }
  60. }

6. 应用实例 1 - 迷宫问题

  1. 小球得到的路径，和程序员设置的找路策略有关，即：找路的上下左右的顺序相关
  2. 再得到小球路径时，可以先使用(下右上左)，再改成(上右下左)，看看路径是不是有变化
  3. 测试回溯现象
  4. 扩展思考：如何求出最短路径？思路：(1)穷举 (2)图->求出最短路径

mk-2022-04-23-22-04.png

  1. public class Hello {
  3.     public static void main(String[] args) {
  4.         // 思路分析
  5.         // 1. 先创建迷宫，用二维数组表示
  6.         // 2. 规定 map 数组的元素值：0 表示可以走；1 表示障碍物
  7.         int[][] map = new int[8][7]; // 共有8行7列
  8.         for (int i = 0; i < 7; i++) {
  9.             // 第一行和最后一行为 1
  10.             map[0][i] = 1;
  11.             map[7][i] = 1;
  12.         }
  13.         for (int i = 0; i < 8; i++) {
  14.             // 第一列和最后一列为 1
  15.             map[i][0] = 1;
  16.             map[i][6] = 1;
  17.         }
  18.         map[3][1] = 1;
  19.         map[3][2] = 1;
  20.         map[2][2] = 1; // 测试回溯
  21.         System.out.println("=======迷宫图=======");
  22.         for (int i = 0; i < map.length; i++) {
  23.             for (int j = 0; j < map[i].length; j++) {
  24.                 System.out.print(map[i][j] + " ");
  25.             }
  26.             System.out.println();
  27.         }
  29.         System.out.println("\n========老鼠走迷宫========");
  30.         T t1 = new T();
  31.         t1.findWay(map, 1, 1);
  32.         for (int i = 0; i < map.length; i++) {
  33.             for (int j = 0; j < map[i].length; j++) {
  34.                 System.out.print(map[i][j] + " ");
  35.             }
  36.             System.out.println();
  37.         }
  38.     }
  39. }
  41. class T {
  42.     /*
  43.     * 使用递归回溯的思想来解决老鼠出迷宫
  44.     * 1. findWay方法就是专门来找出迷宫的路径
  45.     * 2. 如果找到，就返回true，否则返回false
  46.     * 3. map就是二维数组，表示迷宫
  47.     * 4. i, j 是老鼠的位置，初始化位置为(1, 1)
  48.     * 5. 因为是递归找路，所有先规定map数组的各个值含义
  49.     * 0：可以走但没走过的路，1：障碍物，2：确定可以走的路，3：走过，但是走不通
  50.     * 6. 当map[6][5] = 2 就说明找到通路，可以结束，否则继续找
  51.     * 7. 找路策略为：下->右->上->左
  52.     */
  54.     // 找路策略为：下->右->上->左
  55.     public boolean findWay(int[][] map, int i, int j) {
  56.         if (map[6][5] == 2) { // 说明已被找到
  57.             return true;
  58.         } else {
  59.             if (map[i][j] == 0) { // 表示当前点可以走但没走过
  60.                 // 假定可以走通
  61.                 map[i][j] = 2;
  62.                 // 使用找路策略，来确定该位置是否真的走通
  63.                 // 下->右->上->左
  64.                 if (findWay(map, i + 1, j)) { // 下
  65.                     return true;
  66.                 } else if (findWay(map, i, j + 1)) { // 右
  67.                     return true;
  68.                 } else if (findWay(map, i - 1, j)) { // 上
  69.                     return true;
  70.                 } else if (findWay(map, i, j - 1)) { // 左
  71.                     return true;
  72.                 } else {
  73.                     map[i][j] = 3;
  74.                     return false;
  75.                 }
  76.             } else { // map[i][j] == 1, 2, 3
  77.                 return false;
  78.             }
  79.         }
  80.     }
  82.     // 更改找路策略为：上->右->下->左
  83.     public boolean findWay2(int[][] map, int i, int j) {
  84.         if (map[6][5] == 2) { // 说明已被找到
  85.             return true;
  86.         } else {
  87.             if (map[i][j] == 0) { // 表示当前点可以走但没走过
  88.                 // 假定可以走通
  89.                 map[i][j] = 2;
  90.                 // 使用找路策略，来确定该位置是否真的走通
  91.                 // 下->右->上->左
  92.                 if (findWay2(map, i - 1, j)) { // 下
  93.                     return true;
  94.                 } else if (findWay2(map, i, j + 1)) { // 右
  95.                     return true;
  96.                 } else if (findWay2(map, i + 1, j)) { // 上
  97.                     return true;
  98.                 } else if (findWay2(map, i, j - 1)) { // 左
  99.                     return true;
  100.                 } else {
  101.                     map[i][j] = 3;
  102.                     return false;
  103.                 }
  104.             } else { // map[i][j] == 1, 2, 3
  105.                 return false;
  106.             }
  107.         }
  108.     }
  109. }

7. 应用实例 2 - 汉诺塔

  • 汉诺塔：汉诺塔（又称河内塔）问题是源于印度一个古老传说的益智玩具。
  • 大梵天创造世界的时候做了三根金刚石柱子，在一根柱子上从下往上按照大小顺序摞着64片圆盘。
  • 大梵天命令婆罗门把圆盘从下面开始按大小顺序重新摆放在另一根柱子上。
  • 并且规定，在小圆盘上不能放大圆盘，在三根柱子之间一次只能移动一个圆盘。

mk-2022-04-24-17-17.png

  1. public class HanoiTower {
  3.     public static void main(String[] args) {
  4.         Tower tower = new Tower();
  5.         tower.move(5, 'A', 'B', 'C');
  6.     }
  7. }
  9. class Tower {
  10.     // num 代表盘子的个数
  11.     // a01,b,c 代表三个塔 A, B, C
  12.     public void move(int num, char a01, char b, char c) {
  13.         if (num == 1) { // 如果只有一个盘
  14.             System.out.println(a01 + "->" + c); // 从a移动到c
  15.         } else {
  16.             // 如果有多个盘，可以看成一个盘，最下面的和上面的所有盘
  17.             // 1. 先移动上面所有的盘到b，借助c
  18.             move(num - 1, a01, c, b);
  19.             // 2. 把最下面的这个盘，移动到c
  20.             System.out.println(a01 + "->" + c);
  21.             // 3. 再把b塔所有盘，移动到c，借助a
  22.             move(num - 1, b, a01, c);
  23.         }
  24.     }
  25. }

8. 应用实例3 - 八皇后

  • 八皇后问题
  • 在8×8格的国际象棋上摆放八个皇后，使其不能互相攻击
  • 即：任意两个皇后都不能处于同一行、同一列或同一斜上，问有多少种摆法

mk-2022-04-24-17-52.png

  1.     class EightQueens {
  2. /*
  3.  * 思路分析：
  4.  * 1)第一个皇后先放第一行第一列
  5.  * 2)第二个皇后放在第二行第一列、然后判断是否OK，如果不OK，
  6.  * 继续放在第二列、第三列、依次把所有列都放完，找到一个合适
  7.  * 3)继续第三个皇后，还是第一列、第二列直到第8个皇后也能
  8.  * 放在一个不冲突的位置，算是找到了一个正确解
  9.  * 4)当得到一个正确解时，在栈回退到上一个栈时，就会开始回溯，
  10.  * 即将第一个皇后，放到第一列的所有正确解，全部得到。
  11.  * 5)然后回头继续第一个皇后放第二列，后面继续循环执行1,2,3,4的步骤
  12.  * 
  13.  * 说明：理论上应该创建一个二维数组来表示棋盘，但是实际上可以通过算法，
  14.  * 用一个一维数组即可解决问题.arr[8]={0,4,7,5,2,6,1,3}
  15.  * 对应arr下标表示第几行，即第几个皇后，
  16.  * arr[i]=val,val表示第i+1个皇后，放在第i+1行的第val+1列
  17.  */
  18.     public int queen(int[] arr, int i, int val, int res) {
  19.         // 略;
  20.     }
  21. }

四、重载(overload)

1. 重载基本介绍

  • Java中允许同一个类中，多个同名方法的存在，但要求形参列表不一致
  • 重载减轻了起名、记名的麻烦

2. 重载案例演示

  1. public class OverLoadExercise {
  2.     // 方法重载
  3.     public static void main(String[] args) {
  4.         // 求和
  5.         MyCalculator mc = new MyCalculator();
  6.         System.out.println(mc.calculate(1.1, 2));
  8.         // 求最大值
  9.         MyMax md = new MyMax();
  10.         System.out.println(md.max(2.3, 4.5, 7,6));
  11.     }
  12. }
  14. class MyCalculator {
  15.     // 两个整数的和
  16.     public int calculate(int n1, int n2) {
  17.         return n1 + n2;
  18.     }
  20.     // 一个整数，一个double的和
  21.     public double calculate(int n1, double n2) {
  22.         return n1 + n2;
  23.     }
  25.     // 一个double，一个整数的和
  26.     public double calculate(double n1, int n2) {
  27.         return n1 + n2;
  28.     }
  30.     // 三个整数的和
  31.     public int calculate(int n1, int n2, int n3) {
  32.         return n1 + n2 + n3;
  33.     }
  34. }
  36. class MyMax {
  37.     // 返回两个int中的最大值
  38.     public int max(int n1, int n2) {
  39.         n1 > n2 ? n1 : n2;
  40.     }
  42.     // 返回两个double值中的最大值
  43.     public double max(double d1, double d2) {
  44.         d1 > d2 ? d1 : d2
  45.     }
  47.     // 返回三个double值中的最大值
  48.     public double max(double d1, double d2, double d3) {
  49.         double max1 = d1 > d2 ? d1 : d2;
  50.         return max1 > d3 ? max1 : d3;
  51.     }
  52. }

3. 方法重载的注意事项

  1. 方法名：必须相同
  2. 形参列表：必须不同(形参类型、个数、顺序至少有一样不同，参数名无要求)
  3. 返回类型：无要求

五、可变参数

1. 可变参数基本介绍

  • 基本概念：Java允许将用一个类中多个同名同功能但参数个数不同的方法，封装成一个方法。就可以通过可变参数实现
  • 基本语法：访问修饰符 返回类型 方法名(数据类型...形参名) { }

2. 可变参数案例演示

  1. /*
  2.     * 可以计算 2个数的和，3个数的和，4个，5个...
  3.     * 功能相同，参数个数不同 -->> 使用可变参数
  4.     */
  5. public class Hello {
  6.     public static void main(String[] args) {
  7.         HspMethod hsp = new HspMethod();
  8.         System.out.println("和为：" + hsp.sum(1, 2, 3, 4));
  9.     }
  10. }
  12. class HspMethod {
  13.     // 可以计算 2个数的和，3个数的和，4个，5个...
  14.     // 1. int... 表示接收的是可变参数，类型是int，即可以接收多个int
  15.     // 2. 使用可变参数时，可以当做数组来使用，即 nums 可以当做数组
  16.     // 3. 遍历 nums 求和即可
  17.     public int sum(int... nums) {
  18.         System.out.println("接收的参数个数 = " + nums.length);
  19.         int res = 0;
  20.         for (int i = 0; i < nums.length; i++) {
  21.             res += nums[i];
  22.         }
  23.         return res;
  24.     }
  25. }

3. 可变参数的注意事项

  1. 可变参数的实参可以为0个或任意多个
  2. 可变参数的实参可以为数组
  3. 可变参数的本质就是数组
  4. 可变参数可以和普通类型的参数一起放在形参列表，但必须保证可变参数在最后
    public void f2(String str, double... nums) { }
  5. 一个形参列表中只能出现一个可变参数

4. 可变参数课堂练习

  • 有三个方法，分别实现返回姓名和两门课成绩(总分)，返回姓名和三门课成绩(总分)，返回姓名和五门课成绩(总分)。封装成一个可变参数的方法 ```java public class VarParameterExercise { public static void main(String[] args) {
    1.  HspMethod hsp = new HspMethod();
    2.  System.out.println(hsp.showScore("米兰", 90.1, 80.1));
    3.  System.out.println(hsp.showScore("特瑞", 90.0, 80.1, 44.5, 22, 57.65));
    } }

class HspMethod { // 分析：1. 方法名 2. 形参(String, double…) 3. 返回String public String showScore(String name, double… score) { double sum = 0; for (int i = 0; i < score.length; i++) { sum += score[i]; } return name + “ 有 “ + score.length + “ 门课的总分为：” + sum; } }

  3. <a name="qvI7K"></a>
  4. ### 六、作用域
  5. <a name="UhJCt"></a>
  6. #### 1. 作用域基本介绍
  8. 1. 在Java编程中，主要的变量就是属性(成员变量)和局部变量
  9. 1. 局部变量一般是指在**成员方法**中定义的变量
  10. 1. Java中作用域的分类 
  11.    - 全局变量：也就是属性，作用域为**整个类体**
  12.    - 局部变量：也就是除了属性之外的其他变量，作用域为定义它的**代码块**{}中
  13. 4. 全局变量**有默认值**，可以不赋值直接使用，局部变量**没有默认值**，必须赋值后才能使用
  15. <a name="LYyRK"></a>
  16. #### 2. 作用域注意事项
  18. 1.  属性和局部变量可以重名，访问时遵循就近原则 
  19. 1.  在**同一个作用域**中，两个局部变量**不能重名** 
  20. 1.  **属性生命周期较长**，伴随着对象的创建而创建，伴随着对象的销毁而销毁。**局部变量生命周期较短**，伴随着它的代码块的执行而创建，伴随着代码块的结束而销毁。 
  21. 1.  作用域范围不同 
  22.    - 全局变量/属性：可以被本类使用，或其他类使用（通过对象调用）
  23.    - 局部变量：只能在本类中对应的方法中使用
  24. 5.  修饰符不同 
  25.    - 全局变量可以加修饰符
  26.    - 局部变量不可以加修饰符
  27. ```java
  28. public class VarScopDetail {
  29.     public static void main(String[] args) {
  30.         Person p1 = new Person();
  31.         p1.say(); // Alex
  32.         System.out.println(p1.age);
  34.         T t1 = new T();
  35.         t1.test(); // 第一种跨类访问：通过创建对象
  36.         t1.test2(p1); // 第二种跨类访问：通过传入参数
  37.     }
  38. }
  40. class T {
  41.     public void test() {
  42.         Person p1 = new Person();
  43.         System.out.println(p1.name); // Jack
  44.     }
  46.     public void test2(Person p) {
  47.         System.out.println(p.name); // Jack
  48.     }
  49. }
  51. class Person {
  52.     // 属性可以加修饰符(public protected private...)
  53.     public int age = 20;
  54.     String name = "Jack";
  56.     public void say() {
  57.         String name = "Alex";
  58.         System.out.println(name); // Alex
  59.     }
  60. }

七、构造器

1. 构造器基本介绍

  • 构造方法又叫构造器(constructor)，是类的一种特殊的方法，它的主要作用是完成对新对象的初始化
  • 基本语法 
    1. [修饰符] 方法名(形参列表) {
    2.  方法体;
    3. }
  • 构造器的特点
    1. 构造器的修饰符可以默认，也可以是public protected private
    2. 构造器没有返回值
    3. 方法名和类名必须一样
    4. 参数列表和成员方法一样的规则
    5. 在创建对象时，系统会自动的调用该类的构造器完成对象的初始化

2. 构造器快速入门

  • 在创建人类的对象时，直接指定这个对象的年龄和姓名
  1. public class Constructor01 {
  2.    public static void main(String[] args) {
  3.        // 当我们new一个对象时，直接通过构造器指定名字和年龄
  4.        Person p1 = new Person("Smith", 80);
  5.        System.out.println("p1的信息如下：");
  6.        System.out.println("name = " + p1.name);
  7.        System.out.println("age = " + p1.age);
  8.    }
  9. }
  11. class Person {
  12.    String name;
  13.    int age;
  15.    /*
  16.     * 构造器
  17.     * 1. 构造器没有返回值，也不能写void
  18.     * 2. 构造器的名称和类名一样
  19.     * 3. (String pName, int pAge)是构造器的形参列表，规则和成员方法以一样
  20.     */
  21.    public Person(String pName, int pAge) {
  22.        System.out.println("构造器被调用~~ 完成对象的属性初始化");
  23.        name = pName;
  24.        age = pAge;
  25.    }
  26. }

3. 构造器注意事项

  1. 一个类可以定义多个不同的构造器，即构造器重载
    • 比如：我们可以再给Person类定义一个构造器，用来创建对象的时候，只指定人名，不需要年龄
  2. 构造器的名字要和类名完全一样
  3. 构造器没有返回值
  4. 构造器是完成对象的初始化，并不是创建对象
  5. 在创建对象时，系统自动的调用该类的构造方法
  6. 如果没有定义构造器，系统会自动给类生成一个默认无参构造器(也叫默认构造器)，比如Dog(){}，使用javap指令，反编译结果为：Dog();
  7. 一旦定义了自己的构造器，默认的构造器就被覆盖，就不能再使用默认的无参构造器，除非再显式的定义一下，即：Dog(){}

4. 构造器课堂练习

  • 在前面定义的Person类中添加两个构造器：
  • 第一个无参构造器：利用构造器设置所有人的age属性初始值都为18
  • 第二个带pName和pAge两个参数的构造器：使得每次创建Person对象的同时初始化对象的age属性值和name属性值。分别使用不用的构造器，创建对象
  1. public class Constructor01 {
  2.    public static void main(String[] args) {
  3.        // 无参构造器
  4.        Person p1 = new Person();
  5.        System.out.print("p1的信息：");
  6.        System.out.print("name = " + p1.name); // null
  7.        System.out.print("  age = " + p1.age); // 18
  8.        System.out.println();    
  10.        // 两个参数构造器
  11.        Person p2 = new Person("Smith", 80);
  12.        System.out.print("p2的信息：");
  13.        System.out.print("name = " + p2.name); // Smith
  14.        System.out.print("  age = " + p2.age); // 80
  15.    }
  16. }
  18. class Person {
  19.    String name;
  20.    int age;
  22.    // 无参构造器
  23.    public Person() {
  24.        age = 18;
  25.    }
  27.    // 两个参数构造器
  28.    public Person(String pName, int pAge) {
  29.        name = pName;
  30.        age = pAge;
  31.    }
  32. }

5. 对象创建的流程分析

  1. public class Process {
  2.     public static void main(String[] args) {
  3.         Person p = new Person("小倩", 20);
  4.     }
  5. }
  7. class Person {
  8.     int age = 90;
  9.     String name;
  11.     Person(String n, int a01) { // 构造器
  12.         name = n;
  13.         age = a01;
  14.     }
  15. }

mk-2022-04-27-13-28.png

  1. 先加载Person类信息(Person.class)，只会加载一次
  2. 在堆中分配空间(地址)
  3. 完成对象初始化
    1. 默认初始化：age = 0, name = null
    2. 显式初始化：age = 90, name = null
    3. 构造器初始化：age = 20, name = "小倩"
  4. 把对象在堆中的地址，返回给p(p是对象名，也是对象的引用)

八、this

1. this基本介绍

  • Java虚拟机会给每个对象分配this，代表当前对象
  • 哪个对象调用，**this**就代表哪个对象

2. 深入理解

  1. public class This01 {
  2.     public static void main(String[] args) {
  3.         Dog dog1 = new Dog("大壮", 3);
  4.         dog1.info();
  6.         Dog dog2 = new Dog("大黄", 2);
  7.         dog2.info();
  8.     }
  9. }
  11. class Dog {
  12.     public String name;
  13.     public int age;
  15.     public Dog(String name, int age) {
  16.         this.name = name;
  17.         this.age = age;
  18.     }
  20.     public void info() {
  21.         System.out.println(this.name + "  " 
  22.         + this.age + "  " 
  23.         + + "当前对象的hashCode是：" + this.hashCode());
  24.     }
  25. }
  • 内存分析图
    this关键字.svg

3. 注意事项和使用细节

  1. this关键字可以用来访问本类的属性、方法、构造器
  2. this用于区分当前类的属性和局部变量

  3. 访问成员方法的语法：this.方法名(参数列表); 

    1. class T {
    2. // this访问成员方法
    3. public void f1() {
    4.     System.out.println("f1() 方法");
    5. }
    7. public void f2() {
    8.     System.out.println("f2() 方法");
    9.     f1(); // 第一种方式
    10.     this.f1(); // 第二种方式
    11. }
    12. }

  1. 访问构造器语法：this(参数列表);，注意只能在构造器中访问另一个构造器，必须是构造器中的第一条语句 

    1. class T {
    2. // this访问构造器
    3. // 注意只能在构造器中访问另一个构造器
    4. // 如果有 this(参数列表); 必须是构造器中的第一条语句
    5. public T() {
    6.     this("jack", 100); // 放在第一条语句
    7.     System.out.println("T() 构造器");
    8.     // 在这里访问 T(String name, int age) 构造器
    9. }
    11. public T(String name, int age) {
    12.     System.out.println("T(String name, int age) 构造器");
    13. }
    14. }
  1. this不能在类定义的外部使用，只能在类定义的方法中使用

4. this课堂练习

  • 定义Person类，里面有name, age属性，并提供compareTo比较方法，用于判断是否和另一个人相等，提供测试类TestPerson用于测试，名字和年龄完全一样，就返回true，否则返回false ```java public class TestPerson { public static void main(String[] args) {

    1.  Person p1 = new Person("mary", 20);
    2.  Person p2 = new Person("smith", 30);
    4.  System.out.println("p1和p2比较的结果：" + p1.compareTo(p2));

    } }

class Person { String name; int age;

  1. public Person(String name, int age) {
  2.     this.name = name;
  3.     this.age = age;
  4. }
  6. public boolean compareTo(Person p) {
  7.     // if (this.name.equals(p.name) && this.age == p.age) {
  8.     //     return true;
  9.     // } else {
  10.     //     return false;
  11.     // }
  12.     return this.name.equals(p.name) && this.age == p.age;
  13. }

}

  2. <a name="NhqVS"></a>
  3. ### 九、本章作业
  5. 1.  编写类`A01`，定义方法`max`，实现求某个`double数组`的最大值，并返回 
  6. ```java
  7. public class Homework01 {
  8.     public static void main(String[] args) {
  9.         A01 a01 = new A01();
  10.         double[] arr = { 3.2, 4.4, 55.88, 751.4, 44.55 };
  11.         Double res = a01.max(arr);
  13.         if (res != null) { // 代码健壮性
  14.             System.out.println("arr的最大值为：" + res);
  15.         } else {
  16.             System.out.println("arr的输入有误，arr不能为null或{}");
  17.         }
  18.     }
  19. }
  21. class A01 {
  22.     // 先完成正常业务，再考虑代码健壮性
  23.     public Double max(double[] arr) {
  24.         // 先判断arr是否为null，再判断length是否大于0
  25.         if (arr != null && arr.length > 0) {
  26.             double max = arr[0]; // 假定第一个元素为最大值
  27.             for (int i = 1; i < arr.length; i++) {
  28.                 if (arr[i] > max) {
  29.                     max = arr[i];
  30.                 }
  31.             }
  32.             return max;
  33.         } else {
  34.             return null;
  35.         }
  36.     }
  37. }

  1. 编写类A02，定义方法find，实现查找某字符串数组中的元素，并返回索引，如果找不到，返回-1 ```java public class Homework02 { public static void main(String[] args) {

    1. A02 a02 = new A02();
    2. String[] arr = { "aaa", "bbb", "ccc" };
    3. int index = a02.find(arr, "ddd");
    5. if (index == -2) {
    6.     System.out.println("数组不能为null或{}");
    7. } else if (index == -1) {
    8.     System.out.println("没有找到");
    9. } else {
    10.     System.out.println("找到了，索引为：" + index);
    11. }

    } }

class A02 { // 先完成正常业务，再考虑代码健壮性 public int find(String[] arr, String str) { if (arr != null && arr.length > 0) { // 遍历字符串数组，如果找到，返回索引，没有找到返回-1 for (int i = 0; i < arr.length; i++) { if (str.equals(arr[i])) { return i; } } return -1; } else { return -2; } } }

  3. 3.  编写类`Book`，定义方法`updatePrice`，实现更改某本书的价格。具体：如果`价格 > 150`，则更改为150，如果`价格 > 100`，更改为100，否则不变 
  4. ```java
  5. public class Homework03 {
  6.     public static void main(String[] args) {
  7.         Book book = new Book("book1", 200);
  8.         book.info(); // 显示书籍信息
  9.         System.out.println("=====更新书籍价格=====");
  10.         book.updatePrice(); // 更新书籍价格
  11.         book.info(); // 显示书籍信息
  12.     }
  13. }
  15. class Book {
  16.     String name;
  17.     double price;
  19.     // 构造器
  20.     public Book(String name, double price) {
  21.         this.name = name;
  22.         this.price = price;
  23.     }
  25.     public void updatePrice() {
  26.         // 如果方法中，没有price局部变量，this.price 等价 price
  27.         if (price > 150) {
  28.             price = 150;
  29.         } else if (price > 100) {
  30.             price = 100;
  31.         }
  32.     }
  34.     // 显示书籍情况
  35.     public void info() {
  36.         System.out.println("书名：" + name + "\n价格：" + price);
  37.     }
  38. }

  1. 编写类A03，实现数组的复制功能copyArr，输入旧数组，返回一个新数组，元素和旧数组一样 ```java public class Homework04 { public static void main(String[] args) {

    1. A03 a03 = new A03();
    2. int[] arr = { 5, 4, 3 };
    3. int[] arrNew = a03.copyArr(arr);
    5. for (int i = 0; i < arrNew.length; i++) {
    6.     System.out.print(arrNew[i] + " ");
    7. }

    } }

class A03 { public int[] copyArr(int[] arr) { // 在堆中，创建一个长度为arr.length的数组 int[] arrNew = new int[arr.length]; // 遍历arr，将元素拷贝到arrNew for (int i = 0; i < arr.length; i++) { arrNew[i] = arr[i]; } return arrNew; } }

  3. 5.  定义一个圆类`Circle`，定义属性：半径，提供显示圆周长功能的方法，提供显示圆面积的方法 
  4. ```java
  5. public class Homework05 {
  6.     public static void main(String[] args) {
  7.         Circle circle = new Circle(5);
  8.         System.out.println("面积：" + circle.area());
  9.         System.out.println("周长：" + circle.perimeter());
  10.     }
  11. }
  13. class Circle {
  14.     /*
  15.     * 圆的周长 = 2πr
  16.     * 圆的面积 = πr²
  17.     */
  18.     double radius;
  20.     public Circle(double radius) {
  21.         this.radius = radius;
  22.     }
  24.     public double perimeter() {
  25.         return 2 * Math.PI * radius;
  26.     }
  28.     public double area() {
  29.         return Math.PI * radius * radius;
  30.     }
  31. }

  1. 编程创建一个Cale计算类，在其中定义2个变量表示两个操作数，定义四个方法实现求和、差、乘、商（要求除数为0的话，要提示）并创建两个对象，分别测试 ```java public class Homework06 { public static void main(String[] args) {

    1. Cale cale = new Cale(5, 25);
    2. System.out.println("和：" + cale.sum());
    3. System.out.println("差：" + cale.minus());
    4. System.out.println("积：" + cale.mul());
    6. Double divRes = cale.div();
    7. if (divRes != null) {
    8.     System.out.println("商：" + divRes);
    9. }

    } }

class Cale { double num1; double num2;

  1. public Cale(double num1, double num2) {
  2.     this.num1 = num1;
  3.     this.num2 = num2;
  4. }
  6. public double sum() { // 和
  7.     return num1 + num2;
  8. }
  10. public double minus() { // 差
  11.     return num1 - num2;
  12. }
  14. public double mul() { // 积
  15.     return num1 * num2;
  16. }
  18. public Double div() { // 商
  19.     if (num2 == 0) {
  20.         System.out.println("除数不能为零");
  21.         return null;
  22.     } else {
  23.         return num1 / num2;
  24.     }
  25. }

}

  3. 7.  设计一个`Dog`类，有名字、颜色和年龄属性，定义输出方法`show()`显示其信息。并创建对象，进行测试 
  4. ```java
  5. public class Homework07 {
  6.     public static void main(String[] args) {
  7.         Dog dog = new Dog("大黄", "黄色", 5);
  8.         dog.show();
  9.     }
  10. }
  12. class Dog {
  13.     String name;
  14.     String color;
  15.     int age;
  17.     public Dog(String name, String color, int age) {
  18.         this.name = name;
  19.         this.color = color;
  20.         this.age = age;
  21.     }
  23.     public void show() {
  24.         System.out.println("名字：" + name);
  25.         System.out.println("颜色：" + color);
  26.         System.out.println("年龄：" + age);
  27.     }
  28. }
  1. 给定一个Java程序的代码如下，编译运行后，输出结果是：10, 9, 10 ```java public class Homework08 { }

class Test { // 公共类 int count = 9; // 属性

  1. public void count1() { // Test类的成员方法
  2.     count = 10;
  3.     System.out.println("count1 = " + count);
  4. }
  6. public void count2() { // Test类的成员方法
  7.     System.out.println("count2 = " + count++);
  8. }
  10. // 这是Test类的main方法，任何一个类，都可有main
  11. public static void main(String[] args) {
  12.     // 1. new Test() 是匿名对象，只能使用一次
  13.     // 2. new Test().count1(); 创建好匿名对象后，就调用count1()
  14.     new Test().count1();
  16.     Test t1 = new Test();
  17.     t1.count2();
  18.     t1.count2();
  19. }

}

  3. 9.  定义`Music`类，里面有音乐名`name`、音乐时长`time`属性，并有播放`play`功能和返回本身属性信息的功能方法`getInfo` 
  4. ```java
  5. public class Homework09 {
  6.     public static void main(String[] args) {
  7.         Music music = new Music("ABC", 200);
  8.         music.play();
  9.         System.out.println(music.getInfo());
  10.     }
  11. }
  13. class Music {
  14.     String name;
  15.     int time;
  17.     public Music(String name, int time) {
  18.         this.name = name;
  19.         this.time = time;
  20.     }
  22.     public void play() {
  23.         for (int i = 0; i <= time; i++) {
  24.             System.out.printf("音乐《%s》正在播放：%d秒 / %d秒%n", name, i, time);
  25.         }
  26.     }
  28.     public String getInfo() {
  29.         return "歌曲名：" + name + "\n歌曲总时长：" + time;
  30.     }
  31. }
  1. 试写出以下代码的运行结果(101, 100, 101, 101) ```java public class Homework10 { }

class Demo { int i = 100; public void m() { int j = i++; System.out.println(“i = “ + i); // 101 System.out.println(“j = “ + j); // 100 } }

class Test { public static void main(String[] args) { Demo d1 = new Demo(); Demo d2 = d1; d2.m(); System.out.println(d1.i); // 101 System.out.println(d2.i); // 101 } }

  3.    - 分析<br />![mk-2022-04-27-22-44.png](https://cdn.nlark.com/yuque/0/2022/png/2828304/1651853495252-861e32ca-ce64-4963-9d47-df2d1d8b572b.png#clientId=ucc169495-961e-4&crop=0&crop=0&crop=1&crop=1&from=ui&id=u437deb76&name=mk-2022-04-27-22-44.png&originHeight=869&originWidth=1711&originalType=binary&ratio=1&rotation=0&showTitle=false&size=551180&status=done&style=none&taskId=ub6a6e821-4ace-4d39-9026-1c7aac83e26&title=)
  4. 11.  在测试方法中，调用`method`方法，代码如下，编译正确，试写出`method`方法的定义形式，调用语句为：`System.out.println(method(method(10.0, 20.0), 100));` 
  5. ```java
  6. public class Homework11 {
  7. }
  9. class Test {
  10.     public double method(double d1, double d2) {
  11.         return d1 + d2;
  12.     }
  14.     public void print() {
  15.         System.out.println(method(method(10.0, 20.0), 100));
  16.     }
  17. }

  1. 创建一个Employee类，属性有(名字，性别，年龄，职位，薪水)，提供3个构造方法，可以初始化如下，要求充分复用构造器

    1. 名字，性别，年龄，职位，薪水
    2. 名字，性别，年龄
    3. 职位，薪水 ```java public class Homework12 { } class Employee { String name; String gender; int age; String job; int sal;

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

    public Employee(String job, int sal) { this.job = job; this.sal = sal; }

    public Employee(String name, String gender, int age, String job, int sal) { this(name, gender, age); // 使用到前面的构造器，构造器复用 this.job = job; this.sal = sal; } } ```

  2. 将对象作为参数传递给方法
    题目要球：

    1. 定义一个Circle类，包含一个double型的radius属性代表圆的半径，findArea()方法返回圆的面积
    2. 定义一个类PassObject，在类中定义一个方法printAreas()，该方法的定义如下：
      public void printAreas(Circle c, int times) //方法签名/声明
    3. 在printAreas()方法中打印输出1到times之间的每个整数半径值，以及对应的面积
      例如，times为5，则输出半径1,2,3,4,5，以及对应的圆面积

    4. 在main方法中调用printAreas()方法，调用完毕后输出当前半径值。程序运行结果如图所示：
      mk-2022-04-27-23-27.png ```java public class Hello { public static void main(String[] args) { Circle circle = new Circle(); PassObject po = new PassObject();

      po.printAreas(circle, 5); } }

class Circle { double radius; // 圆的半径

  1. // 圆的面积
  2. public double findArea() {
  3.     return Math.PI * radius * radius;
  4. }
  6. // 添加方法setRadius，修改对象的半径值
  7. public void setRadius(double radius) {
  8.     this.radius = radius;
  9. }

}

class PassObject { public void printAreas(Circle c, int times) { System.out.println(“Radius\tArea”); for (double i = 1; i <= times; i++) { c.setRadius(i); System.out.println(i + “\t” + c.findArea()); } } }

  3. 14.  扩展题 
  4.    1. 有个人`Tom`设计他的`成员变量.成员方法`，可以电脑猜拳。每次都会随机生成`0, 1, 2`
  5.    1. `0`表示石头，`1`表示剪刀，`2`表示布
  6.    1. 并要可以显示`Tom`的输赢次数(清单)
  7. ```java
  8. public class Hello {
  9.     public static void main(String[] args) {
  10.         Tom t = new Tom(); // 创建一个玩家对象
  11.         // 用来记录最后输赢的次数
  12.         int isWinCount = 0;
  14.         // 创建一个二维数组，用来接收局数，Tom出拳情况以及电脑出拳情况
  15.         int[][] arr1 = new int[3][3];
  16.         int j = 0;
  18.         // 创建一个一维数组，用来接收输赢情况
  19.         String[] arr2 = new String[3];
  21.         Scanner scanner = new Scanner(System.in);
  22.         for (int i = 0; i < 3; i++) {
  23.             // 获取玩家出的拳
  24.             System.out.print("请输入你要出的拳(0-拳头，1-剪刀，2-布)：");
  25.             int num = scanner.nextInt();
  26.             t.setTomGuessNum(num);
  27.             int tomGuess = t.getTomGuessNum();
  28.             arr1[i][j + 1] = tomGuess;
  30.             // 获取电脑出的拳
  31.             int comGuess = t.comGuess();
  32.             arr1[i][j + 2] = comGuess;
  34.             // 将玩家猜的拳与电脑作比较
  35.             String isWin = t.vsComputer();
  36.             arr2[i] = isWin;
  37.             arr1[i][j] = t.count;
  39.             // 对每一局的情况进行输出
  40.             System.out.println("======================");
  41.             System.out.println("局数\t玩家的出拳\t电脑的出拳\t输赢情况");
  42.             System.out.println(t.count + "\t" + tomGuess + "\t\t" + comGuess + "\t\t" + t.vsComputer());
  43.             System.out.println("\n\n");
  44.             isWinCount = t.winCount(isWin);
  45.         }
  47.         // 对游戏的最终结果进行输出
  48.         System.out.println("局数\t\t玩家的出拳\t电脑的出拳\t输赢情况");
  49.         for (int a = 0; a < arr1.length; a++) {
  50.             for (int b = 0; b < arr1[a].length; b++) {
  51.                 System.out.print(arr1[a][b] + "\t\t");
  52.             }
  54.             System.out.print(arr2[a]);
  55.             System.out.println();
  56.         }
  57.         System.out.println("你赢了" + isWinCount + "次");
  59.     }
  60. }
  62. class Tom {
  63.     int tomGuessNum; // 玩家出拳的类型
  64.     int comGuessNum; // 电脑出拳的类型
  65.     int winCountNum; // 玩家赢的次数
  66.     int count = 1;
  68.     public int comGuess() {
  69.         Random r = new Random();
  70.         comGuessNum = r.nextInt(3); // 返回0-2的随机数
  71.         return comGuessNum;
  72.     }
  74.     /**
  75.     * 设置玩家猜拳的数字的方法
  76.     * 
  77.     * @param tomGuessNum
  78.     */
  79.     public void setTomGuessNum(int tomGuessNum) {
  80.         if (tomGuessNum > 2 || tomGuessNum < 0) {
  81.             // 抛出一个异常
  82.             throw new IllegalArgumentException("数字输入错误");
  83.         }
  84.         this.tomGuessNum = tomGuessNum;
  85.     }
  87.     public int getTomGuessNum() {
  88.         return tomGuessNum;
  89.     }
  91.     /**
  92.     * 比较猜拳的结果
  93.     * 
  94.     * @return
  95.     */
  96.     public String vsComputer() {
  97.         if (tomGuessNum == 0 && comGuessNum == 1) {
  98.             return "你赢了！";
  99.         } else if (tomGuessNum == 1 && comGuessNum == 2) {
  100.             return "你赢了！";
  101.         } else if (tomGuessNum == 2 && comGuessNum == 0) {
  102.             return "你赢了！";
  103.         } else if (tomGuessNum == comGuessNum) {
  104.             return "平手！";
  105.         } else {
  106.             return "你输了！";
  107.         }
  108.     }
  110.     /**
  111.     * 记录玩家赢的次数
  112.     * @return
  113.     */
  114.     public int winCount(String s) {
  115.         count++;
  116.         if (s.equals("你赢了")) {
  117.             winCountNum++;
  118.         }
  119.         return winCountNum;
  120.     }
  121. }