7-1 图形卡片排序游戏
输入格式:
首先，在一行上输入一串数字（1~4，整数），其中，1代表圆形卡片，2代表矩形卡片，3代表三角形卡片，4代表梯形卡片。各数字之间以一个或多个空格分隔，以“0”结束。例如：
1 3 4 2 1 3 4 2 1 3 0
然后根据第一行数字所代表的卡片图形类型，依次输入各图形的相关参数，例如：圆形卡片需要输入圆的半径，矩形卡片需要输入矩形的宽和长，三角形卡片需要输入三角形的三条边长，梯形需要输入梯形的上底、下底以及高。各数据之间用一个或多个空格分隔。
输出格式:
如果图形数量非法（小于0）或图形属性值非法（数值小于0以及三角形三边不能组成三角形），则输出Wrong Format。
如果输入合法，则正常输出，所有数值计算后均保留小数点后两位即可。输出内容如下：
排序前的各图形类型及面积，格式为图形名称1:面积值1图形名称2:面积值2 …图形名称n:面积值n ，注意，各图形输出之间用空格分开，且输出最后存在一个用于分隔的空格；
排序后的各图形类型及面积，格式同排序前的输出；
所有图形的面积总和，格式为Sum of area:总面积值。
输入样例1:
在这里给出一组输入。例如：
1 5 3 2 0
输出样例1:
在这里给出相应的输出。例如：
Wrong Format
输入样例2:
在这里给出一组输入。例如：
4 2 1 3 0
3.2 2.5 0.4 2.3 1.4 5.6 2.3 4.2 3.5
输出样例2:
在这里给出相应的输出。例如：
The original list:
Trapezoid:1.14 Rectangle:3.22 Circle:98.52 Triangle:4.02
The sorted list:
Circle:98.52 Triangle:4.02 Rectangle:3.22 Trapezoid:1.14
Sum of area:106.91
输入样例3:
在这里给出一组输入。例如：
4 2 1 3 0
3.2 2.5 0.4 2.3 1.4 5.6 2.3 4.2 8.4
输出样例3:
在这里给出相应的输出。例如：
Wrong Format
实力太菜，不会写，原文见：https://blog.csdn.net/qq_45028587/article/details/107419481
// https://blog.csdn.net/qq_45028587/article/details/107419481
import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;
public class Main {
//在Main类中定义一个静态Scanner对象，这样在其它类中如果想要使用该对象进行输入，则直接
//使用Main.input.next…即可（避免采坑）
public static Scanner sc = new Scanner(System.in);
public static void main(String[] args) {
ArrayList<Integer> list = new ArrayList<Integer>();
int num = sc.nextInt();
while (num != 0) {
if (num < 0 || num > 4) {
System.out.println("Wrong Format");
System.exit(0);
}
list.add(num);
num = sc.nextInt();
}
DealCardList dealCardList = new DealCardList(list);
if (!dealCardList.validate()) {
System.out.println("Wrong Format");
System.exit(0);
}
dealCardList.showResult();
sc.close();
}
}
class Card {
Shape shape;
Card() {
}
Card(Shape shape) {
this.shape = shape;
}
public Shape getShape() {
return shape;
}
public void setShape(Shape Shape) {
this.shape = shape;
}
}
class DealCardList {
ArrayList<Card> cardList = new ArrayList<Card>();
DealCardList() {
}
DealCardList(ArrayList<Integer> list) {
for (int i = 0; i < list.size(); i++) {
if (list.get(i) == 1) {
double r = Main.sc.nextDouble();
Circle circle = new Circle(r);
Card card = new Card(circle);
card.getShape().setShapeName("Circle");
cardList.add(card);
}
if (list.get(i) == 2) {
double a = Main.sc.nextDouble();
double b = Main.sc.nextDouble();
Rectangle rectangle = new Rectangle(a, b);
Card card = new Card(rectangle);
card.getShape().setShapeName("Rectangle");
cardList.add(card);
}
if (list.get(i) == 3) {
double a = Main.sc.nextDouble();
double b = Main.sc.nextDouble();
double c = Main.sc.nextDouble();
Triangle triangle = new Triangle(a, b, c);
Card card = new Card(triangle);
card.getShape().setShapeName("Triangle");
cardList.add(card);
}
if (list.get(i) == 4) {
double a = Main.sc.nextDouble();
double b = Main.sc.nextDouble();
double c = Main.sc.nextDouble();
Traperoid traperoid = new Traperoid(a, b, c);
Card card = new Card(traperoid);
card.getShape().setShapeName("Trapezoid");
cardList.add(card);
}
}
}
public boolean validate() {
for (int i = 0; i < cardList.size(); i++) {
if (!cardList.get(i).getShape().vaildate())
return false;
}
return true;
}
public void cardSort() {
for (int k = 0; k < cardList.size(); k++)
for (int i = k + 1; i < cardList.size(); i++) {
if (cardList.get(k).getShape().getArea() < cardList.get(i).getShape().getArea())
Collections.swap(cardList, k, i);
}
}
public double getAllArea() {
double s = 0;
for (int i = 0; i < cardList.size(); i++)
s = s + cardList.get(i).getShape().getArea();
return s;
}
public void showResult() {
System.out.println("The original list:");
for (int i = 0; i < cardList.size(); i++)
System.out.print(cardList.get(i).getShape().getShapeName() + ":" + String.format("%.2f", cardList.get(i).getShape().getArea()) + " ");
System.out.println();
System.out.println("The sorted list:");
cardSort();
for (int i = 0; i < cardList.size(); i++)
System.out.print(cardList.get(i).getShape().getShapeName() + ":" + String.format("%.2f", cardList.get(i).getShape().getArea()) + " ");
System.out.println();
System.out.println("Sum of area:" + String.format("%.2f", getAllArea()));
}
}
class Shape {
private String shapeName;
Shape() {
}
Shape(String shapeName) {
this.shapeName = shapeName;
}
public String getShapeName() {
return shapeName;
}
public void setShapeName(String shapeName) {
this.shapeName = shapeName;
}
public double getArea() {
return 0.0;
}
public boolean vaildate() {
return true;
}
}
class Circle extends Shape {
private double radius;
Circle() {
}
Circle(double radius) {
this.radius = radius;
}
public double getArea() {
return Math.PI * radius * radius;
}
public boolean vaildate() {
if (radius > 0)
return true;
else return false;
}
}
class Rectangle extends Shape {
private double width, length;
Rectangle(double width, double length) {
this.width = width;
this.length = length;
}
public double getArea() {
return width * length;
}
public boolean vaildate() {
if (width > 0 && length > 0)
return true;
else return false;
}
}
class Triangle extends Shape {
double side1, side2, side3;
Triangle(double side1, double side2, double side3) {
this.side1 = side1;
this.side2 = side2;
this.side3 = side3;
}
public double getArea() {
double c = (side1 + side2 + side3) / 2;
double s = Math.sqrt(c * (c - side1) * (c - side2) * (c - side3));
return s;
}
public boolean vaildate() {
if (side1 + side2 > side3 && side1 + side3 > side2 && side2 + side3 > side1)
return true;
else
return false;
}
}
class Traperoid extends Shape {
private double topSide, bottomSide, height;
Traperoid() {
}
Traperoid(double topSide, double bottomSide, double height) {
this.bottomSide = bottomSide;
this.height = height;
this.topSide = topSide;
}
public double getArea() {
return (topSide + bottomSide) * height / 2;
}
public boolean validate() {
if (topSide > 0 && bottomSide > 0 && height > 0)
return true;
else return false;
}
}
7-2 设计一个BankAccount类
设计一个BankAccount类，这个类包括：
（1）一个int型的balance表时账户余额。
（2）一个无参构造方法，将账户余额初始化为0。
（3）一个带一个参数的构造方法，将账户余额初始化为该输入的参数。
（4）一个getBlance（）方法，返回账户余额。
（5）一个withdraw（）方法：带一个amount参数，并从账户余额中提取amount指定的款额。
（6）一个deposit（）方法：带一个amount参数，并将amount指定的款额存储到该银行账户上。
设计一个Main类进行测试，分别输入账户余额、提取额度以及存款额度，并分别输出账户余额。
输入格式:
依次输入账户余额、提取额度、存款额度
输出格式:
依次输出初始账户余额、提取amount额度后的账户余额、存入amount后的账户余额
输入样例:
在这里给出一组输入。例如：
700
70
7
输出样例:
在这里给出相应的输出。例如：
700
630
637
这是AI自动生成的代码：
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
int balance = scanner.nextInt();
int amount = scanner.nextInt();
int deposit = scanner.nextInt();
BankAccount bankAccount = new BankAccount(balance);
System.out.println(bankAccount.getBalance());
bankAccount.withdraw(amount);
System.out.println(+ bankAccount.getBalance());
bankAccount.deposit(deposit);
System.out.println(bankAccount.getBalance());
}
}
class BankAccount {
private int balance;
public BankAccount() {
this.balance = 0;
}
public BankAccount(int balance) {
this.balance = balance;
}
public int getBalance() {
return balance;
}
public void withdraw(int amount) {
if (amount > balance) {
System.out.println("余额不足，提取失败");
} else {
balance -= amount;
}
}
public void deposit(int amount) {
balance += amount;
}
}
7-3 两点成线
都说两点确定一条直线，那么设计一个直线类Line，需要通过两个点Point对象来确定。Line类具体要求如下：
1)定义两个Point对象p1，p2；
2)写出有参构造方法，传递两个对象值给p1，p2
3）为p1，p2写出setters，和getters方法
4）为Line写出一个getLength方法求直线中两点的长度
- 为LIne写一个ToString方法，方法如下所示：
public String toString() {
return "Line [p1=" + p1 + ", p2=" + p2 + "]";
}
在Main类的main方法中，定义一个Line数组，数组长度通过键盘给出，然后通过键盘为每线段的两个Point对象的坐标赋值，并生成相应Line对象放入数组中，循环数组，输出每条直线的信息，以及两个点之间的距离。
Point 类如下所示：
public class Point {
private int x, y;// x,y为点的坐标
//求两点之间的距离
public double distance(Point p1) {
return Math.sqrt((p1.x -this.x)*(p1.x -this.x)+(p1.y-this.y)*(p1.y-this.y));
}
public Point(int x, int y) {
super();
this.x = x;
this.y = y;
}
public int getX() {
return x;
}
public void setX(int x) {
this.x = x;
}
public int getY() {
return y;
}
public void setY(int y) {
this.y = y;
}
public Point() {
super();
x = y =0;
}
@Override
public String toString() {
return "Point [x=" + x + ", y=" + y + "]";
}
}
输入格式:
第一行输入数组的长度n
每一行输入一个Line对象的两个点对象的 x y的坐标，中间用空格隔开
输出格式:
循环输出，输出直线的信息，以及每条直线的两个点的距离，保留一位小数。
输入样例:
在这里给出一组输入。例如：
2
0 0 2 3
1 3 2 5
输出样例:
在这里给出相应的输出。例如：
Line [p1=Point [x=0, y=0], p2=Point [x=2, y=3]]
此线段的长度为：3.6
Line [p1=Point [x=1, y=3], p2=Point [x=2, y=5]]
此线段的长度为：2.2
import java.util.ArrayList;
import java.util.Scanner;
public class Main {
public static void main(String[] args){
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
for(int i = 0; i < n; i++){
int x1 = sc.nextInt();
int y1 = sc.nextInt();
int x2 = sc.nextInt();
int y2 = sc.nextInt();
Point p1 = new Point(x1, y1);
Point p2 = new Point(x2, y2);
System.out.println("Line [p1="+p1+", p2="+p2+"]");
System.out.printf("此线段的长度为：%.1f\n",p2.distance(p1));
}
}
}
class Point {
private int x, y;// x,y为点的坐标
//求两点之间的距离
public double distance(Point p1) {
return Math.sqrt((p1.x - this.x) * (p1.x - this.x) + (p1.y - this.y) * (p1.y - this.y));
}
public Point(int x, int y) {
super();
this.x = x;
this.y = y;
}
public int getX() {
return x;
}
public void setX(int x) {
this.x = x;
}
public int getY() {
return y;
}
public void setY(int y) {
this.y = y;
}
public Point() {
super();
x = y = 0;
}
@Override
public String toString() {
return "Point [x=" + x + ", y=" + y + "]";
}
}
7-4 查询某人
有一个人员数组，要在此数组中查询某个人是否存在，具体要求如下：
1.定义Person类：
a 属性 name和age
b 两个属性的getters 和setters
c 带参数构造方法，为name和age给值 以及无参构造方法，给name赋值为none，age赋值为1
d ToString方法
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
2.在main方法中，创建Person数组，数组长度通过键盘输入，数组每一个对象的name和age通过键盘给出，创建数组后，首先显示所有人员的信息，然后输入一个姓名，查询数组中有这个人么？如果有，输出这个人的信息，否则输出not found
输入格式:
请在这里写输入格式。例如：输入在一行中给出2个绝对值不超过1000的整数A和B。
输出格式:
请在这里描述输出格式。例如：对每一组输入，在一行中输出A+B的值。
输入样例:
在这里给出一组输入。例如：
3
tian 3
jerry 23
sun 22
su
3
may 51
sunny 23
lily 32
lily
输出样例:
在这里给出相应的输出。例如：
Person [name=tian, age=3]
Person [name=jerry, age=23]
Person [name=sun, age=22]
not found
Person [name=may, age=51]
Person [name=sunny, age=23]
Person [name=lily, age=32]
查询结果：
Person [name=lily, age=32]
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
Person[] persons = new Person[n];
for (int i = 0; i < n; i++) {
String name = sc.next();
int age = sc.nextInt();
persons[i] = new Person(name, age);
}
// 显示所有人员的信息
for (Person person : persons) {
System.out.println(person);
}
String name = sc.next();
boolean flag = false;
for (int i = 0; i < n; i++) {
if (persons[i].getName().equals(name)) {
System.out.println("查询结果：\n"+persons[i].toString());
flag = true;
break;
}
}
if (!flag) {
System.out.println("not found");
}
}
}
class Person {
private String name;
private int age;
public Person() {
this.name = "";
this.age = 1;
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public void setAge(int age) {
this.age = age;
}
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}
7-5 jmu-Java-03面向对象基础-01-构造函数与toString
定义一个有关人的Person类，内含属性：
String name、int age、boolean gender、int id，所有的变量必须为私有(private)。
注意：属性顺序请严格按照上述顺序依次出现。
1.编写无参构造函数：
打印"This is constructor"。
将name,age,gender,id按照name,age,gender,id格式输出
2.编写有参构造函数
依次对name,age,gender赋值。
3.覆盖toString函数：
按照格式：类名 [name=, age=, gender=, id=]输出。建议使用Eclipse自动生成.
4.对每个属性生成setter/getter方法
5.main方法中
首先从屏幕读取n，代表要创建的对象个数。
然后输入n行name age gender , 调用上面2编写的有参构造函数新建对象。
然后将刚才创建的所有对象逆序输出。
接下来使用无参构造函数新建一个Person对象，并直接打印该对象。
输入样例:
3
a 11 false
b 12 true
c 10 false
输出样例:
Person [name=c, age=10, gender=false, id=0]
Person [name=b, age=12, gender=true, id=0]
Person [name=a, age=11, gender=false, id=0]
This is constructor
null,0,false,0
Person [name=null, age=0, gender=false, id=0]
import java.util.Scanner;
class Person {
private String name;
private int age;
private boolean gender;
private int id;
public Person() {
System.out.println("This is constructor");
System.out.println(this.name + "," + this.age + "," + this.gender + "," + this.id);
}
public Person(String name, int age, boolean gender) {
this.name = name;
this.age = age;
this.gender = gender;
}
public String toString() {
return this.getClass().getSimpleName() + " [name=" + this.name + ", age=" + this.age + ", gender=" + this.gender + ", id=" + this.id + "]";
}
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;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
}
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
Person[] pers = new Person[n];
for (int i = 0; i < n; i++) {
pers[i] = new Person(sc.next(), sc.nextInt(), sc.nextBoolean());
}
for (int i = n - 1; i >= 0; i--) {
System.out.println(pers[i]);
}
Person per = new Person();
System.out.println(per);
}
}
7-6 jmu-Java-03面向对象基础-02-构造函数与初始化块
1.定义一个Person类
属性：String name, boolean gender, int age, int id ,所有的变量必须为私有(private)。
无参构造函数:Person(), 功能：打印This is constructor 。
有参构造函数:Person(name, gender, age) ，功能：给属性赋值。
建议：使用Eclipse自动生成toString方法
2.定义类的初始化块
为Person类加入初始化块，在初始化块中对id属性赋值，并且要保证每次的值比上次创建的对象的值+1。然后在下一行打印This is initialization block, id is ... 其中...是id的值。
提示：可为Person类定义一个static属性来记录所创建的对象个数。
3.编写静态初始化块
打印This is static initialization block
4.编写main方法
首先输入n，代表要创建的对象数量。
然后从控制台分别读取n行的name, gender, age, 并调用有参构造函数Person(name, age, gender)新建对象 。
将创建好的n个对象逆序输出(即输出toString()方法)。
使用无参构造函数新建一个Person对象，然后直接打印该对象。
思考
初始化类与对象有几种方法，构造函数、初始化块、静态初始化块。这三种方法执行的先后顺序是什么？各执行几次。
输入样例:
3
a 11 false
b 12 true
c 10 false
输出样例:
This is static initialization block
This is initialization block, id is 0
This is initialization block, id is 1
This is initialization block, id is 2
Person [name=c, age=10, gender=false, id=2]
Person [name=b, age=12, gender=true, id=1]
Person [name=a, age=11, gender=false, id=0]
This is initialization block, id is 3
This is constructor
null,0,false,3
Person [name=null, age=0, gender=false, id=3]
import java.util.Scanner;
class Person {
private String name;
private int age;
private boolean gender;
private int id;
private static int count = 0;
static {
System.out.println("This is static initialization block");
}
public Person() {
this.id = count++;
System.out.println("This is initialization block, id is " + this.id);
System.out.println("This is constructor");
System.out.println(this.name + "," + this.age + "," + this.gender + "," + this.id);
}
public Person(String name, int age, boolean gender) {
this.id = count++;
System.out.println("This is initialization block, id is " + this.id);
this.name = name;
this.age = age;
this.gender = gender;
}
public String toString() {
return this.getClass().getSimpleName() + " [name=" + this.name + ", age=" + this.age + ", gender=" + this.gender + ", id=" + this.id + "]";
}
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;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
}
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
Person[] pers = new Person[n];
for (int i = 0; i < n; i++) {
pers[i] = new Person(sc.next(), sc.nextInt(), sc.nextBoolean());
}
for (int i = n - 1; i >= 0; i--) {
System.out.println(pers[i]);
}
Person per = new Person();
System.out.println(per);
}
}
7-7 学生类-构造函数
定义一个有关学生的Student类，内含类成员变量：
String name、String sex、int age，所有的变量必须为私有(private)。
1.编写有参构造函数：
能对name,sex,age赋值。
2.覆盖toString函数：
按照格式：类名 [name=, sex=, age=]输出。使用idea自动生成,然后在修改成该输出格式
3.对每个属性生成setter/getter方法
4.main方法中
•输入1行name age sex , 调用上面的有参构造函数新建对象。
输入样例:
tom 15 male
输出样例:
Student [name='tom', sex='male', age=15]
import java.util.Scanner;
class Student {
private String name;
private String sex;
private int age;
public Student(String name, int age, String sex) {
this.name = name;
this.age = age;
this.sex = sex;
}
@Override
public String toString() {
return "Student [" +
"name='" + name + '\'' +
", sex='" + sex + '\'' +
", age=" + age +
']';
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
}
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
Student stu = new Student(sc.next(), sc.nextInt(), sc.next());
System.out.println(stu);
}
}
7-8 jmu-Java-03面向对象基础-04-形状-继承
前言
前面题目形状中我们看到，为了输出所有形状的周长与面积，需要建立多个数组进行多次循环。这次试验使用继承与多态来改进我们的设计。
本题描述
1.定义抽象类Shape
属性：不可变静态常量double PI，值为3.14，
抽象方法:public double getPerimeter(),public double getArea()
2.Rectangle与Circle类均继承自Shape类。
Rectangle类(属性：int width,length)、Circle类(属性：int radius)。
带参构造方法为Rectangle(int width,int length),Circle(int radius)。
toString方法(Eclipse自动生成)
3.编写double sumAllArea方法计算并返回传入的形状数组中所有对象的面积和与
double sumAllPerimeter方法计算并返回传入的形状数组中所有对象的周长和。
4.main方法
4.1 输入整型值n，然后建立n个不同的形状。如果输入rect，则依次输入宽、长。如果输入cir，则输入半径。
4.2 然后输出所有的形状的周长之和，面积之和。并将所有的形状信息以样例的格式输出。 提示：使用Arrays.toString。
4.3 最后输出每个形状的类型与父类型.使用类似shape.getClass() //获得类型, shape.getClass().getSuperclass() //获得父类型;
注意：处理输入的时候使用混合使用nextInt与nextLine需注意行尾回车换行问题。
思考
你觉得sumAllArea和sumAllPerimeter方法放在哪个类中更合适？
是否应该声明为static?
输入样例:
4
rect
3 1
rect
1 5
cir
1
cir
2
输出样例:
38.84
23.700000000000003
[Rectangle [width=3, length=1], Rectangle [width=1, length=5], Circle [radius=1], Circle [radius=2]]
class Rectangle,class Shape
class Rectangle,class Shape
class Circle,class Shape
class Circle,class Shape
太菜，怕麻烦，原文参见：// https://blog.csdn.net/sddfnsff/article/details/106743952
// https://blog.csdn.net/sddfnsff/article/details/106743952
import java.util.Arrays;
import java.util.Scanner;
abstract class Shape{
public static final double PI=3.14;
public abstract double getPerimeter();
public abstract double getArea();
}
class Rectangle extends Shape{
int width,length;
public Rectangle(int width, int length) {
super();
this.width = width;
this.length = length;
}
@Override
public String toString() {
return "Rectangle [width=" + width + ", length=" + length + "]";
}
public double getPerimeter() {
return 2*(width+length);
}
public double getArea() {
return width*length;
}
}
class Circle extends Shape{
int radius;
public Circle(int radius) {
super();
this.radius = radius;
}
@Override
public String toString() {
return "Circle [radius=" + radius + "]";
}
public double getPerimeter() {
return 2*PI*radius;
}
public double getArea() {
return PI*radius*radius;
}
}
public class Main {
public static void main(String e[]) {
Scanner se=new Scanner (System.in);
int n=se.nextInt();
Shape a[]=new Shape[n];
for(int i=0;i<a.length;i++) {
String s=se.next();
if(s.equals("rect")) {
a[i]=new Rectangle(se.nextInt(),se.nextInt());
}else {
a[i]=new Circle(se.nextInt());
}
}
System.out.println(sumAllPerimeter(a));
System.out.println(sumAllArea(a));
System.out.println(Arrays.toString(a));
for(int i=0;i<a.length;i++) {
System.out.println(a[i].getClass()+","+a[i].getClass().getSuperclass());
}
}
public static double sumAllArea(Shape a[]){
double t=0;
for(int i=0;i<a.length;i++) {
if(a[i] instanceof Rectangle) {
t=t+((Rectangle)a[i]).getArea();
}else {
t=t+((Circle)a[i]).getArea();
}
}
return t;
}
public static double sumAllPerimeter(Shape a[]){
double t=0;
for(int i=0;i<a.length;i++) {
if(a[i] instanceof Rectangle) {
t=t+((Rectangle)a[i]).getPerimeter();
}else {
t=t+((Circle)a[i]).getPerimeter();
}
}
return t;
}
}
7-9 jmu-Java-03面向对象-06-继承覆盖综合练习-Person、Student、Employee、Company
定义Person抽象类，Student类、Company类，Employee类。
Person类的属性：String name, int age, boolean gender
Person类的方法:
public Person(String name, int age, boolean gender);
public String toString(); //返回"name-age-gender"格式的字符串
public boolean equals(Object obj);//比较name、age、gender,都相同返回true,否则返回false
Student类继承自Person，属性:String stuNo, String clazz
Student类的方法:
//建议使用super复用Person类的相关有参构造函数
public Student(String name, int age, boolean gender, String stuNo, String clazz);
public String toString(); //返回 “Student:person的toString-stuNo-clazz”格式的字符串
public boolean equals(Object obj);//首先调用父类的equals方法,如果返回true，则继续比较stuNo与clazz。
Company类属性：String name
Company类方法:
public Company(String name);
public String toString(); //直接返回name
public boolean equals(Object obj);//name相同返回true
Employee类继承自Person，属性：Company company, double salary
Employee类方法：
//建议使用super复用Person类的相关有参构造函数
public Employee(String name, int age, boolean gender, double salary, Company company);
public String toString(); //返回"Employee:person的toString-company-salary"格式的字符串
public boolean equals(Object obj);//首先调用父类的equals方法,如果返回true。再比较company与salary。
//比较salary属性时，使用DecimalFormat df = new DecimalFormat(“#.#”);保留1位小数
编写equals方法重要说明：
对Employee的company属性的比较。要考虑传入为null的情况。如果company不为null且传入为null，返回false
对所有String字符类型比较时，也要考虑null情况。
提示
排序可使用Collections.sort
equals方法要考虑周全
main方法说明
创建若干Student对象、Employee对象。
输入s，然后依次输入name age gender stuNo clazz创建Student对象。
输入e，然后依次输入name age gender salary company创建Employee对象。
然后将创建好的对象放入List personList。输入其他字符，则结束创建。
创建说明: 对于String类型，如果为null则不创建对象，而赋值为null。对于company属性，如果为null则赋值为null，否则创建相应的Company对象。
对personList中的元素实现先按照姓名升序排序，姓名相同再按照年龄升序排序。提示：可使用Comparable或Comparator
接受输入，如果输入为exit则return退出程序，否则继续下面步骤。
将personList中的元素按照类型分别放到stuList与empList。注意：不要将两个内容相同的对象放入列表（是否相同是根据equals返回结果进行判定）。
输出字符串stuList，然后输出stuList中的每个对象。
输出字符串empList，然后输出empList中的每个对象。
1-3为一个测试点
4-6为一个测试点
输入样例：
s zhang 23 false 001 net15
e wang 18 true 3000.51 IBM
s zhang 23 false 001 net15
e bo 25 true 5000.51 IBM
e bo 25 true 5000.52 IBM
e bo 18 true 5000.54 IBM
e tan 25 true 5000.56 IBM
e tan 25 true 5000.51 IBM
s wang 17 false 002 null
s wang 17 false 002 null
e hua 16 false 1000 null
s wang 17 false 002 net16
e hua 16 false 1000 null
e hua 18 false 1234 MicroSoft
!
continue
输出样例：
Employee:bo-18-true-IBM-5000.54
Employee:bo-25-true-IBM-5000.51
Employee:bo-25-true-IBM-5000.52
Employee:hua-16-false-null-1000.0
Employee:hua-16-false-null-1000.0
Employee:hua-18-false-MicroSoft-1234.0
Employee:tan-25-true-IBM-5000.56
Employee:tan-25-true-IBM-5000.51
Student:wang-17-false-002-null
Student:wang-17-false-002-null
Student:wang-17-false-002-net16
Employee:wang-18-true-IBM-3000.51
Student:zhang-23-false-001-net15
Student:zhang-23-false-001-net15
stuList
Student:wang-17-false-002-null
Student:wang-17-false-002-net16
Student:zhang-23-false-001-net15
empList
Employee:bo-18-true-IBM-5000.54
Employee:bo-25-true-IBM-5000.51
Employee:hua-16-false-null-1000.0
Employee:hua-18-false-MicroSoft-1234.0
Employee:tan-25-true-IBM-5000.56
Employee:tan-25-true-IBM-5000.51
Employee:wang-18-true-IBM-3000.51
自己写自闭了，原文参见：https://blog.csdn.net/m0_54524462/article/details/120678697
// https://blog.csdn.net/m0_54524462/article/details/120678697
import java.util.Scanner;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.Collections;
class Person implements Comparable<Person>{
private String name;
private int age;
private boolean gender;
public Person(String name, int age, boolean gender) {
this.name = name;
this.age = age;
this.gender = gender;
}
@Override
public String toString() {
return name + "-" + age + "-" + gender;
}
@Override
public int hashCode() {
return Objects.hash(age, gender, name);
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Person other = (Person) obj;
return age == other.age && gender == other.gender && Objects.equals(name, other.name);
}
@Override
public int compareTo(Person o) {
int x = this.name.compareTo(o.name);
if(x!=0) {
return x;
}
else {
if(this.age>o.age)
return 1;
else if (this.age<o.age)
return -1;
else
return 0;
}
}
}
class Student extends Person {
private String stuNo;
private String clazz;
public Student(String name, int age, boolean gender, String stuNo, String clazz) {
super(name, age, gender);
this.stuNo = stuNo;
this.clazz = clazz;
}
@Override
public String toString() {
return "Student:" + super.toString()+ "-" + stuNo + "-" + clazz;
}
@Override
public int hashCode() {
final int prime = 31;
int result = super.hashCode();
result = prime * result + Objects.hash(clazz, stuNo);
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (!super.equals(obj))
return false;
if (getClass() != obj.getClass())
return false;
Student other = (Student) obj;
return Objects.equals(clazz, other.clazz) && Objects.equals(stuNo, other.stuNo);
}
}
class Company{
private String name;
public Company(String name) {
this.name = name;
}
@Override
public String toString() {
return name;
}
@Override
public int hashCode() {
return Objects.hash(name);
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Company other = (Company) obj;
return Objects.equals(name, other.name);
}
}
class Employee extends Person{
private Company company;
private double salary;
public Employee(String name, int age, boolean gender, Company company, double salary) {
super(name, age, gender);
this.company = company;
this.salary = salary;
}
@Override
public String toString() {
return "Employee:"+ super.toString()+ "-" + company + "-" + salary;
}
@Override
public int hashCode() {
final int prime = 31;
int result = super.hashCode();
result = prime * result + Objects.hash(company, salary);
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (!super.equals(obj))
return false;
if (getClass() != obj.getClass())
return false;
Employee other = (Employee) obj;
DecimalFormat df = new DecimalFormat("#.#");//创建一个Decimal的格式
return Objects.equals(company, other.company)
&& (df.format(salary)).equals(df.format(other.salary));
}
}
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
List<Person> personList = new ArrayList<>();
List<Person> stuList = new ArrayList<>();
List<Person> empList = new ArrayList<>();
String choice;
while(sc.hasNext())
{
choice = sc.next();
if(choice.equals("s")) {
String name = sc.next();
if(name.equals("null"))
{
name = null;
}
int age = sc.nextInt();
boolean gender = sc.nextBoolean();
String stuNo = sc.next();
if(stuNo.equals("null"))
{
stuNo = null;
}
String clazz = sc.next();
if(clazz.equals("null"))
{
clazz = null;
}
Person student = new Student(name,age,gender,stuNo,clazz);
personList.add(student);
//
if(!stuList.contains(student)) {
stuList.add(student);
}
}
else if(choice.equals("e")) {
String _name = sc.next();
if(_name.equals("null"))
{
_name = null;
}
int _age = sc.nextInt();
boolean _gender = sc.nextBoolean();
double salary = sc.nextDouble();
String company_name = sc.next();
Company company;
if(company_name.equals("null"))
{
company = null;
}
else
{
company = new Company(company_name);
}
Person employee = new Employee(_name,_age,_gender,company,salary);
personList.add(employee);
//
if(!empList.contains(employee)) {
empList.add(employee);
}
}
else break;
}
//output
Collections.sort(personList);
for (Person person : personList) {
System.out.println(person.toString());
}
if(sc.next().equals("exit")) {
sc.close();
return ;
}
//
Collections.sort(stuList);
System.out.println("stuList");
for (Person person : stuList) {
System.out.println(person.toString());
}
//
Collections.sort(empList);
System.out.println("empList");
for (Person person : empList) {
System.out.println(person.toString());
}
sc.close();
}
}
7-10 横平竖直
程序填空题。根据题目要求完善下面的代码。请提交完整代码。
一个木块如果高度比宽度大，我们说它是竖着放的，否则我们说它是平放的。
读入一个木块的高度和宽度。如果它是平放的，则输出A，否则输出B。
import java.util.Scanner;
public class Main{
public static void main(String[] args){
Scanner in = new Scanner(System.in);
int height, width;
char status;
height = in.nextInt();
width = in.nextInt();
Board board = new Board(height, width);
status = board.getStatus();
System.out.print(status);
}
}
class Board{
int height, width;
public Board(int height, int width){
this.height = height;
this.width = width;
}
public char getStatus(){
if(height<=width){
return status(1);
}else{
return status(1.0);
}
}
public char status(double rate){
}
public char status(int rate){
}
}
输入格式:
输入在一行中给出2个绝对值不超过1000的正整数A和B。
输出格式:
在一行中输出一个字符A或者B。
输入样例:
50 50
输出样例:
A
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
int height, width;
char status;
height = in.nextInt();
width = in.nextInt();
Board board = new Board(height, width);
status = board.getStatus();
System.out.print(status);
}
}
class Board {
int height, width;
public Board(int height, int width) {
this.height = height;
this.width = width;
}
public char getStatus() {
if (height <= width) {
return status(1);
} else {
return status(1.0);
}
}
public char status(double rate) {
return 'B';
}
public char status(int rate) {
return 'A';
}
}
2095
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
