西南石油大学PTA（期末）编程题题面

AORIE

已于 2023-11-15 14:19:03 修改

阅读量4.8k

点赞数 14

分类专栏： JAVA 文章标签： java eclipse jvm

于 2023-05-15 14:18:56 首次发布

本文链接：https://blog.csdn.net/LuciaX_/article/details/130682885

版权

JAVA 专栏收录该内容

3 篇文章 8 订阅

订阅专栏

前言：

本篇用于本人复习，部分代码参考相关博客（就是看头文件啦）

祝大家取得好成绩

7-1 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(name+","+age+","+gender+","+id);
    }
    public  void setname(String name){
        this.name=name;
    }
    public void setage(int age){
        this.age=age;
    }
    public void setgender(boolean gender){
        this.gender =gender;   
    }
    public String getname(){
        return name;
    }
    public int getage(){
        return age;
    }
    public boolean getgender(){
        return gender;
    }
    public Person(String name, int age, boolean gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }
    public String toString(){
        return "Person [name="+name+", age="+age+", gender="+gender+", id="+id+"]";
    }
}
public class Main {
	public static void main(String[] args) {
        Scanner cin=new Scanner(System.in);
        int n=cin.nextInt();
        Person[] p=new Person[n];
       for(int i=n-1;i>=0;i--){
            String name=cin.next();
            int age=cin.nextInt();
            boolean gender =cin.nextBoolean();
            p[i]=new Person(name,age,gender);      
        }
         for (int i = 0; i <n ; i++) {
            System.out.println(p[i].toString());
        }
         Person p1=new Person();
        System.out.println(p1.toString());
    }
}

7-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 , 调用上面的有参构造函数新建对象。

输入样例:

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, String sex, int age) {
        this.name = name;
        this.sex = sex;
        this.age = age;
    }

    @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 scanner = new Scanner(System.in);
        String name = scanner.next();
        int age = scanner.nextInt();
        String sex = scanner.next();
        Student student = new Student(name, sex, age);
        System.out.println(student.toString());
    }
}

7-3 设计一个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.*;
class BankAccout{
    int balance;
    public BankAccout(){
        this.balance=0;
    }
    public BankAccout(int balance){
        this.balance=balance;
    }
    public int getBalance(int balance){
        return balance;
    }
    public int withdraw(int amount){
        return balance=balance-amount;
    }
    public int deposit(int amount){
        return balance=amount+balance;
    }
}
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();
        BankAccout k=new BankAccout(a);
        System.out.println(k.getBalance(a));
        System.out.println(k.withdraw(b));
        System.out.println(k.deposit(c));
        
    }
}

7-4 构造方法

请补充以下代码，完成输出要求。

public class Main {
    public Main(){
        System.out.println("构造方法一被调用了");
    }
    public Main(int x){
        this();
        System.out.println("构造方法二被调用了");
    }
    public Main(boolean b){
        this(1);
        System.out.println("构造方法三被调用了");
    }
    public static void main(String[] args) {
        
    }
}

输入格式:

无

输出格式:

输出以下三行：
构造方法一被调用了
构造方法二被调用了
构造方法三被调用了

输入样例:

无

输出样例:

构造方法一被调用了
构造方法二被调用了
构造方法三被调用了

题解

import java.util.*;

public class Main {
    public Main(){
        System.out.println("构造方法一被调用了");
    }
    public Main(int x){
        this();
        System.out.println("构造方法二被调用了");
    }
    public Main(boolean b){
        this(1);
        System.out.println("构造方法三被调用了");
    }
    public static void main(String[] args) {
    
        // Main obj1 = new Main();
        // Main obj2 = new Main(1);
        Main obj3 = new Main(true);
    }
}

7-5 图形继承

编写程序，实现图形类的继承，并定义相应类对象并进行测试。

类Shape，无属性，有一个返回0.0的求图形面积的公有方法public double getArea();//求图形面积
类Circle，继承自Shape，有一个私有实型的属性radius（半径），重写父类继承来的求面积方法，求圆的面积
类Rectangle，继承自Shape，有两个私有实型属性width和length，重写父类继承来的求面积方法，求矩形的面积
类Ball，继承自Circle，其属性从父类继承，重写父类求面积方法，求球表面积，此外，定义一求球体积的方法public double getVolume();//求球体积
类Box，继承自Rectangle，除从父类继承的属性外，再定义一个属性height，重写父类继承来的求面积方法，求立方体表面积，此外，定义一求立方体体积的方法public double getVolume();//求立方体体积
注意：

每个类均有构造方法，且构造方法内必须输出如下内容：Constructing 类名
每个类属性均为私有，且必须有getter和setter方法（可用Eclipse自动生成）
输出的数值均保留两位小数

主方法内，主要实现四个功能（1-4）：
从键盘输入1，则定义圆类，从键盘输入圆的半径后，主要输出圆的面积；
从键盘输入2，则定义矩形类，从键盘输入矩形的宽和长后，主要输出矩形的面积；
从键盘输入3，则定义球类，从键盘输入球的半径后，主要输出球的表面积和体积；
从键盘输入4，则定义立方体类，从键盘输入立方体的宽、长和高度后，主要输出立方体的表面积和体积；

假如数据输入非法（包括圆、矩形、球及立方体对象的属性不大于0和输入选择值非1-4），系统输出Wrong Format

输入格式:

共四种合法输入

1 圆半径
2 矩形宽、长
3 球半径
4 立方体宽、长、高

输出格式:

按照以上需求提示依次输出

输入样例1:

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

1 1.0

输出样例1:

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

Constructing Shape
Constructing Circle
Circle's area:3.14

输入样例2:

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

4 3.6 2.1 0.01211

输出样例2:

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

Constructing Shape
Constructing Rectangle
Constructing Box
Box's surface area:15.26
Box's volume:0.09

输入样例3:

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

2 -2.3 5.110

输出样例2:

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

Wrong Format

题解

import java.util.*;
 
class Shape{
	public Shape() {
		System.out.println("Constructing Shape");
	}
	public double getArea() {
		return 0.0;
	}
}
 
class Circle extends Shape{
	private double  radius;
	public Circle() {
		System.out.println("Constructing Circle");
	}
	public double getArea() {
		return  Math.PI*radius*radius;
   }
	//就是简单获取到Shape里面的radius，因为题目要求是private类型，
	//我看他给出的意见是protect ，原来写的，不过问题不大
	//void setRadius 要传参，别忘了 
	public double getRadius() {
       return radius;
   }
	public void setRadius(double radius) {
	    this.radius = radius;
	}
}
class Rectangle extends Shape{
	private double  width;
	private double length;
	public Rectangle() {
		System.out.println("Constructing Rectangle");
	}
	public double getArea() {
		return width*length;
	}
	public double getWidth() {
		return width;
	}
	public void setWidth(double width) {
		this.width=width;
	}
	public double getLength() {
		return length;
	}
	public void setLength(double length) {
		this.length=length;
	}
}
 
class Ball extends Circle{
	public Ball() {
		System.out.println("Constructing Ball");
	}
	
	public double getArea() {
		return 4.0*super.getArea();
	}
	//在子类Ball中，我们重写了父类(circle)的getArea方法，
	//如果在重写的getArea方法中我们去调用了父类(circle)的相同方法，
	//必须要通过super关键字显示的指明出来。
	//如果不指出super的话，出来的结果就是circle里面的getArea里面的结果
	//看懂，掌声
	public double getVolume() {
		double l=getRadius();
		//因为父类(circle)里面有，不需要重新定义，我们直接拿下好吧
		return Math.PI*l*l*l*4/3.0;
	}
	
}
class Box extends Rectangle{
	private double height;
	public Box() {
		System.out.println("Constructing Box");
	}
	public double getArea(){
		
		double length=getLength();
		
		double width=getWidth();
		return 2*(width*length+length*height+height*width);
	}
	public double getVolume() {
		return super.getArea()*height;
	}
	public double getHeight() {
		return height;
	}
	public void setHeight(double height) {
		this.height=height;
	}
}
 
 
public class Main {
	public static void main(String[] args) {
	
		Scanner cin=new Scanner(System.in);
		int k=cin.nextInt();
		switch(k) {
		case 1:
			//创建一个圆的对象
			double r0= cin.nextDouble();
           // double r;
           // r=cin.nextDouble();
			
			if(r0<0) {
				System.out.println("Wrong Format");
			}
			else {
			Circle c1= new Circle();
			c1.setRadius(r0);
			System.out.printf("Circle's area:%.2f\n",c1.getArea());
			}
			break;
		case 2:
			//创建一个矩形对象
			double w1= cin.nextDouble();
			double l1= cin.nextDouble();
			if(w1<=0||l1<=0) {
				System.out.println("Wrong Format");
			}
			else {
			Rectangle R1= new Rectangle();
			R1.setWidth(w1);
			R1.setLength(l1);
			System.out.printf("Rectangle's area:%.2f\n",R1.getArea());
			}
			break;
		case 3:
			double r=cin.nextDouble();
			if(r<=0) {
				System.out.println("Wrong Format");
			}
			else {
				Ball B1=new Ball();
				B1.setRadius(r);
				System.out.printf("Ball's surface area:%.2f\n",B1.getArea());
	            System.out.printf("Ball's volume:%.2f\n",B1.getVolume());
			}
			break;
		case 4:
			
			double w2= cin.nextDouble();
			double l2= cin.nextDouble();
			double h2= cin.nextDouble();
			if(w2<=0||l2<=0||h2<=0) {
				System.out.println("Wrong Format");
			}
			else {
				Box BX1=new Box();
				BX1.setHeight(h2);
				BX1.setLength(l2);
				BX1.setWidth(w2);
				System.out.printf("Box's surface area:%.2f\n",BX1.getArea());
	            System.out.printf("Box's volume:%.2f\n",BX1.getVolume());
			}
			break;
		default :
	            System.out.println("Wrong Format");
 
		cin.close();//记得关，好习惯
	}
	}
}

7-6 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

题解

import java.util.*;

abstract class Shape{
    final static 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) {
        this.width = width;
        this.length = length;
    }
    public double getArea() { 
        return width*length;
    }
    public double getPerimeter() {
        return 2*(width+length);
    }
    public String toString() {
        return "Rectangle [" + "width=" + width + ", length=" + length + ']';
    }
}

class Circle extends Shape{
    int  radius;
    public Circle(){
    }
    public Circle(int  r) {
        this.radius = r;
    }
    public double getArea() { 
        return PI*this.radius*this.radius;
    }
    public double getPerimeter() {
        return 2*PI*this.radius;
    }
    @Override
    public String toString() {
        return "Circle [radius=" + radius + "]";
    }
}

public class Main {

    public static void main(String[] args) {
        Scanner cin=new Scanner(System.in);
        int n=cin.nextInt();
        Shape[] a=new Shape[n];
        for(int i=0;i<n;i++) {
            String y=cin.next();
            if(y.equals("rect")) {  
            	int  w=cin.nextInt();
                int  l=cin.nextInt();
              
                a[i]=new Rectangle(w,l);
            } else if(y.equals("cir")) {
                int  r = cin.nextInt();
                a[i] = new Circle(r);
            }
        }
        
        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());
		}
        cin.close();
    }

    private 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 if(a[i] instanceof Circle) {
                t=t+((Circle)a[i]).getPerimeter();
                
            }
        }
        return t;
    }

    private 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 if(a[i] instanceof Circle) {
                t=t+((Circle)a[i]).getArea();
            }
        }
        return t;
    }
}

7-7 接口--四则计算器

利用接口做参数，写个计算器，能完成加减乘除运算。

定义一个接口ICompute含有一个方法int computer(int n, int m)。
定义Add类实现接口ICompute，实现computer方法，求m，n之和
定义Sub类实现接口ICompute，实现computer方法，求n-m之差
定义Main类，在里面输入两个整数a, b，利用Add类和Sub类的computer方法，求第一个数a和第二个数b之和，输出和，第一个数a和第二个数b之差，输出差。

输入格式:

输入在一行中给出2个整数

输出格式:

输出两个数的和、差

输入样例:

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

6 7

输出样例:

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

13
-1

题解：

import java.util.*;
interface ICompute{
	int computer(int n,int m) ;
}
class Add implements ICompute{
	int a,b;
	public Add(int a,int b) {
		this.a=a;
		this.b=b;
	}
	public int computer(int a,int b) {
		return a+b;
	}
	
}
class Sub implements ICompute{
	int a,b;
	public Sub(int a,int b) {
		this.a=a;
		this.b=b;
	}
	public int computer(int a,int b) {
		return a-b;
	}
	
}

public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner cin=new Scanner (System.in);
		int n= cin.nextInt();
		int m=cin.nextInt();
		Add a=new Add(n,m);
		Sub b=new Sub(n,m);
		System.out.println(a.computer(n,m));
		System.out.println(b.computer(n,m));
		
		cin.close();
		
		
	}

}

7-8 jmu-Java-02基本语法-02-StringBuilder

输入3个整数n、begin、end。
首先，使用如下代码：

for(int i=0;i<n;i++)

将从0到n-1的数字拼接为字符串str。如，n=12，则拼接出来的字符串为01234567891011

最后截取字符串str从begin到end(包括begin，但不包括end)之间的字符串，并输出。

输入样例:

输出样例:

567
0330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533

题解

import java.util.*;
public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner cin=new Scanner(System.in);
        int n=cin.nextInt();
        int begin=cin.nextInt();
        int end=cin.nextInt();
        int n2=cin.nextInt();
        int b2=cin.nextInt();
        int e2=cin.nextInt();
        StringBuilder sb = new StringBuilder();
        StringBuilder sb2 = new StringBuilder();
        for(int i=0;i<n;i++){
            sb.append(i);
        }
        for(int i=0;i<n2;i++){
            sb2.append(i);
        }
        System.out.println(sb.substring(begin,end));
        System.out.println(sb2.substring(b2,e2));


    }
}

7-9 单词替换

设计一个对字符串中的单词查找替换方法，实现对英文字符串中所有待替换单词的查找与替换。

输入格式:

首行输入母字符串，第二行输入查询的单词，第三行输入替换后的单词。

输出格式:

完成查找替换后的完整字符串

输入样例:

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

Although I am without you, I will always be ou you
ou
with

输出样例:

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

Although I am without you, I will always be with you

题解：

import java.util.*;
public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
        Scanner in=new Scanner(System.in);
        String str= in.nextLine();
        String str1= in.nextLine();
        String str2= in.nextLine();
       
    
        String []s=str.split(" ");
        for(int i=0;i<s.length;i++){
            if(s[i].equals(str1)){
                s[i]=str2;
            }
        }
        for(int i=0;i<s.length;i++){
            if(i!=s.length-1){
                System.out.printf("%s ",s[i]);
            }else{
                System.out.printf("%s",s[i]);
            }
        }
    }
}

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

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

输入格式:

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

输出格式:

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

输入样例:

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

输出样例:

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

题解：

import java.util.*;
public class Main {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner cin=new  Scanner(System.in);
		String a=cin.nextLine();
		int b=0,c=0,d=0,e=0;
		for(int i=0;i<a.length();i++) {
			char ch=a.charAt(i);
			if((ch>='a'&&ch<='z')||(ch>='A'&&ch<='Z')) {
				b++;
				// continue;
			}else if(ch==' ') {
				c++;
				// continue;
			}else if(ch>='0'&&ch<='9'){
				d++;
				// continue;
			}else {e++;}
			
		}
		System.out.println("字母个数：" + b);
	    System.out.println("数字个数：" + d);
	    System.out.println("空格个数：" + c);
	    System.out.println("其他字符个数：" + e);
		cin.close();
	}

}

7-11 jmu-Java-02基本语法-08-ArrayList入门

本习题主要用于练习如何使用ArrayList来替换数组。
新建1个ArrayList<String> strList用来存放字符串，然后进行如下操作。

提示: 查询Jdk文档中的ArrayList。
注意: 请使用System.out.println(strList)输出列表元素。

输入格式

输入: n个字符串，放入strList。直到输入为!!end!!时，结束输入。
在strList头部新增一个begin，尾部新增一个end。
输出列表元素
输入: 字符串str
判断strList中有无包含字符串str，如包含输出true，否则输出false。并且输出下标，没包含返回-1。
在strList中从后往前找。返回其下标，找不到返回-1。
移除掉第1个(下标为0)元素,并输出。然后输出列表元素。
输入: 字符串str
将第2个（下标为1）元素设置为字符串str.
输出列表元素
输入: 字符串str
遍历strList，将字符串中包含str的元素放入另外一个ArrayList strList1，然后输出strList1。
在strList中使用remove方法，移除第一个和str相等的元素。
输出strList列表元素。
使用clear方法，清空strList。然后输出strList的内容，size()与isEmpty()，3者之间用,连接。

输入样例:

a1 b1 3b a2 b2 12b c d !!end!!
b1
second
b

输出样例:

[begin, a1, b1, 3b, a2, b2, 12b, c, d, end]
true
2
2
begin
[a1, b1, 3b, a2, b2, 12b, c, d, end]
[a1, second, 3b, a2, b2, 12b, c, d, end]
[3b, b2, 12b]
[a1, second, 3b, a2, b2, 12b, c, d, end]
[],0,true

题解：


import java.util.ArrayList;
import java.util.Scanner;
public class Main {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		Scanner cin=new Scanner (System.in);
		ArrayList<String> s1=new ArrayList<String>();
		while(true) {
			String a=cin.next();
			if(a.equals("!!end!!")){
				break;
			}
			s1.add(a);
		}
			s1.add(0,"begin");
			s1.add("end");
			System.out.println(s1);
			
		String b=cin.next();
		if(s1.contains(b)) {
			System.out.println("true");
		}else {System.out.println("false");}
		System.out.println(s1.indexOf(b));
		boolean flag=true;
		for(int i=s1.size()-1;i>=0;i--) {
			if(s1.get(i).equals(b)) {
			    System.out.println(i);
                flag=false;
				break;
			}
			
		}
		if(flag) {
            System.out.println("-1");
        }
        System.out.println(s1.get(0));
		s1.remove(0);
		System.out.println(s1);
		
		String d=cin.next();
		s1.set(1, d);
		System.out.println(s1);
		
		String e=cin.next();
		 ArrayList<String> strList1 = new ArrayList<>();
	        for (String s : s1){
	            if (s.contains(e)){
	                strList1.add(s);
	            }
	        }
	        System.out.println(strList1);
	        for (String s : s1){
	            if (s.equals(e)){
	                s1.remove(e);
	                break;
	            }
	        }
	        System.out.println(s1);
	        s1.clear();
	        System.out.println(s1 + "," + s1.size() + "," + s1.isEmpty());
		
	
		cin.close();

	}

}

7-12 找到出勤最多的人

根据教师的花名册，找到出勤最多的人。

输入格式:

出勤记录单行给出，数据直接使用空格分割。

输出格式:

单行输出（若有多人，人名直接使用空格分割，结尾处没有空格）。

输入样例:

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

zs ls ww ml zs ls ml zs ww

输出样例:

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

zs

题解

import java.util.*;

public class Main {
public static void main(String[] args) {
	    ArrayList<String> List = new ArrayList<>();
	    Scanner scan = new Scanner(System.in);
	    int max=0;
	    String s="";
	    while(scan.hasNext())
	    {
	    	String a=scan.next();
	        List.add(a);
	    }
	    for(int i=0;i<List.size();i++)
	    {
	    	int m=0;
	    	for(int k=0;k<List.size();k++)
	    	{
	    		if(List.get(k).equals(List.get(i)))
	    		{
	    			m++;
		    		if(max<m)
		    		{
		    			max=m;
		    		s=List.get(i);
	    		    }
 
	    		}
	    	}
	    }
	    System.out.println(s);
	}
}

7-13 创建一个倒数计数线程

分数 10

全屏浏览题目

切换布局

作者吴恋

单位贵州师范学院

创建一个倒数计数线程。要求：1.该线程使用实现Runnable接口的写法；2.程序该线程每隔0.5秒打印输出一次倒数数值（数值为上一次数值减1）。

输入格式:

N（键盘输入一个整数）

输出格式:

每隔0.5秒打印输出一次剩余数

输入样例:

输出样例:

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

题解

import java.util.*;

class PrintTask implements Runnable {
	private int n;
	public PrintTask(int n){
		   this.n=n;
	}
	public void run() {
		for(int i=n;i>=0;i--) {
		for(int l=0;l<500;l++);
		System.out.println(i);
	    }
	}
}
public class Main{
	    public static void main(String[] args) {
	    	Scanner cin=new Scanner(System.in) ;
	    	PrintTask ta=new PrintTask(cin.nextInt());
	    	Thread t=new Thread(ta);
	    	t.start();
            cin.close();
	    }
}

7-14 USB接口的定义

定义一个USB接口，并通过Mouse和U盘类实现它，具体要求是：

1.接口名字为USB，里面包括两个抽象方法：

void work（）；描述可以工作

void stop(); 描述停止工作

2.完成类Mouse，实现接口USB，实现两个方法：

work方法输出“我点点点”；

stop方法输出 “我不能点了”；

3.完成类UPan，实现接口USB，实现两个方法：

work方法输出“我存存存”；

stop方法输出 “我走了”；

4测试类Main中，main方法中

定义接口变量usb1 ，存放鼠标对象，然后调用work和stop方法

定义接口数组usbs,包含两个元素，第0个元素存放一个Upan对象，第1个元素存放Mouse对象，循环数组，对每一个元素都调用work和stop方法。

输入格式:

输出格式:

输出方法调用的结果

输入样例:

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

输出样例:

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

我点点点
我不能点了
我存存存
我走了
我点点点
我不能点了

题解

import java.util.*;
interface USB{
	void work();
	void stop();
}
class Mouse implements USB{
	public void work() {
		System.out.println("我点点点");
	}
	public void stop() {
		System.out.println("我不能点了");
	}

}
class UPan implements USB{
	public void work() {
		System.out.println("我存存存");
	}
	public void stop() {
		System.out.println("我走了");
	}

}
public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Mouse usb1=new Mouse();
		usb1.work();
		usb1.stop();
		USB []k=new USB[2];
		k[0]=new UPan();
		k[1]=new Mouse();
		k[0].work();
		k[0].stop();
		k[1].work();
		k[1].stop();
	}

}

7-15 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.*;
class Circle{
	private int radius;
	public Circle() {
		this.radius=2;
		System.out.println("this is a constructor");
	}
	public Circle(int r) {
		if(r<=0) {
			this.radius=2;
			System.out.println("this is a constructor with para");
		}else {this.radius=r;
              System.out.println("this is a constructor with para");}
	}
	public void setRadius(int r) {
		if(r<=0) {
			this.radius=2;
		}else this.radius=r;
	}
	public int getRadius() {
		return this.radius;
	}
	public int  getArea() {
		return (int)(Math.PI*radius*radius);
	}
	@Override
	public String toString() {
		return "Circle [radius=" + radius + "]";
	}
	
}
public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		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());
		int r=cin.nextInt();

        c2.setRadius(r);
        System.out.println( c2.toString());
		System.out.println("c2:area=" + c2.getArea());
		int r1=cin.nextInt();
		Circle c3=new Circle(r1);
       //System.out.println();
		System.out.println(c3.toString());
		System.out.println("c3:area=" + c3.getArea());
		cin.close();
	}
}

7-16 数组与对象

定义一个Person类

包含name
在Person类完成无参构造方法，在无参构造方法设置name值为none
有参构造方法给name传值
为name属性添加set和get方法
<
public String toString(){
return "name:"+name;
}

2 在Main类的main方法中

创建Person类对象数组，其中数组长度为2
并为Person对象数组赋值，其中第一个元素对象为无参person对象，第二个元素对象为有参person对象，姓名为用户键盘给出
并循环输出两个对象的信息（调用toString方法），一个对象输出一行

输入格式:

输入姓名

输出格式:

输出姓名，一行一个对象

输入样例:

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

jerry

输出样例:

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

name:none
name:jerry

题解

import java.util.*;
class Person {
    private String name;
    public Person() {
        this.name = "none";
    }
    public Person(String name) {
        this.name = name;
    }

    public String getName() { return name; }
    public void setName(String name) { this.name = name; }

    public String toString() {
        return "name:" + this.name;
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // 创建Person对象数组，并为数组元素赋值
        Person[] persons = new Person[2];
        persons[0] = new Person();
        persons[1] = new Person(scanner.next());

        // 输出Person对象信息
        for (Person person : persons) {
            System.out.println(person.toString());
        }

        scanner.close();
    }
}

7-17 圆柱体类设计

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.*;
class Cylinder{
	private int radius,height;
	public void setRadius(int r) {
		this.radius=r;
	}
	public void setHeight(int h) {
		this.height=h;
	}
	public int getRadius() {
		return this.radius;
	}
	public int getHeight() {
		return this.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);
	}
}
public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner cin=new Scanner(System.in);
		int r=cin.nextInt();
		int h=cin.nextInt();
		Cylinder c1=new Cylinder(r,h);
		System.out.println(c1.getVolumn());
		Cylinder c2=new Cylinder();
		System.out.println(c2.getVolumn());
		cin.close();

	}

}

7-18 List的使用

本题练习列表的使用。

定义Person类

定义私有属性String name,int age,使用Eclipse生成每个属性setter 、getter，有参Person(String name,int age) 、无参构造方法，toString方法。

定义Main类，在main方法中

定义List list = new ArrayList();
用键盘给变量n赋值
生成n个Person对象并添加到列表中，该Person的name和age通过键盘给出
循环列表，输出列表所有Person对象信息（调用toString方法）
输入一个字符串表示姓名，判断该字符串表示的Person对象在List中是否存在，如果存在，输出该Person，否则输出此人不存在。

输入格式:

先一行输入n表示对象个数，然后每行输入一个Person对象的name和age
一行输入一个人的姓名对其进行查询

输出格式:

对每一对象，在一行中输出对象的信息。
对查询的人员，查到输出该人的信息，否则输出此人不存在。

输入样例:

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

3
zhang 23
li 44
wang 33
li

3
zhang 23
li 44
wang 33
may

输出样例:

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

Person [name=zhang, age=23]
Person [name=li, age=44]
Person [name=wang, age=33]
Person [name=li, age=44]

Person [name=zhang, age=23]
Person [name=li, age=44]
Person [name=wang, age=33]
此人不存在

题解

import java.util.*;

 
class Person{
    private String name;
    private int age;
 
    Person(String name,int age){
        this.name=name;
        this.age=age;
    }
 
    public void setName(String name){
        this.name=name;
    }
 
    public String getName(){
        return name;
    }
 
    public void setAge(int age){
        this.age=age;
    }
 
    public int getAge(){
        return age;
    }
 
    public String toString(){
       return "Person [name=" + name + ", age=" + age + "]";
    }
}
 
public class Main {
	public static void main(String[] args) {
		ArrayList<Person>list=new ArrayList<>();
		Scanner in=new Scanner(System.in);
		int n=in.nextInt();
		for(int i=0;i<n;i++) {
			Person p=new Person(in.next(),in.nextInt());
			list.add(p);
			System.out.println(p.toString());
		}
		String l=in.next();
		int i;
		for(i=0;i<list.size();i++) {
			if(list.get(i).getName().equals(l)) {
				System.out.println(list.get(i).toString());
				break;
			}
		}
		if(i==list.size()) {
			System.out.println("此人不存在");
		}
	}
}

7-19 jmu-Java-03面向对象基础-03-形状

分数 10

全屏浏览题目

切换布局

作者郑如滨

单位集美大学

1. 定义长方形类与圆形类Circle

长方形类-类名：Rectangle，private属性：int width,length
圆形类-类名：Circle，private属性:int radius

编写构造函数：
带参构造函数:Rectangle(width, length),Circle(radius)

编写方法：
public int getPerimeter()，求周长。
public int getArea()，求面积。
toString方法，使用Eclipse自动生成。

注意：

计算圆形的面积与周长，使用Math.PI。
求周长和面积时，应先计算出其值(带小数位)，然后强制转换为int再返回。

2. main方法

输入2行长与宽，创建两个Rectangle对象放入相应的数组。
输入2行半径，创建两个Circle对象放入相应的数组。
输出1：上面2个数组中的所有对象的周长加总。
输出2：上面2个数组中的所有对象的面积加总。
最后需使用Arrays.deepToString分别输出上面建立的Rectangle数组与Circle数组

思考：如果初次做该题会发现代码冗余严重。使用继承、多态思想可以大幅简化上述代码。

输入样例:

输出样例:

69
170
[Rectangle [width=1, length=2], Rectangle [width=3, length=4]]
[Circle [radius=7], Circle [radius=1]]

题解：

import java.util.*;
class Circle{
	private int radius;
	public Circle(int r) {
		this.radius=r;
	}
	public int getPerimeter() {
		return (int)(2*Math.PI*radius);
	}
	public int getArea() {
		return (int)(Math.PI*radius*radius); 
	}
	@Override
	public String toString() {
		return "Circle [radius=" + radius + "]";
	}
	
}
class Rectangle{
	private int width,length;
	public Rectangle(int w,int l) {
		this.width=w;
		this.length=l;
	}
	public int getPerimeter() {
		return 2*(width+length);
	}
	public int getArea() {
		return length*width;
	}
	@Override
	public String toString() {
		return "Rectangle [width=" + width + ", length=" + length + "]";
	}
	
	
}

public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner cin= new Scanner(System.in);
		Rectangle []r=new Rectangle[2];
		for(int i=0;i<2;i++) {
		int w=cin.nextInt();
		int l=cin.nextInt();
	    r[i]=new Rectangle(w,l);
		}
		Circle []k=new Circle[2];
		for(int i=0;i<2;i++) {
		int w=cin.nextInt();
	    k[i]=new Circle(w);
		}
		int sumP=0;
		int sumA=0;
		for(int i=0;i<2;i++) {
			sumP=sumP+r[i].getPerimeter()+k[i].getPerimeter();
			sumA=sumA+r[i].getArea()+k[i].getArea();
		}
		System.out.println(sumP);
		System.out.println(sumA);
		System.out.println(Arrays.deepToString(r));
		System.out.println(Arrays.deepToString(k));
		cin.close();
	}

}

7-20 教师类

设计一个教师类Teacher,要求：
属性有编号（int no）、姓名（String name）、年龄（int age）、所属学院（String seminary），为这些属性设置相应的get和set方法。
为Teacher类重写equals方法，要求：当两个教师对象的no相同时返回true。
重写Teacher类的toString方法，通过该方法可以返回“no: , name:, age: **, seminary: **”形式的字符串。

输入格式:

两个教师对象的编号，姓名，年龄，学院

输出格式:

教师的信息
两个教师是否相等

输入样例:

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

1 Linda 38 SoftwareEngineering
2 Mindy 27 ComputerScience

输出样例:

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

no: 1, name:Linda, age: 38, seminary: SoftwareEngineering
no: 2, name:Mindy, age: 27, seminary: ComputerScience
false

题解

import java.util.*;
class Teacher{
	private int no,age;
	private String name,seminary;
	public void setno(int no){
		this.no=no;
	}
	public int getno(){
		return this.no;
	}
	public void setname(String name){
		this.name=name;
	}
	public String  getname(){
		return this.name;
	}
	public void setage(int age){
		this.age=age;
	}
	public int getage(){
		return this.age;
	}
	public void setseminary(String k){
		this.seminary=k;
	}
	public String  getseminart(){
		return this.seminary;
	}
	 public boolean equals(Object obj) {
	        if (obj == null || !(obj instanceof Teacher)) {
	            return false;
	        }
	        if (no == ((Teacher) obj).no) {
	            return true;
	        }
	        return false;
	    }

	    @Override
	    public String toString() {
	        return "no: " + no + ", name:" + name + ", age: " + age + ", seminary: " + seminary;
	    }
}
public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner cin=new Scanner(System.in);
		   int no1 = cin.nextInt();
	      String name1 = cin.next();
	      int age1 = cin.nextInt();
	      String seminary1 = cin.next();
	      Teacher t1=new Teacher();
	        t1.setno(no1);
	        t1.setname(name1);
	        t1.setage(age1);
	        t1.setseminary(seminary1);
	        System.out.println(t1.toString());
	      int no2 = cin.nextInt();
	      String name2 = cin.next();
	      int age2 = cin.nextInt();
	      String seminary2 = cin.next();
	      Teacher t2=new Teacher();
	        t2.setno(no2);
	        t2.setname(name2);
	        t2.setage(age2);
	        t2.setseminary(seminary2);
	        System.out.println(t2.toString());
	      if (t1.equals(t2)) {
	            System.out.println("true");
	        } else {
	            System.out.println("false");
	        }
		cin.close();
		

	}

}

7-21 正方形类

定义一个正方形类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.*;
class Square{
	private int edge;
	public void setEdge(int e) {
		if(e<=0) {
			this.edge=1;
		}else 	this.edge=e;
	}
	public int getEdge() {
		return this.edge;
	}
	public Square(){
		this.edge=2;
		System.out.println("this is constructor method");
	}
	public int getArea() {
		return this.edge*this.edge;
	}
}
public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner cin=new Scanner(System.in);
		int a=cin.nextInt();
		Square s1=new Square();
		
		System.out.println("s1:edge="+s1.getEdge());
		System.out.println("s1:area="+s1.getArea());
		Square s2=new Square();
		s2.setEdge(a);
		System.out.println("s2:edge="+s2.getEdge());
		System.out.println("s2:area="+s2.getArea());
		cin.close();
	}

}

7-22 定义类与创建对象

定义一个类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.*;
class Person{
	String name;
	int age;
	public Person(String name,int age) {
		this.name=name;
		this.age=age;
	}
	
}
public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Person p1=new Person("lili",19);
		Person p2=new Person("lucy",20);
		System.out.println("this person is "+p1.name+",her age is "+p1.age);
		System.out.println("this person is " +p2.name+",her age is "+p2.age);
		

	}

}

7-23 学生类设计

设计一个类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.*;

class Student {
    private String name;
    private int age;

    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return this.name;
    }

    public void setAge(int age) {
        if (age <= 6) {
            this.age = 7;
        } else {
            this.age = age;
        }
    }

    public int getAge() {
        return this.age;
    }

    public Student() {
        this.name = "无名";
        this.age = 7;
        System.out.println("无参构造方法");
    }

    public void display() {
        System.out.println("name:" + name + ",age:" + age);
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String name = scanner.next();
        int age = scanner.nextInt();

        Student s1 = new Student();
        s1.display();

      
        s1.setName(name);
        s1.setAge(age);
        s1.display();

        scanner.close();
    }
}

7-24 设计BankAccount类

设计一个BankAccount类，这个类包括：

（1）一个int型的balance表时账户余额。

（2）一个无参构造方法，将账户余额初始化为0。

（3）一个带一个参数的构造方法，将账户余额初始化为该输入的参数。

（4）一个getBlance（）方法，返回账户余额。

（5）一个withdraw（）方法：带一个amount参数，并从账户余额中提取amount指定的款额。

（6）一个deposit（）方法：带一个amount参数，并将amount指定的款额存储到该银行账户上。

提供main函数，构造一个账户对象，并对其进行存取款操作。

其中操作类型类型为1表示存款，2表示取款，每次操作后都打印余额

输入格式:

账户余额
操作个数
操作类型操作金额

输出格式:

每次操作后的余额

输入样例:

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

输出样例:

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

题解：

import java.util.*;
class BankAccout{
	int balance;
	public BankAccout() {
		this.balance=0;
	}
	public BankAccout(int bal) {
		this.balance=bal;
	}
	public int getBlance() {
		return this.balance;
	}
	public void withdraw(int amount){
        if(this.balance>=amount)  this.balance=this.balance-amount;  
        else  this.balance=this.balance;
	}
	public int deposit(int amount) {
		return this.balance=this.balance+amount;
	}
}

public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner cin=new Scanner(System.in);
		int bal=cin.nextInt();
		int n=cin.nextInt();
		BankAccout B=new BankAccout(bal);
		for(int i=0;i<n;i++) {
			int k=cin.nextInt();
			int c=cin.nextInt();
			if(k==1) {
				B.deposit(c);
				System.out.println(B.balance);
			}else if(k==2) {
				B.withdraw(c);
				System.out.println(B.balance);
			}
		}
		cin.close();
	}

}

7-25 学生类定义

定义一个Student类，含类成员变量：
String name、String gender、int score、boolean award，所有的变量为私有(private)。

1.编写有参构造函数：
对name、gender、score、award赋初值；
2. 重写（覆盖）toString方法：
按照格式：类名 [name=, gender=,score=, award=]输出;
3.对每个成员变量生成setter/getter方法；
4.main方法中创建对象并输出。

输入格式:

输入1行学生的信息：姓名、性别、成绩、获奖情况。

输出格式:

通过对象调用toString方法输出学生的姓名、性别、成绩、获奖情况信息。

输入样例:

Rose female 96 true

输出样例:

Student [name=Rose, gender=female, score=96, award=true]

题解:

import java.util.*;

class Student {
    private String name;
    private String gender;
    private int score;
    private boolean award;

    public Student(String name, String gender, int score, boolean award) {
        this.name = name;
        this.gender = gender;
        this.score = score;
        this.award = award;
    }

    public String getName() {
        return this.name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getGender() {
        return this.gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public int getScore() {
        return this.score;
    }

    public void setScore(int score) {
        this.score = score;
    }

    public boolean getAward() {
        return this.award;
    }

    public void setAward(boolean award) {
        this.award = award;
    }

    @Override
    public String toString() {
        return "Student [name=" + this.name + ", gender=" + this.gender + ", score=" + this.score
                + ", award=" + this.award + "]";
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // 输入学生信息
        String name = scanner.next();
        String gender = scanner.next();
        int score = scanner.nextInt();
        boolean award = scanner.nextBoolean();

        // 创建Student对象并输出学生信息
        Student student = new Student(name, gender, score, award);
        System.out.println(student);

        scanner.close();
    }
}

7-26 BankAccount类定义

定义银行账户BankAccount类。

私有数据成员：余额balance（整型）。
公有成员方法：
无参构造方法BankAccount()：将账户余额初始化为0；
带参构造方法BankAccount(int m)：将账户余额初始化为指定的参数。
int getbalance() 方法：返回账户余额。
void withdraw(int m) 取款方法：从账户余额中提取m指定的款额，如果余额不足，给出” Insufficient balance.”。
void deposit(int m) 存款方法：将m指定的款项存到账户。
在main方法中构造银行账户，对其进行存取款操作。
其中操作类型类型为d表示存款，w表示取款，每次操作后打印账户余额。

输入格式:

账户余额
存取款操作数
操作类型金额

输出格式:

操作后的账户余额。

输入样例:

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

输出样例:

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

balance: 600
balance: 700
balance: 200
Insufficient balance.balance: 200
balance: 100

题解：

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        // 输入账户余额
        int balance = scanner.nextInt();

        // 创建银行账户对象
        BankAccount account = new BankAccount(balance);

        // 输入操作次数
        int n = scanner.nextInt();

        // 执行存取款操作
        while (n > 0) {
            // 输入本次操作类型和金额
            String type = scanner.next();
            int amount = scanner.nextInt();
            n--;

            // 根据操作类型进行存取款操作，并输出余额
            if (type.equals("d")) {
                account.deposit(amount);
                System.out.println("balance: " + account.getbalance());
            } else if (type.equals("w")) {
                if (account.getbalance() >= amount) {
                    account.withdraw(amount);
                    System.out.println("balance: " + account.getbalance());
                } else {
                    System.out.println("Insufficient balance." + "balance: " + account.getbalance());
                }
            }
        }

        scanner.close();
    }
}

class BankAccount {
    private int balance;

    public BankAccount() {
        this.balance = 0;
    }

    public BankAccount(int balance) {
        this.balance = balance;
    }

    public int getbalance() {
        return this.balance;
    }

    public void withdraw(int m) {
        this.balance -= m;
    }

    public void deposit(int m) {
        this.balance += m;
    }
}

7-27 设计一个矩形类Rectangle

编写一个Java应用程序，该程序包含两个类，类的定义如下：

(1) 一个有关计算矩形面积的类Rectangle，定义如下成员：
① 两个私有的成员变量：length（长，double类型）、width（宽，double类型）；
② 一个公有的无参数的构造方法，该构造方法将所有成员变量初始化为零；
③ 一个公有的有参数的方法void setXY(double a, double b)，该方法用于设置矩形的属性length与width；
④ 一个公有的无参数的方法double getArea( )，该方法计算并返回矩形的面积;
⑤一个公有的无参数的方法double getPerimeter( )，该方法计算并返回矩形的周长;

(2) 一个测试类Main，在main方法中声明1个Rectangle类的对象rect，通过setXY方法给rect的属性length和width进行赋值（从键盘输入），通过getArea方法来计算rect的面积，通过getPerimeter方法来计算rect的周长，然后输出其面积与周长。

输入格式:

输入两个数，作为矩形的长、宽。

输出格式:

第一行输出矩形的面积。
第二行输出矩形的周长。

输入样例:

3.5  2

输出样例:

面积为7.0
周长为11.0

题解：


import java.util.*;
class Rectlangle{
	private double l,w;
	public Rectlangle(){
		this.w=0;
		this.l=0;
	}
	public Rectlangle(double l,double w) {
		this.l=l;
		this.w=w;
	}
	public void setXY(double a,double b) {
		this.l=a;
		this.w=b;
	}
	public double getArea() {
		return l*w;
	}
	public double getPerimeter() {
		return 2*(l+w);
	}
}
public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner cin=new Scanner (System.in);
		double width=cin.nextDouble();
		double length =cin.nextDouble();
		Rectlangle rect=new Rectlangle(length,width) ;
		rect.setXY(length, width);
		System.out.println("面积为"+rect.getArea());
		System.out.println("周长为"+rect.getPerimeter());
		cin.close();
		

	}

}

7-28 设计一个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.*;
abstract class Shape{
	double PI =3.1415926;
	abstract double area();
	abstract double perimeter();
}
class Oval extends Shape{
	private double a,b;
	Oval(double a,double b){
		this.a=a;
		this.b=b;
	}
	Oval(){
		a=b=0;
	}
	double area() {
		return PI*a*b;
	}
	double perimeter() {
		return 2*PI*Math.sqrt( ( a * a + b * b ) / 2 );
	}
	@Override
	public String toString() {
		return "Oval(a:" + a + ",b:" + b + ")";
	}
	
}
public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner cin=new Scanner(System.in);
		double lr=cin.nextDouble();
		double dr=cin.nextDouble();
		Oval O1= new Oval(lr,dr);
		  System.out.println("The area of "+O1.toString()+" is "+O1.area());
	        System.out.println("The perimeterof "+O1.toString()+" is "+O1.perimeter());
	cin.close();
	}

}

7-29 定义抽象类Person、派生类Student和类Teacher

设计抽象类Person，派生出具体类：学生类Student和教师类Teacher，创建若干不同类对象后并在主方法中测试。
数据成员定义：
Person [ID，姓名，生日]
Student [专业，成绩]
Teacher [职称，工资]
带参构造方法分别为：
Person(int id,String name, int bir)
Student(int id,String name, int bir, String major,double score)
Teacher(int id,String name, int bir, String title, double salary)
toString方法(Eclipse自动生成)

输入格式:

第一行整数n表示有n个对象，每个对象占2行，第一行为数字0（表示学生）或1（表示教师），第二行为生成对象的参数。

输出格式:

按行输出具体对象的信息。

输入样例:

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

5
0
10101 Peter 20010121 Computer 87.5
1
20110014 Crystal 19900103 AI 7000
0
10102 Rose 20010715 E-Commerce 90
1
20120019 David 19781218 Prof 12000
0
10103 Semon 20000405 Computer 88

输出样例:

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

Student [id=10101, name=Peter, bir=20010121, major=Computer, score=87.5]
Teacher [id=20110014, name=Crystal, bir=19900103, title=AI, salary=7000.0]
Student [id=10102, name=Rose, bir=20010715, major=E-Commerce, score=90.0]
Teacher [id=20120019, name=David, bir=19781218, title=Prof, salary=12000.0]
Student [id=10103, name=Semon, bir=20000405, major=Computer, score=88.0]

题解：

import java.util.*;

abstract class Person {
    private int id;
    private String name;
    private int bir;

    public Person(int id, String name, int bir) {
        this.id = id;
        this.name = name;
        this.bir = bir;
    }

    public int getId() { return id; }
    public void setId(int id) { this.id = id; }

    public String getName() { return name; }
    public void setName(String name) { this.name = name; }

    public int getBir() { return bir; }
    public void setBir(int bir) { this.bir = bir; }

    @Override
    public String toString() {
        return "Person [id=" + id + ", name=" + name + ", bir=" + bir + "]";
    }
}

class Student extends Person {
    private String major;
    private double score;

    public Student(int id, String name, int bir, String major, double score) {
        super(id, name, bir);
        this.major = major;
        this.score = score;
    }

    public String getMajor() { return major; }
    public void setMajor(String major) { this.major = major; }

    public double getScore() { return score; }
    public void setScore(double score) { this.score = score; }

    @Override
    public String toString() {
        return "Student [id=" + getId() + ", name=" + getName() + ", bir=" + getBir() +
                ", major=" + major + ", score=" + score + "]";
    }
}

class Teacher extends Person {
    private String title;
    private double salary;

    public Teacher(int id, String name, int bir, String title, double salary) {
        super(id, name, bir);
        this.title = title;
        this.salary = salary;
    }

    public String getTitle() { return title; }
    public void setTitle(String title) { this.title = title; }

    public double getSalary() { return salary; }
    public void setSalary(double salary) { this.salary = salary; }
    
    @Override
    public String toString() {
        return "Teacher [id=" + getId() + ", name=" + getName() + ", bir=" + getBir() +
                ", title=" + title + ", salary=" + salary + "]";
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        int n = scanner.nextInt();
        for (int i = 0; i < n; i++) {
            int type = scanner.nextInt();
            if (type == 0) {
                int id = scanner.nextInt();
                String name = scanner.next();
                int bir = scanner.nextInt();
                String major = scanner.next();
                double score = scanner.nextDouble();
                Student student = new Student(id, name, bir, major, score);
                System.out.println(student.toString());
            } else if (type == 1) {
                int id = scanner.nextInt();
                String name = scanner.next();
                int bir = scanner.nextInt();
                String title = scanner.next();
                double salary = scanner.nextDouble();
                Teacher teacher = new Teacher(id, name, bir, title, salary);
                System.out.println(teacher.toString());
            }
        }

        scanner.close();
    }
}

7-30 设计一个学生类和它的一个子类——本科生类

设计一个学生类（Student）和它的一个子类——本科生类（Undergraduate）。要求如下：
（1）Student类有姓名（name）和年龄（age）属性，两者的访问权限为protected；一个包含两个参数的构造方法，用于给姓名和年龄属性赋值；一个show( )方法用于输出Student的属性信息，输出格式为Student[name=XXX,age=XX]。
（2）Undergraduate类增加一个专业（major）属性，该属性的访问权限为private；有一个包含三个参数的构造方法，前两个参数用于给继承的年龄和姓名属性赋值，第三个参数给专业属性赋值；一个show( )方法用于输出Undergraduate的属性信息，输出格式为Undergraduate[name=XXX,age=XXX,major=XXX]。

在测试类Main的main( )方法中，调用Student类的带参数的构造方法创建对象object1，调用Undergraduate类的带参数的构造方法创建对象object2，然后分别调用它们的show( )方法。

输入格式:

第一行从键盘输入姓名（字符串）、年龄（整数）给Student类的对象object1，中间以空格隔开。
第二行从键盘输入姓名（字符串）、年龄（整数）、专业（字符串）给Undergraduate类的对象object2，中间以空格隔开。

输出格式:

第一行输出object1的姓名、年龄，格式为：Student[name=XXX,age=XX]
第二行输出object2的姓名、年龄、专业，格式为： Undergraduate[name=XXX,age=XXX,major=XXX]

输入样例:

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

张三 12
李四 19 计算机科学与技术

输出样例:

在这里给出相应的输出，其中的标点符号为英文格式。例如：

Student[name=张三,age=12]
Undergraduate[name=李四,age=19,major=计算机科学与技术]

题解

import java.util.*;
class Student{
	protected String name;
	protected int age;
	public Student(String name ,int age) {
		this.age=age;
		this.name=name;
	}
	public void show() {
		System.out.println("Student[name="+this.name+",age="+this.age+"]");
	}
}
class Undergraduate extends Student{
	private String major;
	public Undergraduate(String name,int age,String major) {
		super(name,age);
		this.major=major;
	}
	public void show() {
		System.out.println("Undergraduate[name="+this.name+",age="+this.age+",major="+this.major+"]");
	}
	
}
public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner cin=new Scanner (System.in);
		String A=cin.next();
		int id=cin.nextInt();
		String A1=cin.next();
		int id1=cin.nextInt();
		String M1=cin.next();
		Student o1=new Student(A,id);
		o1.show();
		Undergraduate o2=new Undergraduate(A1,id1,M1);
		o2.show();
		cin.close();

	}

}

7-31 定义接口（Biology、Animal）、类（Person）、子类（Pupil）

（1）定义Biology（生物）、Animal（动物）2个接口，其中Biology声明了抽象方法breathe( )，Animal声明了抽象方法eat( )和sleep( )。
（2）定义一个类Person（人）实现上述2个接口，实现了所有的抽象方法，同时自己还有一个方法think( )。breathe()、eat()、sleep()、think()四个方法分别输出：
我喜欢呼吸新鲜空气
我会按时吃饭
早睡早起身体好
我喜欢思考
（3）定义Person类的子类Pupil（小学生），有私有的成员变量school（学校），公有的成员方法setSchool( )、getSchool( )分别用于设置、获取学校信息。
（4）在测试类Main中，用Pupil类创建一个对象zhangsan。尝试从键盘输入学校信息给zhangsan，获取到该信息后输出该学校信息，格式为“我的学校是XXX”；依次调用zhangsan的breathe()、eat()、sleep()、think()方法。

输入格式:

从键盘输入一个学校名称（字符串格式）

输出格式:

第一行输出：我的学校是XXX（XXX为输入的学校名称）
第二行是breathe()方法的输出
第三行是eat()方法的输出
第四行是sleep()方法的输出
第五行是think()方法的输出

输入样例:

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

新余市逸夫小学

输出样例:

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

我的学校是新余市逸夫小学
我喜欢呼吸新鲜空气
我会按时吃饭
早睡早起身体好
我喜欢思考

题解

import java.util.*;
interface Biology{
	void breathe();
}
interface Animal{
	 public void eat();
	public void sleep();
}
class Person implements Biology,Animal {
	public void  breathe() {
		System.out.println("我喜欢呼吸新鲜空气");
	}

	public void eat() {
		System.out.println("我会按时吃饭");
		
	}

	public void sleep() {
		System.out.println("早睡早起身体好");
		
	}
	public void think() {
		System.out.println("我喜欢思考");
		
	}
	
}
class Pupil extends Person{
	private String school;
	public void setSchool(String school) {
		this.school=school;
		
	}
	public String  getSchool() {
		return this.school;
	}
	public void ASchool() {
		System.out.println("我的学校是"+this.school);
	}
	public Pupil(){
		
	}
	
}
public class Main {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner cin=new Scanner(System.in);
		String a=cin.next();
		Pupil k=new Pupil();
		k.setSchool(a);
		k.ASchool();
		k.breathe();
		k.eat();
		k.sleep();
		k.think();
		cin.close();
	}
}