一、类的声明之学生类的定义
定义一个 Student 学生公开类，该类具有学号 id(int)，年龄 age(int)，grade(int) 等属性；它们所具有的行为有学习 study()，考试 examination()，讲话 tell()，它们都无返回值和传入的参数。
study 方法的功能为换行输出：学号为xx的学生正在学习。；
examination 方法的功能为换行输出：xx年级正在考试。；
tell 方法的功能为不换行输出：正在讲话的是一个xx岁的学生。
/**
* 任务：定义一个 Student 学生公开类，该类具有学号 id(int)，年龄 age(int)，grade(int) 等属性；
* 它们所具有的行为有学习 study()，考试 examination()，讲话 tell()，它们都无返回值和传入的参数。
* 类名为：Student
*/
//第一步：创建一个名为 Student 的公开类
public class Student {
// 第二步：定义学生的属性
int id;
int age;
int grade;
public Student(int id, int age, int grade) {
this.id = id;
this.age = age;
this.grade = grade;
}
public Student() {
}
// 第三步：定义学生的行为方法
public void study() {
System.out.println("学号为"+id+"的学生正在学习。");
}
public void examination() {
System.out.println(grade+"年级正在考试。");
}
public void tell() {
System.out.println("正在讲话的是一个"+age+"岁的学生。");
}
public static void main(String[] args) {
Student s = new Student(20110624,18,12);
s.study();
s.examination();
s.tell();
}
}
二、类的声明之复数运算
任务：求两个复数相加后的结果。
两个复数之间相加的运算法则：实部与实部相加，虚部与虚部相加。
/**
* 任务：求两个复数相加后的结果。
*/
//定义一个圆类，类名为 Complex
public class Complex {
// 定义四个变量：real1、image1、real2、image2 分别表示第一个虚数的实部与虚部和第二个虚数的实部与虚部，类型为int
int real1,image1,real2,image2;
public Complex(int real1, int image1, int real2, int image2) {
this.real1 = real1;
this.image1 = image1;
this.real2 = real2;
this.image2 = image2;
}
public Complex() {
}
// 定义一个成员方法，方法名为add，不带参数，实现两个复数相加，将实部结果与虚部结果用+拼接后返回，返回类型为String，
public String add() {
int real = real1 + real2;
int image = image1 + image2;
// 相加后结果如果有虚部，将计算结果的虚部后加上i
// 如果没有虚部，只返回实部即可。
// 如果没有实部，只返回虚部，将计算结果的虚部后加上i
// 如果都没有值，返回零。
if(real == 0 && image == 0) {
return "0";
}
else if(real == 0) {
return (String)(image+"i");
}
else if(image == 0) {
return (String) (real+"");
}
else {
return (String)(real+"+"+image+"i");
}
}
@Override
public String toString() {
return real1+"+"+image1+"i+"+real2+"+"+image2+"i+"+"的结果为："+add();
}
public static void main(String[] args) {
Complex c1 = new Complex(10,5,18,32);
System.out.println(c1.toString());
Complex c2 = new Complex(10,7,-10,6);
System.out.println(c2.toString());
Complex c3 = new Complex(125,-8,1,8);
System.out.println(c3.toString());
Complex c4 = new Complex(21,6,-21,-6);
System.out.println(c4.toString());
}
}三、构造方法与对象创建之求椭圆面积
任务：已知椭圆的短半轴长为 15.50，长半轴的长为 20.00，计算椭圆面积。
椭圆的面积公式为S=πab，其中a、b分别为椭圆的短半轴长和长半轴长。
/**
* 任务：已知椭圆的短半轴长为20.00，长半轴的长为15.50，计算椭圆面积。
* 类名为：EllipseArea
*/
//创建一个名为 EllipseArea 的公开类
public class EllipseArea {
// 定义椭圆的两个属性 ：短半轴长b和长半轴长a
double a,b;
// 定义一个显示有参构造方法，携带两个参数，分别表示为传来的短半轴的值和长半轴传来的值
public EllipseArea(double a, double b) {
this.a = a;
this.b = b;
}
// 该方法实现将短半轴长和长半轴长分别初始化为携带的两个参数的值。
// 定义一个方法，该方法实现计算椭圆的面积，并将其返回，返回值类型为double
public double area(){
return Math.PI*a*b;
}
// 定义主方法
public static void main(String[] args) {
// 在主方法中通过有参构造方法实例化一个对象，将椭圆的短半轴的值和长半轴的值传入其中
EllipseArea e = new EllipseArea(15.50,20.00);
// 调用计算椭圆的面积的方法，计算该椭圆的面积
double s = e.area();
// 将计算后的结果四舍五入保留两位小数后输出，输出格式为：椭圆形的面积为xx
System.out.printf("椭圆形的面积为%.2f\n",s);
}
}
四、构造方法与对象创建之计算数学中的分数值
任务：跟据键盘输入的分子和分母求出该分数的值。其中第一次输入的值为分子的值，第二次输入的值为分母的值，两次的值均为 int 型。
import java.util.Scanner;
/**
* 任务：跟据键盘输入的分子和分母求出该分数的值。其中第一次输入的值为分子的值，第二次输入的值为分母的值，两次的值均为 int 型。
* 类名为：Fraction
*/
//创建一个名为 Fraction 的公开类
public class Fraction {
// 定义分数的两个属性 ：分子和分母
double a,b;
public Fraction(double a, double b) {
this.a = a;
this.b = b;
}
public Fraction() {
}
/**
* 定义一个方法，该方法实现计算该分数的值，携带两个参数，分别为传来的分子和分母的值
* 如果分母为0，不换行输出：分母不能为0
* 如果分母不为0，将该分数的值四舍五入保留两位小数后输出
* 输出格式为：该分数的值为xx
*/
public void result() {
if(b == 0) {
System.out.printf("分母不能为0");
}
else {
System.out.printf("该分数的值为%.2f",a/b);
}
}
// 定义主方法
public static void main(String[] args) {
// 获取键盘传来的分子和分母的值
double a,b;
Scanner input = new Scanner(System.in);
a = input.nextDouble();
b = input.nextDouble();
Fraction s =new Fraction(a,b);
// 调用计算分数值的方法，将获取到的分子和分母分别传入该方法中
s.result();
}
}
五、构造方法与对象创建之比较大小
任务：比较键盘输入的两个 double 型的数值的大小，输出较大的值。
import java.util.Scanner;
/**
* 任务：比较键盘输入的两个 double 型的数值的大小，输出较大的值。
* 类名为：Compare
*/
//创建一个名为 Compare 的公开类
public class Compare {
// 分别定义两个数
double a,b;
public Compare(double a, double b) {
this.a = a;
this.b = b;
}
/**
* 定义一个方法，该方法实现比较两数大小，携带两个参数，分别为传来的两个数的值
* 将两个数中较大的那个数返回，返回类型为double
*/
public double max() {
return Math.max(a, b);
}
// 定义主方法
public static void main(String[] args) {
// 获取键盘传来的两个数
Scanner input = new Scanner(System.in);
double a = input.nextDouble();
double b = input.nextDouble();
// 在主方法中通过无参构造方法定义一个对象
Compare max = new Compare(a,b);
// 调用比较大小的方法，获得较大的那个数
// 不换行输出较大的那个数
System.out.print(max.max());
}
}
六、static关键字之求圆环面积和周长
任务：已知圆环的大圆半径 R 和 小圆半径 r 的长度分别为 32.0 和 10.0，求该圆环的面积和周长。
圆环面积公式为：S=π(R2−r2)；
圆环周长公式为：C=2π(R+r)。
/**
* 任务：已知圆环的大圆半径 R 和 小圆半径 r 的长度分别为 32.0 和 10.0，求该圆环的面积和周长。
* 类名为：RingArea
*/
public class RingArea {
// 定义三个量，两个变量分别为大圆半径和小圆半径，常量表示π，它的值可以调用 Math.PI获取，并将其设为静态常量。
static double R,r;
static double pi = Math.PI;
// 定义一个无参构造方法，将小圆半径设为 10.0，大圆半径设为32.0
public RingArea() {
this.R = 32.0;
this.r = 10.0;
}
/**
* 定义一个静态方法，该方法实现计算圆环的周长，携带两个参数，分别为传来的小圆半径和大圆半径的值。
* 将圆环周长的计算结果返回，返回类型为double
*/
public static double l() {
return 2*pi*(R + r);
}
/**
* 定义一个静态方法，该方法实现计算圆环的面积，携带两个参数，分别为传来的小圆半径和大圆半径的值。
* 将圆环面积的计算结果返回，返回类型为double
*/
public static double s() {
return pi*(R * R - r * r);
}
// 定义主方法\
public static void main(String[] args) {
// 在主方法中通过定义的无参构造方法定义一个对象
// 通过类名.方法名的方式调用计算圆环周长的方法，获取圆环周长，分别将该对象的小圆半径的值和大圆半径的值传入该方法中
// 通过类名.方法名的方式调用计算圆环面积的方法，获取圆环面积，分别将该对象的小圆半径的值和大圆半径的值传入该方法中
// 不换行四舍五入保留两位小数后格式化输出求出的值，输出格式：该圆环的周长为xx，面积为xx
RingArea a =new RingArea();
System.out.printf("该圆环的周长为%.2f，面积为%.2f",RingArea.l(),RingArea.s());
}
}
七、static关键字之检验三边是否构成三角形
任务：根据键盘输入的三个 double 型的数字判断其是否能构成三角形。
import java.util.Scanner;
/**
* 任务：根据键盘输入的三个 double 型的数字判断其是否能构成三角形。
* 类名为：Triangle
*/
public class Triangle {
/**
* 定义一个静态方法，该方法检验三边是否能构成三角形，携带三个参数，分别为传来的三个参数，无返回值
* 如果能构成，不换行输出：这三条边可以构成三角形
* 如果不能，不换行输出：这三条边不能构成三角形
*/
public static void check(double a,double b,double c) {
if(a+b>c && a+c>b && b+c>a) {
System.out.print("这三条边可以构成三角形");
}
else {
System.out.print("这三条边不能构成三角形");
}
}
// 定义主方法
public static void main(String[] args) {
// 获取键盘输入的三个数
Scanner input =new Scanner(System.in);
double a = input.nextDouble();
double b = input.nextDouble();
double c = input.nextDouble();
// 通过类名.方法名的方式调用检验三边是否能构成三角形的方法，分别将键盘输入的三个数传入该方法中
Triangle.check(a, b, c);
}
}
八、参数传值机制之求球面积
任务：已知一个球的半径为 12.0，求该球的表面积。
球的表面积计算公式：S=4πR2,R为球的半径。
/**
* 任务：已知一个球的半径为 12.0，求该球的表面积。
* 类名为：Sphere
*/
public class Sphere {
// 定义圆的半径和π，π为 Math中的π
double r;
final double pi = Math.PI;
// 无参构造
public Sphere() {
}
// 有参构造
public Sphere(double r) {
this.r = r;
}
/**
* 定义一个方法，该方法实现计算球的表面积，返回值为double，携带一个参数，为球的半径
*/
public double s(double r) {
return 4*pi*r*r;
}
// 定义主方法
public static void main(String[] args) {
// 通过无参构造创建球对象
Sphere a = new Sphere();
// 调用计算球面积的方法，将半径 r 的值传入
// 四舍五入格式化不换行输出球的面积，输出格式：球的表面积为xx
System.out.printf("球的表面积为%.2f",a.s(12.0));
}
}
九、可变参数
任务：编写程序输出考试学生的人数及姓名。
/**
* 定义输出考试学生的人数及姓名的方法，方法名为 print，传参的类型为String，无返回值。
*/
public class Student {
public static void print(String... names) {
System.out.println("本次参加考试的有"+names.length+"人，名单如下：");
for(String name:names) {
System.out.println(name);
}
}
public static void main(String[] args) {
print("张强","李成","王勇");
print("马丽","陈玲");
}
}十、可变参数
任务：定义一个名为 add 的静态方法，返回值为 int，参数数量可变，且为 int，将这些参数相加后返回。
/**
* 定义一个名为 add 的静态方法，返回值为 int，参数数量可变，且为 int，将这些参数相加后返回。
*/
public class Add {
public static int add(int... numbers) {
int sum = 0;
for (int number : numbers) {
sum += number;
}
return sum;
}
public static void main(String[] args) {
System.out.println("add(25,36)的值为："+ Add.add(25,36));
System.out.println("add(58,96,754)的值为："+Add.add(58,96,754));
}
}十一、参数传值机制之求球体积
任务：已知球的半径为 12.0，求球的体积。
球的体积公式：S=34πR3，其中，R为球的半径。
/**
* 任务：已知一个球的半径为 12.0，求该球的体积。
* 类名为：Sphere
*/
public class Sphere {
// 定义圆的半径和π，π为 Math中的π
private double r;
private static final double pi = Math.PI;
// 无参构造
public Sphere() {
this.r = 12.0;
}
// 有参构造
public Sphere(double r) {
this.r = r;
}
/**
* 定义一个方法，该方法实现计算球的体积，返回值为double，携带一个参数，为球的半径
*/
public double v() {
return 4*pi*r*r*r/3;
}
// 定义主方法
public static void main(String[] args) {
// 通过无参构造创建球对象
Sphere a = new Sphere();
// 调用计算球体积的方法，将半径 r 的值传入
// 四舍五入格式化不换行输出球的体积，输出格式：球的体积为xx
System.out.printf("球的体积为%.2f",a.v());
}
}十二、对象组合之求圆柱体积
任务：已知圆柱的底面半径为 20，高为 50，求该圆柱的体积。 圆柱的体积公式：S=πr2h。
/**
* 任务：已知圆柱的底面半径为 20，高为 50，求该圆柱的体积。
*/
public class Cylinder{
// 定义一个圆类，类名为 Circle
public static class Circle{
// 定义两个量，分别为半径和π值
private double r;
private static final double pi = Math.PI;
// 有参构造器
public Circle(double r) {
this.r = r;
}
public Circle() {
}
// 定义一个方法，实现求圆面积，将圆面积返回，返回类型为double
public double s() {
return pi*r*r;
}
}
// 定义一个公开的圆柱类 Cylinder
public static class Cylinders{
// 定义圆柱中的高
private double h;
// 引用圆类
Circle a = new Circle();
// 有参构造
public Cylinders(double h, Circle a) {
this.h = h;
this.a = a;
}
/**
* 定义一个方法，该方法实现计算圆柱的体积，返回值为double
*/
public double v() {
return this.a.s()*this.h;
}
}
// 定义主方法
public static void main(String[] args) {
// 通过有参构造创建圆对象，将底面半径设置为 20
Circle a = new Circle(20);
// 通过有参构造创建圆柱对象，将圆柱的高设置为 50，将圆对象传入
Cylinders b = new Cylinders(50,a);
// 调用计算圆柱积的方法
// 四舍五入格式化不换行输出圆柱的体积，输出格式：圆柱的体积为xx
System.out.printf("圆柱的体积为%.2f",b.v());
}
}
//圆柱的体积为62831.85
十三、对象组合之求圆锥体表面积
任务：已知圆锥的母线长为 15，底面半径为 8，求圆锥的表面积。
圆锥的表面积公式为：πr2+πrl。
也就是底面积加上圆锥的侧面积。
/**
* 任务：已知圆锥的母线为 15，底面半径为 8，求圆锥的表面积。
*/
public class Cone {
// 定义一个圆类，类名为 Circle
public static class Circle {
// 定义两个量，分别为半径和π值
private double r;
private static final double pi = Math.PI;
// 有参构造器
public Circle(double r) {
this.r = r;
}
// 定义一个方法，实现求圆面积，将圆面积返回，返回类型为double
public double s1() {
return pi * r * r;
}
}
// 定义一个扇形类，类名为 Sector
public static class Sector {
private double r, l;
private static final double pi = Math.PI;
// 有参构造器
public Sector(double r, double l) {
this.r = r;
this.l = l;
}
// 定义一个方法，实现求圆锥侧面积，将侧面积返回，返回类型为double，
public double s2() {
return pi * r * l;
}
}
// 定义一个公开的圆锥类 Cone
public static class Cones {
/**
* 定义一个方法，该方法实现计算圆锥的表面积，返回值为double
*/
private Circle a;
private Sector b;
public Cones(Circle a, Sector b) {
this.a = a;
this.b = b;
}
public double s3() {
return a.s1() + b.s2();
}
}
// 定义主方法
public static void main(String[] args) {
// 通过有参构造创建圆对象，将底面半径设置为 8
Circle a = new Circle(8);
// 通过有参构造创建扇形对象，将扇形所需的半径和母线传入
Sector b = new Sector(8,15);
// 通过有参构造创建圆锥对象，将圆对象和矩形对象传入
Cones c = new Cones(a,b);
// 调用计算圆锥表面积的方法
// 四舍五入格式化不换行输出圆锥表面积，输出格式：圆锥的表面积为xx
System.out.printf("圆锥的表面积为%.2f",c.s3());
}
}十四、包的定义
任务：声明一个包，在另一个包中引用该包中的类。
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
/********** Begin **********/
// 声明一个名为 com.pojo 的包
package com.pojo;
public class Student {
public static String[] info() {
// 实现返回所有学生的功能，在该方法中定义一个 String 数组
String[] students = {"小明","小红","小强","小刚"};
// 返回该数组
return students;
}
}
/********** End **********/十五、包的定义
任务：定义一个电影类和一个电影测试类，在电影测试类中通过对象完成成员变量和成员方法的使用。
// 声明一个名为 com.model 的包
package com.model;
// 定义一个 Movie 的公开类
public class Movie{
// 该类具有电影名称、电影类别、电影时长、地区等属性（都是字符串类型、私有）
private String name;
private String sex;
private String hour;
private String space;
// 定义获取和设置电影属性的方法
public void setName(String name) {
this.name = name;
}
public void setSex(String sex) {
this.sex = sex;
}
public void setHour(String hour) {
this.hour = hour;
}
public void setSpace(String space) {
this.space = space;
}
// 定义获取电影信息的方法，无返回值
public void getMovieInfo() {
System.out.println("电影名称：" + name + "，电影类别：" + sex + "，电影时长：" + hour + "，地区：" + space + "。");
}
}
/********** End **********/// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
/********** Begin **********/
// 声明一个名为 com.test 的包
package com.test;
// 导入 Movie 类
import com.model.Movie;
// 导入 java.util.Scanner 类
import java.util.Scanner;
// 定义一个公开的 Test 类
public class Test{
// 定义主方法
public static void main(String[] args) {
// 实例化 Movie 对象
Scanner input = new Scanner(System.in);
Movie a = new Movie();
// 将键盘四次输入的电影信息赋值给 Movie 对象
a.setName(input.nextLine());
a.setSex(input.nextLine());
a.setHour(input.nextLine());
a.setSpace(input.nextLine());
// 调用获取 Movie 信息的方法
a.getMovieInfo();
}
}
/********** End **********/十六、this关键字
任务：编写一个商品结算的小程序。
/**
* 任务：编写一个商品结算的小程序
* 类名为：Shop
*/
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
/********** Begin **********/
public class Shop {
// 定义该商品的两个属性：价格（double）和数量（int）
private double price;
private int total;
// 将形参的值赋值给成员变量
public Shop(double price, int total) {
this.price = price;
this.total = total;
}
// 该方法实现计算价钱的功能，将计算结果返回，价钱 = 价格 * 数量
public double sum() {
return price*total;
}
public static void main(String[] args) {
Shop a = new Shop(230.4,1);
System.out.printf("总共花费%.2f元",a.sum());
}
}
/********** End **********/十七、this关键字
任务：定义一个完整的学生类，该类定义了学生的基本信息。
/**
* 任务：定义一个完整的学生类，该类定义了学生的基本信息。
* 类名为：Student
*/
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
/********** Begin **********/
// 创建一个名为 Student 的公开类
public class Student {
// 定义学生的两个属性：姓名（name String）和年龄（age int）
private String name;
private int age;
// 获取学生年龄
public int getAge() {
return age;
}
// 设置学生的年龄，将形参的值赋值给成员变量
public void setAge(int age) {
this.age = age;
}
// 获取学生姓名
public String getName() {
return name;
}
// 设置学生姓名，将形参的值赋值给成员变量
public void setName(String name) {
this.name = name;
}
// 该方法实现输出学生信息的功能。 输出格式：学生姓名：xx，年龄：xx
public void info() {
System.out.println("学生姓名："+name+"，年龄："+age);
}
public static void main(String[] args) {
Student a = new Student();
a.setName("张三");
a.setAge(22);
a.info();
}
}
/********** End **********/十八、访问限制
任务：实现一个电影类。
/**
* 任务：实现一个电影类
* 类名为：Movie
*/
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
/********** Begin **********/
public class Movie {
// 定义6个变量
// 电影id（id int） 电影名称（movieName String） 电影类型（movieType String）
// 电影评分（double score） 电影时长（totalTime int） 电影简介（content String）
private int id;
private String movieName;
private String movieType;
private double score;
private int totalTime;
private String content;
// 定义设置和获取6个变量值的方法
// 定义6个变量
// 定义设置和获取6个变量值的方法
public void setId(int id) {
this.id = id;
}
public int getId() {
return id;
}
public void setMovieName(String movieName) {
this.movieName = movieName;
}
public String getMovieName() {
return movieName;
}
public void setMovieType(String movieType) {
this.movieType = movieType;
}
public String getMovieType() {
return movieType;
}
public void setScore(double score) {
this.score = score;
}
public double getScore() {
return score;
}
public void setTotalTime(int totalTime) {
this.totalTime = totalTime;
}
public int getTotalTime() {
return totalTime;
}
public void setContent(String content) {
this.content = content;
}
public String getContent() {
return content;
}
@Override
public String toString() {
return "电影id：" + id + "\n电影名称：" + movieName + "\n电影类型：" + movieType + "\n电影评分：" + score
+ "\n电影时长：" + totalTime + "\n电影简介：" + content ;
}
public static void main(String[] args) {
Movie a = new Movie();
a.setId(1);
a.setMovieName("流浪地球");
a.setMovieType("科幻");
a.setScore(7.90);
a.setTotalTime(125);
a.setContent("近未来，科学家们发现太阳急速衰老膨胀，短时间内包括地球在内...");
System.out.println(a.toString());
}
}
/********** End **********/十九、对象数组
任务：定义一个 Dog 类，使用对象数组的方式创建 3 个 Dog 对象。
/**
* 任务：使用对象数组的方式创建 3 个 Dog 对象
* 类名为：Dog
* 该类为 Dog 的基本属性
*/
public class Dog {
private String name; // 小狗名称
private String type; // 小狗品种
private int age; // 小狗年龄
private String hobby; //小狗爱好
public Dog(){
}
public Dog(String name, String type, int age, String hobby) {
this.name = name;
this.type = type;
this.age = age;
this.hobby = hobby;
}
// 获取Dog姓名
public String getName() {
return name;
}
// 设置Dog姓名
public void setName(String name) {
this.name = name;
}
// 获取Dog种类
public String getType() {
return type;
}
// 设置Dog种类
public void setType(String type) {
this.type = type;
}
// 获取Dog年龄
public int getAge() {
return age;
}
// 设置Dog年龄
public void setAge(int age) {
this.age = age;
}
// 获取爱好
public String getHobby() {
return hobby;
}
// 设置爱好
public void setHobby(String hobby) {
this.hobby = hobby;
}
// Dog的详细信息
public void info(){
System.out.printf("小狗名称：%s\n品种：%s\n小狗年龄：%d\n小狗爱好：%s\n",name,type,age,hobby);
}
public static void main(String[] args) {
Dog d1 = new Dog("Tom", "哈士奇",2,"拆家");
Dog d2 = new Dog("jerry", "中华田园犬",3,"护家");
Dog d3 = new Dog("旺财","柯基",2,"吃喝玩");
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
/********** Begin **********/
// 将三个狗的对象放进对象数组中，并依次调用该对象的info方法
d1.info();
d2.info();
d3.info();
/********** End **********/
}
}
二十、对象数组
任务：将键盘输入的三个学生的信息存入 Student 对象中，最后将这些学生信息按右侧预期输出格式打印输出。
/**
* 任务：将键盘输入的三个学生的信息存入 Student 对象中，最后将这些学生信息按预期输出格式打印输出。
* 类名为：Student
*/
import java.util.Scanner;
public class Student {
private String name; // 学生的姓名
private String num; // 学生的学号信息
private double grades; // 学生的成绩
// 有参构造方法
public Student(String name, String num, double grades) {
this.name = name;
this.num = num;
this.grades = grades;
}
// 获取和设置学生的属性信息
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getNum() {
return num;
}
public void setNum(String num) {
this.num = num;
}
public double getGrades() {
return grades;
}
public void setGrades(double grades) {
this.grades = grades;
}
public static void main(String[] args) {
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
/********** Begin **********/
// 创建可以存放三个对象的对象数组
Student[] students = new Student[3];
// 获取键盘输入的学生信息，将数组中的对象进行实例化
Scanner input = new Scanner(System.in);
for(int i = 0;i < students.length;i++) {
String[] s = input.nextLine().split(",");
String name = s[0];
String num = s[1];
double grades = Double.parseDouble(s[2]);
students[i] = new Student(name, num, grades);
}
// 打印输出每个学生的信息
for (Student student : students) {
System.out.println("姓名：" + student.getName() + "\t学号："
+ student.getNum() + "\t成绩：" + student.getGrades());
/********** End **********/
}
}
}二十一、访问限制
任务：实现图书类，该类包含了图书的基本属性和信息。
/**
* 任务：实现图书类，该类包含了图书的基本属性和信息。
* 类名为：Book
*/
// 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
/********** Begin **********/
public class Book {
// 定义四个私有变量
private String bookName; // 图书名称
private double price; // 图书单价
private int total; // 图书库存
private int bookId; // 图书id
// 获取图书名称
public String getBookName() {
return bookName;
}
// 设置图书名称
public void setBookName(String bookName) {
this.bookName = bookName;
}
// 获取图书单价
public double getPrice() {
return price;
}
// 设置图书单价
public void setPrice(double price) {
this.price = price;
}
// 获取图书库存
public int getTotal() {
return total;
}
// 设置图书库存
public void setTotal(int total) {
this.total = total;
}
// 获取图书id
public int getBookId() {
return bookId;
}
// 设置图书id
public void setBookId(int bookId) {
this.bookId = bookId;
}
// public Book( int bookId,String bookName, double price, int total) {
// this.bookName = bookName;
// this.price = price;
// this.total = total;
// this.bookId = bookId;
// }
// public void print() {
// System.out.println("图书编号：" + bookId + "\n图书名称：" + bookName + "\n图书单价：" + price + "\n图书库存：" + total );
// }
public static void main(String[] args) {
Book a = new Book();
a.setBookId(1);
a.setBookName("射雕侠侣");
a.setPrice(32);
a.setTotal(35941);
System.out.println("图书编号："+a.getBookId());
System.out.println("图书名称："+a.getBookName());
System.out.printf("图书单价：%.2f\n",a.getPrice());
System.out.println("图书库存："+a.getTotal());
}
}
/********** End **********/
3597
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
