头歌 实验二 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);}
}