java上机练习题
【问题描述】
输入一组数据(定义1个数组并定义元素个数),求此组数据的最大值和最小值。
【输入形式】
输入一组数据，以空格隔开。
【输出形式】
输出此数组元素的最大值和最小值
【样例输入】
78 63 52 87 45 98
【样例输出】
98
45
【样例说明】
定义数组元素个数为6，输出它们的最大和最小值。
【评分标准】
该程序要求输出所输入数据的最大和最小值。
package operation;
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
int size=6;
int arr[]=new int [size];
Scanner sc=new Scanner(System.in);
for(int i=0;iarr[i]){
min=arr[i];
}
}
System.out.println(max);
System.out.println(min);
}
}
【问题描述】实现一个基于ASCII码的简单加密系统。
加密规则如下：
if (OriginalChar + Key > 126) then
EncryptedChar = ((OriginalChar + Key)-127) + 32
else
EncryptedChar = (OriginalChar + Key)
限定密钥是1~100之间的某个数字。原始消息全部由ASCII码组成，
编写加密解密功能，实现这个加密系统。输入密钥和一行明文，输出密文；再对密文解密，输出明文。
提示：String.charAt()方法可用于获取字符串中的某个字符
String.length()方法可返回字符串长度（字符个数）
Scanner.nextLine()方法可从键盘输入一行字符
【输入形式】
【输出形式】
【样例输入】
【样例输出】
package ASCIIjiami;
import java.util.Scanner;
public class ASCII {
public static void main(String[] args) {
int size=100;
char OriginalChar = 0;
char EncryptedChar1[]=new char[15] ;
char EncryptedChar2[] =new char[15];
Scanner sc=new Scanner(System.in);
System.out.print("Enter a message for encrypt: ");
String arr1;
arr1=sc.nextLine();
System.out.print("Enter a key between 1 to 100: ");
int Key=sc.nextInt();
for(int i=0;i126)
EncryptedChar1[i] = (char) (((OriginalChar+Key)-127) + 32);
else
EncryptedChar1[i] = (char) (OriginalChar + Key);
}
String arr2= String.valueOf(EncryptedChar1); //将char变量转换成字符串
System.out.println("message: "+arr1);
System.out.println("result: "+arr2);
for(int i=0;i 3.组合实现汽车类
一辆Car有(has)四个轮子(Wheels)和一个发动机(Engine)。现在要求用组合方法设计类Car、类Wheel和类Engine.
(1) 类Engine 有字符串属性type记录发动机的型号，
有构造方法，可设置发动机的型号
有方法start()启动引擎(输出下面样例中包含发动机型号和“starts”的字符串)
(2)类Wheel有字符串属性type记录轮胎的型号，有整数类型属性index记录当前轮胎编号(1:front-left，2:front-right，3:back-left，4:back-right)，
有构造方法，可设置轮胎的型号和编号
有方法roll()表示轮胎正在转动(输出下面样例中包含轮胎型号、轮胎位置和“rolling”的字符串)
(3)类Car有字符串属性model记录轿车的型号，有属性wheels[]和engine，分别是Wheel类对象数组和Engine类对象
有构造方法，参数是三个字符串，分别表示轿车的型号、轮胎型号和发动机的型号，
有方法changeWheel()可以改变指定轮胎的型号，
有方法start()，先输出下面样例中包含轿车型号和“firing”的字符串，然后调用engine的start()，再调用所有轮胎的roll()，最后显示轿车型号和“running”。
要求编程实现类Car、类Wheel和类Engine，使给定的Test类能正常运行，并实现指定的输出内容。
public class Test
{
public static void main(String[] args){
String wheel="BridgeStone";
String model="BMW";
String engine="Mode L";
Car car1=new Car(model,wheel,engine);
car1.start();
System.out.println("=================");
model="Benz";
engine="Model S";
Car car2=new Car(model,wheel,engine);
car2.changeWheel(2,"Michelin");
car2.start();
}
}
【输入形式】
【输出形式】
【样例输入】
【样例输出】
package day416;
public class Test
{
public static void main(String[] args){
String wheel="BridgeStone";
String model="BMW";
String engine="Mode L";
Car car1=new Car(model,wheel,engine);
car1.start();
System.out.println("=================");
model="Benz";
engine="Model S";
Car car2=new Car(model,wheel,engine);
car2.changeWheel(2,"Michelin");
car2.start();
}
}
package day416;
public class Car {
private String model;
private String wheel;
private String engine;
private String []wheels=new String[5];
public Car(String model, String wheel, String engine) {
super();
this.model = model;
this.wheel = wheel;
this.engine = engine;
for(int i=0;i is firing!");
Engine e=new Engine(this.engine);
e.start();
for(int i=0;i is running");
}
}
package day416;
public class Engine {
private String type;
public Engine(String type) {
super();
this.type = type;
}
public void start(){
System.out.println("Engine"+"<"+this.type+">"+" starts!");
}
}
package day416;
public class Wheel {
private String type;
private int index;
public Wheel(String type, int index) {
super();
this.type = type;
this.index = index;
}
public void roll(String type,int index){
this.type = type;
this.index = index;
if(this.index==1){
System.out.println("Wheel front-left"+" <"+this.type+"> "+"is rolling");
}
if(this.index==2){
System.out.println("Wheel front-right"+" <"+this.type+"> "+"is rolling");
}
if(this.index==3){
System.out.println("Wheel back-left"+" <"+this.type+"> "+"is rolling");
}
if(this.index==4){
System.out.println("Wheel back-right"+" <"+this.type+"> "+"is rolling");
}
}
}
4.
| 时间类
【问题描述】 MyTime类可以表示时间（小时+分钟），具有两个整数属性和一个字符串属性： 小时值 分钟值 错误消息提示 并具有一个构造方法(与类同名的方法)和三个普通方法： 构造方法：接收两个整数作为参数，并进行合理性判断（小时值应在0-23之间，分钟值 应在0-59之间），如合理则分别用于设定小时值 和分钟值，如不合理，则输出错误提示信息，并将小时值 和分钟值均设为0。 setTime()方法，接收两个整数作为参数，并进行合理性判断（小时值应在0-23之间，分钟值 应在0-59之间），如合理则分别用于设定小时值 和分钟值，如不合理，则输出错误提示信息，并保持原值 不变 showTime()方法，输出时间信息，格式形如“Time is 23:18” getTime12()方法，输出12小时制的时间信息，格式形如“Time in 12---10:35 am”或“Time in 12---10:35 pm” 要求编程实现MyTime类，使给定的Test类能正常运行，并实现指定的输出内容。
public class Test{ static public void main(String args[]){ MyTime mt = new MyTime(25,43); mt.showTime();
mt = new MyTime(10,35); mt.showTime(); System.out.println("Time in 12---"+mt.getTime12());
mt.setTime(25,16); mt.showTime();
mt.setTime(23,18); mt.showTime();
System.out.println("Time in 12---"+mt.getTime12()); } } 【输入形式】 invalid time value! Time is 0:0 Time is 10:35 Time in 12---10:35 am invalid time value! Time is 10:35 Time is 23:18 Time in 12---11:18 pm 【样例输入】 |
public class Test{
static public void main(String args[]){
MyTime mt = new MyTime(25,43);
mt.showTime();
mt = new MyTime(10,35);
mt.showTime();
System.out.println("Time in 12---"+mt.getTime12());
mt.setTime(25,16);
mt.showTime();
mt.setTime(23,18);
mt.showTime();
System.out.println("Time in 12---"+mt.getTime12());
}
}
public class MyTime {
int hour;
int min;
String error="invalid time value! ";
public MyTime(int hour, int min) {
if((hour>=0&&hour<=23)&&(min>=0&&min<=59)){
this.hour = hour;
this.min = min;
}
else
{
this.hour=0;
this.min=0;
System.out.print(error);
}
}
public void setTime(int hour,int min){
if(hour>=0&&hour<=23&&min>=0&&min<=59){
this.hour = hour;
this.min = min;
}else
System.out.print(error);
}
public void showTime(){
System.out.println("Time is "+hour+":"+min);
}
public String getTime12(){
if(hour<=12&&hour>=0){
return (hour+":"+min+" am");
}else
{
return ((hour-12)+":"+min+" pm");
}
}
}
5.类的继承
【问题描述】设计学生类Student和它的子类Undergraduate，要求：
（1）Student类有name(姓名）和age（年龄）属性，有一个包含两个参数的构造方法，为两个属性赋值，一个show()方法输出Student的属性信息；
（2）Undergraduate类增加一个major（专业）属性。有一个包含三个参数的构造方法，前两个参数用于给继承的name和age属性赋值，第三个参数给major属性赋值，一个show()方法输出Undergraduate的属性信息。
（3）在测试类中分别 创建Student对象和Undergraduate对象，调用它们的show()。
【输入形式】
【输出形式】
【样例输入】无
【样例输出】
information：
name=zhangsan
age=20
information:
name=lisi
age=21
major=math
【样例说明】
【评分标准】
package day423;
public class Test {
public static void main(String[] args) {
Student s=new Student("zhangsan",20);
Undergraduate u=new Undergraduate("lisi",21,"math");
System.out.println("information:");
s.show();
System.out.println("information:");
u.show();
}
}
package day423;
public class Student {
private String name;
private int age;
public Student(String name, int age) {
super();
this.name = name;
this.age = age;
}
public void show(){
System.out.println("name="+name);
System.out.println("age="+age);
}
}
package day423;
public class Undergraduate extends Student{
private String major;
public Undergraduate(String name, int age,String major) {
super(name, age);
this.major=major;
}
public void show(){
super.show();
System.out.println("major="+major);
}
}
6.多态编程
| 多态编程
【问题描述】类的继承关系如图所示。 其中： Test类代码如下： public class Test 【输入形式】 Name: Tom |
package day4231;
public class Person {
private String name;
public Person(String name) {
super();
this.name = name;
}
public void display(){
System.out.println("Name: "+name);
}
}
package day4231;
public class Teacher extends Person{
private String professionTitle;
public Teacher(String name,String professionTitle) {
super(name);
this.professionTitle=professionTitle;
}
public void display(){
super.display();
System.out.println("Professional Title: "+professionTitle);
}
}
package day4231;
public class Student extends Person{
private int studentNumber;
public Student(String name,int studentNumber) {
super(name);
this.studentNumber=studentNumber;
}
public void display(){
super.display();
System.out.println("StudeneNumber: "+studentNumber);
}
}
package day4231;
public class Graduate extends Student{
private String major;
public Graduate(String name, int studentNumber,String major) {
super(name, studentNumber);
this.major=major;
}
public void display(){
super.display();System.out.println("Major: "+major);
}
}
package day4231;
public class Undergraduate extends Student{
private int grade;
public Undergraduate(String name, int studentNumber,int grade) {
super(name, studentNumber);
this.grade=grade;
}
public void display(){
super.display();
System.out.println("Grade: "+grade);
}
}
package day4231;
public class Test
{
public static void main(String[] args)
{
Person[] people = new Person[5];
people[0] = new Person("Tom");
people[1] = new Teacher("Kevin","professor");
people[2] = new Student("Jerry",21);
people[3] = new Undergraduate("John",22,3);
people[4] = new Graduate("Mary",23,"computer");
for (Person p: people)
{
p.display();
System.out.println(">>>");
}
}
}
7.
| 接口编程一
【问题描述】要求编程实现Student类，使给定的Test类能正常运行，并实现按字母顺序输出姓名。 import java.util.Arrays; Arrays.sort()方法是Java已经实现好的工具类Arrys中用于对数组元素进行排序的方法。它要求数组中的元素已经实现了Comparable接口。 Comparable接口是Java已经实现好的一个接口，该接口主要代码如下： 【输入形式】 【样例说明】 |
package day430;
import java.util.Arrays;
public class Test
{
public static void main(String[] args)
{
Student[] s = new Student[4];
s[0] = new Student("May");
s[1] = new Student("Jack");
s[2] = new Student("Armstrong");
s[3] = new Student("Linda");
Arrays.sort(s);
System.out.println("according to alphabetical order:");
for (Student stu:s)
{
System.out.println(stu.getName());
}
}
}
package day430;
public class Student implements Comparable{
private String name;
String t="o";
public Student(String name) {
super();
this.name = name;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public int compareTo(Student student) {
if(this.name.compareTo(student.name)>0){
return 1;
}else if(this.name.compareTo(student.name)<0){
return -1;
}else
return 0;
}
}
8.
| 判断两个数据集是否相同
【问题描述】 从标准输入中读入两个整数集，整数集中数据无序，且可能有重复数据。当两个数据集中数据完全相同（数据相同，数据若重复，重复个数也相同，顺序不一定相同），则两个数据集相同。编写一程序判断输入的两数据集是否相同：用1表示相同，用0表示不同。 【输入形式】 先输入第一组整数集的个数（大于等于1，小于等于20），然后输入第一组整数（以一个空格分隔）；再输入第二组整数集的个数（大于等于1，小于等于20），并输入第二组整数（以一个空格分隔）。 【输出形式】 若两数据集相同，则输出1，否则输出0，然后按照从小到大的顺序分行输出第一个数据集中的数据及重复个数（以一个空格分隔数据和重复个数）。 【样例输入1】 10 【样例输出1】 1 【样例输入2】 10 【样例输出2】 0 【样例说明】 样例1中输入的两个数据集的数据和各个数据的重复个数都完全相同，所以输出1，然后按从小到大的顺序输出第一个数据集中的数据及重复个数（即：有2个-12，2个7，2个56，1个89，3个100）。 【评分标准】
该题要求判断两数据集是否相同。
|
package numorsame;
import java.util.*;
public class Demo {
public static void main(String[] args) {
int size1 ,size2;
Scanner sc=new Scanner(System.in);
size1=sc.nextInt();
int arr1[]=new int [size1];
for(int i=0;i9.异常处理
【问题描述】编写程序，把24小时表示法的时间转换为12小时表示法。定义名为TimeFormatException的异常类，如果输入的时间是非法值，比如10:65或者abc，程序应该抛出并处理TimeFormatException异常。
提示1：输入一行使用Scanner.nextLine()方法。
提示2：时间格式转换可以使用java.text.SimpleDateFormat类，具体用法自行查看API文档或网上资料。
【输入形式】
【输出形式】
【交互样例】
Enter time in 24-hour notation:
15:20
>>>Time in 12-hour notation is: 03:20 PM
Again?(y/n)
y
Enter time in 24-hour notation:
27:10
TimeFormatException: Invalid Value for Hour!
Try again:
Enter time in 24-hour notation:
16:78
TimeFormatException: Invalid Value for Minute!
Try again:
Enter time in 24-hour notation:
abc
TimeFormatException: Invalid Value for Time!
Try again:
Enter time in 24-hour notation:
6:30
>>>Time in 12-hour notation is: 06:30 AM
Again?(y/n)
n
End of program
【样例说明】
【评分标准】
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Locale;
import java.util.Scanner;
public class App {
public static void main(String[] args) throws ParseException {
while (true) {
System.out.println("Enter time in 24-hour notation:");
Scanner sc = new Scanner(System.in);
String line = sc.nextLine();
try {
checkTime(line);
} catch (Exception e) {
System.out.println("Try again:");
continue;
}
System.out.println("Again?(y/n)");
line = sc.nextLine();
if ("n".equalsIgnoreCase(line)) {
break;
}
}
System.out.println("End of program");
}
public static void checkTime(String str) throws TimeFormatException {
SimpleDateFormat _24time = new SimpleDateFormat("HH:mm");
SimpleDateFormat _12time = new SimpleDateFormat("hh:mm a",Locale.ENGLISH);
String str1="Hour";
String str2="Minute";
String str3="Time";
try {
if(!str.matches("\\d{1,2}\\:\\d{2}")){
throw new TimeFormatException(str3);
}
String[] array = str.split(":");
if (Integer.parseInt(array[0]) < 0 || Integer.parseInt(array[0]) > 23) {
throw new TimeFormatException(str1);
}
if (Integer.parseInt(array[1]) < 0|| Integer.parseInt(array[1]) > 59) {
throw new TimeFormatException(str2);
}
System.out.println(">>>Time in 12-hour notation is: "+_12time.format(_24time.parse(str)));
}
catch (Exception e) {
throw new TimeFormatException();
}
}
}
class TimeFormatException extends Exception{
static final long serialVersionUID = 20190218L;
public TimeFormatException() {
}
public TimeFormatException(String message) {
System.out.println("TimeFormatException: Invalid Value for "+message+"!");
}
}
10.手机话费异常
【问题描述】
定义了一个接口PayAble，包含计算电话话费的方法pay()。在手机类定义中增加计算话费异常，如果话费小于0则抛出异常。
要点提示：1) 自定义一个异常类，表示话费小于0的异常；2) 计算话费时如果小于0则抛出异常，在测试类中处理异常。
【输入形式】无
【输出形式】话费结果或者异常
【样例输入】10 0.5
【样例输出】
Fee=5.0
【样例输入】0 0.7
【样例输出】
Exception isPayException: Fee is 0！
Fee=0.0
【样例说明】
【评分标准】
import java.util.Scanner;
public class Test{
public static void main(String [] args){
Scanner sc = new Scanner(System.in);
int times = sc.nextInt();
double price = sc.nextDouble();
double pay2 = 0;
MobilePhone phone1=new MobilePhone("13899999999",times, price);
try{
pay2=phone1.pay();
}
catch(PayException e)
{
System.out.println("Exception is"+e);
}
System.out.println("Fee="+pay2);
}
}
abstract class Phone{
private String code;
public Phone(String code){
this.code = code;
}
public abstract void display();
}
interface PayAble{
public double pay()throws PayException;
}
class MobilePhone extends Phone implements PayAble{
private int time;
private double price;
public MobilePhone(String code,int time, double price){
super(code);
this.time =time;
this.price = price;
}
public double pay() throws PayException{
double p;
p=time*price;
if(p<=0){
throw new PayException("Fee is 0!");
}
return p;
}
public void display(){
}
}
class PayException extends Exception {
public PayException(String string) {
super(string);
}
}