├── 1.md
├── 3_最大公约数和最小公倍数.java
├── 3_计算字符组中每个字符的出现次数.java
├── 4_Poker外部类和Card内部类.java
├── 4_设计用户类User.java
├── 5_Geometric几何图形抽象类.java
├── 6_Circle和Triangle类的异常类创建.java
├── 7_StringBuffer反转字符串指定位置.java
├── 7_trim功能模拟方法.java
├── 7_打鱼晒网问题.java
├── README.md
├── 更新7_多线程.java
└── 更新7_继承Thread实现多线程.java


/1.md:
--------------------------------------------------------------------------------
 1 | ```mermaid
 2 | usecaseDiagram
 3 |     actor Student as S
 4 |     S --> (Login) 
 5 |     S --> (Query Grades)
 6 |     (Query Grades) .u.> (Login) : includes
 7 |     (Login) --> (Enter Student ID)
 8 |     (Login) --> (Enter Password)
 9 |     (Query Grades) --> (Select Course)
10 |     (Query Grades) --> (View Results)
11 |     (Query Grades) --> (Logout)
12 | 


--------------------------------------------------------------------------------
/3_最大公约数和最小公倍数.java:
--------------------------------------------------------------------------------
 1 | public class GCDAndLCM {
 2 | 
 3 |     // 方法：计算最大公约数 (GCD)
 4 |     public static int gcd(int a, int b) {
 5 |         while (b != 0) {
 6 |             int temp = b;
 7 |             b = a % b;
 8 |             a = temp;
 9 |         }
10 |         return a;
11 |     }
12 | 
13 |     // 方法：计算最小公倍数 (LCM)
14 |     public static int lcm(int a, int b) {
15 |         return (a * b) / gcd(a, b);
16 |     }
17 | 
18 |     public static void main(String[] args) {
19 |         int num1 = 12;
20 |         int num2 = 18;
21 | 
22 |         System.out.println("最大公约数: " + gcd(num1, num2));
23 |         System.out.println("最小公倍数: " + lcm(num1, num2));
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/3_计算字符组中每个字符的出现次数.java:
--------------------------------------------------------------------------------
 1 | import java.util.HashMap;
 2 | 
 3 | public class CharacterCount {
 4 |     
 5 |     // 方法：计算字符数组中每个字符出现的次数
 6 |     public static void countCharacters(char[] array) {
 7 |         HashMap<Character, Integer> charCountMap = new HashMap<>();
 8 |         
 9 |         // 遍历字符数组并统计每个字符的出现次数
10 |         for (char c : array) {
11 |             charCountMap.put(c, charCountMap.getOrDefault(c, 0) + 1);
12 |         }
13 |         
14 |         // 输出每个字符及其出现次数
15 |         for (char key : charCountMap.keySet()) {
16 |             System.out.println("字符 '" + key + "' 出现次数: " + charCountMap.get(key));
17 |         }
18 |     }
19 | 
20 |     public static void main(String[] args) {
21 |         char[] inputArray = {'a', 'b', 'c', 'a', 'b', 'a', 'd'};
22 |         
23 |         countCharacters(inputArray); // 调用方法，统计字符出现次数
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/4_Poker外部类和Card内部类.java:
--------------------------------------------------------------------------------
 1 | import java.util.ArrayList;
 2 | import java.util.Collections;
 3 | import java.util.List;
 4 | 
 5 | public class Poker {
 6 | 
 7 |     // 定义花色和点数数组
 8 |     private String[] suits = {"S", "H", "C", "D"}; // 使用字母表示花色
 9 |     private String[] ranks = {"2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A"}; // 点数
10 |     
11 |     // 定义一副扑克牌的数组
12 |     private List<Card> deck;
13 | 
14 |     // 构造方法，初始化一副牌
15 |     public Poker() {
16 |         deck = new ArrayList<>();
17 |         // 构造扑克牌，每张牌由花色和点数组合
18 |         for (String suit : suits) {
19 |             for (String rank : ranks) {
20 |                 deck.add(new Card(suit, rank));
21 |             }
22 |         }
23 |     }
24 | 
25 |     // 洗牌方法，使用Math.random()来打乱扑克牌顺序
26 |     public void shuffle() {
27 |         Collections.shuffle(deck); // 使用Collections的shuffle方法打乱顺序
28 |     }
29 | 
30 |     // 发牌方法
31 |     public Card deal() {
32 |         if (!deck.isEmpty()) {
33 |             return deck.remove(deck.size() - 1); // 从扑克牌的末尾发牌
34 |         } else {
35 |             return null; // 如果牌已经发完，返回null
36 |         }
37 |     }
38 | 
39 |     // 内部类Card，表示扑克牌的每一张牌
40 |     public class Card {
41 |         private String suit; // 花色
42 |         private String rank; // 点数
43 | 
44 |         // 构造方法
45 |         public Card(String suit, String rank) {
46 |             this.suit = suit;
47 |             this.rank = rank;
48 |         }
49 | 
50 |         // 打印牌的信息
51 |         public void printCard() {
52 |             System.out.println(rank + suit); // 输出牌的点数和花色
53 |         }
54 | 
55 |         // 获取花色
56 |         public String getSuit() {
57 |             return suit;
58 |         }
59 | 
60 |         // 获取点数
61 |         public String getRank() {
62 |             return rank;
63 |         }
64 |     }
65 | 
66 |     // 测试类，包含main方法
67 |     public static void main(String[] args) {
68 |         Poker poker = new Poker();  // 创建一副牌
69 | 
70 |         System.out.println("初始牌顺序:");
71 |         // 打印初始顺序的扑克牌
72 |         for (int i = 0; i < 5; i++) { // 先显示五张牌
73 |             poker.deal().printCard();
74 |         }
75 | 
76 |         System.out.println("\n洗牌后:");
77 | 
78 |         // 洗牌
79 |         poker.shuffle();
80 |         
81 |         // 打印洗牌后的扑克牌顺序
82 |         for (int i = 0; i < 5; i++) { // 继续显示五张牌
83 |             poker.deal().printCard();
84 |         }
85 |     }
86 | }
87 | 


--------------------------------------------------------------------------------
/4_设计用户类User.java:
--------------------------------------------------------------------------------
 1 | public class User {
 2 |     // 类的变量
 3 |     private String username;
 4 |     private String password;
 5 |     private static int userCount = 0;  // 记录用户数量
 6 | 
 7 |     // 无参构造方法
 8 |     public User() {
 9 |         userCount++;  // 每次创建新用户时，用户数量加1
10 |     }
11 | 
12 |     // 只为用户名赋值的构造方法
13 |     public User(String username) {
14 |         this.username = username;
15 |         userCount++;  // 每次创建新用户时，用户数量加1
16 |     }
17 | 
18 |     // 为用户名和密码赋值的构造方法
19 |     public User(String username, String password) {
20 |         this.username = username;
21 |         this.password = password;
22 |         userCount++;  // 每次创建新用户时，用户数量加1
23 |     }
24 | 
25 |     // 获取密码的方法
26 |     public String getPassword() {
27 |         return password;
28 |     }
29 | 
30 |     // 设置密码的方法
31 |     public void setPassword(String password) {
32 |         this.password = password;
33 |     }
34 | 
35 |     // 返回类信息的方法
36 |     public String getUserInfo() {
37 |         return "用户名: " + username + ", 密码: " + password;
38 |     }
39 | 
40 |     // 返回当前用户数量的方法
41 |     public static int getUserCount() {
42 |         return userCount;
43 |     }
44 | 
45 |     public static void main(String[] args) {
46 |         // 创建用户对象
47 |         User user1 = new User("Alice", "password123");
48 |         User user2 = new User("Bob", "password456");
49 | 
50 |         // 输出用户信息
51 |         System.out.println(user1.getUserInfo());  // 输出: 用户名: Alice, 密码: password123
52 |         System.out.println(user2.getUserInfo());  // 输出: 用户名: Bob, 密码: password456
53 | 
54 |         // 设置并获取密码
55 |         user1.setPassword("newPassword123");
56 |         System.out.println("更新后的密码: " + user1.getPassword());  // 输出: 更新后的密码: newPassword123
57 | 
58 |         // 输出当前用户数量
59 |         System.out.println("当前用户数量: " + User.getUserCount());  // 输出: 当前用户数量: 2
60 |     }
61 | }
62 | 


--------------------------------------------------------------------------------
/5_Geometric几何图形抽象类.java:
--------------------------------------------------------------------------------
  1 | public abstract class Geometric {
  2 |     // 属性：颜色和是否填充
  3 |     private String color;
  4 |     private boolean filled;
  5 | 
  6 |     // 无参构造方法
  7 |     public Geometric() {
  8 |         this.color = "white"; // 默认颜色
  9 |         this.filled = false;   // 默认不填充
 10 |     }
 11 | 
 12 |     // 带参数的构造方法
 13 |     public Geometric(String color, boolean filled) {
 14 |         this.color = color;
 15 |         this.filled = filled;
 16 |     }
 17 | 
 18 |     // 获取颜色
 19 |     public String getColor() {
 20 |         return color;
 21 |     }
 22 | 
 23 |     // 设置颜色
 24 |     public void setColor(String color) {
 25 |         this.color = color;
 26 |     }
 27 | 
 28 |     // 检查是否填充
 29 |     public boolean isFilled() {
 30 |         return filled;
 31 |     }
 32 | 
 33 |     // 设置是否填充
 34 |     public void setFilled(boolean filled) {
 35 |         this.filled = filled;
 36 |     }
 37 | 
 38 |     // 抽象方法：获取面积
 39 |     public abstract double getArea();
 40 | 
 41 |     // 抽象方法：获取周长
 42 |     public abstract double getPerimeter();
 43 | 
 44 |     // 返回类的字符串描述
 45 |     @Override
 46 |     public String toString() {
 47 |         return "Geometric[color=" + color + ", filled=" + filled + "]";
 48 |     }
 49 |     
 50 |     public static void main(String[] args) {
 51 |         // 创建 Circle 对象
 52 |         Circle circle = new Circle(5);
 53 |         System.out.println(circle);
 54 | 
 55 |         // 创建 Rectangle 对象
 56 |         Rectangle rectangle = new Rectangle(2, 4);
 57 |         System.out.println(rectangle);
 58 | 
 59 |         // 创建 Triangle 对象
 60 |         Triangle triangle = new Triangle(3, 4, 5);
 61 |         System.out.println(triangle);
 62 |     }
 63 | }
 64 | 
 65 | // Circle 类
 66 | class Circle extends Geometric {
 67 |     private double radius;
 68 | 
 69 |     // 无参构造方法
 70 |     public Circle() {
 71 |         this.radius = 1.0;
 72 |     }
 73 | 
 74 |     // 带指定半径的构造方法
 75 |     public Circle(double radius) {
 76 |         if (radius < 0) {
 77 |             throw new IllegalArgumentException("Radius cannot be negative.");
 78 |         }
 79 |         this.radius = radius;
 80 |     }
 81 | 
 82 |     // 获取半径
 83 |     public double getRadius() {
 84 |         return radius;
 85 |     }
 86 | 
 87 |     // 设置半径
 88 |     public void setRadius(double radius) {
 89 |         if (radius < 0) {
 90 |             throw new IllegalArgumentException("Radius cannot be negative.");
 91 |         }
 92 |         this.radius = radius;
 93 |     }
 94 | 
 95 |     @Override
 96 |     public double getArea() {
 97 |         return Math.PI * radius * radius;
 98 |     }
 99 | 
100 |     @Override
101 |     public double getPerimeter() {
102 |         return 2 * Math.PI * radius;
103 |     }
104 | 
105 |     @Override
106 |     public String toString() {
107 |         return "Circle[radius=" + radius + ", area=" + getArea() + ", perimeter=" + getPerimeter() + "]";
108 |     }
109 | 
110 | }
111 | 
112 | // Rectangle 类
113 | class Rectangle extends Geometric {
114 |     private double side1;
115 |     private double side2;
116 | 
117 |     // 无参构造方法
118 |     public Rectangle() {
119 |         this.side1 = 1.0;
120 |         this.side2 = 1.0;
121 |     }
122 | 
123 |     // 带指定边长的构造方法
124 |     public Rectangle(double side1, double side2) {
125 |         this.side1 = side1;
126 |         this.side2 = side2;
127 |     }
128 | 
129 |     // 获取 side1
130 |     public double getSide1() {
131 |         return side1;
132 |     }
133 | 
134 |     // 设置 side1
135 |     public void setSide1(double side1) {
136 |         this.side1 = side1;
137 |     }
138 | 
139 |     // 获取 side2
140 |     public double getSide2() {
141 |         return side2;
142 |     }
143 | 
144 |     // 设置 side2
145 |     public void setSide2(double side2) {
146 |         this.side2 = side2;
147 |     }
148 | 
149 |     @Override
150 |     public double getArea() {
151 |         return side1 * side2;
152 |     }
153 | 
154 |     @Override
155 |     public double getPerimeter() {
156 |         return 2 * (side1 + side2);
157 |     }
158 | 
159 |     @Override
160 |     public String toString() {
161 |         return "Rectangle[side1=" + side1 + ", side2=" + side2 + ", area=" + getArea() + ", perimeter=" + getPerimeter() + "]";
162 |     }
163 |     
164 | }
165 | 
166 | class Triangle extends Geometric {
167 | 
168 |     // 属性：三条边
169 |     private double side1;
170 |     private double side2;
171 |     private double side3;
172 | 
173 |     // 无参构造方法
174 |     public Triangle() {
175 |         this.side1 = 1.0;
176 |         this.side2 = 1.0;
177 |         this.side3 = 1.0;
178 |     }
179 | 
180 |     // 带参数的构造方法
181 |     public Triangle(double side1, double side2, double side3) {
182 |         this.side1 = side1;
183 |         this.side2 = side2;
184 |         this.side3 = side3;
185 |     }
186 |     
187 |     // 获取side1
188 |     public double getSide1() {
189 |         return side1;
190 |     }
191 | 
192 |     // 设置side1
193 |     public void setSide1(double side1) {
194 |         this.side1 = side1;
195 |     }
196 | 
197 |     // 获取side2
198 |     public double getSide2() {
199 |         return side2;
200 |     }
201 | 
202 |     // 设置side2
203 |     public void setSide2(double side2) {
204 |         this.side2 = side2;
205 |     }
206 | 
207 |     // 获取side3
208 |     public double getSide3() {
209 |         return side3;
210 |     }
211 | 
212 |     // 设置side3
213 |     public void setSide3(double side3) {
214 |         this.side3 = side3;
215 |     }
216 | 
217 |     // 判断是否能构成三角形
218 |     public boolean isTriangle() {
219 |         return (side1 + side2 > side3) && (side1 + side3 > side2) && (side2 + side3 > side1);
220 |     }
221 | 
222 |     // 计算面积（海伦公式）
223 |     @Override
224 |     public double getArea() {
225 |         if (!isTriangle()) {
226 |             return 0;
227 |         }
228 |         double s = getPerimeter() / 2;
229 |         return Math.sqrt(s * (s - side1) * (s - side2) * (s - side3));
230 |     }
231 | 
232 |     // 计算周长
233 |     @Override
234 |     public double getPerimeter() {
235 |         return side1 + side2 + side3;
236 |     }
237 | 
238 |     // 返回字符串描述
239 |     @Override
240 |     public String toString() {
241 |         return "Triangle[side1=" + side1 + ", side2=" + side2 + ", side3=" + side3 + ", color=" + getColor() + ", filled=" + isFilled() + "]";
242 |     }
243 | }
244 | 


--------------------------------------------------------------------------------
/6_Circle和Triangle类的异常类创建.java:
--------------------------------------------------------------------------------
  1 | public class AbnormalClass{
  2 |     public static void main(String[] args) {
  3 |         try {
  4 |             // 创建一个合法的三角形
  5 |             Triangle triangle1 = new Triangle(3.0, 4.0, 5.0);
  6 |             triangle1.printTriangleInfo();
  7 | 
  8 |             // 创建一个非法的三角形（任意两边之和小于或等于第三边）
  9 |             Triangle triangle2 = new Triangle(1.0, 2.0, 3.0); // 会抛出异常
 10 |             triangle2.printTriangleInfo();
 11 |         } catch (IllegalTriangleException e) {
 12 |             System.out.println("Error: " + e.getMessage());
 13 |         }
 14 | 
 15 |          try {
 16 |             // 使用默认构造方法创建一个圆
 17 |             Circle circle1 = new Circle();
 18 |             circle1.printCircleInfo();
 19 | 
 20 |             // 使用指定半径的构造方法创建一个圆
 21 |             Circle circle2 = new Circle(5.0);
 22 |             circle2.printCircleInfo();
 23 | 
 24 |             // 尝试使用一个无效的半径（负数）
 25 |             Circle circle3 = new Circle(-3.0); // 会抛出异常
 26 |             circle3.printCircleInfo();
 27 |         } catch (InvalidRadiusException e) {
 28 |             System.out.println("Error: " + e.getMessage());
 29 |         }
 30 |     }
 31 | }
 32 | 
 33 | // 定义InvalidRadiusException异常类
 34 | class InvalidRadiusException extends Exception {
 35 |     // 构造方法
 36 |     public InvalidRadiusException(String message) {
 37 |         super(message);
 38 |     }
 39 | }
 40 | 
 41 | // 定义Circle类
 42 | class Circle {
 43 |     private double radius;
 44 | 
 45 |     // 默认构造方法，默认半径为1
 46 |     public Circle() {
 47 |         this.radius = 1.0;
 48 |     }
 49 | 
 50 |     // 创建指定半径的构造方法
 51 |     public Circle(double radius) throws InvalidRadiusException {
 52 |         setRadius(radius);  // 使用setRadius方法验证半径
 53 |     }
 54 | 
 55 |     // 获取半径的方法
 56 |     public double getRadius() {
 57 |         return radius;
 58 |     }
 59 | 
 60 |     // 设置半径的方法，验证半径是否有效
 61 |     public void setRadius(double radius) throws InvalidRadiusException {
 62 |         if (radius < 0) {
 63 |             throw new InvalidRadiusException("Invalid radius: Radius cannot be negative.");
 64 |         }
 65 |         this.radius = radius;
 66 |     }
 67 | 
 68 |     // 计算圆的面积
 69 |     public double area() {
 70 |         return Math.PI * radius * radius;
 71 |     }
 72 | 
 73 |     // 计算圆的周长
 74 |     public double perimeter() {
 75 |         return 2 * Math.PI * radius;
 76 |     }
 77 | 
 78 |     // 打印圆的信息
 79 |     public void printCircleInfo() {
 80 |         System.out.println("Radius: " + radius);
 81 |         System.out.println("Area: " + area());
 82 |         System.out.println("Perimeter: " + perimeter());
 83 |     }
 84 | }
 85 | 
 86 | // 定义IllegalTriangleException异常类
 87 | class IllegalTriangleException extends Exception {
 88 |     // 构造方法
 89 |     public IllegalTriangleException(String message) {
 90 |         super(message);
 91 |     }
 92 | }
 93 | 
 94 | // 定义Triangle类
 95 | class Triangle {
 96 |     private double side1;
 97 |     private double side2;
 98 |     private double side3;
 99 | 
100 |     // 构造方法，验证三角形的合法性
101 |     public Triangle(double side1, double side2, double side3) throws IllegalTriangleException {
102 |         if (side1 <= 0 || side2 <= 0 || side3 <= 0) {
103 |             throw new IllegalTriangleException("Sides must be positive values.");
104 |         }
105 |         // 验证三角形的合法性，任意两边之和必须大于第三边
106 |         if (side1 + side2 <= side3 || side1 + side3 <= side2 || side2 + side3 <= side1) {
107 |             throw new IllegalTriangleException("Invalid triangle sides: The sum of any two sides must be greater than the third side.");
108 |         }
109 |         this.side1 = side1;
110 |         this.side2 = side2;
111 |         this.side3 = side3;
112 |     }
113 | 
114 |     // 获取三角形的三边
115 |     public double getSide1() {
116 |         return side1;
117 |     }
118 | 
119 |     public double getSide2() {
120 |         return side2;
121 |     }
122 | 
123 |     public double getSide3() {
124 |         return side3;
125 |     }
126 | 
127 |     // 计算三角形的周长
128 |     public double perimeter() {
129 |         return side1 + side2 + side3;
130 |     }
131 | 
132 |     // 计算三角形的面积（使用海伦公式）
133 |     public double area() {
134 |         double s = perimeter() / 2;
135 |         return Math.sqrt(s * (s - side1) * (s - side2) * (s - side3));
136 |     }
137 | 
138 |     // 打印三角形的信息
139 |     public void printTriangleInfo() {
140 |         System.out.println("Side 1: " + side1);
141 |         System.out.println("Side 2: " + side2);
142 |         System.out.println("Side 3: " + side3);
143 |         System.out.println("Perimeter: " + perimeter());
144 |         System.out.println("Area: " + area());
145 |     }
146 | }    
147 | 


--------------------------------------------------------------------------------
/7_StringBuffer反转字符串指定位置.java:
--------------------------------------------------------------------------------
 1 | public class StringReverser {
 2 | 
 3 |     // 方法：反转字符串指定起始和结束位置之间的子字符串
 4 |     public static String reverseSubstring(String str, int start, int end) {
 5 |         if (str == null || start < 0 || end >= str.length() || start >= end) {
 6 |             throw new IllegalArgumentException("Invalid start or end indices");
 7 |         }
 8 | 
 9 |         // 创建一个 StringBuffer 对象
10 |         StringBuffer buffer = new StringBuffer(str);
11 |         // 将指定位置的子字符串进行反转
12 |         buffer.replace(start, end + 1, new StringBuffer(buffer.substring(start, end + 1)).reverse().toString());
13 | 
14 |         return buffer.toString();
15 |     }
16 | 
17 |     // 测试方法
18 |     public static void main(String[] args) {
19 |         String original = "Hello, World!";
20 |         int start = 7;
21 |         int end = 11;
22 | 
23 |         // 运行测试
24 |         String result = reverseSubstring(original, start, end);
25 |         System.out.println("Original: " + original);
26 |         System.out.println("Modified: " + result);
27 |     }
28 | }
29 | 


--------------------------------------------------------------------------------
/7_trim功能模拟方法.java:
--------------------------------------------------------------------------------
 1 | public class CustomTrim {
 2 | 
 3 |     // Method to simulate the trim() function
 4 |     public static String customTrim(String input) {
 5 |         if (input == null || input.isEmpty()) {
 6 |             return input;
 7 |         }
 8 |         int start = 0;
 9 |         int end = input.length() - 1;
10 | 
11 |         // Move start index to the right while it points to a space
12 |         while (start <= end && input.charAt(start) == ' ') {
13 |             start++;
14 |         }
15 |         
16 |         // Move end index to the left while it points to a space
17 |         while (end >= start && input.charAt(end) == ' ') {
18 |             end--;
19 |         }
20 |         
21 |         // Return the trimmed substring
22 |         return input.substring(start, end + 1);
23 |     }
24 | 
25 |     public static void main(String[] args) {
26 |         // Test cases
27 |         String test1 = "   Hello World!   ";
28 |         String test2 = "NoLeadingOrTrailingSpaces";
29 |         String test3 = "   LeadingOnly";
30 |         String test4 = "TrailingOnly   ";
31 |         String test5 = "      "; // String with only spaces
32 |         String test6 = ""; // Empty string
33 |         
34 |         // Print results
35 |         System.out.println("Test 1: [" + customTrim(test1) + "]");
36 |         System.out.println("Test 2: [" + customTrim(test2) + "]");
37 |         System.out.println("Test 3: [" + customTrim(test3) + "]");
38 |         System.out.println("Test 4: [" + customTrim(test4) + "]");
39 |         System.out.println("Test 5: [" + customTrim(test5) + "]");
40 |         System.out.println("Test 6: [" + customTrim(test6) + "]");
41 |     }
42 | }
43 | 


--------------------------------------------------------------------------------
/7_打鱼晒网问题.java:
--------------------------------------------------------------------------------
 1 | public class FishingNetCheck {
 2 |     public static void main(String[] args) {
 3 |         // Start date: January 1, 1990
 4 |         // Target date: January 1, 2016
 5 | 
 6 |         // Calculate total number of days between the two dates
 7 |         int startYear = 1990;
 8 |         int endYear = 2016;
 9 |         int totalDays = 0;
10 | 
11 |         for (int year = startYear; year < endYear; year++) {
12 |             // Check if the year is a leap year
13 |             if (isLeapYear(year)) {
14 |                 totalDays += 366;
15 |             } else {
16 |                 totalDays += 365;
17 |             }
18 |         }
19 | 
20 |         // Determine the activity on January 1, 2016
21 |         // The cycle is 5 days long: 3 days fishing, 2 days net drying
22 |         String[] cycle = {"Fishing", "Fishing", "Fishing", "Net Drying", "Net Drying"};
23 |         String activityOnTargetDate = cycle[totalDays % 5];
24 | 
25 |         System.out.println("On January 1, 2016, the activity is: " + activityOnTargetDate);
26 |     }
27 | 
28 |     // Helper method to check if a year is a leap year
29 |     private static boolean isLeapYear(int year) {
30 |         return (year % 4 == 0 && (year % 100 != 0 || year % 400 == 0));
31 |     }
32 | }
33 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # Java_cb_3_to_7
2 | 最终版本，1602刘王哲制作，请理解了再抄，祝抄的开心！
3 | 


--------------------------------------------------------------------------------
/更新7_多线程.java:
--------------------------------------------------------------------------------
 1 | public class MultiThreadOddEven {
 2 |     public static void main(String[] args) {
 3 |         Thread oddThread = new Thread(new OddNumberPrinter(), "OddThread");
 4 |         Thread evenThread = new Thread(new EvenNumberPrinter(), "EvenThread");
 5 | 
 6 |         oddThread.start();
 7 |         evenThread.start();
 8 | 
 9 |         try {
10 |             oddThread.join(); // 等待 oddThread 执行完毕
11 |             evenThread.join(); // 等待 evenThread 执行完毕
12 |         } catch (InterruptedException e) {
13 |             e.printStackTrace();
14 |         }
15 | 
16 |         System.out.println("end");
17 |     }
18 | }
19 | 
20 | class OddNumberPrinter implements Runnable {
21 |     @Override
22 |     public void run() {
23 |         for (int i = 1; i < 10; i += 2) {
24 |             System.out.println(Thread.currentThread().getName() + " outputs: " + i);
25 |             try {
26 |                 Thread.sleep(100); // 模拟线程执行的延迟
27 |             } catch (InterruptedException e) {
28 |                 e.printStackTrace();
29 |             }
30 |         }
31 |     }
32 | }
33 | 
34 | class EvenNumberPrinter implements Runnable {
35 |     @Override
36 |     public void run() {
37 |         for (int i = 2; i <= 10; i += 2) {
38 |             System.out.println(Thread.currentThread().getName() + " outputs: " + i);
39 |             try {
40 |                 Thread.sleep(100); // 模拟线程执行的延迟
41 |             } catch (InterruptedException e) {
42 |                 e.printStackTrace();
43 |             }
44 |         }
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------
/更新7_继承Thread实现多线程.java:
--------------------------------------------------------------------------------
 1 | import java.util.Random;
 2 | 
 3 | public class MultiThreadOddEven {
 4 |     public static void main(String[] args) {
 5 |         MyThread thread1 = new MyThread("Thread-1", new Random().nextInt(1000));
 6 |         MyThread thread2 = new MyThread("Thread-2", new Random().nextInt(1000));
 7 |         MyThread thread3 = new MyThread("Thread-3", new Random().nextInt(1000));
 8 | 
 9 |         thread1.start();
10 |         thread2.start();
11 |         thread3.start();
12 |     }
13 | }
14 | 
15 | class MyThread extends Thread {
16 |     private final String whoAmI;
17 |     private final int delay;
18 | 
19 |     public MyThread(String whoAmI, int delay) {
20 |         this.whoAmI = whoAmI;
21 |         this.delay = delay;
22 |         this.setName(whoAmI);
23 |     }
24 | 
25 |     @Override
26 |     public void run() {
27 |         System.out.println(whoAmI + " will sleep for " + delay + " milliseconds.");
28 |         try {
29 |             Thread.sleep(delay);
30 |         } catch (InterruptedException e) {
31 |             e.printStackTrace();
32 |         }
33 |         System.out.println(whoAmI + " has finished execution.");
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------