西南石油大学PTA（期末）编程题题面
前言：
本篇用于本人复习，部分代码参考相关博客（就是看头文件啦）
祝大家取得好成绩
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
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;i7-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将从0到n-1的数字拼接为字符串str。如，n=12，则拼接出来的字符串为01234567891011
最后截取字符串str从begin到end(包括begin，但不包括end)之间的字符串，并输出。
输入样例:
10
5
8
1000
800
900
输出样例:
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;i7-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;i7-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'&&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用来存放字符串，然后进行如下操作。
提示: 查询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 s1=new ArrayList();
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 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 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 7-13 创建一个倒数计数线程
分数 10
全屏浏览题目
切换布局
作者 吴恋
单位 贵州师范学院
创建一个倒数计数线程。要求：1.该线程使用实现Runnable接口的写法；2.程序该线程每隔0.5秒打印输出一次倒数数值（数值为上一次数值减1）。
输入格式:
N（键盘输入一个整数）
输出格式:
每隔0.5秒打印输出一次剩余数
输入样例:
6
输出样例:
在这里给出相应的输出。例如：
6
5
4
3
2
1
0题解
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
- 方法定义 包括下列要求
- 定义无参构造方法 ，给radius赋值为2，并添加语句System.out.println("this is a constructor");
- 定义有参构造方法 ，接收用户给给radius赋值，如果用户输入半径为<=0,则让半径的值为2，并添加语句System.out.println("this is a constructor with para");
- 为radius半径添加setter方法，接收用户输入的半径，如果用户输入半径为<=0,则让半径的值为2
- 为radius半径添加getter方法，返回用户输入的半径
- 定义求面积方法public int gerArea(),π使用Math.PI代替，面积的结果强制转换为int返回
- 定义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 圆柱体类设计
-
- 定义一个圆柱类Cylinder
- 里面包含私有属性 private int radius（半径）,height(高）
- 为属性完成其setter getter方法
- 完成带参构造方法Cylinder(int radius,height),该方法中包含一句System.out.println("Constructor with para");
- 完成无参构造方法Cylinder()，在无参构造方法中调用有参构造方法，为半径和高赋值为2,1,该方法包含一句System.out.println("Constructor no para");
- 完成求体积方法 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) {
ArrayListlist=new ArrayList<>();
Scanner in=new Scanner(System.in);
int n=in.nextInt();
for(int i=0;i 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数组
思考：如果初次做该题会发现代码冗余严重。使用继承、多态思想可以大幅简化上述代码。
输入样例:
1 2
3 4
7
1
输出样例:
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方法，求面积方法等，要求如下所示：
- 定义正方形类的构造方法：在构造方法中给edge赋值为2，并添加System.out.println("this is constructor method");
- 为成员变量edge设置set方法，用来接收用户给edge的值，如果用户给的值<=0,则设置edge值为1
- 为成员变量edge设置get方法，用来返回edge的值
- 完成求面积方法，得到正方形的面积：public int getArea()
定义类Main，并在main方法中， 1.首先创建正方形对象s1，然后通过getEdge()方法输出edge的值，然后调用getArea方法求出s1的面积并输出
2.创建正方形对象s2,并通过键盘输入s2对象的边的值，然后通过getEdge()方法输出edge的值，然后调用getArea方法求出s1的面积并输出
输入格式:
输入在一行中给出边的值。
输出格式:
输出s1对象的边、输出s1对象的面积
输出s2对象的边、s2对象的面积
输入样例:
在这里给出一组输入。例如：
3
-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表示取款，每次操作后都打印余额
输入格式:
账户余额
操作个数
操作类型 操作金额
输出格式:
每次操作后的余额
输入样例:
在这里给出一组输入。例如：
0
4
1 100
1 200
2 100
2 100
输出样例:
在这里给出相应的输出。例如：
100
300
200
100题解：
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;i7-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表示取款，每次操作后打印账户余额。
输入格式:
账户余额
存取款操作数
操作类型 金额
输出格式:
操作后的账户余额。
输入样例:
在这里给出一组输入。例如：
1000
5
w 400
d 100
w 500
w 300
w 100
输出样例:
在这里给出相应的输出。例如：
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();
}
}