java基础语法函数题（pta）

6-1 是否偶数

本题要求实现一个函数，判盘输入的整数是否是偶数，如果是偶数，返回true，否则返回false。

函数接口定义：

public static boolean isOdd(int data)

说明：其中 data 是用户传入的参数。 data 的值不超过int的范围。函数须返回 true 或者 false。

裁判测试程序样例：

import java.util.Scanner;
public class Main {public static void main(String[] args) {Scanner in=new Scanner(System.in);int data=in.nextInt();System.out.println(isOdd(data));}/* 请在这里给出isOdd(i)函数 */}

输入样例：

输出样例：

true

答案代码如下：

 public static boolean isOdd(int data) {if(data%2==0) {return true;}else {return false;}}

6.2设计一个矩形类Rectangle

设计一个名为Rectangle的类表示矩形。这个类包括：
两个名为width和height的double型数据域，它们分别表示矩形的宽和高。width和height的默认值都为1.
一个无参构造方法。
一个为width和height指定值的矩形构造方法。
一个名为getArea()的方法返回这个矩形的面积。
一个名为getPerimeter()的方法返回这个矩形的周长。

类名为：

Rectangle

裁判测试程序样例：

import java.util.Scanner;
/* 你的代码将被嵌入到这里 */public class Main {public static void main(String[] args) {Scanner input = new Scanner(System.in);double w = input.nextDouble();double h = input.nextDouble();Rectangle myRectangle = new Rectangle(w, h);System.out.println(myRectangle.getArea());System.out.println(myRectangle.getPerimeter());input.close();}
}

输入样例：

3.14  2.78

输出样例：

8.7292
11.84

答案代码如下：·

class Rectangle{double width=1;double height=1;Rectangle(){}Rectangle(double width,double height){this.width=width;this.height=height;}double getArea() {return width*height;}double getPerimeter() {return 2*width+2*height;}}

6-3 根据派生类写出基类（Java）

裁判测试程序样例中展示的是一段定义基类People、派生类Student以及测试两个类的相关Java代码，其中缺失了部分代码，请补充完整，以保证测试程序正常运行。

函数接口定义：

提示：观察派生类代码和main方法中的测试代码，补全缺失的代码。

裁判测试程序样例：

注意：真正的测试程序中使用的数据可能与样例测试程序中不同，但仅按照样例中的格式调用相关方法（函数）。

class People{protected String id;protected String name;/** 你提交的代码将被嵌在这里（替换此行） **/}class Student extends People{protected String sid;protected int score;public Student() {name = "Pintia Student";}public Student(String id, String name, String sid, int score) {super(id, name);this.sid = sid;this.score = score;}public void say() {System.out.println("I'm a student. My name is " + this.name + ".");}}
public class Main {public static void main(String[] args) {Student zs = new Student();zs.setId("370211X");zs.setName("Zhang San");zs.say();System.out.println(zs.getId() + " , " + zs.getName());Student ls = new Student("330106","Li Si","20183001007",98);ls.say();System.out.println(ls.getId() + " : " + ls.getName());People ww = new Student();ww.setName("Wang Wu");ww.say();People zl = new People("370202", "Zhao Liu");zl.say();}
}

输入样例：

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

（无）

输出样例：

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

I'm a student. My name is Zhang San.
370211X , Zhang San
I'm a student. My name is Li Si.
330106 : Li Si
I'm a student. My name is Wang Wu.
I'm a person! My name is Zhao Liu.

答案代码如下：

public String getId() {return id;}public void setId(String id) {this.id = id;}public String getName() {return name;}public void setName(String name) {this.name = name;}public void say() {System.out.println("I'm a person! My name is " + this.name + ".");}People(){}People(String id,String name){this.id=id;this.name=name;}

补充相关知识点的前后知识

1.类是对某一类事物的抽象描述，对象是某一类中一个或多个具体的事物

类是创建对象的模板，对象是类的实例

2.封装：将对象的属性（域/数据）和行为（方法/函数）定义在一起，形成一个类

隐藏：对类中属性和行为起到一定的保护作用，不能直接修改，提供一些接口、函数访问

3.成员变量与局部变量

前者是在类中，后者是方法中定义的变量或方法的参变量

成员变量属于类，可以用public，protected，private，static修饰而局部变量不允许。

都可以用final修饰

4.方法的重载

指一个类中可以声明多个同名、但参数列表不同的成员方法。（参数的个数不同、参数的类型不同）

5.对象运算符instanceof用于判断当前对象是否是属于某个类。

6.this用法

This是当前对象，也可以看作是当前对象的别名，哪一对象调用这个方法，this就表示的是哪一个对象。一般用于指代对象本身、访问本类的成员变量和成员方法、调用本类重载的构造方法。

经典实例：

区分成员变量和局部变量

Point(int x,int y){
this.x=x;
this.y=y;//成员变量x和参数x同名，用this区分
}
void setX(int x){
this.x=x;
}
void printInfo(){
System.out.println("坐标值（"+this.x+","+this.y+"）");
}

调用实例方法

void changePoint(int x,int y){
this.setX(x);
this.y=y;
}
void changePoint(Point p){
this.setX(p.x);
this.y=p.getY();
}

拷贝构造方法

Point(int x,int y){
this.x=x;
this.y=y;
}
Point(){
this(1,1);//设置无参构造方法的初始值
}
Point(Point p){
this(p.x,p.y);
}

比较对象

public boolean equals(Point p){
return (this==p)||(p!=null&&this.x==p.x&&this.y==y);
//this指代调用当前方法的对象，通过this引用访问当前对象的成员变量
}

7.在静态成员方法体中，不能访问实例成员，不能使用this引用。static不能修饰方法的局部变量。

8.如果一个类中的成员变量是由其他类所定义的对象，这个类称为组合类，组合类所定义的对象称为组合对象。

9.在类的内部定义类，称为嵌套类或者内部类；嵌套类的定义形式与非嵌套类的定义形式基本相同，在嵌套类中可以定义变量和方法；可以将嵌套的类看作外层类的一个成员，所以它可以访问外层类中的任何成员。

6-4 写出派生类构造方法（Java）

函数接口定义：

提示：观察类的定义和main方法中的测试代码，补全缺失的代码。

裁判测试程序样例：

注意：真正的测试程序中使用的数据可能与样例测试程序中不同，但仅按照样例中的格式调用相关方法（函数）。

class People{private String id;private String name;public People(String id, String name) {this.id = id;this.name = name;}public String getId() {return id;}public String getName() {return name;}
}class Student extends People{private String sid;private int score;public Student(String id, String name, String sid, int score) {/** 你提交的代码将被嵌在这里（替换此行） **/}public String toString(){return ("(Name:" + this.getName() + "; id:" + this.getId() + "; sid:" + this.sid+ "; score:" + this.score + ")");}}
public class Main {public static void main(String[] args) {Student zs = new Student("370202X", "Zhang San", "1052102", 96);System.out.println(zs);}
}

输入样例：

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

（无）

输出样例：

(Name:Zhang San; id:370202X; sid:1052102; score:96)

答案代码如下：

super(id,name);
this.sid=sid;
this.score=score;

6-5 重写父类方法equals

在类Student中重写Object类的equals方法。使Student对象学号(id)相同时判定为同一对象。

函数接口定义：

在类Student中重写Object类的equals方法。使Student对象学号(id)相同时判定为同一对象。

裁判测试程序样例：

import java.util.Scanner;
class Student {int id;String name;int age;public Student(int id,     String name,     int age) {this.id = id;this.name = name;this.age = age;}/* 请在这里填写答案 */}
public class Main {public static void main(String[] args) {Scanner sc = new Scanner(System.in);Student s1 = new Student(sc.nextInt(),sc.next(),sc.nextInt());Student s2 = new Student(sc.nextInt(),sc.next(),sc.nextInt());System.out.println(s1.equals(s2));sc.close();}
}

答案代码如下：

 public boolean equals(Object obj) {boolean b=false;if(obj instanceof Student){Student s=(Student) obj;if(s.id==this.id) {b=true;}  }return b;  }

6-6 从抽象类shape类扩展出一个圆形类Circle

请从下列的抽象类shape类扩展出一个圆形类Circle,这个类圆形的半径radius作为私有成员，类中应包含初始化半径的构造方法。

public abstract class shape {// 抽象类public abstract double getArea();// 求面积public abstract double getPerimeter(); // 求周长
}

主类从键盘输入圆形的半径值，创建一个圆形对象，然后输出圆形的面积和周长。保留4位小数。

圆形类名Circle

裁判测试程序样例：

import java.util.Scanner;
import java.text.DecimalFormat;abstract class shape {// 抽象类/* 抽象方法 求面积 */public abstract double getArea( );/* 抽象方法 求周长 */public abstract double getPerimeter( );
}/* 你提交的代码将被嵌入到这里 */public class Main {public static void main(String[] args) {Scanner input = new Scanner(System.in);DecimalFormat d = new DecimalFormat("#.####");// 保留4位小数double r = input.nextDouble( ); shape c = new  Circle(r);System.out.println(d.format(c.getArea()));System.out.println(d.format(c.getPerimeter()));input.close();}
}

输入样例：

3.1415926

输出样例：

31.0063
19.7392

答案代码如下：

 class Circle extends shape{private double radius;public Circle(double radius) {this.radius=radius;}public double getArea() {return Math.PI*radius*radius;}public double getPerimeter() {return 2.0*Math.PI*radius;}
}

6-7 创建一个直角三角形类实现IShape接口

创建一个直角三角形类（regular triangle）RTriangle类，实现下列接口IShape。两条直角边长作为RTriangle类的私有成员，类中包含参数为直角边的构造方法。

interface IShape {// 接口

public abstract double getArea(); // 抽象方法求面积

public abstract double getPerimeter(); // 抽象方法求周长

}

###直角三角形类的定义：

直角三角形类的构造函数原型如下： RTriangle(double a, double b);

其中 a 和 b 都是直角三角形的两条直角边。

裁判测试程序样例：


import java.util.Scanner;
import java.text.DecimalFormat;interface IShape {public abstract double getArea();public abstract double getPerimeter();
}/*你写的代码将嵌入到这里*/public class Main {public static void main(String[] args) {DecimalFormat d = new DecimalFormat("#.####");Scanner input = new Scanner(System.in);double a = input.nextDouble();double b = input.nextDouble();IShape r = new RTriangle(a, b);System.out.println(d.format(r.getArea()));System.out.println(d.format(r.getPerimeter()));input.close();}
}

输入样例：

3.1 4.2

输出样例：

6.51
12.5202

答案代码如下：

class RTriangle implements IShape{private double width;private double length;public RTriangle(double width,double length) {this.length=length;this.width=width;}public double getArea() {return 0.5*width*length;}public double getPerimeter() {return length+width+Math.sqrt(length*length+width*width);}
}

6-8 jmu-Java-06异常-多种类型异常的捕获

如果try块中的代码有可能抛出多种异常，且这些异常之间可能存在继承关系，那么在捕获异常的时候需要注意捕获顺序。

补全下列代码，使得程序正常运行。

裁判测试程序：

public static void main(String[] args) {Scanner sc = new Scanner(System.in);while (sc.hasNext()) {String choice = sc.next();try {if (choice.equals("number"))throw new NumberFormatException();else if (choice.equals("illegal")) {throw new IllegalArgumentException();} else if (choice.equals("except")) {throw new Exception();} elsebreak;}/*这里放置你的答案*/}//end whilesc.close();
}

###输出说明
在catch块中要输出两行信息：
第1行：要输出自定义信息。如下面输出样例的number format exception
第2行：使用System.out.println(e)输出异常信息，e是所产生的异常。

输入样例

number illegal except quit

输出样例

number format exception
java.lang.NumberFormatException
illegal argument exception
java.lang.IllegalArgumentException
other exception
java.lang.Exception

答案代码如下：

catch(Exception e) {if(choice.equals("number")) {System.out.println("number format exception");System.out.println(e);}if(choice.equals("illegal")) {System.out.println("illegal argument exception");System.out.println(e);}if(choice.equals("except")) {System.out.println("other exception");System.out.println(e);}}

6-9 jmu-Java-03面向对象基础-Object

输入整数n，创建n个对象，放入同一个数组中。

如果输入c，则new Computer(); //注意：Computer是系统中已有的类，无需自己编写

如果输入d，则根据随后的输入创建Double类型对象。

如果输入i，则根据随后的输入创建Integer类型对象。

如果输入s，则根据随后的输入创建String类型对象。

如果不是以上这些输入，则不创建对象，而是将null存入数组相应位置。

最后倒序输出数组中的所有对象，如果数组中相应位置的元素为null则不输出。

裁判测试程序：

public static void main(String[] args) {Scanner sc = new Scanner(System.in);//这边是你的代码sc.close();
}

输入样例：

5
c
d 2.3
other
i 10
s Test

输出样例：

Test
10
2.3
//这行显示Computer对象toString方法

答案代码如下：

   int n=sc.nextInt();Object obj[]=new Object[n];for(int i=0;i<n;i++) {String s=sc.next();switch(s) {case "c":obj[i]=new Computer();break;case "d":obj[i]=new Double(sc.nextDouble());break;case "i":obj[i]=new Integer(sc.nextInt());break;case "s":obj[i]=new String(sc.next());break;default:obj[i]=null;          }}for(int i=n-1;i>=0;i--) {if(obj[i]!=null)System.out.println(obj[i]);}

6-10 人口统计

本题运行时要求键盘输入10个人员的信息（每一个人信息包括：姓名，性别，年龄，民族），要求同学实现一个函数，统计民族是“汉族”的人数。

函数接口定义：

public static int numofHan(String data[])

其中 data[] 是传入的参数。 data[]中的每一个元素都是一个完整的人员信息字符串，该字符串由“姓名，性别，年龄，民族”，各项之间用英文半角的逗号分隔。函数须返回值是汉族的人数。

裁判测试程序样例：

import java.util.Scanner;public class Main {public static void main(String[] args) {final int HUMANNUM=10;String persons[]=new String[HUMANNUM];Scanner in=new Scanner(System.in);for(int i=0;i<persons.length;i++)persons[i]=in.nextLine();int result=numofHan(persons);System.out.println(result);}/*在此处给出函数numofHan()*/}

输入样例：

Tom_1,男,19,汉族
Tom_2,女,18,汉族
Tom_3,男,20,满族
Tom_4,男,18,汉族
Tom_5,男,19,汉族人
Tom_6,女,17,汉族
Tom_7,男,19,蒙古族
汉族朋友_1,男,18,汉族
Tom_8,male,19,老外
Tom_9,female,20,汉族

输出样例：

答案代码如下：

    public static int numofHan(String data[]) {int count=0;String s="汉族";for(String str:data) {if(str.indexOf(s)>=0) {count++;}}return count;}

备注：多种方法可见链接博客

java 6-1 人口统计_故园归梦的博客-CSDN博客_人口统计java

6-11 jmu-Java-05集合-List中指定元素的删除

编写以下两个函数

//以空格(单个或多个)为分隔符，将line中的元素抽取出来，放入一个List
public static List<String> convertStringToList(String line)
//在list中移除掉与str内容相同的元素
public static void remove(List<String> list, String str)

裁判测试程序：

public class Main {/*covnertStringToList函数代码*/   /*remove函数代码*/public static void main(String[] args) {Scanner sc = new Scanner(System.in);while(sc.hasNextLine()){List<String> list = convertStringToList(sc.nextLine());System.out.println(list);String word = sc.nextLine();remove(list,word);System.out.println(list);}sc.close();}}

样例说明：底下展示了4组测试数据。

输入样例

1 2 1 2 1 1 1 2
1
11 1 11 1 11
11
2 2 2
1
1   2 3 4 1 3 1
1

输出样例

[1, 2, 1, 2, 1, 1, 1, 2]
[2, 2, 2]
[11, 1, 11, 1, 11]
[1, 1]
[2, 2, 2]
[2, 2, 2]
[1, 2, 3, 4, 1, 3, 1]
[2, 3, 4, 3]

答案代码如下：

 public static List<String> convertStringToList(String line) {List<String> list=new ArrayList<String>();String line1[]=line.split("\\s+");for(int i=0;i<line1.length;i++) {list.add(line1[i]);}return list;}public static void remove(List<String> list, String str) {for(int i=0;i<list.size();) {if(str.equals(list.get(i))) {list.remove(i);i=0;}else {i++;}}}

相关知识点补充：

什么是泛型？

泛型允许类的成员的类型可以由外部程序来指定，也就是说可以以参数形式来指定类型，即“参数化类型”

常用泛型有泛型接口、泛型类、泛型方法

public class ArrayList<E>{}

public interface List<E>{}

public boolean add(E e){}

集合类的特点

空间自主调整，提高空间利用率，动态存储多个对象

提供不同的数据结构和算法，减少编程工作量

提高程序的处理速度和质量

备注：集合类支持引用类型，包括包装类；集合类中存放的是对象的引用，而不是对象本身。

集合类均采用泛型进行定义，分为Collection和Map两种体系

Collection接口：List(元素有序，可重复的集合) ;Set(元素无需，不可重复的集合)

Map接口：具有映射关系的”Key-value对”的集合

Collection接口方法列表：（除特殊标注外均为boolean类型）

Add(E e):向集合中添加新元素

addAll(Collection c):将指定集合中的所有元素添加到当前集合中

remove(Object o):删除当前集合中包含的指定元素

removeAll(Collection c):删除当前集合中与指定集合相同的所有元素

retainAll(Collection c):保留当前集合中与指定集合相同的所有元素

clear():删除当前集合中的所有元素 void

contains(Object o):查找当前集合中是否有指定元素

containsAll(Collection c):查找当前集合中是否包含指定集合中的所有元素

isEmpty():当前集合是否为空

size():返回当前集合的元素个数 int

iterator():返回一个可遍历当前集合的迭代器 iterator

stream():返回一个连接集合的顺序流 Stream

toArray():返回一个当前集合所有元素的数组 Object[]

List集合

List集合接口，也称之为线性表，是一个有序列表；集合中的元素是顺序存储，可以通过下标访问；List集合中允许出现重复元素；实现List集合接口的常用类：ArrayList,LinkedList,Vector和Stack.

List接口的定义：public interface List<E> extends Collection<E>

List接口中的主要方法：

Boolean add(E e)把元素加到表的尾部

Void add(int index,E e)把元素e加到表的index位置，原index位置元素顺序后移动

Boolean equals(Object o)比较对象o是否与表中的元素是同一元素

E get(int index)得到表中index位置的元素

Int indexOf(Object o)判断元素o在表中是否存在，如果不存在，则返回-1

Iterator<E> iterator()获得表的遍历器

E set（int index,E e）修改位置上的元素

ArrayList集合类

使用数组方式实现List接口，检索效率很高，删除效率很低，即数据结构的顺序表

Vetor集合类

是一种动态数组，元素只能是对象，与ArrayList,LinkedList相比，线程安全，通过synchronized关键字修饰方式，实现线程安全。

6-12 jmu-Java-07多线程-Thread

编写MyThread类继承自Thread。创建MyThread类对象时可指定循环次数n。
功能：输出从0到n-1的整数。并在最后使用System.out.println(Thread.currentThread().getName()+" "+isAlive())打印标识信息

裁判测试程序：

import java.util.Scanner;/*这里放置你的答案，即MyThread类的代码*/public class Main {public static void main(String[] args) {Scanner sc = new Scanner(System.in);Thread t1 = new MyThread(Integer.parseInt(sc.next()));t1.start();}
}

输入样例：

输出样例：

0
1
2
标识信息

答案代码如下：

class MyThread extends Thread{Integer n=3;public MyThread(Integer n){this.n=n;}public void run() {for(int i=0;i<n;i++) {System.out.println(i);}System.out.println(Thread.currentThread().getName()+" "+isAlive());}
}

补充本题相关知识点：继承Thread类

自定义线程类：class 类名 extends Thread

需要重写run方法，run方法是线程执行的内容

public class MyThread extends Thread{

public void run(){

//线程体

} }

启动线程的方法：start方法

MyThread mt=new MyThread();//创建线程对象

mt.start();//启动线程

6-13 jmu-Java-07多线程-PrintTask

编写PrintTask类实现Runnable接口。
功能：输出从0到n-1的整数(n在创建PrintTask对象的时候指定)。并在最后使用System.out.println(Thread.currentThread().getName());输出标识信息。

裁判测试程序：

import java.util.Scanner;/*这里放置你的答案，即PrintTask类的代码*/public class Main {public static void main(String[] args) {Scanner sc = new Scanner(System.in);PrintTask task = new PrintTask(Integer.parseInt(sc.next()));Thread t1 = new Thread(task);t1.start();sc.close();}
}

输入样例：

输出样例：

0
1
2
标识信息

答案代码如下：

class PrintTask implements Runnable{Integer n;public PrintTask(Integer n) {this.n=n;}public void run() {for(int i=0;i<n;i++) {System.out.println(i);}System.out.println(Thread.currentThread().getName());}
}

补充相关知识点：Runnable接口定义

public interface Runnable{

public void run();//只有一个run方法

}

class 类名 implements Runnable//自定义线程类

需要重写run方法，run方法是线程执行内容

创建线程

Runnable runnable=new MyRunnable();//创建Runnable对象

Thread thread=new Thread(runnable);

thread.start();//启动线程

运用事例如下

import java.util.Scanner;class MyRunnable implements Runnable{private String name;public MyRunnable(String name) {this.name=name;}public void run() {System.out.println("线程"+this.name+"执行开始");try {Thread.sleep(2000);//休眠2秒}catch(InterruptedException e) {e.printStackTrace();}System.out.print("线程"+this.name+"执行结束");}
}
public class Main {public static void main(String[] args) {Runnable r1=new MyRunnable("1号");Thread thread1=new Thread(r1);Runnable r2=new MyRunnable("2号");Thread thread2=new Thread(r2);thread1.start();thread2.start();}
}

执行结果如下：

6-14 jmu-Java-03面向对象基础-覆盖与toString

有Person类，Company类，Employee类。

其中Employee类继承自Person类，属性为：

private Company company;
private double salary;

现在要求编写Employee类的toString方法，返回的字符串格式为:父类的toString-company的toString-salary

函数接口定义：

public String toString()

输入样例：

输出样例：

Li-35-true-MicroSoft-60000.0

答案代码如下：

public String toString(){return super.toString()+"-"+company.toString()+"-"+salary;
}

6-15 学生、大学生、研究生类

定义Student学生类，拥有学号、姓名、性别属性，提供构造函数，以及相应属性的get set函数，提供函数attendClass(String className)表示上课。
定义CollegeStudent大学生类继承自Student类，拥有新增属性专业，提供构造函数，提供新增属性的get和set函数
定义GraduateStudent研究生类继承自CollegeStudent类，拥有新增属性导师，提供构造函数，提供新增属性的get和set函数，提供函数doResearch() 表示做研究（打印xx is doing research）。

main函数中对构造的类进行测试

输入描述：

学生类信息，学号、姓名、性别
大学生类信息，学号、姓名、性别、专业
研究生类信息，学号、姓名、性别、专业、导师

输出描述：

学生类信息
大学生类信息
研究生类信息

裁判测试程序样例：

import java.util.Scanner;
public class Main{public static void main(String[] args) {Scanner scan = new Scanner(System.in);      int no = scan.nextInt();String name = scan.next();      String sex = scan.next();      Student s = new Student(no, name, sex);s.print();no = scan.nextInt();name = scan.next();      sex = scan.next();      String major = scan.next();CollegeStudent c = new CollegeStudent(no, name, sex, major);c.print();no = scan.nextInt();name = scan.next();      sex = scan.next();      major = scan.next();String supervisor = scan.next();GraduateStudent g = new GraduateStudent(no, name, sex, major, supervisor );g.print();g.doResearch();scan.close(); }
}/* 你的代码被嵌在这里*/

输入样例：

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

1 liu female
2 chen female cs
3 li male sc wang

输出样例：

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

no: 1
name: liu
sex: female
no: 2
name: chen
sex: female
major: cs
no: 3
name: li
sex: male
major: sc
supervisor: wang
li is doing research

答案代码如下：

class Student{public int id;public String name;public String sex;public Student(int id,String name,String sex) {this.id=id;this.name=name;this.sex=sex;}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 String getSex() {return sex;}public void setSex(String sex) {this.sex = sex;}public void attendClass(String className) {}public void print() {System.out.println("no: "+this.id);System.out.println("name: "+this.name);System.out.println("sex: "+this.sex);}}
class CollegeStudent extends Student{String major;public CollegeStudent(int id,String name,String sex,String major){super(id,name,sex);this.major=major;}public String getMajor() {return major;}public void setMajor(String major) {this.major = major;}public void print() {super.print();System.out.println("major: "+this.major);}}
class GraduateStudent extends CollegeStudent{String supervisor;public GraduateStudent(int id,String name,String sex,String major,String supervisor){super(id,name,sex,major);this.supervisor=supervisor;}public String getSupervisor() {return supervisor;}public void setSupervisor(String supervisor) {this.supervisor = supervisor;}public void doResearch() {System.out.println(this.name+" is doing research");}public void print() {super.print();System.out.println("supervisor: "+this.supervisor);}}

6-16 Shape类

定义一个形状类Shape，提供计算周长getPerimeter()和面积getArea()的函数
定义一个子类正方形类Square继承自Shape类，拥有边长属性，提供构造函数，能够计算周长getPerimeter()和面积getArea()
定义一个子类长方形类Rectangle继承自Square类，拥有长、宽属性，提供构造函数，能够计算周长getPerimeter()和面积getArea()
定义一个子类圆形类Circle继承自Shape，拥有半径属性，提供构造函数，能够计算周长getPerimeter()和面积getArea()

在main函数中，分别构造三个子类的对象，并输出他们的周长、面积.
提示：用System.out.printf("%.2f",d)进行格式化输出

输入描述：

正方形类的边长
长方形类的长宽
圆类的半径

输出描述：

正方形的周长、面积
长方形的周长、面积

裁判测试程序样例：

import java.util.Scanner;
public class Main{public static void main(String[] args) {Scanner scan = new Scanner(System.in);      double length = scan.nextDouble();Square s = new Square(length);System.out.printf("%.2f ",s.getPerimeter());System.out.printf("%.2f\n",s.getArea());length = scan.nextDouble();double wide = scan.nextDouble();Rectangle r = new Rectangle(length,wide);System.out.printf("%.2f ",r.getPerimeter());System.out.printf("%.2f\n",r.getArea());double radius = scan.nextDouble();Circle c = new Circle(radius);System.out.printf("%.2f ",c.getPerimeter());System.out.printf("%.2f\n",c.getArea());scan.close(); }
}/* 你的代码被嵌在这里 */

输入样例：

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

1
1 2
2

输出样例：

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

4.00 1.00
6.00 2.00
12.57 12.57

答案代码如下：

abstract class Shape{public abstract double getPerimeter(); public abstract double  getArea();
}class Square extends Shape{public double length;public Square(double length) {this.length=length;}public double getPerimeter() {return 4.0*length;}public double getArea() {return length*length;}
}
class Rectangle extends Shape{//长方形类double broad;double length;public Rectangle(double length,double broad) {this.length=length;this.broad=broad;}public double getPerimeter() {return 2*length+2*this.broad;}public double getArea() {return this.length*this.broad;} }class Circle extends Shape{double radius;public Circle(double radius) {this.radius=radius; }public double getPerimeter() {return Math.PI*radius*2.0;}public double getArea() {return Math.PI*radius*radius;}
}

6-17 长方形长方体类

定义一个长方形类Rectangle，拥有长、宽属性，提供构造函数，能够计算周长getPerimeter()和面积getArea()
定义一个子类长方体类，拥有长、宽、高属性，提供构造函数，getPerimeter函数计算所有边的周长，getArea函数计算表面积，新增getVolume函数，计算体积
在main函数中，分别构造长方形类和长方体类的对象，并输出他们的周长、面积、体积，保留两位小数

输入描述：

长方形类的长、宽
长方体类的长、宽、高

输出描述：

长方形的周长和面积
长方体的周长，表面积，体积

裁判测试程序样例：

import java.util.Scanner;
public class Main{public static void main(String[] args) {Scanner scan = new Scanner(System.in);      double length = scan.nextDouble();double wide = scan.nextDouble();Rectangle r = new Rectangle(length,wide);System.out.printf("%.2f ",r.getPerimeter());System.out.printf("%.2f",r.getArea());
System.out.println();length = scan.nextDouble();wide = scan.nextDouble();double height = scan.nextDouble();Cuboid  c = new Cuboid (length, wide, height);System.out.printf("%.2f ",c.getPerimeter());System.out.printf("%.2f ",c.getArea());System.out.printf("%.2f",c.getVolume());scan.close(); }
}/* 你的代码被嵌在这里 */

输入样例：

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

1 2
1 2 3

输出样例：

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

6.00 2.00
24.00 22.00 6.00

答案代码如下：

class Rectangle{public double length;public double wide;public Rectangle(double length,double wide) {this.length=length;this.wide=wide;}public double getPerimeter() {return 2*length+2*wide;}public double getArea() {return wide*length;}
}
class Cuboid extends Rectangle{public double height;public Cuboid(double length, double wide,double height) {super(length, wide);this.height=height;}public double getPerimeter() {return 4*length+4*wide+4*height;}public double getArea() {return 2*length*wide+2*wide*height+2*height*length;}public double getVolume() {return length*wide*height;}
}

6-18 模拟题：设计一个BankAccount类

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

（1）一个int型的balance变量表示账户余额。

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

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

（4）一个int型的accountNumber变量表示开户数量，每创建一个BankAccount对象就自动加1。

（5）一个getBalance()方法：返回账户余额。

（6）一个withdraw()方法：带一个int型的amount参数，从账户余额中提取amount指定的款额。
如果amount<0或者大于当前账户余额，则输出“Invalid Amount”。

（7）一个deposit()方法：带一个int型的amount参数，将amount指定的款额存储到该银行账户上。
如果amount<0，则输出“Invalid Amount”。

裁判测试程序样例：

import java.util.Scanner;
/* 请在这里填写答案 */
public class Main {public static void main(String[] args) {Scanner scanner = new Scanner(System.in);boolean choice1 = scanner.nextBoolean();//是否创建对象 if (choice1==true){//账户1BankAccount myAccount1=new BankAccount();//账户2BankAccount myAccount2=new BankAccount(100);//选择操作类型int choice2 = scanner.nextInt();switch(choice2){case 0://存款int depositAmount=scanner.nextInt();myAccount2.deposit(depositAmount);break;case 1://取款int withdrawAmount=scanner.nextInt();myAccount2.withdraw(withdrawAmount);break;}System.out.println(myAccount2.getBalance());}System.out.println(BankAccount.accountNumber);scanner.close();}}

输入样例：

输入1：

true
0 20

输出样例：

120
2

输入样例：

输入2：

true
1 120

输出样例：

输出2：

Invalid Amount
100
2

输入样例：

输入3：

false

输出样例：

输出3：

答案代码如下：

class BankAccount{int balance;//账户余额static int accountNumber=0;//开户数量public BankAccount() {accountNumber++;balance=0;}public BankAccount(int balance) {accountNumber++;this.balance=balance;}public int getBalance() {return this.balance;}public int withdraw(int amount) {if(amount<0||amount>balance) {System.out.println("Invalid Amount");}else {this.balance=this.balance-amount;}return balance;}public int deposit(int amount) {if(amount<0) {System.out.println("Invalid Amount");}else{this.balance=this.balance+amount;}return balance;}}

6-19 圆柱体计算

1.构造一个Circle类：

1)该类有一个double型成员变量radius存放半径；

2)该类有一个有参构造方法，为成员变量radius赋值；

3)该类具有getArea和getLength两个方法，能够利用半径和Math.PI计算高精度的面积和周长。

2.构造一个Column类：

1）该类有一个Circle型成员变量bottom为圆柱体的底面；

2）该类有一个double型成员变量height存放圆柱体的高；

3）该类有getBottom和setBottom方法作为成员变量bottom的访问方法和赋值方法；

4）该类有getHeight和setHeight方法作为成员变量height的访问方法和赋值方法；

5）该类有getVolume方法，计算并返回圆柱体的体积。

裁判测试程序样例：

在这里给出函数被调用进行测试的例子。例如：
import java.util.Scanner;
public class Main {public static void main(String[] args) {Scanner scanner=new Scanner(System.in);      double r=scanner.nextDouble();double h=scanner.nextDouble();Circle c = new Circle(r);Column column=new Column();column.setBottom(c);column.setHeight(h);System.out.printf("底面面积和周长分别为：%.2f %.2f\n",column.getBottom().getArea(),column.getBottom().getLength());System.out.printf("体积为：%.2f\n",column.getVolume());      scanner.close();}
}/* 请在这里填写答案 */

输入样例：

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

10 2

输出样例：

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

底面面积和周长分别为：314.16 62.83
体积为：628.32

答案代码如下：

class Circle {double radius;public Circle(double radius) {this.radius=radius;}public double getArea() {return Math.PI*radius*radius;}public double getLength() {return Math.PI*radius*2.0;}
}
class Column {Circle bottom;public double height;public Circle getBottom() {return bottom;}public void setBottom(Circle bottom) {this.bottom = bottom;}public double getHeight() {return height;}public void setHeight(double height) {this.height = height;}public double getVolume(){return height*bottom.getArea();}}

欢迎大家批评指正！！！