PTA 2022秋-Java-04-面向对象2（继承与多态）
题目：f4.2 jmu-Java-03面向对象基础-Object
输入整数n，创建n个对象，放入同一个数组中。
如果输入
c，则new Computer();//注意：Computer是系统中已有的类，无需自己编写如果输入
d，则根据随后的输入创建Double类型对象。如果输入
i，则根据随后的输入创建Integer类型对象。如果输入
s，则根据随后的输入创建String类型对象。如果不是以上这些输入，则不创建对象，而是将
null存入数组相应位置。最后倒序输出数组中的所有对象，如果数组中相应位置的元素为
null则不输出。
裁判测试程序：
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
//这边是你的代码
sc.close();
}
输入样例：
5
c
d 2.3
other
i 10
s Test
输出样例：
Test
10
2.3
//这行显示Computer对象toString方法
//我的代码
int n=sc.nextInt();
Object[] a=new Object[n];
for (int i = 0; i < n; i++)
{
String letter=sc.next();
switch (letter)
{
case "c":
Computer c=new Computer();
a[i]=c;
break;
case "d":
double d=sc.nextDouble();
a[i]=d;
break;
case "i":
Integer m=sc.nextInt();
a[i]=m;
break;
case "s":
String s=sc.next();
a[i]=s;
break;
default:
a[i]=null;
break;
}
}
for (int i = n-1; i >=0; i--) {
if(a[i]!=null)
System.out.println(a[i]);
}总结：
当一个数组中含有多个类型的对象的时候，可以尝试使用Object来定义数组
（使用接口或者继承，可以利用父类来定义一个数组，包含多个子类的类型）
题目：f4.3 jmu-Java-03面向对象基础-覆盖与equals
有
Person类，Company类，Employee类。其中
Employee类继承自Person类，属性为：private Company company; private double salary;
现在要求覆盖Employee类的
equals方法，判定两个Employee对象是否相等，请见如下判断方法：
其继承自父类Person的属性值都相等，其company属性对象equals返回true，且其salary也相等。
salary是double型，比较时，使用
DecimalFormat df = new DecimalFormat("#.##");使salary保留两位小数，然后再进行比较。注意：要考虑company为
null的情况。
//函数接口定义：
public boolean equals(Object obj)
输入样例：
输出样例：
false
true
false
true
false
true
false
@Override
public boolean equals(Object obj)
{
//直接比较引用的地址码是否相同
if(this==obj)
return true;
//判断传入的参数是否为null
else if(obj==null)
return false;
//比较父类属性是否相同
else if(!super.equals(obj))
return false;
DecimalFormat df = new DecimalFormat("#.##");
//将obj转为Employee型来进行比较
Employee other=(Employee) obj;
if(company==null&&other.company==null)
return df.format(salary).equals(df.format(other.salary));
else if(company==null||other.company==null)
return false;
return company.equals(other.company)
&& df.format(salary).equals(df.format(salary));
}总结：
1、DecimalFormat是的具体子类NumberFormat格式化十进制数字。
2、此为equals的常用比较内容编写
//直接比较引用的地址码是否相同
if(this==obj)
return true;
//判断传入的参数是否为null
else if(obj==null)
return false;
//比较父类属性是否相同
else if(!super.equals(obj))
return false;题目： 4.1 jmu-Java-03面向对象基础-05-覆盖
Java每个对象都继承自Object,都有equals、toString等方法。
现在需要定义PersonOverride类并覆盖其toString与equals方法。1. 新建PersonOverride类
a. 属性：
String name、int age、boolean gender，所有的变量必须为私有(private)。b. 有参构造方法，参数为
name, age, genderc. 无参构造方法，使用
this(name, age,gender)调用有参构造方法。参数值分别为"default",1,trued.
toString()方法返回格式为：name-age-gendere.
equals方法需比较name、age、gender，这三者内容都相同，才返回true.2. main方法
2.1 输入n1，使用无参构造方法创建n1个对象，放入数组persons1。
2.2 输入n2，然后指定name age gender。每创建一个对象都使用equals方法比较该对象是否已经在数组中存在，如果不存在，才将该对象放入数组persons2。
2.3 输出persons1数组中的所有对象
2.4 输出persons2数组中的所有对象
2.5 输出persons2中实际包含的对象的数量
2.5 使用System.out.println(Arrays.toString(PersonOverride.class.getConstructors()));输出PersonOverride的所有构造方法。提示：使用
ArrayList代替数组大幅复简化代码，请尝试重构你的代码。
输入样例:
1 3 zhang 10 true zhang 10 true zhang 10 false
输出样例:
default-1-true zhang-10-true zhang-10-false 2 [public PersonOverride(), public PersonOverride(java.lang.String,int,boolean)]
代码解析：
1、需要用到的类
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.Objects;
import java.util.Scanner;2、 新建PersonOverride类
/*
* 重新定义PersonQverride类并覆盖其toString和equals
* */
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;
}
@Override
public String toString() {
return name+"-"+age+"-"+gender;
}
public boolean equals(Object obj) {
if(this == obj)
return true;
if(obj == null)
return false;
if(this.getClass() != obj.getClass())
return false;
PersonOverride a = (PersonOverride)obj;
return Objects.equals(this.name, a.name) && this.gender == a.gender && this.age == a.age;
}
}
Objects.equals解释：
Objects.equal与equals的区别：
3、Main
①利用数组编写
public class Main
{
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
int n1=sc.nextInt();
PersonOverride[] persons1=new PersonOverride[n1];
for (int i = 0; i < n1; i++)
persons1[i]=new PersonOverride();
int n2=sc.nextInt();
PersonOverride[] persons2=new PersonOverride[n2];
int length=0;
for (int i = 0; i < n2; i++) {
//System.out.println(i+"\n");
boolean flag=true;
PersonOverride person2=new PersonOverride(sc.next(),sc.nextInt(),sc.nextBoolean());
for (int j = 0; j ②利用List编写
import java.util.List;
public class Main
{
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
int n1=sc.nextInt();
List persons1=new ArrayList<>();
for (int i = 0; i < n1; i++)
{
PersonOverride person1=new PersonOverride();
persons1.add(person1);
}
for (PersonOverride e1 : persons1) {
System.out.println(e1.toString());
}
int n2=sc.nextInt();
List persons2=new ArrayList<>();
for (int i = 0; i < n2; i++)
{
PersonOverride person2=new PersonOverride(sc.next(),sc.nextInt(),sc.nextBoolean());
if(!persons2.contains(person2))
persons2.add(person2);
}
for (PersonOverride e2 : persons2)
System.out.println(e2.toString());
System.out.println(persons2.size());
System.out.println(Arrays.toString(PersonOverride.class.getConstructors()));
}
}
import java.util.List; ：
import java.awt.List;
两者区别：
java.util.* 内是一些工具类，java.util.* 是有关图形组件的。
*.contains利用了*.equals方法
题目：4.2 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需注意行尾回车换行问题。
输入样例:
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
代码解析：
1、所用到的类
import java.util.Arrays;
import java.util.Random;
import java.util.Scanner;2、Shape类
（存疑：抽象类创建以此抽象类为元素的数组，这个数组的元素是该抽象类型？包含的功能？）
abstract class Shape
{
protected static double PI=3.14;
//抽象方法
public abstract double getPerimeter();
public abstract double getArea();
//普通方法
public static double sumAllArea(Shape []arr)
{
double sum=0;
for (Shape e : arr)
sum+=e.getArea();
return sum;
}
public static double sumAllPerimeter(Shape []arr)
{
double sum=0;
for (Shape e : arr)
sum+=e.getPerimeter();
return sum;
}
}
抽象类（有抽象方法的类）中的方法：
1>抽象方法：
public abstract double getPerimeter();
public abstract double getArea();关键字：abstract
抽象方法里面没有方法体
抽象方法在被继承之后，需要在子类中重载方法
@Override
public double getPerimeter() {
return 2*(width+length);
}
@Override
public double getArea() {
return width*length;
} @Override
public double getPerimeter() {
return 2*PI*radius;
}
@Override
public double getArea() {
return PI*radius*radius;
}2>普通方法：
//普通方法
public static double sumAllArea(Shape []arr)
{
double sum=0;
for (Shape e : arr)
sum+=e.getArea();
return sum;
}
public static double sumAllPerimeter(Shape []arr)
{
double sum=0;
for (Shape e : arr)
sum+=e.getPerimeter();
return sum;
}普通方法无法被重载，即方法体无法改变。
3>虚拟方法
3、Rectangle类
class Rectangle extends Shape
{
private int width;
private int length;
public Rectangle(int width,int length)
{
this.width=width;
this.length=length;
}
@Override
public String toString() {
return "Rectangle [width=" + width + ", length=" + length + "]";
}
@Override
public double getPerimeter() {
return 2*(width+length);
}
@Override
public double getArea() {
return width*length;
}
}4、Circle类
class Circle extends Shape
{
private int radius;
public Circle(int radius) {
this.radius=radius;
}
@Override
public String toString() {
return "Circle [radius=" + radius + "]";
}
@Override
public double getPerimeter() {
return 2*PI*radius;
}
@Override
public double getArea() {
return PI*radius*radius;
}
}5、 Main
public class Main
{
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
Shape[] shape=new Shape[n];
for (int i = 0; i < n; i++)
{
String s=sc.next();
if(s.equals("rect"))
{
int width=sc.nextInt();
int length=sc.nextInt();
shape[i]=new Rectangle(width, length);
}
else if(s.equals("cir"))
{
int radius=sc.nextInt();
shape[i]=new Circle(radius);
}
}
sc.close();
System.out.printf("%.2f\n",Shape.sumAllPerimeter(shape));
System.out.println(Shape.sumAllArea(shape));
System.out.println(Arrays.toString(shape));
for (Shape e : shape)
System.out.println(e.getClass()+","+e.getClass().getSuperclass());
}
}题目：4.3 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,否则返回falseStudent类继承自
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相同返回trueEmployee类继承自
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
代码解析：
1、所用到的各个类：
import java.util.Scanner;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.Collections;2、Person类
class Person implements Comparable
{
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 this.name+"-"+this.age+"-"+this.gender;
}
@Override
public boolean equals (Object obj)
{
if(this==obj)
return true;
if(obj==null)
return false;
if(this.getClass()!=obj.getClass())
return false;
Person other=(Person) obj;
return this.age==other.age
&& this.gender==other.gender
&& Objects.equals(this.name,other.name);
}
@Override
public int compareTo(Person o) {
int num=this.name.compareTo(o.name);
return num==0?this.age-o.age:num;
/*
如果num==0成立，则返回this.age-o.age，否则返回num
this.age-o.age按照升序排列
*/
}
} 1>a?b:c解析：如果a成立，则返回b，否则返回c
2>public int compareTo(Object o) {}有三种返回值：分别为1、0、-1
retutn 1:大于，进行交换
return 0：等于，不进行交换
return -1：小于，不进行交换
3、Student类
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 boolean equals(Object obj)
{
if(super.equals(obj))
{
Student other=(Student) obj;
return Objects.equals(this.stuNo,other.stuNo)
&& Objects.equals(this.clazz, other.clazz);
}
return false;
}
}4、Company类
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);
}
}
5、Employee类
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 boolean equals(Object obj)
{
if(super.equals(obj))
{
Employee other=(Employee) obj;
//数字格式化
DecimalFormat df = new DecimalFormat("#.#");//创建一个Decimal的格式
return Objects.equals(this.company, other.company)
&& df.format(this.salary).equals(df.format(other.salary));
}
return false;
}
}
6、Main
public class Main {
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
List personList=new ArrayList<>();
List stuList=new ArrayList<>();
List empList=new ArrayList<>();
String choice;
while(sc.hasNext())
{
boolean flag=false;
choice=sc.next();
switch (choice) {
case "s":
String nameS=sc.next();
if(nameS.equals("null"))
nameS=null;
int ageS=sc.nextInt();
boolean genderS=sc.nextBoolean();
String stuNoS=sc.next();
if(stuNoS.equals("null"))
stuNoS=null;
String clazzS=sc.next();
if(clazzS.equals("null"))
clazzS=null;
Person student=new Student(nameS, ageS, genderS, stuNoS, clazzS);
personList.add(student);
if(!stuList.contains(student))
stuList.add(student);
break;
case "e":
String nameE = sc.next();
if(nameE.equals("null"))
nameE = null;
int ageE = sc.nextInt();
boolean genderE = sc.nextBoolean();
double salary = sc.nextDouble();
String companyName = sc.next();
Company company;
if(companyName.equals("null"))
company = null;
else
company = new Company(companyName);
Person employee = new Employee(nameE,ageE,genderE,company,salary);
personList.add(employee);
if(!empList.contains(employee)) {
empList.add(employee);
}
break;
default:
flag=true;
break;
}
if(flag)
break;
}
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();
}
}