Java面向对象程序设计综合练习2（编程题）

真题OK撒

已于 2022-06-24 18:04:03 修改

阅读量2.5k

点赞数 1

分类专栏： java 文章标签： java 算法开发语言

于 2022-06-21 23:33:02 首次发布

本文链接：https://blog.csdn.net/qq_51916951/article/details/125396655

版权

java 专栏收录该内容

55 篇文章 19 订阅

订阅专栏

R7-1 学生类-构造函数

定义一个有关学生的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;

public class Main {

	public static void main(String[] args) {
		Scanner cin = new Scanner(System.in);
		Student stu = new Student(cin.next(), cin.nextInt(), cin.next());
		System.out.println(stu.toString());
	}

}

class Student {

	String name;
	String sex;
	int age;

//	tom 15 male
	public Student(String name, int age, String sex) {
		this.name = name;
		this.sex = sex;
		this.age = age;
	}

	@Override
	public String toString() {
		return "Student" + " [name=\'" + name + "\', sex=\'" + sex + "\', age=" + age + ']';
	}

}

R7-2 Ring类设计

编写一个圆环类Ring的Java程序。

a定义圆环类的2个数据成员，分别是内半径innerRadius，外半径outerRadius，这些属性通过get和set方法进行封装。

b 定义圆环类有参构造方法Ring(int innerRadius,int outerRadius),在有参构造方法中加入System.out.println("constructor");

c完成无参构造方法Ring(),要求在无参构造方法中使用this调用有参构造方法给两个半径赋值（外半径赋值3，内半径赋值1）

d 圆环类中定义 public int getArea（）方法可以返回其面积。面积求出后强制转换为整型值返回，π使用Math.PI表示。

在Main类中先生成一个圆环类对象，这个圆环的两个半径通过键盘读入，调用求面积方法求出面积后，输出面积。

然后再次定义一个圆环对象，调用无参构造方法，调用求面积方法求出面积后，输出面积。

输入格式:

输入在一行中先给出内半径，再给出外半径。

输出格式:

在一行中输出圆环的面积。

输入样例:

在这里给出一组输入。先是内半径，然后是外半径，例如：

1   2

输出样例:

在这里给出相应的输出。例如：

constructor
9
constructor
25

import java.util.*;

public class Main {
    
    public static void main(String[] args) {
        
        Scanner cin = new Scanner(System.in);
        int in = cin.nextInt();
        int out = cin.nextInt();
        Ring r1 = new Ring(in, out);
        System.out.println(r1.getArea());
        Ring r2 = new Ring();
        System.out.println(r2.getArea());
    }
    
}

class Ring {
    
    int innerRadius;
    int outerRadius;
    
    public int setouterRadius() {
        return outerRadius;
    }
    
    public void getouterRadius(int outerRadius) {
        this.outerRadius = outerRadius;
    }
    
    public int setinnerRadius() {
        return innerRadius;
    }
    
    public void getinnerRadius(int innerRadius) {
        this.innerRadius = innerRadius;
    }
    
    public Ring() {
        this(1, 3);
    }
    
    public Ring(int innerRadius,int outerRadius) {
        this.innerRadius = innerRadius;
        this.outerRadius = outerRadius;
        System.out.println("constructor");
    }
    
    public int getArea() {
        return (int)(Math.PI * (this.outerRadius * this.outerRadius - this.innerRadius * this.innerRadius));
    }
}

R7-3 圆柱体类设计

1. 定义一个圆柱类Cylinder
2. 里面包含私有属性 private int radius（半径）,height(高）
3. 为属性完成其setter getter方法
4. 完成带参构造方法Cylinder(int radius,height),该方法中包含一句System.out.println("Constructor with para");
5. 完成无参构造方法Cylinder()，在无参构造方法中调用有参构造方法，为半径和高赋值为2,1,该方法包含一句System.out.println("Constructor no para");
6. 完成求体积方法 public int getVolumn(){} 求圆柱体积,π使用Math.PI
定义测试类Main，在main方法中，按照顺序要求完成下列操作
从键盘接收两个数，第一个为半径，第二个为高，并利用刚才输出两个数创建圆柱体对象c1,求c1的体积并输出。
使用无参构造方法创建第二个圆柱体对象c2，求c2的体积并输出。

输入格式:

在一行中输入半径和高。

输出格式:

对每一个圆柱体输出它的体积

输入样例:

在这里给出一组输入。例如：

2   3

输出样例:

在这里给出相应的输出。例如：

Constructor with para
37
Constructor with para
Constructor no para
12

import java.util.*;

public class Main {
    
    public static void main(String[] rags) {
        Scanner cin = new Scanner(System.in);
        int r1 = cin.nextInt();
        int h1 = cin.nextInt();
        Cylinder c1 = new Cylinder(r1, h1);
        System.out.println(c1.getVolumn());
        Cylinder c2 = new Cylinder();
        System.out.println(c2.getVolumn());
    }
    
}

class Cylinder {
    private int radius;
    private int height;
    public void setradius(int radius) {
        this.radius = radius;
    }
    public int getradius() {
        return radius;
    }
    public void setheight(int height) {
        this.height = height;
    }
    public int getheight() {
        return height;
    }
    public Cylinder(int radius, int height) {
        this.radius = radius;
        this.height = height;
        System.out.println("Constructor with para");
    }
    public Cylinder() {
        this(2, 1);
        System.out.println("Constructor no para");
    }
    public int getVolumn(){
        return (int)(Math.PI * radius * radius * height);
    }
}

R7-4 通过键盘输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数。

统计一行字符串中的英文字母个数、空格个数、数字个数、其他字符个数

输入格式:

通过键盘输入一行字符(任意字符）

输出格式:

统计一行字符串中的中英文字母个数、空格个数、数字个数、其他字符个数

输入样例:

rwrwewre2345asdJSJQI%^&(&   *&sdf YY( 2342-k'

输出样例:

字母个数：22
数字个数：8
空格个数：5
其他字符个数：10

import java.util.*;

public class Main {
    
    public static void main(String[] args) {
        
        Scanner cin = new Scanner(System.in);
        String l = cin.nextLine();
        String[] s = l.split("");
        char[] c = new char[123];
        c = l.toCharArray();
        int a = 0;
        int b = 0;
        int x = 0;
        int d = 0;
        for (int i = 0;  i < c.length; i++) {
            if (c[i] >= 'a' && c[i] <= 'z' || c[i] >= 'A' && c[i] <= 'Z') {
                a++;
            }
            else if (c[i] >= '0' && c[i] <= '9') {
                b++;
            }
            else if (c[i] == ' ') {
                x++;
            }
            else {
                d++;
            }
//             System.out.println(s[i]);
        }
        System.out.println("字母个数：" + a + "\n" + "数字个数：" + b + "\n" +"空格个数：" + x + "\n" +"其他字符个数：" + d);
    }
    
}

R7-5 数组元素交换

数组元素交换，要求：（1）最大的元素与第一个元素交换（2）最小的元素与最后一个元素交换。

输入格式:

输入一行字符串（由不同的整数组成，以空格分开）

输出格式:

首先以数组形式输出初始字符串（一行一个数字），然后以数组形式输出完成交换后的字符串（一行一个数字）。

输入样例:

2 9 0 10

输出样例:

import java.util.*;

public class Main {
    
    public static void main(String[] args) {
        
        Scanner cin = new Scanner(System.in);
        String l = cin.nextLine();
        String[] str = l.split(" ");
        int minn = 0x3f3f3f3f;
        int maxn = -0x3f3f3f3f;
        int[]  a = new int[123];
//         System.out.println(str.length);
        for (int i = 0 ; i < str.length; i++) {
            System.out.println(str[i]);
        }
        for (int i = 0; i < str.length; i++) {
            a[i] = Integer.parseInt(str[i]);
        }
        int idx1 = 0;
        int idx2 = 0;
        for (int i = 0; i < a.length; i++) {
            if (maxn < a[i]) {
                maxn = a[i];
                idx1 = i;
            }
        }
        for (int i = 0; i < a.length; i++) {
            if (minn > a[i]) {
                minn = a[i];
                idx2 = i;
            }
        }
        
        int t = a[0];
        a[0] = a[idx1];
        a[idx1] = t;
        
        t = a[str.length - 1];
        a[str.length - 1] = a[idx2];
        a[idx2] = t;
        
        for (int i = 0; i < str.length; i++) {
            System.out.println(a[i]);
        }
    }
    
}

R7-6 sdust-Java-学生成绩读取与排序

1）从键盘录入多行学生成绩的信息，每行表示一个学生的一门课的成绩，最后一行以“exit”结束。每行文本的格式为：学号,姓名,课程名,成绩。程序能够读取学生及其成绩，将具有相同学号的学生及其成绩读取到一个Student（学生类）类对象的列表（List）stuList中；
2）程序在读取完学生及其成绩的数据后，能够将stuList中的学生按照平均成绩降序排列(如果平均成绩相同，学号数字小的排在前面)，并输出排序后的学生学号、姓名和成绩。

输入格式:

多行表示的学生成绩，每一行是一个学生的姓名、学号、课程名、成绩（整数）。不同行可以是同一名学生（学号相同的为同一名学生）不同课程的成绩。

输出格式:

按照学生平均成绩降序排序（平均成绩相同的学号小的在前面）的学生排名（具体输出格式参照样例）。

输入样例:

小明,2001,Java,88
小刚,2002,Java,78
小丁,2003,Java,56
小宏,2004,Java,85
小明,2001,Python,84
小刚,2002,Python,98
小丁,2003,JavaWeb,66
小宏,2004,Algorithm,87
exit

输出样例:

No1:2002,小刚
No2:2001,小明
No3:2004,小宏
No4:2003,小丁

R7-7 统计商品总价

消费者购买超市5件商品，输入商品名和价格，输出购买的商品信息，并输出应付的总价。

要求：定义Goods类及其成员变量和方法。
（1）定义Goods类：成员变量有 name,  price 
（2）定义Goods类的带两个参数的构造方法。
（3）定义Goods类的toString()方法，getPrice()方法。

输入格式:

输入5行数据，每行一个商品信息，包括商品名和价格，以一个空格分隔。

输出格式:

输出商品信息，格式：商品名,价格
最后输出总价，格式：should pay:总价

裁判程序如下：

class Main{
    public static void main(String args[]){
        Goods ga[] =new Goods[5];
        Scanner sc = new Scanner(System.in);
        
        for(int i =0;i<5;i++){
            ga[i]= new Goods(sc.next(),sc.nextDouble());
        }        
        
        double  shouldPay = 0;
        for(Goods g:ga){
            shouldPay += g.getPrice();
            System.out.println(g.toString());
        }
        
        System.out.println("should pay:"+shouldPay);            
    }
}

输入样例:

book 5.5 
pencil 1.2 
pen 8.0 
ruler 2.5 
eraser 1.0

输出样例:

book,5.5
pencil,1.2
pen,8.0
ruler,2.5
eraser,1.0
should pay:18.2

import java.util.*;

public class Main {
    
    public static void main(String[] args) {
        
        Scanner cin = new Scanner(System.in);
        double sum = 0;
        while (cin.hasNext()) {
            String x = cin.next();
            double p = cin.nextDouble();
            System.out.println(x + "," + p);
            sum += p;
        }
        System.out.println("should pay:" + sum);
    }
    
}

import java.util.*;

public class Main {
    
    public static void main(String[] args) {
        
        Scanner cin = new Scanner(System.in);
        List<Student>  stu= new ArrayList<>();
        int cnt = 0;
        int flag = 0;
        while(cin.hasNext()) {
            String l = cin.nextLine();
            if (l.equals("exit")) break;
            String[] s = l.split(",");
            for (int i = 0; i < stu.size(); i++) {
                if (stu.get(i).id.compareTo(s[1]) == 0) {
                    stu.get(i).getSum(Integer.parseInt(s[3]));
                    flag = 1;
                    break;
                }
            }
            if (flag == 0) {
//                 System.out.println(s[0] + " " + s[1] + " " + s[2] + " " + s[3]);
                Student s1 = new Student(s[0], s[1], s[2], Integer.parseInt(s[3]));
                stu.add(s1);
            }
        }
        
        for (int i = 0; i < stu.size(); i++) {
            stu.get(i).getScore();
        }
        Collections.sort(stu);
        for (int i = 0; i < stu.size(); i++) {
            System.out.println("No" + (i + 1) + ":" + stu.get(i).id + "," + stu.get(i).name);
        }
    }
    
}

class Student implements Comparable<Student>{
    
    String name;
    String id;
    String cousrce;
    int grade;
    int sum = 0;
    static int num = 0;
    public Student(String name, String id, String cousrce, int grade) {
        this.name = name;
        this.id = id;
        this.cousrce = cousrce;
        this.grade = grade;
    }
    
    public void getSum (int grade) {
        num++;
        this.grade += grade;
    }
    public double getScore () {
        return grade / num;
    }
    public int compareTo(Student o) {
        if(this.getScore()==o.getScore())
            return id.compareTo(o.id);
        else
            return (int)(o.getScore() - getScore());
    }
    
}

R7-8 定义商品类，封装成员变量，输出对象

定义一个商品类。创建对象并按指定格式输出它。
商品类要求：

（1）成员变量：商品编号（String） 、商品名称(String)、商品单价(double)
（2）成员变量封装，定义为私有属性，并为每个成员变量定义getXXXX，setXXXX方法
（3）定义构造方法，要求带三个参数，参数值用于给成员变量赋值。
（4）重写toString（）方法，将对象转换为字符串，格式：商品编号，商品名称，商品单价

测试类要求：

按指定的格式 输入商品信息，调用构造方法生成对象，并输出它。
例：输入：WJ002 记事本 5.5
输出：WJ002,记事本,5.5

输入商品的信息，每个属性值之间用1个空格分隔。
输出格式，商品的每个属性值之间用逗号分隔。

输入样例:

WJ002 记事本 5.5

输出样例:

WJ002,记事本,5.5

import java.util.*;
 
class Shangping {
    String num;
    String name;
    double price;
 
    public String getNum() {
        return num;
    }
 
    public double getPrice() {
        return price;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public void setNum(String num) {
        this.num = num;
    }
 
    public void setPrice(double price) {
        this.price = price;
    }
 
    @Override
    public String toString() {
        return num + ',' + name + ',' + price;
    }
 
    public Shangping(String num, String name, double price) {
        this.num = num;
        this.name = name;
        this.price = price;
    }
}
 
class Main {
    public static void main(String args[]) {
        Scanner cin = new Scanner(System.in);
        String l = cin.nextLine();
        String[] s = l.split(" ");
        Shangping res = new Shangping(s[0], s[1], Double.parseDouble(s[2]));
        System.out.println(res.toString());
    }
}

R7-9 正方形类

定义一个正方形类square，在次类中包括写内容：

定义成员变量边长private int edge;
定义方法：包括构造方法，setter getter方法，求面积方法等，要求如下所示：
1. 定义正方形类的构造方法：在构造方法中给edge赋值为2，并添加System.out.println("this is constructor method");
2. 为成员变量edge设置set方法，用来接收用户给edge的值，如果用户给的值<=0,则设置edge值为1
3. 为成员变量edge设置get方法，用来返回edge的值
4. 完成求面积方法，得到正方形的面积：public int getArea()

定义类Main，并在main方法中， 1.首先创建正方形对象s1，然后通过getEdge()方法输出edge的值，然后调用getArea方法求出s1的面积并输出
2.创建正方形对象s2,并通过键盘输入s2对象的边的值，然后通过getEdge()方法输出edge的值，然后调用getArea方法求出s1的面积并输出

输入格式:

输入在一行中给出边的值。

输出格式:

输出s1对象的边、输出s1对象的面积
输出s2对象的边、s2对象的面积

输入样例:

在这里给出一组输入。例如：

-5

输出样例:

在这里给出相应的输出。例如：

this is constructor method
s1:edge=2
s1:area=4
this is constructor method
s2:edge=3
s2:area=9

this is constructor method
s1:edge=2
s1:area=4
this is constructor method
s2:edge=1
s2:area=1

import java.util.*;

public class Main {
    
    public static void main(String[] args) {
        
        Scanner cin = new Scanner(System.in);
        int e1 = cin.nextInt();
        Square s1 = new Square();
        System.out.println("s1:edge=" + s1.getEdge());
        System.out.println("s1:area=" + s1.getArea());
        Square s2 = new Square(e1);
        System.out.println("s2:edge=" + s2.getEdge());
        System.out.println("s2:area=" + s2.getArea());
    }
    
}

class Square {
    private int edge;
    public void setEdge(int edge) {
        if (edge < 0) {
            edge = 1;
        }
        else this.edge = edge;
    }
    public int getEdge() {
        return edge;
    }
    public Square() {
        edge = 2;
         System.out.println("this is constructor method");
    }
    public Square(int edge) {
        super();
        this.edge = edge;
        System.out.println("this is constructor method");
    }
    public int getArea() {
        return edge * edge;
    }
}

R7-10 Circle类

a 定义圆类Circle，其中包括：

成员变量定义 private int radius
方法定义包括下列要求
1. 定义无参构造方法，给radius赋值为2，并添加语句System.out.println("this is a constructor");
2. 定义有参构造方法，接收用户给给radius赋值，如果用户输入半径为<=0,则让半径的值为2，并添加语句System.out.println("this is a constructor with para");
3. 为radius半径添加setter方法，接收用户输入的半径，如果用户输入半径为<=0,则让半径的值为2
4. 为radius半径添加getter方法，返回用户输入的半径
5. 定义求面积方法public int gerArea(),π使用Math.PI代替，面积的结果强制转换为int返回
6. 定义toString方法，public String toString( )方法体为：
  return "Circle [radius=" + radius + "]";

b定义Main类，在main方法中，完成下列操作

.定义并创建Circle的第一个对象c1，并使用println方法输出c1
求c1的面积并输出
定义并创建Circle的第一个对象c2，并使用println方法输出c2
从键盘接收整数半径，并赋值给c2的半径，使用println方法输出c2
求c2的面积并输出
从键盘接收整数半径，并创建Circle的第三个对象c3，并将用户输入整数半径通过有参构造方法传递给出c3，使用println方法输出c3
求c3的面积并输出

### 输入格式: 从键盘输入一个整数半径

输出格式:

分别输出c1和c2对象的信息

输入样例:

在这里给出一组输入。例如：

4
5

-4
-2

输出样例:

在这里给出相应的输出。例如：

this is a constructor
Circle [radius=2]
c1:area=12
this is a constructor
Circle [radius=2]
Circle [radius=4]
c2:area=50
this is a constructor with para
Circle [radius=5]
c3:area=78

this is a constructor
Circle [radius=2]
c1:area=12
this is a constructor
Circle [radius=2]
Circle [radius=2]
c2:area=12
this is a constructor with para
Circle [radius=2]
c3:area=12

import java.util.*;

public class Main {
    
    public static void main(String[] args) {
        
        Scanner cin = new Scanner(System.in);
        Circle c1 = new Circle();
        System.out.println(c1.toString());
        System.out.println("c1:area=" + c1.getArea());
        Circle c2 = new Circle();
        System.out.println(c2.toString());
        c2.setter(cin.nextInt());
        System.out.println(c2.toString());
        System.out.println("c2:area=" + c2.getArea());
        Circle c3 = new Circle(cin.nextInt());
        System.out.println(c3.toString());
        System.out.println("c3:area=" + c3.getArea());
    }
    
}

class Circle {
    
    private int radius;
    
    public Circle() {
        radius = 2;
        System.out.println("this is a constructor");
    }
    
    public Circle(int radius) {
//         this();
        if (radius <= 0) {
            radius = 2;
        }
        else {
            this.radius = radius;
        }
        System.out.println("this is a constructor with para");
    }
    public void setter(int radius) {
        if (radius <= 0) {
            radius = 2;
        }
        else {
            this.radius = radius;
        }
    }
    public int getter() {
        return radius;
    }
    public int getArea() {
        return (int)(Math.PI * radius * radius);
    }
    public String toString() {
        return "Circle [radius=" + radius + "]";
    }
}

R7-11 定义类与创建对象

定义一个类Person,定义name和age属性，定义有参的构造方法对name和age进行初始化。在测试类中创建该类的2个对象，姓名、年龄分别为lili、19和lucy、20，在屏幕打印出2个对象的姓名和年龄。

输入格式:

本题目无输入

输出格式:

在一行中输出一个人的姓名和年龄

输入样例:

在这里给出一组输入。例如：

输出样例:

在这里给出相应的输出。例如：

this person is lili,her age is 19
this person is lucy,her age is 20

import java.util.*;
public class Main {
    
    public static void main(String[] args) {
        
        Scanner cin = new Scanner(System.in);
        Persion p1 = new Persion("lili",19);
        System.out.println(p1.toString());
        Persion p2 = new Persion("lucy",20);
        System.out.println(p2.toString());
    }
    
}

class Persion {
    
    String name;
    int age;
    
    public Persion(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    public String toString() {
        return "this person is " + name +",her age is " + age;
    }
}

R7-12 点

点是最简单的形，是几何图形最基本的组成部分。要求设计一个点类Point类，Point类包括：

坐标成员变量 int x,int y
成员变量x,y的setter gette方法，以及ToString方法
带参无参构造方法
重写hashcode和equals方法，判断两个点是否相同
实现接口Comparable，可以比较两个点的大小，比较规则是若第一个点x大，则第一个点大，第一个点x小则第一个点小，若相同，比较y，根据y值判断大小。
实现方法 int distance(Point p2),求两个点的距离（开平方根使用方法Math.sqrt()）

测试类中main方法中，要求如下：

通过键盘输入2个点坐标，创建2个点对象
输出第一个点的信息（调用ToString方法），
比较他们的大小，如果第一点大于等于第二个点，输出true否则输出false
求这两个点的距离并输出。

### 输入格式:

请在这里写输入格式。例如：输入在一行中给出2个绝对值不超过1000的整数A和B。

输出格式:

输入两行，每行为一个点的坐标

输入样例:

在这里给出一组输入。例如：

4 6
6 7

4 5
3 2

输出样例:

在这里给出相应的输出。例如：

Point [x=4, y=6]
false
2

Point [x=4, y=5]
true
3

import java.util.*;

public class Main {
    
    public static void main(String[] args) {
        
        Scanner cin = new Scanner(System.in);
        
        int x1 = cin.nextInt();
        int y1 = cin.nextInt();
        int x2 = cin.nextInt();
        int y2 = cin.nextInt();
        System.out.printf("Point [x=%d, y=%d]\n",x1, y1);
        if (x1 >= x2 && y1 >= y2) System.out.println(
"true");
        else System.out.println("false");
        int x = (x1 - x2);
        int y = (y1 - y2);
        System.out.println((int)(Math.sqrt(x * x + y * y)));
    }
    
}

R7-13 设计一个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

import java.util.*;

public class Main {
    
    public static void main(String[] args) {
        
        Scanner cin = new Scanner(System.in);
        int a = cin.nextInt();
        int b = cin.nextInt();
        int c = cin.nextInt();
        
        BankAccount bankAccount = new BankAccount(a);
        System.out.println(bankAccount.getBalance());
        System.out.println(bankAccount.withdraw(b));
        System.out.println(bankAccount.deposit(c));
        
    }
    
}

class BankAccount {
    
    private int balance;
    
    BankAccount() {
        balance = 0;
    }
    public BankAccount(int balance) {
        super();
        this.balance = balance;
    }
    
    public int getBalance() {
        return balance;
    }
    public int withdraw(int amount) {
        return balance = balance - amount;
    }
    public int deposit(int amount) {
        return balance = balance + amount;
    }
}

R7-14 马里奥赛车

你玩过马里奥游戏吗？你当然有，谁没有？！不管怎么说，马里奥游戏的新版本已经发布了，它是某种卡丁车比赛游戏。你决定写一个程序来找到你完成每一个阶段的最佳策略。

每一条水平轨道可以模拟为一条无限长的直线，在这条直线上的某些特定点上有一些站点。每个站点都有一个整数，表示其在轨道上的位置。你的任务是从第一个站（位置最小的站）到最后一个站（位置最大的站）最小移动次数。

你可以直接在任何两个电台之间移动（你可以去一个不相邻的电台，也可以回到位置较低的电台，如果你愿意的话！）如果你有足够的提升金币来完成这个动作。在每个关卡中，你都有一些可以使用的提升币。每一个推进硬币都有成本和能量价值。你可以为每一步选择硬币的任何一个子集，但是每个硬币每次只能使用一次。硬币是永久性的，你可以在同一级别的其他招式中再次使用硬币。

要移动，你必须选择一个子集的增加硬币，这样他们的成本总和不能超过L，他们的权力值的总和必须完全等于你要移动的两个电台的位置之间的绝对差。如果没有这样的子集，则不能直接进行移动。
现在你得到了一些级别的配置，你需要找到完成每一个级别的最小移动次数，或者说不可能完成这个级别。

输入格式:

您的程序将在一个或多个测试用例上进行测试。输入的第一行将是单个整数 T、测试用例数（1≤T≤100）。

接下来是测试用例，每个测试用例的第一行包含3个整数，用单个空格N M L（2≤N≤100），（1≤M≤100）和（1≤L≤1000）,表示站点数量、提升硬币数量和最大硬币总数每次行动的成本。

后跟一行，其中包含N个分隔开的唯一正整数按一个空格（不需要排序，每个整数最多1000个），代表位置所有的车站。后面是M行，每行包含2个整数，用一个空格C V（1≤C，V≤100）隔开，分别代表一枚硬币的成本和权力价值。

输出格式:

对于每个测试用例，打印一行包含单个整数的行，如果无法从最左边的工作站转到最右边的工作站，那么这个整数应该是-1，如果可能的话，这个整数应该是最小移动次数。

输入样例:

输出样例:

2
-1

题意：

一条路上有n个车站，你有m个金币，金币有各自的费用和价值，可以通过金币在车站间移动；

每次移动要选择一些金币，总成本不能超过L，其价值和必须刚好等于abs(i-j)；

问从1号站移动到n号站最少移动多少次？

注意：

在第一个测试用例中，站点位置是[3，1，6]，从1开始，必须在6结束。你会必须做2个移动，

从1->3使用硬币（3，2），从3->6使用硬币（3，3）。你不能直接从1->6使用（3，2）和（3，3），因为硬币的成本总和超出限制4。

R7-15 学生类设计

设计一个类Student，并在Main类中生成Student类对象进行测试

1.对于Student类，设计私有属性name和age，并为每一个成员变量name和age设计其setXXX（）和getXXX（）方法,并对于setAge方法，如果age被赋值为<=6,则age值为7，其他为参数值。

2.对于Student类，设计无参构造方法，在构造方法中为age赋值为7，name赋值为“无名" 并添加语句System.out.println("无参构造方法")；

3.设计方法public void display(),方法中显示该学生的姓名和年龄，显示格式为name：无名，age：8

Main类的main方法中，创建1个学生对象，然后调用display方法显示学生信息，接着通过键盘输入1个学生的姓名和年龄，调用display方法去显示学生信息。

输入格式:

在一行内输入学生的姓名和年龄

输出格式:

对每一组输入，输出学生的姓名和年龄。

输入样例:

在这里给出一组输入。例如：

tom 6

jerry 8

输出样例:

在这里给出相应的输出。例如：

无参构造方法
name:无名,age:7
name:tom,age:7

无参构造方法
name:无名,age:7
name:jerry,age:8

import java.util.*;

public class Main {
    
    public static void main(String[] args) {
        
        Scanner cin = new Scanner(System.in);
        Student stu = new Student();
        stu.display();
        Student stu1 = new Student(cin.next(), cin.nextInt());
        stu1.display();
    }
}

class Student {
    
    private String name;
    private int age;
    
    public void setName(String name) {
        this.name = name;
    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        if (age <= 6) {
            this.age = 7;
        }
        else {
            this.age = age;
        }
    }
    public Student() {
        name = "无名";
        age = 7;
        System.out.println("无参构造方法");
    }
    public Student(String name, int age) {
        this.name = name;
        if (age <= 6) {
            this.age = 7;
        }
        else this.age = age;
    }
    public void display() {
        System.out.println("name:" + this.name + ",age:" + this.age);
    }
}

R7-16 物联网感知位置计算

物联网程序设计中，经常用到两个点的地理位置信息。和数学中的坐标系一个，你生活环境的每一个位置都有一个坐标（经度，纬度）可以用以下方式来声明：

double longitude;
double latitude;

A ,B两个点可以用以下方式：

double longitudeA;
double latitudeA;
double longitudeB;
double latitudeB;

然而你每天生活的轨迹并不是只有两个点，为了更好的表示这些点，我们需要申明一个点类：

class GeographicInfo {
    double latitude;
    double longitude;
}

然后再写出主程序：

public class Main {

   public static void main(String[] args) {
      // TODO Auto-generated method stub
       GeographicInfo G;
       G = new GeographicInfo();
       G.latitude = 35.66;
       G.longitude = 139.75;
       System.out.println(G.latitude);
       System.out.println(G.longitude);
   }

}

假如你的位置信息是从A到B,写一个程序输出你的出行轨迹，注意你的位置用键盘输入语句。

longitudeA;

double latitudeA;

double longitudeB;

double latitudeB;

输入格式:

输入四个double类型变量。

输出格式:

输出这几个变量的位置.

输入样例:

在这里给出一组输入。例如：

输出样例:

在这里给出相应的输出。例如：

(35.66,139.75)
(95.66,939.75)

import java.util.*;

public class Main {
    
    public static void main(String[] args) {
        
        Scanner cin = new Scanner(System.in);
        GeographicInfo a = new GeographicInfo();
        GeographicInfo b = new GeographicInfo();
        a.latitude = cin.nextDouble();
        a.longitude = cin.nextDouble();
        b.latitude = cin.nextDouble();
        b.longitude = cin.nextDouble();
        
        System.out.println("(" + a.latitude + "," + a.longitude + ")");
        System.out.println("(" + b.latitude + "," + b.longitude + ")");
        
    }
    
}

class GeographicInfo {
    
    double latitude;
    double longitude;
    
}

R7-17 物联网远程点灯实验

远程点亮一个LED 灯是物联网最基本的实验，假如灯的位置用一个点的从标来表示，请设计一个点类，并针对这个类进行编程实验，当输入位置坐标和开关状态时输出Led灯的 on或off状态。

输入格式:

坐标和开关状态，如x y true

输出格式:

灯的开关状态 on或off

输入样例:

在这里给出一组输入。例如：

1 1 false

输出样例:

在这里给出相应的输出。例如：

off

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);
        int x = cin.nextInt();
        int y = cin.nextInt();
        boolean state = cin.nextBoolean();
        Point point = new Point(x,y,state);
    }
}
class Point{
    int x,y;
    boolean state;
    public Point(){
    }
    public Point(int x,int y,boolean state){
        this.x = x;
        this.y = y;
        this.state = state;
        check();
    }
    public void check(){
        if(this.state==true){
            System.out.println("on");
        }
        else{
            System.out.println("off");
        }
    }
}

R7-18 两点成线

都说两点确定一条直线，那么设计一个直线类Line，需要通过两个点Point对象来确定。Line类具体要求如下：

1)定义两个Point对象p1，p2；

2)写出有参构造方法，传递两个对象值给p1，p2

3）为p1，p2写出setters，和getters方法

4）为Line写出一个getLength方法求直线中两点的长度

5) 为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

R7-18 两点成线

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.*;

public class Main {
    
    public static void main(String[] args) {
        
        Scanner cin = new Scanner(System.in);
        int n = cin.nextInt();
        for (int i = 0; i < n; i++) {
            int x1 = cin.nextInt();
            int y1 = cin.nextInt();
            int x2 = cin.nextInt();
            int y2 = cin.nextInt();
            System.out.printf("Line [p1=Point [x=%d, y=%d], p2=Point [x=%d, y=%d]]\n",x1,y1,x2,y2);
            System.out.printf("此线段的长度为：%.1f\n",Math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)));
        }
        
    }
    
}

R7-19 查询某人

有一个人员数组，要在此数组中查询某个人是否存在，具体要求如下：

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.*;

public class Main {
    
    public static void main(String[] args) {
        
        Scanner cin = new Scanner(System.in);
        int n = cin.nextInt();
        Persion[] p = new Persion[n];
        for (int i = 0; i < n; i++) {
            p[i] = new Persion(cin.next(), cin.nextInt());
            System.out.println(p[i].toString());
        }
        String s = cin.next();
        for (int i = 0; i < n; i++) {
            if (s.equals(p[i].name)) {
                System.out.println("查询结果：");
                System.out.println(p[i].toString());
                System.exit(0);
            }
        }
        System.out.println("not found");
    }
    
}
 class Persion {
     
     String name;
     int age;
     
     public Persion(String name, int age) {
         this.name = name;
         this.age = age;
     }
     
     public String toString() {
         return "Person [name=" + name +", age=" + age + "]";
     }
     
 }

R7-21 集体评分2

程序填空题。请补充以下代码，完成题目要求。（注意：需要提交完整代码）有一个团队由5个人组成。他们每个人给指导老师一个分数，去掉最高分，去掉最低分，剩下的3个分数的平均分就是该团队对指导老师的评分。

import java.util.Scanner;
public class Main {
    public static void main(String[] args) {
                Scanner in = new Scanner(System.in);
                int[] grade = new int[5];
                for(int i=0; i<grade.length; i++){
                      grade[i] = in.nextInt();
                 }

                RR rr = new RT(grade);
                double dd = rr.mark();
                System.out.printf("%.2f",dd);
    }
}
interface RR{
   double mark();
}
class RT implements RR{
   int[] grade;
   public RT(int[] grade){
      this.grade = grade;
   }
}

输入格式:

在一行中给出5个不超过10的正整数（从小到大排列）。

输出格式:

输出集体评分，保留小数点后两位。

输入样例:

1 2 4 6 9

输出样例:

4.00

import java.util.*;

public class Main {
    
    public static void main(String[] args) {
        
        Scanner cin = new Scanner(System.in);
        String l = cin.nextLine();
        String[] str = l.split(" ");
        int[] a = new int[str.length];
        int cnt = 0;
        for (int i = 0; i < str.length; i++) {
//             System.out.println(str[i]);
            a[cnt++] = Integer.parseInt(str[i]);
        }
        
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a.length; j++) {
                if (a[i] > a[j]) {
                    int t = a[i];
                    a[i] = a[j];
                    a[j] = t;
                }
            }
        }
        double sum = 0;
        for (int i = 1; i < a.length -1; i++) {
//             System.out.println(a[i]);
            sum += a[i];
        }
        System.out.printf("%.2f",sum / (a.length - 2));
    }
    
}

R7-26 设计一个Shape及其子类Oval

编写一个完整的Java Application 程序。包含类Shape、类Oval、类ShapeTest，具体要求如下：
(1)编写一个抽象类Shape表示形状对象，包含以下成员
①属性：
PI：double型常数，值为3.1415926；
②方法：

double area(), 抽象方法；
double perimeter()，抽象方法；
(2)编写一个Shape类的子类Oval，表示椭圆对象，包含以下成员
①属性：
a：私有，double型，长轴半径；
b：私有，double型，短轴半径；
②方法：
Oval(double a，double b), 构造方法,用参数设置椭圆的长轴半径和短轴半径
Oval(),构造方法，将椭圆的长轴半径和短轴半径都初始化为0。
double area()，重写Shape类中的area方法，返回椭圆的面积( )
double perimeter()，重写Shape类中的perimeter方法，返回椭圆的周长( )
public String toString( )，将把当前椭圆对象的转换成字符串形式，例如长轴半径为10.0，短轴半径为5，返回字符串"Oval(a:10.0,b:5.0)"。
（3）编写公共类Main,实现如下功能
输入长轴半径和短轴半径，并创建一个椭圆对象；
分别用area和perimeter方法，求出以上椭圆的面积和宽度并输出，输出过程中要求使用到toString方法，输出格式如下：

输入格式:

输入长轴半径和短轴半径

输出格式:

输出椭圆的面积和周长。

输入样例:

8 6

输出样例:

在这里给出相应的输出。例如：

The area of Oval(a:8.0,b:6.0) is 150.79644480000002
The perimeterof Oval(a:8.0,b:6.0) is 44.42882862370954

import java.util.*;

public class Main {
    
    public static void main(String[] args) {
        
        Scanner cin = new Scanner(System.in);
        double a = cin.nextDouble();
        double b = cin.nextDouble();
        Oval o = new Oval(a ,b);
        o.area();
        o.perimeter();
        System.out.println(o.toString());
        
    }
    
}

abstract class Shape {
    
    protected final double PI = 3.1415926;
    abstract public double area();
    abstract public double perimeter();
}

class Oval extends Shape{
    
    private double a;
    private double b;
    public Oval() {
        this(0,0);
    }
    public Oval(double a, double b) {
        super();
        this.a = a;
        this.b = b;
    }
//     S=π×a×b
    public double area(){
        return this.PI * a * b;
    }
//     L=2πb+4(a-b)
    public double perimeter() {
        return 2 * this.PI *  Math.sqrt((a * a + b * b) / 2);
    }
    public String toString() {
        return "The area of Oval(a:" + a + ",b:" + b + ") is " + area() + "\n" +
            "The perimeterof Oval(a:" + a + ",b:" + b + ") is " + perimeter();
    }
}

R7-27 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<Person> personList。输入其他字符，则结束创建。

创建说明: 对于String类型，如果为null则不创建对象，而赋值为null。对于company属性，如果为null则赋值为null，否则创建相应的Company对象。

对personList中的元素实现先按照姓名升序排序，姓名相同再按照年龄升序排序。提示：可使用Comparable<Person>或Comparator<Person>
接受输入，如果输入为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

import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;

import static java.lang.System.exit;

/**
 *
 * @author 梓叶枫林
 * @date 2020/11/01
 */
public class Main {
    public static void main (String [] args) {

        Scanner sc = new Scanner(System.in);

        List<Person> personList = new ArrayList<>();

        //创建对象并放入personList
        while (true) {

            String str = sc.next();


            if ("s".equals(str)) {
                //创建Student对象
                Student stu = new Student(sc.next(), sc.nextInt(), sc.nextBoolean(), sc.next(), sc.next());

                personList.add(stu);


            } else if ("e".equals(str)) {
                //创建Employee对象
                Employee emp = new Employee(sc.next(), sc.nextInt(), sc.nextBoolean(), sc.nextDouble(), new Company(sc.next()));

                personList.add(emp);


            } else {
                //结束创建
                sc.close();
                break;
            }
        }


        //排序
        Collections.sort(personList);

         //输出personList
        for (Person p : personList) {
            System.out.println(p.toString());
        }
        
        //判断是否是接下来的输入是否exit
        String s = sc.next();
        if ("exit".equals(s)) {
            exit(0);
        }

        //分类：将personList中的元素按照类型分别放到stuList与empList

        List<Student> stuList = new ArrayList<>();
        List<Employee> empList = new ArrayList<>();

        for (int i = 0; i < personList.size(); i++) {

             Person currentPerson = personList.get(i);
            if (currentPerson instanceof Student) {
                if (stuList.isEmpty()) {
                    stuList.add( (Student) currentPerson);
                } else if (!stuList.get(stuList.size()-1).equals(currentPerson)){
                    stuList.add((Student) currentPerson);
                }
            } else if (personList.get(i) instanceof Employee) {

                if (empList.isEmpty()) {
                    empList.add((Employee) currentPerson);
                } else if (!empList.get(empList.size()-1).equals(currentPerson)) {
                    empList.add((Employee) currentPerson);
                }
            }
        }

        //输出stuList
        System.out.println("stuList");
        for (Student stu : stuList) {
            System.out.println(stu.toString());
        }

        //输出empList
        System.out.println("empList");
        for (Employee emp : empList) {
            System.out.println(emp.toString());
        }

    }
}

abstract class Person implements Comparable<Person> {
    String name;
    int age;
    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 boolean equals(Object obj) {
        if (obj == null) {
            return false;
        }
        if (obj instanceof Person) {
            Person p = (Person) obj;
            return name.equals(p.name) && age == p.age && gender == p.gender;
        }
        return false;
    }


    @Override
    public int compareTo (Person p) {

        int temp = this.name.compareTo(p.name);
        return temp == 0 ? this.age - p.age : temp;

    }
}


class Student extends Person {

    String stuNo;
    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:" + name + "-" + age + "-" + gender + "-" + stuNo + "-" + clazz;
    }

    @Override
    public boolean equals(Object obj) {

        if (!super.equals(obj)) {
            return false;
        }
        if (obj instanceof Student) {
            Student stu = (Student) obj;
            return stuNo.equals(stu.stuNo) && clazz.equals(stu.clazz);
        }
        return false;
    }
}

class Company {
    String name;

    public Company(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return name;
    }

    @Override
    public boolean equals(Object obj) {

        if (obj == null) {
            return false;
        }
        if (obj instanceof Company) {
            Company c = (Company) obj;
            return name.equals(c.name);
        }
        return false;
    }
}

class Employee extends Person {

    Company company;
    double salary;

    public Employee(String name, int age, boolean gender, double salary, Company company) {

        super(name, age, gender);
        this.salary = salary;
        this.company = company;
    }

    @Override
    public String toString() {
        return "Employee:" + name + "-" + age + "-" + gender + "-" + company + "-" + salary;
    }

    @Override
    public boolean equals(Object obj) {

        if (!super.equals(obj)) {
            return false;
        }
        
        //salary保留一位小数
        DecimalFormat df = new DecimalFormat("#.#");
        if (obj instanceof Employee) {
            Employee employee = (Employee) obj;
            return company.equals(employee.company) && df.format(salary).equals(df.format(employee.salary));
        }
        return false;
    }

}

R7-29 jmu-Java-04面向对象进阶-04-嵌套类-静态嵌套类

定义类ArrayUtils，在该类内部创建一个静态嵌套类PairResult，该嵌套类包含：
属性: private double min与private double max，用于存放最小值最大值
方法：toString方法，格式见下面的输出样例。

为ArrayUtils类创建一个静态方法PairResult findMinMax(double[] values)，对传递进来的数组找到其中的最大值和最小值并返回PairResult对象。

main方法说明

输入n，创建大小为n的double型数组
依次输入n个double型数值放入数组
调用findMinMax方法得到结果，并输出。
最后使用System.out.println(ArrayUtils.PairResult.class)打印标识信息

输入样例

5
0 -1 1 1.1 1.1

输出样例

PairResult [min=-1.0, max=1.1]
\\这里打印标识

import java.util.*;

public class Main {

	public static void main(String[] args) {
		Scanner in=new Scanner(System.in);
		int n=in.nextInt();
		
		
		double s[]=new double[n];//为什么不用ArrayUtils[]s=new ArrayUtils[n];因为是double数组
		for(int i=0;i<s.length;i++) {
			double m=in.nextDouble();
			s[i]=m;
		}
		ArrayUtils l=new ArrayUtils();
		double max=s[0];
		double min=s[0];
		
		System.out.println(l.findMinMax(s).toString());
		System.out.println(ArrayUtils.PairResult.class);
	}

}
class ArrayUtils{
	
	static PairResult findMinMax(double[] s)
	{
		PairResult b=new PairResult();
		double min=s[0];
		double max=s[0];
		for(int i=0;i<s.length;i++) {
			if(s[i]>max) {
				max=s[i];
			}
			else if(s[i]<min) {
				min=s[i];
			}
		}
		b.setMax(max);
		b.setMin(min);
		return b;
	}

	static class PairResult{
		private double min;
		private double max;
		@Override
		public String toString() {
			return "PairResult [min=" + min + ", max=" + max + "]";
		}
		public void setMin(double min) {
			this.min = min;
		}
		public void setMax(double max) {
			this.max = max;
		}
		
		
	}
}

真题OK撒

关注

1
点赞
踩
25

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java面向对象程序设计综合练习2（编程题）

定义一个有关学生的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 , 调用上面的有参构造函数新建对象。输入样例:输出样例:
复制链接

扫一扫