头歌 实验二 Java类编程实验
制作不易，点个关注！给大家带来更多的价值！
目录
- 头歌 实验二 Java类编程实验
- `制作不易，点个关注！给大家带来更多的价值！`
- 第一关： 编写一个代表三角形的类
- 第二关： 编写一个圆环类
- 第三关：编写一个学生类
第一关： 编写一个代表三角形的类
任务描述
本关任务：创建一个类和一个对象，调用这个对象的属性和方法。
相关知识
为了完成本关任务，你需要掌握：1、什么是类和对象； 2、怎么定义类； 3、怎么创建对象并使用对象的属性和方法。
类的设计
作为Java程序的基本要素，类由成员变量(也称属性)和成员方法组成。属性包括常量和变量，方法则包括构造方法和自定义方法，在定义类时，它们习惯上按如下次序排列：
public class Order{
// final属性
// 属性
// 构造方法
// 自定义方法
}
类的属性一般定义为私有的，而类的方法定义为public。
访问修饰符
Java中定义了private、public、protected和默认的访问修饰符，这些修饰符控制着对类和类的成员变量以及成员方法的访问规则。另外，还可以辅助static和final关键字定义特殊规则。
,
public是公有类型的权限修饰符，使用public修饰的类、成员变量和成员方法，其他类都可以访问，包括任意包中的任意类以及子类。
private是私有类型的权限修饰符，使用private修饰的成员变量和成员方法，只能在本类中被使用，在子类中是不可见的，并且对其他包的类也是不可见的。
protected是保护级别的权限修饰符，它保护成员不会被其他包或非子类访问。也就是说protected修饰的成员只能被子类和同一包中定义的其他类访问。
当不添加任何权限修饰符时，编译器会使用默认权限修饰符，该修饰符的权限级别与protected类似，不同之处在于，其他包定义的子类无法访问父类默认权限修饰的成员。
封装(encapsulation)
封装是指把对象的属性隐藏在对象的内部，不允许外部直接访问和修改。Java规范中的设置器和 访问器就是实现封装的标准方法，它们用于设置和获取对象的属性值。
设置器方法的命名一般以set作为方法名的前缀，以属性名作为后缀。
访问器方法的命名一般以get或is作为方法名称的前缀，以属性名作为后缀。对于boolean类型的属性，应该使用is前缀定义访问器 方法。例如：
public class Car {
private String color;
private boolean running;
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public boolean isRunning() {
return running;
}
public void setRunning(boolean running) {
this.running = running;
}
}
Object类
在Java中，所有的类都直接或间接继承了java.lang.Object类，它是所有类的父类。Object类中常用的两个方法为equals()和toString()方法。任何类都可以重写Object类中的方法。
Object类处于Java继承层次中的最顶端，它封装了所有类的公共行为。
Object类的equals()方法采用的是==运算比较，也就是只有两个引用变量指向同一对象时才相等。而实际上我们期望该方法进行对象的内容比较，因此子类中通常将equals()方法改写。
类的toString()方法返回对象的描述信息，在Object类中该方法返回对象的类名及对象引用地址。子类中通常要提供自己的toString()方法，以便更好地描述对象。
对象的创建与构造方法
类是创建对象的模板，而对象是类的实例。对象是一组属性和方法的封装体，创建对象要用到保留字new，对象的构造方法的语法格式为：
引用变量 = new 构造方法(参数)
有关构造方法有以下几点说明：
(1) 创建对象时将用到构造方法，系统自动调用参数匹配的构造方法为对象初始化。
(2) 构造方法的名称必须与类名同名，构造方法没有返回类型。
(3) —个类可提供多个构造方法，这些构造方法的参数不同。
(4) 如果程序中未提供构造方法，系统自动提供空的无参构造方法。
对象引用变量与对象关系
对象创建后，将对象的引用赋值给某个引用变量，就可以通过该变量访问对象的成员属性和方法，成员的调用通过“.”运算符实现，格式为：
对象名.属性
对象名.方法(参数)
静态空间与实例空间
带有static修饰的属性称为静态属性或类变量；带有static修饰的方法称为静态方法， 在静态方法内可以直接讨问静态属性或调用其他静态方法，静态属性在分配空间时与对象无关，静态空间的引用是与类关联的，一个类的静态属性成员只有一份，访问静态成员可以通过类名(在自己类中也可以直接访问)，也可以通过对象。静态属性是共享的，该类的任何对象均可访问它。
【思考】静态属性归属类，因此必须指明是访问哪个类的静态成员，如果是在自己类中则可以省略，由于对象由类创建，自然对象能标识其所属类，因此也允许用对象做前缀访问静态属性。非静态属性也称实例变量，也就是说，要通过实际的对象才能访问，不同对象其实例变量的值通常是不同的。
Math类
Java 的 Math类包含了用于执行基本数学运算的属性和方法，如平方、对数、平方根和三角函数等。下表为 Math 类的一些常用方法。
例如：如何求取2 的3次方和0.5 的3次方？
Math.pow(x, y) 方法为Java 的幂运算，意思为求x的y次方，x和y可以是整型也可以是浮点型，该方法返回一个浮点型的值
例子：
double a = Math.pow(2, 3); // 求2的3次方，并将其赋值给一个double型的变量a
System.out.print(a);
执行结果：8.0
例如：如何求取 根号4？
Math.sqrt(x) 为Java 开平方的方法，意思为求x的平方根，x可以是整型也可以是浮点型，该方法返回一个浮点型的值。
例子：
double a = Math.sqrt(4);// 求4的平方根，并将其赋值给一个double型的变量a
System.out.print(a);
执行结果：2.0
Random类
在 Java 中有一个 Random 类，他可以在指定的取值范围内随机产生数字。要想使用 Random 类，第一步需要导入 java.util.Random 这个包。例如：
import java.util.Random;
第二步需要创建 Random 对象。
Random random = new Random();
创建完 Random 对象之后，我们就可以使用它提供的方法来创建随机数了。
,
代码示例：
public class RandomTest {
public static void main(String[] args) {
Random random = new Random();
System.out.println(random.nextInt(10));
System.out.println(random.nextFloat());
System.out.println(random.nextDouble());
}
}
第一次运行结果：
4
0.60541
0.7046691676099207
第二次运行结果：
3
0.055246472
0.47445795351116005
我们可以看到第一次运行结果和第二次运行的结果是不一样的。当我们想要第一次和第二次运行结果一致的话，可以在创建 Random 对象的时候传入一个Long 类型的数字，这个数字叫随机种子。具有相同随机种子的 Random 对象生成的随机数是一样的。
示例：
public static void main(String[] args) {
// 创建一个Random对象并传入随机种子
Random random = new Random(10);
System.out.println(random.nextInt(10));
System.out.println(random.nextFloat());
System.out.println(random.nextDouble());
}
第一次运行结果：
3
0.44563425
0.2578027905957804
第二次运行结果：
3
0.44563425
0.2578027905957804
编程要求
根据提示，在右侧编辑器Begin-End处补充代码：
编写一个代表三角形的类（Triangle.java）。其中，三条边a,b,c（数据类型为double类型）为三角形的属性，该类封装有求三角形的面积和周长的方法。分别针对给定的三条边进行测试（给定三条边已经满足三角形构成条件），输出面积和周长保留2位小数。
提示：三角形面积计算公式为
测试说明
测试输入：3 4 5
预期输出：
三角形(3.0,4.0,5.0)的面积为:6.00
三角形(3.0,4.0,5.0)的周长为:12.00
开始你的任务吧，祝你成功！
代码如下：
package step1;
import java.lang.Math;
import java.util.Scanner;
public class Triangle {
// 自行设计类的实现
/********** Begin **********/
double a,b,c;
public Triangle(double a, double b, double c) {
this.a = a;
this.b = b;
this.c = c;
}
public double getArea() {
double s = (a + b + c) / 2;
return Math.sqrt(s * (s - a) * (s - b) * (s - c));
}
public double getPerimeter() {
return a + b + c;
}
/********** End **********/
public static void main(String[] args) {
/********** Begin **********/
Scanner sc = new Scanner(System.in);
double a,b,c; //定义三条边
a = sc.nextDouble();
b = sc.nextDouble();
c = sc.nextDouble();
Triangle t1 = new Triangle(a, b, c);
//输出面积
System.out.printf("三角形(%.1f,%.1f,%.1f)的面积为:%.2f\n",t1.a,t1.b,t1.c,t1.getArea());
//输出周长
System.out.printf("三角形(%.1f,%.1f,%.1f)的周长为:%.2f",t1.a,t1.b,t1.c,t1.getPerimeter());
/********** End **********/
}
}
第二关： 编写一个圆环类
任务描述
本关任务：创建对象给对象定义有参构造方法和封装成员变量。
相关知识
构造方法
构造方法是类的一种特殊方法，用来初始化类的一个新的对象。构造方法的名称必须和类的名称相同，而且没有返回类型。构造方法的默认返回类型就是对象类型本身，并且构造方法不能被 static、final、synchronized、abstract 和 native 关键字修饰。
提示：构造方法用于初始化一个新对象，所以用 static 修饰没有意义；构造方法不能被子类继承，所以用 final 和 abstract 修饰没有意义；多个线程不会同时创建内存地址相同的同一个对象，所以用 synchronized 修饰没有必要。
构造方法只能在创建类对象时由系统隐含调用，而不能直接引用。类对象创建时，利用new运算符在内存中开辟专用空间，存放指定的类的实例（即对象），这时会自动执行类的构造方法，初始化新对象的成员变量。构造方法的语法格式如下：
class class_name
{
public class_name(){} //默认无参构造方法
public ciass_name([paramList]){} //有参构造方法
…
//类主体
}
不同的条件下使用不同的初始化行为创建类的对象，这时候就需要在一个类中创建多个构造方法。构造方法分为无参构造方法和有参构造方法。在一个类中定义多个具有不同参数的同名方法，这就是 Java 的重载。
类的构造方法不是要求必须定义的。如果在类中没有定义任何一个构造方法，则 Java 会自动为该类生成一个默认的构造方法。默认的构造方法不包含任何参数，并且方法体为空。如果类中显式地定义了一个或多个构造方法，则 Java 不再提供默认构造方法。
【例1】创建一个Person类，用无参构造方法和有参构造方法初始化类成员变量。
/* 文件名 : Person.java */
public class Person {
public String name;
public int age;
//无参构造方法
public Person() {
this.name = "Jerry";
this.age = 18;
}
//有参构造方法
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public void info() {
System.out.println("你的名字是 : " + name + ", 年龄是： " + age);
}
public static void main(String[] args) {
Person p1 = new Person(); // 调用无参构造方法
Person p2 = new Person("tom", 20); // 调用有参构造方法
p1.info();
p2.info();
}
}
运行结果：
你的名字是 : Jerry, 年龄是： 18
你的名字是 : tom, 年龄是： 20
对象的 this 引用
Java提供了this关键字，它是一个特殊的对象引用，泛指对this所在类的对象自身的引用。this关键字出现在类的构造方法中时，代表使用该构造方法所创建的对象。当this关键字出现在类的实例方法中时，代表正在调用该方法的当前对象。
当类中定义方法的参数或者方法的局部变量与类的成员变量同名时，类的成员变量作用域将被局部变量所覆盖，此时要访问类的成员变量则需要使用this.成员变量的方式。
在例1的有参构造方法中，由于形参和成员变量的名字相同，则必须使用this来明确类的成员变量的引用，避免产生指代不明确的问题。例如：
public Person(String name, int age) {
this.name = name;
this.age = age;
}
this关键字的另外一个作用是让类中的一个方法，访问该类里的另一个方法或实例变量。例如，在下面代码中，Person类定义了两个成员方法run()和jump()，在执行run()的同时可以执行jump()的操作，这时可以通过this代表正在调用该方法的当前对象。
public class Person {
public void run() {
this.jump();
System.out.println("正在执行run方法");
}
public void jump() {
System.out.println("正在执行jump方法");
}
public static void main(String[] args) {
Person p = new Person();
p.run();
}
}
在现实世界里，对象的一个方法依赖于另一个方法的情形很常见，这种依赖都是同一个对象两个方法之间的依赖。这时，也可以省略this前缀。例如，将上面的run()方法改为如下形式也完全正确。
public void run() {
jump();
System.out.println("正在执行run方法");
}
当一个构造方法调用本类中的另一个构造方法时，也要使用关键字this，同时这个调用语句应该是整个构造方法的第一条可执行语句。在一个构造方法中，当使用this并给它一个参数列表时，this显示调用参数匹配的另一个构造方法。
set和get方法
在前面的讲解中，我们将类的成员变量声明为public(公有)类型，在类的内部和外部都可以访问这些成员变量，程序运行没有任何问题，但是这样做会导致数据的不安全性。
为了避免上述问题，我们通常将类的成员变量声明为private(私有)类型，只有本类才能访问，在类的外部无法访问，防止该类的代码和数据被外部类任意访问，对信息进行了隐藏，提高了数据的安全性。例如：
public class Person {
private String name;
private int age;
private boolean married;
}
同时，我们应该对外提供能够访问(读写)成员变量的方法，以根据需要修改成员变量的值。这些方法通常用get成员变量名称(), 用于读取成员变量的值; set成员变量名称(), 用于写入/设置成员变量的值。get和set后的成员变量名称首字母应大写。这种命名方式的方法, 分别称为get/set方法。
【例2】get/set方法的应用。
/* 文件名 : Person.java */
public class Person {
private String name;
private int age;
private boolean married;
public int getAge() {
return age;
}
public String getName() {
return name;
}
public void setAge(int age) {
this.age = age;
}
public void setName(String name) {
this.name = name;
}
public boolean isMarried() {
return married;
}
public void setMarried(boolean married) {
this.married = married;
}
}
/ 文件名 : TestPerson.java /
public class TestPerson {
public static void main(String args[]){
Person p = new Person();
p.setName("James");
p.setAge(20);
p.setMarried(true);
System.out.print("Name : " + p.getName() +
" Age : "+ p.getAge() +
" Married: " + p.isMarried());
}
}
运行结果：
Name : James Age : 20 Married: true
在上面代码中，对于boolean类型的成员变量，其get方法为is成员变量名称()，用于读取成员变量的值。在set方法中，采用 this 关键字是为了解决成员变量和局部变量之间发生的同名的冲突问题。
编程要求
根据提示，在右侧编辑器Begin-End处补充代码:
编写一个圆环类（Ring.java）。圆环类有3个数据成员，分别是内半径innerRadius，外半径outerRadius和颜色color，这些属性通过get和set方法进行封装，该类封装有求圆环面积、外圆周长和内圆周长的方法。
① 通过构造方法传递内半径5，外半径8，颜色为red，输出测试结果；
② 将内半径改为4，外半径改为6，颜色改为blue后，再次输出测试结果。
③ 所有输出结果要求保留2位小数。
测试说明
测试输入：
无
预期输出：
圆环的内半径: 5.0
圆环的外半径: 8.0
圆环的颜色: red
圆环的面积: 122.52
圆环的外圆周长: 50.27
圆环的内圆周长: 31.42
圆环的内半径: 4.0
圆环的外半径: 6.0
圆环的颜色: blue
圆环的面积: 62.83
圆环的外圆周长: 37.70
圆环的内圆周长: 25.13
开始你的任务吧，祝你成功！
代码如下：
package step2;
import java.lang.Math;
public class Ring {
/********** Begin **********/
//自行设计类的实现
double innerRadius,outerRadius;
String color;
public Ring(double innerRadius, double outerRadius, String color) {
this.innerRadius = innerRadius;
this.outerRadius = outerRadius;
this.color = color;
}
public double getArea() {
return Math.PI * (outerRadius * outerRadius - innerRadius * innerRadius);
}
public double getInnerPerimeter() {
return 2 * Math.PI * innerRadius;
}
public double getOuterPerimeter() {
return 2 * Math.PI * outerRadius;
}
public void setInnerRadius(double innerRadius){
this.innerRadius = innerRadius;
}
public void setOuterRadius(double outerRadius){
this.outerRadius = outerRadius;
}
public void setColor(String color){
this.color = color;
}
/********** End **********/
public static void main(String[] args) {
Ring ring = new Ring(5, 8, "red");
System.out.printf("圆环的内半径: %.1f\n",ring.innerRadius);
System.out.printf("圆环的外半径: %.1f\n",ring.outerRadius);
System.out.println("圆环的颜色: "+ring.color);
System.out.printf("圆环的面积: %.2f\n",ring.getArea());
System.out.printf("圆环的外圆周长: %.2f\n",ring.getOuterPerimeter());
System.out.printf("圆环的内圆周长: %.2f\n",ring.getInnerPerimeter());
System.out.println();
ring.setInnerRadius(4);
ring.setOuterRadius(6);
ring.setColor("blue");
System.out.printf("圆环的内半径: %.1f\n",ring.innerRadius);
System.out.printf("圆环的外半径: %.1f\n",ring.outerRadius);
System.out.println("圆环的颜色: "+ring.color);
System.out.printf("圆环的面积: %.2f\n",ring.getArea());
System.out.printf("圆环的外圆周长: %.2f\n",ring.getOuterPerimeter());
System.out.printf("圆环的内圆周长: %.2f",ring.getInnerPerimeter());
}
}
第三关：编写一个学生类
任务描述
本关任务：对象数组的使用。
编程要求
根据提示，在右侧编辑器Begin-End处补充代码:
编写一个学生类（Student.java），包含的属性有学号、姓名、年龄。将所有学生存储在一个数组中，自拟数据，用数组的初始化方法给数组赋值，并实现如下操作：
① 按数组中顺序显示所有学生信息。
② 将所有学生年龄增加1岁。
③ 显示所有年龄大于20岁的学生信息。
测试说明
测试输入：
无
预期输出：
班级学生名单如下：
学号:1,姓名:小明,年龄:18
学号:2,姓名:小张,年龄:20
学号:3,姓名:小李,年龄:19
学号:4,姓名:小王,年龄:18
学号:5,姓名:小赵,年龄:20
所有学生年龄加 1 后…
学号:1,姓名:小明,年龄:19
学号:2,姓名:小张,年龄:21
学号:3,姓名:小李,年龄:20
学号:4,姓名:小王,年龄:19
学号:5,姓名:小赵,年龄:21
大于 20 岁人数是：2
开始你的任务吧，祝你成功！
代码如下：
package step3;
public class Student {
int id;
int age;
String name;
public Student(int id, int age, String name) {
this.id = id;
this.age = age;
this.name = name;
}
public void increaseAge() {
this.age += 1;
}
public static void main(String[] args) {
// 创建并初始化学生数组
Student s1 = new Student(1, 18, "小明");
Student s2 = new Student(2, 20, "小张");
Student s3 = new Student(3, 19, "小李");
Student s4 = new Student(4, 18, "小王");
Student s5 = new Student(5, 20, "小赵");
Student s[] = { s1, s2, s3, s4, s5 }; // 给对象数组赋值
System.out.println("班级学生名单如下：");
// 显示所有学生信息
for (Student student : s) {
System.out.println("学号:" + student.id + ",姓名:" + student.name + ",年龄:" + student.age);
}
// 将所有学生年龄增加1岁
System.out.println("所有学生年龄加 1 后...");
for (Student student : s) {
student.increaseAge();
}
for (Student student : s) {
System.out.println("学号:" + student.id + ",姓名:" + student.name + ",年龄:" + student.age);
}
// 显示所有年龄大于20岁的学生信息
int number = 0;
for (Student student : s) {
if (student.age > 20) {
number++;
}
}
System.out.println("大于 20 岁人数是：" + number);
}
}
