-
前言
- 知识点：
- 类和对象：定义班级、学生和课程等类，并创建相应的对象；
- 封装和访问控制：使用private、public等关键字对类的字段进行封装和访问控制；
- 集合类：使用ArrayList或者其他集合类存储学生和课程信息；
- 输入输出：通过控制台或者文件读写来输入和输出学生课程成绩信息；
- 循环和条件语句：使用for循环和if语句进行遍历和条件判断；
- 数组：使用数组存储学生的各门课程成绩；
- 方法和函数：定义方法来计算学生课程总分、平均分等；
- 异常处理：处理可能出现的异常情况，如输入格式错误等。
- 题量：感觉有点大
- 难度：成绩计算系列难度大，其它还好
-
设计与分析
-
课程成绩统计程序-1：
1 import java.util.ArrayList;
2 import java.util.Scanner;
3 public class Main {
4 static ArrayList<Course> listCourse = new ArrayList<>();
5 static ArrayList<Student> listStudent = new ArrayList<>();
6 public static void main(String[] args) {
7 ArrayList<String> list = new ArrayList<>();
8 Scanner sc = new Scanner(System.in);
9 String s = null;
10 while (!("end".equals(s = sc.nextLine()))){
11 list.add(s);
12 }
13 int count = 0;
14 for (String s1 : list) {
15 //System.out.println(s1);
16 /*java 选修 考察
17 20201103 张三 java 40
18 end*/
19 String[] s2 = s1.split(" ");
20 if(s2.length == 3){
21 Course cou = new Course();
22 cou.setCourse(s2[0]);
23 cou.setMajor(s2[1]);
24 cou.setElective(s2[2]);
25 listCourse.add(cou);
26 }
27 if(s2.length == 4){
28 Student stuTemp = new Student();
29 stuTemp.setId(s2[0]);
30 stuTemp.setName(s2[1]);
31 }
32 }
33
34 System.out.println("wrong format");
35 /*for (Course course : stu.getListCourse()) {
36 System.out.println(course.getCourse()+","+course.getMajor()+","+course.getElective());
37 }*/
38
39 }
40 }
41 class Student {
42 private String name;
43 private String Id;
44 private String keChen;
45 private int pinShiFen;
46 private int kaoShiFen;
47
48 public Student() {
49 }
50
51 public Student(String name, String id) {
52 this.name = name;
53 Id = id;
54 }
55
56 public String getName() {
57 return name;
58 }
59
60 public void setName(String name) {
61 this.name = name;
62 }
63
64 public String getId() {
65 return Id;
66 }
67
68 public void setId(String id) {
69 Id = id;
70 }
71 }
72 class Course {
73 private String major;//主修
74 private String elective;//选修
75
76 private String course;//课程
77
78 public Course() {
79 }
80
81 public Course(String major, String elective, String course) {
82 this.major = major;
83 this.elective = elective;
84 this.course = course;
85 }
86
87 public String getMajor() {
88 return major;
89 }
90
91 public void setMajor(String major) {
92 this.major = major;
93 }
94
95 public String getElective() {
96 return elective;
97 }
98
99 public void setElective(String elective) {
100 this.elective = elective;
101 }
102
103 public String getCourse() {
104 return course;
105 }
106
107 public void setCourse(String course) {
108 this.course = course;
109 }
110 }
111 class Class {
112
113 private String num;
114 private int classAverage;
115
116 public Class() {
117 }
118
119 public Class( String num, int classAverage) {
120 this.num = num;
121 this.classAverage = classAverage;
122 }
123
124
125 public String getNum() {
126 return num;
127 }
128
129 public void setNum(String num) {
130 this.num = num;
131 }
132
133 public int getClassAverage() {
134 return classAverage;
135 }
136
137 public void setClassAverage(int classAverage) {
138 this.classAverage = classAverage;
139 }
140 }
- 代码中定义了三个类：Main、Student和Course。其中，Main类是程序的入口，Student类表示学生对象，Course类表示课程对象。
-
程序开始时创建了两个ArrayList集合变量listCourse和listStudent，用于存储课程对象和学生对象。然后通过Scanner读取用户输入的信息，将每行信息添加到list集合中，直至输入"end"结束。接下来，程序对list集合进行遍历，根据空格分隔每行信息并判断长度。长度为3表示该行为课程信息，创建一个Course对象并设置相应属性，然后将其添加到listCourse集合中。长度为4表示该行为学生信息，创建一个Student对象并设置相应属性，但在代码中没有将该学生对象添加到listStudent集合中，可能是遗漏了这部分代码。最后，程序输出"wrong format"，表示输入的信息格式错误。
-
第7次题目集
- 7-1 容器-HashMap-检索：
import java.util.HashMap;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
HashMap<String, String> student = new HashMap<>();
Scanner sc = new Scanner(System.in);
while (true) {
String input = sc.nextLine();
if (input.equals("end")) {
break;
} else {
String[] s = input.split(" ");
student.put(s[0], s[1] + " " + s[2]);
}
}
String id = sc.nextLine();
if (student.containsKey(id)) {
System.out.println(id + " " + student.get(id));
} else {
System.out.println("The student " + id + " does not exist");
}
}
}
- 使用了HashMap<String, String>来存储学生信息，其中键（key）表示学生的编号，值（value）表示学生的姓名和姓氏。程序通过Scanner从控制台读取用户输入的学生信息，直到输入"end"为止。
- 在读取每行学生信息时，代码使用split方法将输入的字符串按空格进行分割，得到一个包含学生编号和姓名的String数组s。然后，将学生编号作为键，姓名作为值，将它们添加到HashMap对象student中。
- 接下来，代码继续通过Scanner获取一个学生编号id，并使用containsKey方法判断该编号是否存在于student的键集合中。如果存在，则通过get方法获取对应的值（即学生的姓名和姓氏），并将学生编号和姓名输出到控制台。如果不存在，则输出"The student + 学生编号 + does not exist"。
- 这段代码实现了一个简单的学生信息查询功能，用户可以输入一系列学生信息，然后通过学生编号来查询对应的学生姓名和姓氏。
-
7-2 容器-HashMap-排序：
1 import java.util.*;
2 public class Main {
3 public static void main(String[] args) {
4 HashMap<String, String> student = new HashMap<>();
5 Scanner sc = new Scanner(System.in);
6 //System.out.println("请输入学生信息（格式：学号 姓名 成绩），以end结束：");
7 while (true) {
8 String input = sc.nextLine();
9 if (input.equals("end")) {
10 break;
11 } else {
12 String[] s = input.split(" ");
13 student.put(s[0], s[1] + " " + s[2]);
14 }
15 }
16 ArrayList<String> list = new ArrayList<>(student.keySet());
17 //System.out.println(list);
18 Collections.sort(list, Collections.reverseOrder());
19 //System.out.println(list);
20 for (String s : list) {
21 System.out.println(s+" "+student.get(s));
22 }
23 }
24 }
- 首先创建了一个HashMap对象student，用于存储学生信息。然后通过Scanner从控制台读取用户输入的学生信息，直到输入"end"为止。
- 在读取每行学生信息时，代码使用split方法将输入的字符串按空格进行分割，得到一个包含学号、姓名和成绩的String数组s。然后，将学号作为键，姓名和成绩拼接后的字符串作为值，将它们添加到HashMap对象student中。
- 接下来，代码将student的键集合转换为一个ArrayList对象list，并使用Collections.sort方法对list进行倒序排序。
- 最后，通过for循环遍历排好序的list，根据学号获取对应学生的完整信息，并将其输出到控制台。
-
7-3 课程成绩统计程序-2：
1 import java.util.ArrayList;
2 import java.util.Scanner;
3 public class Main {
4 static ArrayList<Course> listCourse = new ArrayList<>();
5 static ArrayList<Student> listStudent = new ArrayList<>();
6 public static void main(String[] args) {
7 ArrayList<String> list = new ArrayList<>();
8 Scanner sc = new Scanner(System.in);
9 String s = null;
10 while (!("end".equals(s = sc.nextLine()))){
11 list.add(s);
12 }
13 int count = 0;
14 for (String s1 : list) {
15 //System.out.println(s1);
16 /*java 选修 考察
17 20201103 张三 java 40
18 end*/
19 String[] s2 = s1.split(" ");
20 if(s2.length == 3){
21 Course cou = new Course();
22 cou.setCourse(s2[0]);
23 cou.setMajor(s2[1]);
24 cou.setElective(s2[2]);
25 listCourse.add(cou);
26 }
27 if(s2.length == 4){
28 Student stuTemp = new Student();
29 stuTemp.setId(s2[0]);
30 stuTemp.setName(s2[1]);
31 }
32 }
33
34 System.out.println("wrong format");
35 /*for (Course course : stu.getListCourse()) {
36 System.out.println(course.getCourse()+","+course.getMajor()+","+course.getElective());
37 }*/
38
39 }
40 }
41 class Student {
42 private String name;
43 private String Id;
44 private String keChen;
45 private int pinShiFen;
46 private int kaoShiFen;
47
48 public Student() {
49 }
50
51 public Student(String name, String id) {
52 this.name = name;
53 Id = id;
54 }
55
56 public String getName() {
57 return name;
58 }
59
60 public void setName(String name) {
61 this.name = name;
62 }
63
64 public String getId() {
65 return Id;
66 }
67
68 public void setId(String id) {
69 Id = id;
70 }
71 }
72 class Course {
73 private String major;//主修
74 private String elective;//选修
75
76 private String course;//课程
77
78 public Course() {
79 }
80
81 public Course(String major, String elective, String course) {
82 this.major = major;
83 this.elective = elective;
84 this.course = course;
85 }
86
87 public String getMajor() {
88 return major;
89 }
90
91 public void setMajor(String major) {
92 this.major = major;
93 }
94
95 public String getElective() {
96 return elective;
97 }
98
99 public void setElective(String elective) {
100 this.elective = elective;
101 }
102
103 public String getCourse() {
104 return course;
105 }
106
107 public void setCourse(String course) {
108 this.course = course;
109 }
110 }
111 class Class {
112
113 private String num;
114 private int classAverage;
115
116 public Class() {
117 }
118
119 public Class( String num, int classAverage) {
120 this.num = num;
121 this.classAverage = classAverage;
122 }
123
124
125 public String getNum() {
126 return num;
127 }
128
129 public void setNum(String num) {
130 this.num = num;
131 }
132
133 public int getClassAverage() {
134 return classAverage;
135 }
136
137 public void setClassAverage(int classAverage) {
138 this.classAverage = classAverage;
139 }
140 }
-
定义一个空的数据结构，用于存储课程信息和成绩。
-
输入课程信息和成绩：
- 读取用户输入的课程数目n。
- 创建一个循环，从1到n依次执行以下步骤：
- 读取用户输入的课程名称、课程性质和考核方式。
- 将课程信息添加到数据结构中。
-
输入考试/考查课程成绩：
- 读取用户输入的考试/考查课程数目m。
- 创建一个循环，从1到m依次执行以下步骤：
- 读取用户输入的学号、姓名、课程名称、平时成绩和期末成绩。
- 根据课程名称找到对应的课程信息。
- 计算考试/考查课程的总成绩并将其添加到数据结构中。
-
输入实验课程成绩：
- 读取用户输入的实验课程数目k。
- 创建一个循环，从1到k依次执行以下步骤：
- 读取用户输入的学号、姓名、课程名称、实验次数和实验成绩。
- 根据课程名称找到对应的课程信息。
- 计算实验课程的总成绩（实验成绩的平均值）并将其添加到数据结构中。
-
输出课程统计信息：
- 创建一个循环，遍历数据结构中的课程信息。
- 对于每个课程，根据课程性质判断考核方式，分别计算总成绩。
- 输出每个课程的名称、性质、考核方式和总成绩。
-
7-4 动物发声模拟器（多态）：
public class Main {
public static void main(String[] args) {
//动物发生模拟器. 请在下面的【】处添加代码。
Cat cat = new Cat();
Dog dog = new Dog();
Goat goat = new Goat();
speak(cat);
speak(dog);
speak(goat);
}
//定义静态方法speak()
public static void speak(Animal animal) {
System.out.print(animal.getAnimalClass() + "的叫声：");
animal.shout();
}
}
//定义抽象类Animal
abstract class Animal {
//获取动物类别getAnimalClass()、动物叫shout()；
public abstract String getAnimalClass();
public abstract void shout();
}
//基于Animal类，定义猫类Cat，并重写两个抽象方法
class Cat extends Animal {
@Override
public String getAnimalClass() {
return "猫";
}
@Override
public void shout() {
System.out.println("喵喵");
}
}
//基于Animal类，定义狗类Dog，并重写两个抽象方法
class Dog extends Animal {
@Override
public String getAnimalClass() {
return "狗";
}
@Override
public void shout() {
System.out.println("汪汪");
}
}
//基于Animal类，定义山羊类Goat，并重写两个抽象方法
class Goat extends Animal {
@Override
public String getAnimalClass() {
return "山羊";
}
@Override
public void shout() {
System.out.println("咩咩");
}
}
-
代码定义了一个抽象类
Animal作为基类，其中包含两个抽象方法getAnimalClass()和shout()。然后通过三个具体的子类Cat、Dog和Goat分别继承Animal类，并实现了这两个抽象方法。在
Main类的main方法中，创建了一个Cat对象、一个Dog对象和一个Goat对象，并依次调用了speack方法。speak方法接受一个Animal类型的参数，输出动物的类别和叫声。运行程序时，会依次输出每个动物的类别和对应的叫声，分别是猫的"喵喵"、狗的"汪汪"和山羊的"咩咩"。
-
7-1 容器-ArrayList-排序：
import java.util.*;
public class Main {
public static void main(String[] args) {
ArrayList<Student> list = new ArrayList<>();
Scanner sc = new Scanner(System.in);
String line = sc.nextLine();
while (!line.equals("end")) {
String[] s = line.split(" ");
if (s.length == 4) {
list.add(new Student(s[0], s[1], Integer.parseInt(s[2]), Integer.parseInt(s[3])));
}
line = sc.nextLine();
}
//简单理解:
//o1 - o2 :升序排列
//o2 - o1 :降序排序
//Integer[] arr = {2,3,1,5,6,7,8,4,9};
/*Arrays.sort(arr, new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o1 - o2;
}
});*/
// 按数学和物理成绩之和从高到低排序
Collections.sort(list, new Comparator<Student>() {
@Override
public int compare(Student o1, Student o2) {
return Integer.compare(o2.getSum(), o1.getSum()); // 从大到小排序
}
});
for (Student student : list) {
System.out.println(student.getId() + " " + student.getName() + " " + student.getSum());
}
}
}
class Student {
private String id;
private String name;
private int math;
private int physics;
public Student() {
}
public Student(String id, String name, int math, int physics) {
this.id = id;
this.name = name;
this.math = math;
this.physics = physics;
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getMath() {
return math;
}
public void setMath(int math) {
this.math = math;
}
public int getPhysics() {
return physics;
}
public void setPhysics(int physics) {
this.physics = physics;
}
public int getSum() {
return math + physics;
}
}
-
首先创建了一个存储
Student对象的ArrayList列表，并通过用户输入添加学生信息。每个学生信息包括学号(id)、姓名(name)、数学成绩(math)和物理成绩(physics)。然后，使用
Collections.sort()方法对学生列表进行排序，排序规则是通过自定义的比较器(Comparator)来实现的。比较器通过比较学生对象的数学和物理成绩之和(getSum())进行排序，按照从高到低排列。比较器的定义通过实现compare()方法来实现。最后，通过遍历排序后的学生列表，打印每个学生的学号、姓名和总成绩。
-
7-2 课程成绩统计程序-3：
- 太复杂了
7-3 jmu-Java-02基本语法-03-身份证排序
import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
ArrayList<String> list1 = new ArrayList<>();
ArrayList<String> list2 = new ArrayList<>();
ArrayList<String> list3 = new ArrayList<>();
Scanner sc = new Scanner(System.in);
//System.out.println("要输入的次数");
int a = sc.nextInt();
sc.nextLine();//读取多余的换行符
for (int i = 0; i < a; i++) {
String s = sc.nextLine();
list1.add(s);
}
for (String s : list1) {
String s1 = s.substring(6, 10) + "-" + s.substring(10, 12) + "-" + s.substring(12, 14);
list2.add(s1);
}
for (String s : list1) {
String s1 = s.substring(6, 10) + s.substring(10, 12) + s.substring(12, 14);
list3.add(s1);
}
while (true) {
//System.out.println("请选择要使用的方式");
String choose = sc.nextLine();
switch (choose) {
case "sort1": {
Collections.sort(list2);
for (String s : list2) {
System.out.println(s);
}
break;
}
case "sort2": {
Collections.sort(list3);
for (int i = 0; i < list1.size(); i++) {
for (int j = 0; j < list1.size(); j++) {
if (list1.get(j).contains(list3.get(i))){
System.out.println(list1.get(j));
}
}
}
break;
}
default:{
System.out.println("exit");
System.exit(0);
}
}
}
}
}
- 首先，定义了三个
ArrayList列表list1、list2和list3用于存储输入的字符串信息。通过Scanner类获取用户输入的次数a，然后使用nextLine()方法读取每行输入的字符串，并将其添加到list1中。接下来，分别对
list1中的每个字符串进行处理，提取其中的日期部分并格式化为YYYY-MM-DD的形式，并将结果添加到list2中。同时，将日期部分整合为纯数字的形式(YYYYMMDD)，并添加到list3中。然后，通过一个无限循环，等待用户选择要使用的方式(
sort1或sort2)，用户可以通过输入命令来执行相应的操作。如果选择sort1，则对list2进行排序并打印排序后的结果；如果选择sort2，则对list3进行排序，并根据排序后的结果匹配并打印原始输入的字符串；如果选择其他任何值，则退出程序。
-
7-4 jmu-Java-04面向对象进阶-03-接口-自定义接口ArrayIntegerStack
import java.util.Arrays;
import java.util.Scanner;
interface IntegerStack {
public Integer push(Integer item); //如果item为null，则不入栈直接返回null。如果栈满，也返回null。如果插入成功，返回item
public Integer pop(); //出栈，如果为空，则返回null。出栈时只移动栈顶指针，相应位置不置为null
public Integer peek(); //获得栈顶元素，如果为空，则返回null
public boolean empty(); //如果为空返回true
public int size(); //返回栈中元素个数
}
class ArrayIntegerStack implements IntegerStack{
private Integer[] arr;
private int top = 0;
public ArrayIntegerStack(int n){
arr = new Integer[n];
Arrays.fill(arr, null);
}
public ArrayIntegerStack(){}
@Override
public String toString() {
return Arrays.toString(arr);
}
@Override
public Integer push(Integer item) {
if (item == null || arr.length == top){
return null;
}
arr[top++] = item;
return item;
}
@Override
public Integer pop() {
if (top == 0){
return null;
}
return arr[--top];
}
@Override
public Integer peek() {
if (top == 0){
return null;
}
return arr[top - 1];
}
@Override
public boolean empty() {
return top == 0;
}
@Override
public int size() {
return top;
}
}
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt();
ArrayIntegerStack ais = new ArrayIntegerStack(n);
int m = scanner.nextInt();
while(m-- > 0){
int item = scanner.nextInt();
System.out.println(ais.push(item));
}
System.out.println(ais.peek() + "," + ais.empty() + "," + ais.size());
System.out.println(ais);
int x = scanner.nextInt();
while(x-- > 0){
System.out.println(ais.pop());
}
System.out.println(ais.peek() + "," + ais.empty() + "," + ais.size());
System.out.println(ais);
}
}
-
这段代码实现了一个整数栈数据结构，包括入栈、出栈、获取栈顶元素、判断栈是否为空以及获取栈中元素个数等功能。
首先定义了一个
IntegerStack接口，该接口包含了五个方法：push()用于将元素入栈，pop()用于出栈，peek()用于获取栈顶元素，empty()用于判断栈是否为空，size()用于获取栈中元素个数。然后实现了一个名为
ArrayIntegerStack的类，该类实现了IntegerStack接口。它通过一个数组来保存栈中的元素，使用一个变量top表示栈顶的位置。在初始化时，可以指定栈的容量。栈的大小可以通过调用size()方法获得。入栈时，检查元素是否为null以及栈是否已满，如果满足条件则返回null，否则将元素添加到栈顶，并返回插入的元素。出栈时，检查栈是否为空，如果为空则返回null，否则返回栈顶元素并将栈顶指针前移。获取栈顶元素时，检查栈是否为空，如果为空则返回null，否则返回栈顶元素。判断栈是否为空时，只需判断栈顶指针是否为0即可。最后，通过重写toString()方法，可以直接打印整个栈的元素。在
Main类的main()方法中，首先通过Scanner类获取用户输入的栈的容量和操作次数，并创建一个ArrayIntegerStack对象。然后，根据用户输入的操作类型进行相应的操作：入栈、获取栈顶元素、判断栈是否为空以及出栈。最后，输出栈顶元素、判断栈是否为空以及栈中元素个数，并打印整个栈的元素。
-
7-5 jmu-Java-03面向对象基础-05-覆盖
import java.util.Arrays; import java.util.Scanner; class PersonOverride { private String name; private int age; private boolean gender; public PersonOverride() { this("default", 1, true); } public PersonOverride(String name, int age, boolean gender) { this.name = name; this.age = age; this.gender = gender; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int getAge() { return age; } public void setAge(int age) { this.age = age; } public boolean isGender() { return gender; } public void setGender(boolean gender) { this.gender = gender; } @Override public String toString() { String s = name + "-" + age + "-" + gender; return s; } @Override public boolean equals(Object obj) { if (this == obj) { return true; } if (obj == null || getClass() != obj.getClass()) { return false; } PersonOverride other = (PersonOverride) obj; return name.equals(other.name) && age == other.age && gender == other.gender; } } public class Main { public static void main(String[] args) { Scanner sc = new Scanner(System.in); int n1 = sc.nextInt(); sc.nextLine(); PersonOverride[] persons1 = new PersonOverride[n1]; for (int i = 0; i < n1; i++) { PersonOverride p1 = new PersonOverride(); persons1[i] = p1; } int n2 = sc.nextInt(); sc.nextLine(); int number = 0; PersonOverride[] persons2 = new PersonOverride[n2]; for (int i = 0; i < n2; i++) { String s1 = sc.nextLine(); String[] s = s1.split(" "); PersonOverride po = new PersonOverride(s[0], Integer.parseInt(s[1]), Boolean.parseBoolean(s[2])); boolean duplicated = false; for (int j = 0; j < i; j++) { if (po.equals(persons2[j])) { duplicated = true; break; } } if (!duplicated) { persons2[i] = po; number++; } } for (int i = 0; i < n1; i++) { System.out.println(persons1[i]); } for (int i = 0; i < n2; i++) { if (persons2[i] != null) { System.out.println(persons2[i]); } } System.out.println(number); System.out.println(Arrays.toString(PersonOverride.class.getConstructors())); } }
-
首先定义了一个
PersonOverride类，该类有私有成员变量name（姓名）、age（年龄）和gender（性别），以及对应的getter和setter方法。还重写了toString()方法和equals()方法。然后在
Main类中的main方法中，通过用户输入获取两个整数n1和n2，分别表示要创建的PersonOverride对象的数量。接下来创建了长度为n1和n2的persons1和persons2数组用于存储PersonOverride对象。通过循环语句，分别创建了
n1个默认的PersonOverride对象，并将其存储到persons1数组中。然后通过循环语句，根据用户输入的字符串创建
PersonOverride对象，并检查是否与之前创建的对象重复。如果未重复，则将其存储到persons2数组中，并递增number计数器。最后，分别遍历
persons1和persons2数组，输出其中的对象。同时输出number的值和PersonOverride类的构造方法列表。
三、采坑心得
- 在编写日期相关的程序时，需要仔细学习和理解Java API提供的相关类和方法，以确保程序的正确性和稳定性。注意一些特殊情况的处理，输入错误、异常的处理要完善，而且变量名命名要具有可读性，要更加清晰易懂以提高代码可维护性，当输入格式不正确、数组越界等情况需要进行相关判断和处理。使用纯数组来计算，没有进行任何异常处理和错误提示，容易造成数字溢出等错误，需要注意程序在处理字符时要特别小心，防止出现数组越界等问题。
标签：题目,String,int,System,PTA,new,return,成绩,public From： https://www.cnblogs.com/wrf24/p/17507044.html