JAVA入门速成(一)

发布于 2023-03-28  1270 次阅读

实验1

1-1 Java-Basic-编写程序计算公式

编写程序，计算下列公式，并输出公式的结果

img

public class Main{
        public static void main(String[] args){
                 System.out.println((9.5 * 4.5 - 2.5 * 3)/(45.5-3.5));
        }
}
  • println是输出自动换行

1-2 Java-Basic-计算矩形的面积和周长

Write a program that displays the area and perimeter of a rectangle using following formula:

area = width * height
perimeter = （width+height）*2

输入格式:

输入的是double类型的数据 20.0 10.0

输出格式:

分别输出计算得到的矩形的面积和周长。

输入样例:

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

20.0 10.0

输出样例:

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

The area is 200.0
The perimeter is 60.0
import java.util.Scanner;

public class Main {
        public static void main(String[] args) {
                    Scanner input = new Scanner(System.in);
                    double h = input.nextDouble();
                    double w = input.nextDouble();
                    System.out.println("The area is "+h*w);
                    System.out.println("The perimeter is "+ (h+w)*2);
        }
}
  • input.nextDouble()和input.next()相比将输入的数标记为双精度浮点

1-3 Java-Basic-温度单位换算(摄氏度转华氏度)

Write a program that reads a Celsius degree in a double value from the console, then converts it to Fahrenheit and displays the result.

The formula for the conversion is as follows:

fahrenheit = (9 / 5 ) * celsius + 32;

输入格式:

在控制台输入一个实数，表示摄氏度温度。

输出格式:

输出转换后的华氏度温度值

img

输入样例:

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

43

输出样例:

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

43.0 Celsius is 109.4 Fahrenheit
import java.util.Scanner;

public class Main{
        public static void main(String[] args){
                    Scanner input = new Scanner(System.in);
                    double c = input.nextDouble();
                    double f = ((9/5.0) * c + 32);
                    System.out.printf("%.1f Celsius is %.1f Fahrenheit\n",c,f);
        }
}
  • printf可以格式化输出

1-4 Java-Basic-计算BMI

写程序计算身体质量指数BMI，BMI=体重（千克）除以身高（米）的平方。

输入体重（单位是千克）和身高（单位是米），输出BMI指数值，BMI指数值保留4位小数(提示：使用printf方法)；

double d = 1.23256233;
System.out.printf("%.4f",d);
//输出 1.2326

根据BMI指数值再输出身体指数状况：

如果BMI小于18.5，输出: It's underweight

如果BMI大于等于18.5，且小于24，表示体重正常，输出: It's normal weight

如果BMI大于等于24，表示体重偏重，输出: It's fat

可以在main方法中直接实现，也可以定义方法实现。

输出示例：

img

输入格式:

输入体重（单位是千克）和身高（单位是米），用空格分开两个输入值，例如： 70 1.75，表示体重为70公斤，身高为1.75米

输出格式:

输出BMI值，并根据BMI输出身体质量状况， The BMI is 22.8571 BMI指数值 It's normal weight 身体状况

输入样例:

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

78 1.85

输出样例:

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

The BMI is 22.7904
It's normal weight
import java.util.Scanner;

public class Main {
        public static void main(String[] args) {
                    Scanner input = new Scanner(System.in);
                    int kg = input.nextInt();
                    double m = input.nextDouble();
                    double bmi = kg / (m * m);
                    System.out.printf("The BMI is %.4f\n", bmi);
                    if (bmi < 18.5) {
                                    System.out.print("It's underweight");
                    } else if (bmi < 24) {
                                    System.out.print("It's normal weight");
                    } else {
                                    System.out.print("It's fat");
                    }
        }
}

实验2

选择

  1. 关于字符串的方法，如下代码执行结果是（ ）。
String fileName = "中国China"; 
System.out.println(fileName.indexOf("国"));

A.0

B.1

C.2

D.3

  • b
  • indexOf 方法返回指定字符串在当前字符串中第一次出现的位置，如果没找到则返回 -1。在这个例子中，"国" 第一次出现在 "中国China" 的第2个字符位置，即索引 1。所以输出结果为 1。
  1. 关于字符串的方法，如下代码执行结果是（ ）。
String fileName = "中国China"; 
System.out.println(fileName.length());

A.7

B.9

C.11

D.13

  • a
  • 字符串的类有length()方法查看字符串长度
  1. 关于字符串的比较，如下代码执行结果是（ ）。
        String s1 = "imooc";
        String s2 = "I love " + s1;
        String s3="I love imooc";
        System.out.println(s2 == s3);

A.true

B.false

C.0

D.1

  • b
  • ==比较的是字符串地址
  1. 关于字符串的方法，如下代码执行结果是（ ）。
String str1 = "sdut@sdut.edu.cn";   
System.out.println(str1.toUpperCase());
System.out.println(str1);

A.

sdut@sdut.edu.cn
SDUT@SDUT.EDU.CN

B.

sdut@sdut.edu.cn
sdut@sdut.edu.cn

C.

SDUT@SDUT.EDU.CN
SDUT@SDUT.EDU.CN

D.

SDUT@SDUT.EDU.CN
sdut@sdut.edu.cn
  • d
  • toUpperCase()转换为大写,toLowerCase()转换为小写
  1. 关于字符串的方法，如下代码执行结果是（ ）。
String str1 = "sdut@sdut.edu.cn";
String str2 = str1.toLowerCase();
System.out.println(str2);
System.out.println(str1);
System.out.println(str1 == str2);

A.

sdut@sdut.edu.cn
sdut@sdut.edu.cn
true

B.

sdut@sdut.edu.cn
sdut@sdut.edu.cn
false

C.

sdut@sdut.edu.cn
SDUT@SDUT.EDU.CN
true

D.

sdut@sdut.edu.cn
SDUT@SDUT.EDU.CN
false
  • a
  • 后者取的前者的值,java自动合并地址
  1. 关于字符串的方法，如下代码执行结果是（ ）。
String str1 = "abcd"; 
String str2="sdut";
System.out.println(str1.compareTo(str2)>0);

A.true

B.false

C.1

D.-1

  • b
  1. 关于字符串的方法，如下代码执行结果是（ ）。
String str1 = "sdut12"; 
String str2="sDut12";
System.out.println(str1.equalsIgnoreCase(str2));

A.true

B.false

C.0

D.1

  • a
  • compareTo()方法比较两个字符串的字典顺序，如果当前字符串大于参数字符串，则返回正整数，如果当前字符串小于参数字符串，则返回负整数，如果两个字符串相等，则返回0。在这个例子中，str1与str2没有公共前缀，因此会根据字典顺序进行比较，a在 s的前面，所以 str1比 str2小，str1.compareTo(str2) 返回负整数，因此 `str1.compareTo(str2)>0 返回 false。
  • 如果使用 compareTo()方法比较 "a"和 "ab"，则返回的结果应该是一个负数，因为 "a"在字典序上应该排在 "ab"前面。具体的值取决于具体的实现。

  1. 关于字符串的方法，如下代码执行结果是（ ）。

    String str1 = "sdut12"; 
String str2="sDut12";
System.out.println(str1.equalsIgnoreCase(str2))

A.true

B.false

C.0

D.1

  • a
  • 因为 equalsIgnoreCase()方法是忽略大小写比较两个字符串是否相等，所以忽略了 str2中的大写字母，最终返回 true。
  1. 关于字符串对象的比较，==用于比较字符串对象的（ ）是否相同；equals()方法用于比较字符串对象的（ ）是否相同。

A.存储地址 字符序列

B.存储地址 存储地址

C.字符序列 存储地址

D.字符序列 字符序列

  • a
  1. 关于字符串的方法，如下代码执行结果是（ ）。
String str = "    abcd123";
  str.toUpperCase();
  str.trim();
  System.out.println(str);

A.

    abcd123

B.abcd123

C.

   ABCD123

D.ABCD123

  • a
  • 虽然在第二行使用了toUpperCase()方法和第三行使用了trim()方法，但是这两个方法都不会改变原始字符串的值，而是返回一个新的字符串。因此，原始字符串的值仍然是" abcd123"。
  1. 已知: String s="abcdedcba”; 则 s.substring(3,4) 返回的字符串是哪个?（ ）

A.cd

B.de

C.d

D.dedc

  • c
  • s.substring(3, 4) 表示截取从第3个字符开始(从第0位来记)，到第4个字符之前（不包括第4个字符）的子串。

7-1 判断回文

编码实现：输入一个字符串，判断该字符串是否是回文（回文是指将该字符串含有的字符逆序排列后得到的字符串和原字符串相同的字符串）如果是回文，则输出“Yes”；否则输出“No”。

输入格式:

判定是否是回文的字符串

输出格式:

“Yes”或者“No”

输入样例:

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

TooooT

输出样例:

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

Yes
import java.util.Scanner;

class Main {

        public static void main(String[] args) {
                    int q=1;
                    Scanner in = new Scanner(System.in);
                    String s = in.nextLine();
                    for(int i=0,j=s.length()-1;i<=j;i++,j--)
                    {
                                    if(s.charAt(i)!=s.charAt(j))
                                    {
                                    q=0;
                                    //System.out.println(s.charAt(i));
                                    //System.out.println(s.charAt(j));
                                    //System.out.println(q);
                                    };
                    }
                    if(q==1)System.out.println("Yes");
                    if(q==0)System.out.println("No");
        }

}

7-2 各类字符数

从键盘输入一个字符串，程序输出该字符串中的大写英文字母数，小写英文字母数以及非英文字母数

输入格式:

字符串

输出格式:

大写英文字母数 小写英文字母数 非英文字母数

输入样例:

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

Hello My Dear Friend, I Miss You Very Much!

输出样例:

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

9
24
10
import java.util.Scanner;
public class Main {

     public static void main(String[] args) {

Scanner scan = new Scanner(System.in);

String str = scan.nextLine();

int small = 0;

int big = 0;

int nothing = 0;

for(int i = 0;i<str.length();i++) {

if(str.charAt(i) >= 'a' && str.charAt(i)<='z')

{

small ++;

}

if(str.charAt(i) >= 'A' && str.charAt(i) <= 'Z')

{

big ++;

}

}

nothing = str.length() - big - small;

System.out.println(big);

System.out.println(small);

System.out.println(nothing);

        }

}

7-3 数据类型判断

从键盘分别输入通过空格分割的整型(int)、浮点型(double)、字符型(String)、布尔型(boolean)，根据读取的内容判断他们的类型并将他们解析为正确的对象，并都放到一个数组中。输出各个对象的类型

输入格式:

字符串

输出格式:

数据类型

输入样例:

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

2.1 true 123 abcde

输出样例:

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

double boolean int String
import java.util.Scanner;

public class Main {

     public static void main(String []args){

Scanner scan = new Scanner(System.in);

String s;

int j=0;

while(scan.hasNext()){

if(j!=0)

System.out.print(" ");

if(scan.hasNextInt()){

System.out.print("int");

}

else if(scan.hasNextDouble()){

System.out.print("double");

}

else if(scan.hasNextBoolean()){

System.out.print("boolean");

}

else System.out.print("String");

scan.next();

j=1;

}

}

}

7-4 数组中偶数的和

求任意10个整数中的偶数的和。

输入格式:

在一行中输入10个用空格间隔的整数。

输出格式:

在一行中按照“s=结果”的顺序输出，结果是原样输出的整数，没有其它附加格式。

输入样例:

2 5 4 8 4 1 3 6 1 10

输出样例:

s=34
import java.util.Scanner;

public class Main {

        public static void main(String []args){

                    Scanner scan = new Scanner(System.in);

                    String s;

                    int j=0;
                    String temp = scan.nextLine();
                    String[] ss = temp.trim().split(" ");
                    for(int i=0;i<=9;i++)
                    {
                    if(Integer.parseInt(ss[i])%2==0)
                    {j=j+Integer.parseInt(ss[i]);
                    //System.out.print('6');}
                    }

                    }
        System.out.printf("s=%d",j);
        }
}

实验3

选择

  1. 以下语句不能通过编译的是( )。

A.int[] a={1,2,3,4};

B.int b[];

C.int c[]=new int[3];

D.int d=new int[];

  • d
  • 在Java中，定义数组可以有以下几种方式：

  1. 静态初始化：在定义数组的同时直接为数组元素赋值。例如：

    javaCopy code
int[] array = {1, 2, 3};

  2. 动态初始化：先定义数组，再为数组元素赋值。例如：

    javaCopy codeint[] array = new int[3];
array[0] = 1;
array[1] = 2;
array[2] = 3;

  3. Test.java程序代码如下：

public class Test {
     public static void main(String[] args) {
           System.out.println(args[1]);
    }
}

以上程序编译后，用命令：java Test 2 3 4 5运行的输出结果是什么？ ( )

A.1

B.2

C.3

D.4

  • c
  • 其中 args 数组中第一个元素是 args[0]，也就是 2，第二个元素是 args[1]，也就是 3，所以输出的结果为 3。
  1. 有如下程序代码，程序输出结果是：（ ）。
int[] arr1=new int[10];
int[] arr2=new int[arr1.length];
System.out.println(Arrays.equals(arr1,arr2));

A.true

B.false

C.0

D.1

  • a
  • Arrays.equals()方法用于判断两个数组是否相等，如果两个数组长度相等，并且对应位置上的元素都相等，则返回true
  1. 有如下程序代码，执行后输出结果是：（ ）。
int[] arr1=new int[10];
int[] arr2=new int[arr1.length];
System.out.println(arr1==arr2);

A.true

B.false

C.0

D.1

  • b
  • arr1和arr2虽然长度相同，但它们是不同的数组对象，使用 ==来比较数组对象的地址时，返回的结果为 false,想要比较元素应该用Arrays.equals()方法
  1. 如下语句执行结果是：（ ）。
int[] intArr=new int[10];
System.out.println(intArr[0]);

A.编译错误

B.会报运行错误

C.0

D.null

  • c
  • 在Java中，当创建一个新的int数组时，该数组的每个元素都会被初始化为0。因此，使用索引0访问intArr数组的第一个元素将返回0。
  1. 如下语句执行结果是：（ ）。
int[] intArr=new int[10];    
System.out.println(intArr[10]);

A.编译错误

B.会报运行错误

C.0

D.null

  • B. 会报运行错误。因为intArr数组的长度是10，而下标是从0开始的，所以最后一个元素的下标是9，访问下标为10的元素会越界。
  • 编译错误通常是在编译代码时出现的语法错误或者类型错误，导致编译器无法将代码转换为可执行代码，无法通过编译。常见的编译错误包括拼写错误、语法错误、类型不匹配等。
  • 运行错误则是在代码编译后运行过程中出现的错误，通常是由于代码逻辑错误、资源不足或者外部条件发生变化等原因导致程序运行出现异常。常见的运行错误包括数组越界、空指针引用、除零异常等。
  1. 关于一维数组的定义形式，哪个是错误的？

A.int intArr=new int[10];

B.int intArr[]=new int[10];

C.int intArr[]={1,2,3,4,5};

D.int intArr[]=new int[]{1,2,3,4,5};

E.int intArr[]={1,2,3,4,5};

  • a
  1. 设有数组的定义int[] a = new int[3]，则下面对数组元素的引用错误的是（ ）。

A.a[0]=8;

B.a[a.length-1]=90;

C.a[3]=9;

D.int i=1;a[i]=0;

  • c
  1. 数组的定义为：int[] arr=new int[10]; 如何获得数组的长度？

A.arr.length()

B.arr.size()

C.arr.length

D.arr.size

  • c
  • Arrays.equals()方法是静态方法,比较两个函数的字典序,而length是数组对象的固定属性,而不是获取长度的函数
  1. 执行完以下代码int[ ] x = new int[25]；后，以下哪项说明是正确的（ ）。

A.x[24]为0

B.x[25]为0

C.x[0]为空

D.x[24]未定义

  • a
  1. 请选择下面程序正确的输出结果（ ）
public class Main{
        public static void main(String args[ ]){
            String a = new String("A");
            String b = new String("B");
            mb_operate(a,b);
            System.out.println(a + "." + b);
}
static void mb_operate(String x,String y){
    x.concat(y);
    y=x;
}
}

A.A.B

B.A.A

C.AB.AB

D.AB.B

  • a
  • 正确的输出结果是A.B。原因是Java中的String对象是不可变的，调用concat方法会创建一个新的字符串对象，而不会修改原来的字符串对象。在mb_operate方法中，虽然x.concat(y)方法被调用了，但是没有将其结果赋值给x，所以x仍然是原来的"A"字符串对象。同时，y=x操作只是改变了y的引用，而没有改变原来的b对象，因此main方法中的a和b变量值没有被改变。
  • 在 Java 中，参数传递是按值传递的。也就是说，当你在方法中修改参数的值时，只是修改了参数的副本，而不是修改了原始值。因此，在这道题中，即使在 mb_operate()方法中修改了x和 y的值，也不会影响到 main()方法中 a和 b的值。如果你希望 main()方法中的 a和 b的值也被修改，你需要将方法的返回值设置为修改后的值，然后在 main()方法中重新赋值。例如：
javaCopy codepublic class Main {
    public static void main(String args[]) {
        String a = new String("A");
        String b = new String("B");
        b = mb_operate(a, b);
        System.out.println(a + "." + b);
    }

    static String mb_operate(String x, String y) {
        x = x.concat(y);
        y = x;
        return y;
    }
}
  1. 有如下程序代码，程序运行的结果是（ ）。
String s1 = "sdut"; 
String s2 = "sdut"; 
System.out.print(s1 == s2); 
System.out.println(" "+s1.equals(s2));

A.true false

B.true true

C.false true

D.false false

  • b
  • 第一处是因为之前说的为了节省内存所以内存合并,第二处是字符类拥有equals()方法,要与静态函数Arrays.equals()区分开
  1. 在下面的代码中，程序执行的结果将是：（ ）。
public class Test {
  public static void main(String[] args) {
         String str = "123";
         System.out.println(str);
         change(str);
         System.out.println(str);
     }
    public static void change(String str){
      str = "456";
    }
}

A.

456
123

B.

456
456

C.

123
456

D.

123
123
  • d
  • 上面提到了因为java没有引用变量所以没法在函数中操作局部变量(全局变量可以),只能用return来实现
  1. 关于字符串的方法，如下代码执行结果是（ ）。
String fileName = "sdut@sdut.edu.cn"; 
System.out.println(fileName.lastIndexOf("."));

A.9

B.10

C.13

D.12

  • c
  • lastIndexOf()方法返回指定字符串在当前字符串中最后一次出现的位置。在这个例子中，"."在字符串中的位置是9，因为它是文件扩展名的分隔符。
  1. 关于字符串的方法，如下代码执行结果是（ ）。
String fileName = "中国China"; 
System.out.println(fileName.indexOf("国"));

A.0

B.1

C.2

D.3

  • b
  • indexOf 方法返回指定字符串在当前字符串中第一次出现的位置，如果没找到则返回 -1。第一位是0
  1. 关于字符串的方法，如下代码执行结果是（ ）。
String fileName = "中国China"; 
System.out.println(fileName.length());

A.7

B.9

C.11

D.13

  • a
  • 字符类拥有length()方法返回长度,和length属性的返回结果是相同的,两者都能得到字符串的长度
  1. 关于字符串的比较，如下代码执行结果是（ ）。
        String s1 = "imooc";
        String s2 = "I love " + s1;
        String s3="I love imooc";
        System.out.println(s2 == s3);

A.true

B.false

C.0

D.1

  • b
String a="1234";
String b="1234";
String c = new String("1234");

a==b
a!=c
  1. 关于字符串的方法，如下代码执行结果是（ ）。
String str1 = "abcd"; 
String str2="sdut";
System.out.println(str1.compareTo(str2)>0);

A.true

B.false

C.1

D.-1

  • b
  1. 关于字符串的方法，如下代码执行结果是（ ）。
String str1 = "sdut12"; 
String str2="sDut12";
System.out.println(str1.equalsIgnoreCase(str2));

A.true

B.false

C.0

D.1

  • a
  • equalsIgnoreCase()表示比较时不考虑大小写
  1. What is the value of s2 after this code executes?
String s1 = "Happy#day";
String s2 = s1.substring(1,5);

A."Happ"

B."Happy"

C."appy"

D."appy#"

  • c
  • 从第0位开始计,从第一位(包括第一位)到第五位(不包括第五位)

5-1Java-OOP-定义矩形类Rectangle

按下面的要求定义一个类Rectangle表示矩形；

  • 矩形有长（length）和宽（width）两个属性，定义两个私有成员变量表示矩形的长和宽；
  • 为矩形定义一个默认构造器，初始化的长和宽都是1.0；
  • 为矩形定义一个带参数构造器，参数用于设置矩形对象的长和宽；
  • 为私有成员变量定义setter和getter方法
  • 定义一个成员方法：float getArea()，该方法计算并返回矩形的面积
  • 定义一个成员方法：float getPerimeter()，该方法计算并返回矩形的周长
定义的Rectangle类代码写在下面的框中。

import java.util.Scanner;
class Rectangle {
//代码在这里
}
public class Main {
    public static void main(String[] args) {
        Rectangle rectangle0 = new Rectangle();
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入矩形的长和宽:");
        float length = scanner.nextFloat();
        float width = scanner.nextFloat();
        Rectangle rectangle = new Rectangle(width,length);
        System.out.println("Output:");
        System.out.println("rectangle0的面积是:"+rectangle0.getArea()+",周长是:"+rectangle0.getPerimeter());
        System.out.println("rectangle的面积是:"+rectangle.getArea()+",周长是:"+rectangle.getPerimeter());
        System.out.print("修改rectangle的长和宽,");
        rectangle.setWidth(30.0f);
        rectangle.setLength(12.0f);
        System.out.println("修改后,rectangle的面积是:"+rectangle.getArea()+",周长是:"+rectangle.getPerimeter());
    }
}
 double length, width;

    public void setLength(double length){
        this.length = length;
    }
    public void setWidth(double width){
        this.width = width;
    }

    public double getLength(){
        return length;
    }
    public double getWidth(){
        return width;
    }

    public Rectangle(double length, double width){
        this.length = length;
        this.width = width;
    }
    public Rectangle(){
        this(1.0, 1.0);
    }

    public double getPerimeter(){
        return length + length + width + width;
    }
    public double getArea(){//面积
        return length*width;
    }

5-2Java-OOP-定义类-QuadraticEquation

定义类QuadraticEquation表示一元二次方程。ax²+bx+c=0（a≠0）

  • 私有的成员变量a,b,c，表示方程的三个系数；
  • 一个构造器，对三个系数进行初始化；
  • 成员变量a,b,c的getter方法；
  • 定义一个方法getDiscriminant(),方程是否有根的判别式，该方法返回 b²-4ac 的值；
  • 定义方法getRoot1()，当判别式大于等于0时，返回方程的第一个根x1，计算公式为:

img

反之返回0；

  • 定义方法,getRoot2()当判别式大于等于0时，返回方程的第二个根x2，计算公式为:

img

反之返回0；

程序运行结果示例：

img

请在下面的框中填写QuadraticEquation类的代码，提示：QuadraticEquation类请不要用public修饰

import java.util.Scanner;

//代码在这里
public class Main {
     public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        int a = scanner.nextInt();
        int b = scanner.nextInt();
        int c = scanner.nextInt();
        int a1 = scanner.nextInt();
        int b1 = scanner.nextInt();
        int c1 = scanner.nextInt();
        QuadraticEquation equation = new QuadraticEquation(a,b,c);
        System.out.println("equation discriminant is:"+(Math.pow(equation.getB(),2)-4*equation.getA()*equation.getC()));
        if (equation.getDiscriminant() < 0){
            System.out.println("The equation has no roots");
        }else{
            System.out.println("equation root1:"+equation.getRoot1());
            System.out.println("equation root2:"+equation.getRoot2());
        }

        QuadraticEquation equation1 = new QuadraticEquation(a1,b1,c1);
        System.out.println("equation1 discriminant is:"+(Math.pow(equation1.getB(),2)-4*equation1.getA()*equation1.getC()));
        if (equation1.getDiscriminant() < 0){
            System.out.println("The equation1 has no roots");
        }else{
            System.out.println("equation1 root1:"+equation1.getRoot1());
            System.out.println("equation1 root2:"+equation1.getRoot2());
        }
    }
}
class QuadraticEquation{
    private int a,b,c;
    public QuadraticEquation(int a, int b, int c) {
        this.a = a;
        this.b = b;
        this.c = c;
    }
    public int getA() {
        return a;
    }
    public int getB() {
        return b;
    }
    public int getC() {
        return c;
    }
    public int getDiscriminant(){
        return b*b-4*a*c;
    }
    public double getRoot1(){
        if (getDiscriminant() >= 0){
            return (-b+Math.pow(getDiscriminant(),0.5))/(2*a);
        }else{
            return 0;
        }
    }
    public double getRoot2(){
        if (getDiscriminant() >= 0){
            return (-b-Math.pow(getDiscriminant(),0.5))/(2*a);
        }else{
            return 0;
        }
    }
}
A

实验4

判断

  1. 如果在子类的构造方法中，没有使用关键字super调用父类的某个构造方法，那么默认有super();语句，即调用父类的不带参数的构造方法。
  • 是的，如果子类的构造方法中没有使用关键字super调用父类的某个构造方法，则默认会在子类的构造方法的第一行调用父类的无参构造方法，即隐式地调用super()。这是因为每个类都必须有一个构造方法，并且构造方法的第一行要么是调用父类的构造方法，要么是隐式地调用父类的无参构造方法。如果父类没有无参构造方法，并且子类的构造方法没有显式地调用父类的有参构造方法，则编译器会报错。
  1. 引用一个类的属性或调用其方法，必须以这个类的对象为前缀。
  • 错误，在Java中，如果要引用一个类的属性或调用其方法，通常需要使用该类的实例对象来作为前缀。这是因为类是一个抽象的概念，只有实例对象才能够真正地使用该类所提供的属性和方法。当你需要使用某个类的属性或方法时，你需要先创建该类的一个实例对象，然后通过该实例对象来访问该类的属性或方法。例如，如果你要访问一个类的属性x，你需要使用该类的实例对象obj来引用该属性，如obj.x；如果你要调用一个类的方法foo()，你需要使用该类的实例对象obj来调用该方法，如obj.foo()。在某些情况下，也可以使用类名来引用该类的静态属性或静态方法，例如ClassName.staticField或ClassName.staticMethod()，但这与使用实例对象的方式有所不同。
  1. 对象是类的实例（instance）。
  • 是的
  1. 构造方法不能被重载。
  • 错误,构造方法是可以被重载的。在Java中，重载是指在同一个类中，可以定义多个方法名相同但参数列表不同的方法。构造方法也不例外，我们可以在同一个类中定义多个构造方法，只要它们的参数列表不同即可。当我们创建一个类的对象时，根据所提供的参数列表来自动选择调用相应的构造方法。这样就可以根据不同的情况提供不同的构造方法，以满足不同的需求。
  1. 构造方法可以是静态的。
  • 错误,构造方法不能是静态的。构造方法是用于创建对象的特殊方法，它的主要作用是对对象进行初始化。因为静态方法不依赖于实例对象，所以静态方法不能访问非静态的成员变量和非静态的方法，而构造方法需要访问实例对象的成员变量，因此不能是静态的。
  1. 构造方法没有返回类型，甚至连void也没有。
  • 是的，构造方法没有返回类型，包括void类型。构造方法的主要作用是初始化对象，而不是返回任何值。
  1. 构造方法是类的一种特殊方法，它的方法名必须与类名相同。
  • 是的，构造方法是类的一种特殊方法，它的方法名必须与类名相同。当创建一个新对象时，构造方法会被自动调用。
  1. 在实例方法或构造器中，this用来引用当前对象，通过使用this可引用当前对象的任何成员。
  • 是的，this关键字用于引用当前对象，在实例方法或构造器中，使用this可以引用当前对象的任何成员，包括成员变量和其他实例方法。
  1. 声明构造方法时，可以使用private访问修饰符
  • 错误，声明构造方法时，可以使用private访问修饰符。使用private修饰构造方法可以防止外部类直接实例化该类，从而实现类的封装，只能在该类内部使用构造方法创建实例。这种方式通常被称为私有构造方法（private constructor)本来是这样的,但是我们没学到这里,,,,
  1. 定义一个类时，无论有没有显示地给出构造方法的定义，系统都会提供一个默认的、无参的构造方法。
  • 错误,如果你定义了一个有参数的构造函数，系统将不会再为你生成默认的无参构造函数。这是因为在Java中，当你定义一个构造函数时，编译器会默认生成一个无参构造函数，但是一旦你定义了任何一个构造函数（不论有参或者无参），编译器将不再自动生成无参构造函数。因此，如果你需要一个无参构造函数，你需要显式地定义一个。

选择

  1. 已知name，age是Person类的成员属性，关于构造方法，下面哪个描述是正确的？

    A.

    public void Person(String name){
   this.name=name;
} //这是Person类中的构造方法

    B.

    public Person(){
   name="";
   age=10;
}
public Person(String name){
   Person();
   this.name=name;
} //这是Person类中两个构造方法

    C.

    public Person(String name){
   this();
   this.name=name;
} //这是Person类中唯一的构造方法

    D.

    public Person(){
   name="";
   age=10;
}
public Person(String name){
   this();
   this.name=name;
} //这是Person类中两个构造方法
  • d
  • a中java构造函数没有返回值,所以不能void,b中Person()的调用方法不能调用构造函数,会报错的,c显然少了不赋初始值的构造函数,因为java编译器只会在没有定义时才给类默认加上没有初始值的构造函数

  1. 在Java中，负责对不再使用的对象自动回收的是（ ）

    A.垃圾回收器

    B.虚拟机

    C.编译器

    D.多线程机制

  • a

  1. 以下说法错误的是（ ）

    A.静态方法可以直接访问本类的静态变量和静态方法

    B.静态方法可以直接访问本类的非静态变量和非静态发方法

    C.非静态方法可以直接访问本类的静态变量和静态方法

    D.非静态方法可以直接访问本类的非静态变量和非静态方法

  • b
  • 静态变量和静态方法随便访问,非静态变量和方法绑定了对象,对象拥有的方法(非静态方法)才能访问

  1. 下面关于类的封装性的描述中，错误的是（ ）。

    A.封装体包含属性和行为

    B.被封装的某些信息在外不可见

    C.封装提高了可重用性

    D.封装体中的属性和行为的访问权限相同

  • d
  • 可以通过private之类的关键字来控制访问权限

  1. 以下有关构造方法的说法，正确的是： 。

    A.一个类的构造方法可以有多个

    B.构造方法在类定义时被调用

    C.构造方法只能由对象的其它方法调用

    D.构造方法可以和类同名，也可以和类名不同

  • a

  1. 类中的一个成员方法被下面哪个修饰符修饰，该方法只能在本类被访问？（ ）

    A.pubic

    B.protected

    C.private

    D.默认

  • c
public：公共的，可以被任意访问。

protected：受保护的，可以被当前类、子类、同一个包中的类访问。

default：默认的，如果没有指定访问权限修饰符，那么默认为default，可以被同一个包中的类访问。

private：私有的，只能被当前类访问。

在继承的时候，子类可以访问父类中的public和protected方法，但不能访问父类中的private方法。而对于父类中缺省（即
没有修饰符）的方法，在同一包中的子类可以访问，不在同一包中的子类则不能访问。需要注意的是，子类中不能访问父类中
被声明为private的方法，即使它们有相同的方法名和参数列表。

  1. 哪种访问权限修饰的成员，在任何包、任何类中都可以进行访问?（ ）

    A.private

    B.默认

    C.protected

    D.public

  • d

  1. 在非静态成员方法中，可以使用关键字（ ）指代当前对象，访问类的其他非静态成员。

    A.this

    B.super

    C.static

    D.public

  • a

  1. 定义一个Java类时，如果前面使用关键字（ ）修饰，它是最终类，该类不可以被继承。

    A.private

    B.final

    C.static

    D.public

  • b
  • 当用 final修饰一个变量时，表示该变量只能被赋值一次，即为常量，且一旦被赋值，就不能再次更改。例如：final int MAX_VALUE = 100;
  • 当用 final 修饰一个方法时，表示该方法不能被子类重写，即该方法的实现不能被修改。例如：public final void doSomething() { ... }
  • 当用 final修饰一个类时，表示该类不能被继承，即不能有子类继承该类。例如：public final class MyClass { ... }

  1. 有如下程序代码，哪处出现编译错误？（ ）

    class Father {
int a = 100;    // A
final public void print() { // B
 System.out.println(a);
}
}

class Child extends Father { 
int a = 200;                // C
public void print() {       // D
 System.out.println(a);  
}
}

    A.A处

    B.B处

    C.C处

    D.D处

  • d
  • 在Java中，重写（Override）和覆盖（Overload）是指在子类中重新实现继承自父类的方法。重写是指子类中实现与父类中同名、同参数列表的方法，覆盖则是指在同一类中实现与其父类同名、不同参数列表的方法。
  • 重写的方法签名必须与被重写的方法完全一致，包括方法名、参数列表、返回类型和抛出的异常类型，而覆盖的方法只需要方法名相同即可。重写是面向对象中的多态性体现，子类重写父类的方法后，调用该方法时会自动调用子类的方法实现。
  • 也就是说照抄final定义的方法都不行

6-1 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
class Square{
        public double length;
        public Square(double i)
        {
                    this.length=i;
        }
        public double getPerimeter()
        {   
                return this.length*4;
            }
        public double getArea()
        {   
                return this.length*this.length;
            }
}
class Rectangle{
        public double wide;
        public double length;
        public Rectangle(double j,double i)
        {
                    this.length=j;
                    this.wide=i;
        }
        public double getPerimeter()
        {   
                return (this.length+this.wide)*2;
            }
        public double getArea()
        {   
                return this.length*this.wide;
            }
}
class Circle{
        public double radius;
        public Circle(double k)
        {
                    this.radius=k;
        }
        public double getPerimeter()
        {   
                return this.radius*Math.PI*2;
            }
        public double getArea()
        {   
                return this.radius*this.radius*Math.PI;
            }
}

6-2 按照要求设计Rectangle类

按要求写出Rectangle类的定义

Rectangle类是以下结构：考试只需要填写该段代码！

class Rectangle{
....
}

注意：因为是单文件编译，Rectangle类不能定义成public，不能在class签名加public！按照上述结构定义。不用写主函数，只用写类的定义即可。建议使用String.format来对输出字符串进行格式化。

要求：

  1. 私有变量width和height，类型double用于存宽和高；
  2. 对变量width和height的set与get方法；
  3. 一个静态变量numberOfObjects，用于统计类创建的个数；
  4. 一个静态方法getNumberOfObjects，返回对象被创建的个数；
  5. 一个静态方法printNumberOfObjects打印对象被创建的个数（详见输入输出）；
  6. getArea方法，返回矩形的面积；
  7. getPerimeter方法，返回矩形的周长；
  8. 重写（overwrite）toString方法，按照格式要求返回对象的信息（详见输入输出）；
  9. 需要判断width或者height小于0的情况，并按照要求在toString方法中输出（详见输入输出）

裁判测试程序样例：

// 类定义在这里！类定义的代码就是你的答案。

// 下面是测试代码，不用写在你的答案中！
public class Main {
    public static void main(String[] args) {
        double w, h;
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNext()) {
            w = scanner.nextDouble();
            h = scanner.nextDouble();
            Rectangle rectangle = new Rectangle(w, h);
            rectangle.setWidth(w);
            rectangle.setHeight(h);
            System.out.printf("Object %d Width=%f Height=%f Perimeter=%f Area=%f\n", Rectangle.getNumberOfObjects(),
                    rectangle.getWidth(), rectangle.getHeight(), rectangle.getPerimeter(), rectangle.getArea());
            System.out.println(rectangle.toString());
            Rectangle.printNumberOfObjects();
        }
    }
}

输入样例1：

1 2 3 4 -4 5

输出样例1：

Object 1 Width=1.000000 Height=2.000000 Perimeter=6.000000 Area=2.000000
Width is 1.000000; Height is 2.000000; Perimeter is 6.000000; Area is 2.000000
Objects=1
Object 2 Width=3.000000 Height=4.000000 Perimeter=14.000000 Area=12.000000
Width is 3.000000; Height is 4.000000; Perimeter is 14.000000; Area is 12.000000
Objects=2
Object 3 Width=-4.000000 Height=5.000000 Perimeter=2.000000 Area=-20.000000
Width or Height should not less than 0
Objects=3
class Rectangle {
    private double width;
    private double height;
    private static int numberOfObjects = 0;

    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
        numberOfObjects++;
    }

    public double getWidth() {
        return width;
    }

    public void setWidth(double width) {
        this.width = width;
    }

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

    public static int getNumberOfObjects() {
        return numberOfObjects;
    }

    public static void printNumberOfObjects() {
        System.out.println("Objects=" + numberOfObjects);
    }

    public double getArea() {
        return width * height;
    }

    public double getPerimeter() {
        return 2 * (width + height);
    }

    @Override
    public String toString() {
        if (width < 0 || height < 0) {
            return "Width or Height should not less than 0";
        }
        return String.format("Width is %f; Height is %f; Perimeter is %f; Area is %f",
                width, height, getPerimeter(), getArea());
    }
}

6-3 按照要求设计Stack（堆栈）类

按照要求设计Stack（堆栈类）实现堆栈的基本功能。堆栈的内部存储实现可以使用一维数组或者是ArrayList，推荐使用ArrayList。

Stack类型定义：考试只需要填写该段代码！

class Stack{
    ...
}

注意：因为是单文件编译，Stack类不能定义成public，不能在class签名加public！按照上述结构定义。不用写主函数，只用写类的定义即可。

要求：

  1. Stack存放字符串；
  2. 实现push、pop、peek、empty、getSize函数；
  3. 如果堆栈为空，pop、peek函数应该返回null；
  4. 测试数据参考输入样例和测试代码。

裁判测试程序样例：

// 类定义在这里！类定义的代码就是你的答案。

// 下面是测试代码，不用写在你的答案中！
public class Main {
    public static void main(String[] args) {
        Stack stack = new Stack();
        Scanner scanner = new Scanner(System.in);

        String inLine = scanner.nextLine();

        String[] inArray = inLine.split(" ");

        for (String s : inArray)
            stack.push(s);

        int size = stack.getSize();
        for (int i = 0; i < size; i++) {
            System.out.println("--------------------------------");
            System.out.printf("Size of stack is %d, the top element is:%s\n", stack.getSize(), stack.peek());
            System.out.printf("Pop element:%s\n", stack.pop());
            System.out.println(stack.empty() ? "Stack is empty!" : "Stack is not empty!");
        }

        System.out.println("**********************");
        if (stack.peek() == null)
            System.out.println("peek return null!");
        if (stack.pop() == null)
            System.out.println("pop return null!");

        scanner.close();

    }
}

输入样例：

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

this is my first stack ？

输出样例：

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

--------------------------------
Size of stack is 6, the top element is:？
Pop element:？
Stack is not empty!
--------------------------------
Size of stack is 5, the top element is:stack
Pop element:stack
Stack is not empty!
--------------------------------
Size of stack is 4, the top element is:first
Pop element:first
Stack is not empty!
--------------------------------
Size of stack is 3, the top element is:my
Pop element:my
Stack is not empty!
--------------------------------
Size of stack is 2, the top element is:is
Pop element:is
Stack is not empty!
--------------------------------
Size of stack is 1, the top element is:this
Pop element:this
Stack is empty!
**********************
peek return null!
pop return null!
class Stack {
    private String[] data;
    private int top;

    public Stack() {
        data = new String[1000];
        top = -1;
    }

    public void push(String str) {
        top++;
        data[top] = str;
    }

    public String pop() {
        if (empty()) {
            return null;
        }
        String str = data[top];
        top--;
        return str;
    }

    public String peek() {
        if (empty()) {
            return null;
        }
        return data[top];
    }

    public boolean empty() {
        return top == -1;
    }

    public int getSize() {
        return top + 1;
    }
}

实验5

6-1 按照要求设计Queue（队列）类

按照要求设计Queue（队列类）实现队列的基本功能。队列的内部存储实现可以使用一维数组或者是ArrayList，推荐使用ArrayList。

Queue类型定义：考试只需要填写该段代码！

class Queue{
    ...
}

注意：因为是单文件编译，Queue类不能定义成public，不能在class签名加public！按照上述结构定义。不用写主函数，只用写类的定义即可。

要求：

  1. Queue存放字符串；
  2. 实现offer、pull、peek、empty、getSize函数；
  3. 如果队列为空，pull、peek函数应该返回null；
  4. 测试数据参考输入样例和测试代码。

裁判测试程序样例：

//类定义在这里！类定义的代码就是你的答案。

//下面是测试代码，不用写在你的答案中！
public class Main {
    public static void main(String[] args) {
        Queue queue = new Queue();
        Scanner scanner = new Scanner(System.in);

        String inLine = scanner.nextLine();
        String[] items = inLine.split(" ");

        for (String item : items)
            queue.offer(item);

        int queueSize = queue.getSize();
        for (int i = 0; i < queueSize; i++) {
            System.out.println("--------------------------------");
            System.out.printf("Size of queue is %d, the first element is:%s\n", queue.getSize(), queue.peek());
            System.out.printf("Pull element:%s\n", queue.pull());
            System.out.println(queue.empty() ? "Queue is empty!" : "Queue is not empty!");
        }

        System.out.println("**********************");
        if (queue.peek() == null)
            System.out.println("peek return null!");
        if (queue.pull() == null)
            System.out.println("pull return null!");
    }
}

输入样例：

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

this is my first queue ?

输出样例：

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

--------------------------------
Size of queue is 6, the first element is:this
Pull element:this
Queue is not empty!
--------------------------------
Size of queue is 5, the first element is:is
Pull element:is
Queue is not empty!
--------------------------------
Size of queue is 4, the first element is:my
Pull element:my
Queue is not empty!
--------------------------------
Size of queue is 3, the first element is:first
Pull element:first
Queue is not empty!
--------------------------------
Size of queue is 2, the first element is:queue
Pull element:queue
Queue is not empty!
--------------------------------
Size of queue is 1, the first element is:?
Pull element:?
Queue is empty!
**********************
peek return null!
pull return null!
import java.util.ArrayList;

class Queue {
        private ArrayList<String> queue = new ArrayList<>();

        public void offer(String s) {
                    queue.add(s);
        }

        public String pull() {
                    if (empty()) {
                                    return null;
                    }
                    return queue.remove(0);
        }

        public String peek() {
                    if (empty()) {
                                    return null;
                    }
                    return queue.get(0);
        }

        public boolean empty() {
                    return queue.isEmpty();
        }

        public int getSize() {
                    return queue.size();
        }
}

6-2 设计门票（抽象类)

某学校举办一次活动，需要凭票参加，每张票都有票号和售价。 门票分为3类：当天票，预订票和学生预订票。 当天票价格50。 预订票，提前时间>10天的，售价30；提前10天以内的，售价40； 学生预订票，提前时间>10天的，售价15；提前10天以内的，售价20。

（1）编写抽象类Ticket类，包含以下成员 ①属性： number：私有，int型，表示票号； ②方法：

  1. Ticket(int number), 构造方法,初始化票号；
  2. int getPrice(), 返回票价，抽象方法；
  3. String toString()，返回一个字符串，格式为“Number:票号,Price:票价”。

（2）编写Ticket类的子类WalkupTicket，表示当天票，包含以下成员 ①方法： 1)WalkupTicket(int number), 构造方法,初始化票号； 2)int getPrice(), 返回票价50。

（3）编写Ticket类的子类AdvanceTicket，表示预订票，包含以下成员 ①属性：

  1. leadTime：私有，int型，表示提前预订的天数； ②方法：
  2. AdvanceTicket(int number,int leadTime), 构造方法,初始化票号和提前天数；
  3. int getPrice(), 如果提前天数>10天，票价30，否则，票价40。

（4）编写AdvanceTicket类的子类StudentAdvanceTicket，表示学生预订票，包含以下成员 ①属性：

  1. height：私有，int型，表示购票学生的身高（单位厘米）； ②方法： 1）StudentAdvanceTicket(int number,int leadTime,int height), 构造方法,初始化票号、提前天数和身高； 2）int getPrice(),

    如果学生身高>120：提前天数>10天，票价20，否则，票价30。 如果学生身高<=120，票价是身高120以上学生的对折。

裁判测试程序样例：

public class Main{
    public static void main(String args[]) {
        Scanner in = new Scanner(System.in);
        Ticket a = new WalkupTicket(in.nextInt());
        System.out.println(a.toString());
        Ticket b = new AdvanceTicket(in.nextInt(), in.nextInt());
        System.out.println(b.toString());
        Ticket c = new StudentAdvanceTicket(in.nextInt(), in.nextInt(), in.nextInt());
        System.out.println(c.toString());
    }
}

/* 请在这里填写答案 */

按如下框架设计类后提交即可：

abstract class Ticket {
……
}
class WalkupTicket extends Ticket {
……
}
class AdvanceTicket extends Ticket {
……
}
class StudentAdvanceTicket extends AdvanceTicket {
……
}

输入样例：

输入票号，创建一个WalkupTicket对象。 输入票号和提前天数，创建一个AdvanceTicket对象。 输入票号、提前天数和身高，创建一个StudentAdvanceTicket对象。

1
2 10
3 11 130

输出样例：

输出创建的3个对象的票号和票价（调用toString()方法）。

Number:1,Price:50
Number:2,Price:40
Number:3,Price:20
abstract class Ticket {
        private int number;

        public Ticket(int number) {
                    this.number = number;
        }

        public abstract int getPrice();

        @Override
        public String toString() {
                    return "Number:" + number + ",Price:" + getPrice();
        }
}
class WalkupTicket extends Ticket {
        public WalkupTicket() {
                    this(0);
        }
        public WalkupTicket(int number) {
                    super(number);
        }
        public int getPrice() {
                    return 50;
        }
}
class AdvanceTicket extends Ticket {
        private int leadTime;

        public AdvanceTicket(int number, int leadTime) {
                    super(number);
                    this.leadTime = leadTime;
        }
        public int getPrice() {
                    if (leadTime > 10) {
                                    return 30;
                    } else {
                                    return 40;
                    }
        }
}
class StudentAdvanceTicket extends AdvanceTicket {
        private int height;

        public StudentAdvanceTicket(int number, int leadTime, int height) {
                    super(number, leadTime);
                    this.height = height;
        }

        @Override
        public int getPrice() {
                    if (height > 120) {
                                    if (super.getPrice() == 30) {
                                                        return 20;
                                    } else {
                                                        return 30;
                                    }
                    } else {
                                    return super.getPrice() / 2;
                    }
        }
}

6-3 创建一个直角三角形类实现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 a;
private double b;
private double c;

public RTriangle(double a, double b) {
this.a = a;
this.b = b;
this.c = Math.sqrt(a * a + b * b);
}

public double getArea() {
return a * b / 2;
}

public double getPerimeter() {
return a + b + c;
}
}

6-4 可比较的几何类（抽象类与接口)

通过继承和多态的学习，同学们熟悉了GeometricObject类，现在用抽象类的观点，修改GeometricObject类以实现Comparable接口，且在GeometricObject类中定义一个静态方法：求两个GeometricObject对象中较大者。

此题提交时将会附加下述代码到被提交的Java程序末尾。

裁判测试程序样例：

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

        Circle circle1 = new Circle(input.nextInt());
        Circle circle2 = new Circle(input.nextInt());

        Circle circle = (Circle) GeometricObject.max(circle1, circle2);
        System.out.println("The max circle's radius is " + circle.getRadius());
        System.out.println(circle);
    }
}

/* 请在这里填写答案 */

输入样例：

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

4 10

输出样例：

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

The max circle's radius is 10.0
Circle radius = 10.0
import java.util.Scanner;

abstract class GeometricObject implements Comparable<GeometricObject> {
        public static GeometricObject max(GeometricObject o1, GeometricObject o2) {
                    if (o1.compareTo(o2) > 0) {
                                    return o1;
                    } else {
                                    return o2;
                    }
        }

        public abstract double getArea();

        public abstract double getPerimeter();

        @Override
        public int compareTo(GeometricObject o) {
                    if (this.getArea() > o.getArea()) {
                                    return 1;
                    } else if (this.getArea() < o.getArea()) {
                                    return -1;
                    } else {
                                    return 0;
                    }
        }
}

class Circle extends GeometricObject {
        private double radius;

        public Circle(int radius) {
                    this.radius = radius;
        }

        public double getRadius() {
                    return radius;
        }

        public void setRadius(int radius) {
                    this.radius = radius;
        }

        @Override
        public double getArea() {
                    return Math.PI * radius * radius;
        }

        @Override
        public double getPerimeter() {
                    return 2 * Math.PI * radius;
        }

        @Override
        public String toString() {
                    return "Circle radius = " + radius;
        }
}

7-1 抽象类与继承-几何图形

定义一个抽象类 GeometricObject 包含以下成员：

  1. 成员变量
成员名 类型 访问限制 变量类型 其他说明
color String private 实例变量 颜色，缺省white
filled boolean privat 实例变量 图形是否被填充，缺省 true
  1. 成员函数

A: 无参数的构造函数

B: 带参数的构造函数，参数1是颜色字符串，参数2表示是否被填充

C: 抽象函数 double getArea() 用于计算图形的面积

D: 对 color 和 filled 的 setter 和 getter 函数

定义一个类 Circle 继承于 GeometricObject

  1. 必要的成员变量，如半径；
  2. 实现 getArea() 函数。
  3. 构造函数，用于初始化半径。
  4. 构造函数，用于初始化半径、颜色、是否填充

定义一个类 Rectangle 继承于 GeometricObject

  1. 必要的成员变量，如长和宽
  2. 实现getArea() 函数
  3. 构造函数，用于初始化长和宽。第1个参数是长；第二个参数是宽
  4. 构造函数，用于初始化长、宽、颜色、是否填充

实现主函数

读取控制台输入，输入格式如下

参数序号 参数含义 说明
1 生成对象的类型 1 表示 Circle；2 表示 Rectangle；0表示退出主程序
2 图形参数1 如果是类型是Circle，表示半径；如果是类型是Rectangle，表示长
3 图形参数2 如果是类型是Circle，无意义，必须输入；如果是类型是Rectangle，表示宽
4 颜色 字符串表示颜色，必须输入
5 填充 true 表示填充，false表示不填充，必须输入

程序一次读取5个参数，根据参数生成对象，并按照格式答应输出，直到第一个参数为0退出循环，打印 ----------后计算输入所有图形的总面积并打印（见样例1）。

可以考虑把所有的对象保存在ArrayList中，最后对ArrayList进行遍历得到总面积。

请使用JAVA中的PI常量，不需要自己定义。

注意：实际运行中输入输出是混杂在一起的，例如：

1 1 1 green true
Circle area is:3.141593 color is:green
2 2 2 blue false
Rectangle area is:4.000000 color is:blue
0 0 0 0 false
----------
2 objects, total area are: 7.141593

下述的样例只表明输入输出的数据分类！不表示你的运行结果！

输入样例

1 1 1 green true
2 2 2 blue false
0 0 0 0 false

输出样例

Circle area is:3.141593 color is:green
Rectangle area is:4.000000 color is:blue
----------
2 objects, total area are: 7.141593
import java.util.ArrayList;
import java.util.Scanner;

abstract class GeometricObject{
        private String color;
        private boolean filled;

        public GeometricObject(){}

        public GeometricObject(String color, boolean filled){
                    this.color = color;
                    this.filled = filled;
        }
        public abstract double getArea();

        public String getColor(){
                    return color;
        }
        public void setColor(String color){
                    this.color = color;
        }

        public boolean isFilled(){
                    return filled;
        }

        public void setFilled(boolean filled){
                    this.filled = filled;
        }
}

class Circle extends GeometricObject{
        private double radius;

        public Circle(double radius){
            this.radius = radius;
        }
        public Circle(double radius, String color, boolean filled){
                    super(color, filled);
                    this.radius = radius;
        }

        @Override
        public double getArea(){
                    return Math.PI * radius * radius;
        }
}

class Rectangle extends GeometricObject{
        private double width;
        private double height;

        public Rectangle(double width, double height){
                    this.width = width;
                    this.height = height;
        }
        public Rectangle(double width, double height, String color, boolean filled){
                    super(color, filled);
                    this.width = width;
                    this.height = height;
        }

        @Override
        public double getArea(){
                    return width * height;
        }
}

public class Main{
        public static void main(String[] args){
                    Scanner scanner = new Scanner(System.in);
                    ArrayList<GeometricObject>list = new ArrayList<>();
                    int count = 0;
                    double totalArea = 0;

                    while(true){
                                    int type = scanner.nextInt();
                                    if(type == 0){
                                                        break;
                                    }
                                    double param1 = scanner.nextDouble();
                                    double param2 = scanner.nextDouble();
                                    String color = scanner.next();
                                    boolean filled = scanner.nextBoolean();

                                    GeometricObject obj;
                                    if(type == 1){
                                                        obj = new Circle(param1, color, filled);
                                    }else{
                                                        obj = new Rectangle(param1, param2, color, filled);
                                    }
                                    list.add(obj);
                                    count++;
                    }

                    for(int i = 0; i < count; i++){
                                    GeometricObject obj = list.get(i);
                                    String type = obj instanceof Circle ? "Circle" : "Rectangle";
                                    System.out.printf("%s area is:%.6f color is:%s\n", type, obj.getArea(), obj.getColor());
                                    totalArea += obj.getArea();
                    }

                    System.out.println("----------");
                    System.out.printf("%d objects, total area are: %.6f", count, totalArea);
        }
}

实验6

6-1 Java-OOP-定义抽象类Converter及其子类CurrencyConverter

定义一个抽象类Converter，表示换算器，其定义的如下

  1. 一个私有的String类型成员变量：name，表示换算器Converter的名称，并定义name变量的getter方法；
  2. 一个带参数的构造器，用于对name赋值；
  3. 一个公有的抽象方法：void convert(); 表示进行换算操作。

继承Converter类定义一个新类：CurrencyConverter表示货币换算器；

对于CurrencyConverter类的要求如下：

  1. 成员变量 localCurrency表示本币金额（人民币 RMB），并定义其getter方法；
  2. 成员变量 foreignCurrency 表示换算后的外币金额，并定义其getter方法；
  3. 成员变量 exchangeRate 表示汇率，表示 1元RMB换算成对应的外汇货币的汇率，并定义其getter和setter方法；
  4. 带三个参数的构造器，在实例化CurrencyConverter对象时初始化：换算器名称、本币金额以及汇率；
  5. 实现父类Converter中的convert方法，将本币金额按汇率换算成外币金额

Main类代码：

import java.lang.reflect.Modifier;
import java.util.Scanner;
public class Main {
    public static void main(String[] args) throws ClassNotFoundException {
            //验证两个类的定义是否符合要求
            //**如果你的这两个类是定义在特定包下的，在下面的类名前加上包路径**
        Class<?> clazz = Class.forName("Converter");
        Class<?> clazz2 = Class.forName("CurrencyConverter");
        boolean isAbs = Modifier.isAbstract(clazz.getModifiers()) ;
        System.out.println(clazz.isAssignableFrom(clazz2)+" "+Modifier.isAbstract(clazz.getModifiers()));
            //输入开始
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入换算器名称、本币金额和汇率，中间用空格分开：");
        String name = scanner.next();
        double localCurrency = scanner.nextDouble();
        double exchangeRate = scanner.nextDouble();
        CurrencyConverter converter = new CurrencyConverter(name,localCurrency,exchangeRate);
        converter.convert();
        System.out.println(converter.getName()+"：本币："+converter.getLocalCurrency()+"，汇率："+converter.getExchangeRate()+"，外币："+converter.getForeignCurrency());
        converter.setExchangeRate(0.7);
        converter.convert();
        System.out.println(converter.getName()+"：本币："+converter.getLocalCurrency()+"，汇率："+converter.getExchangeRate()+"，外币："+converter.getForeignCurrency());
    }
}

输入样例：

请输入换算器名称、本币金额和汇率，中间用空格分开：：

img

美元换算器 2000 0.67

输出样例：

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

img

true true
请输入换算器名称、本币金额和汇率，中间用空格分开：
美元换算器：本币：2000.0，汇率：0.67，外币：1340.0
美元换算器：本币：2000.0，汇率：0.7，外币：1400.0
abstract class Converter{
    private String name;
    Converter(String name){
        this.name=name;
    }
    abstract void convert();
    public  String getName(){
        return name;
    }
}
class CurrencyConverter extends Converter{
    double rmb,md,e;
    CurrencyConverter(String name,double rmb,double e){
        super(name);
        this.rmb=rmb;
        this.e=e;
    }
    public void convert(){
        md=rmb*e;
    }
    public double getLocalCurrency(){
        return rmb;
    }
    public double getExchangeRate(){
        return e;
    }
    public double getForeignCurrency(){
        return md;
    }
    public void setExchangeRate(double e){
        this.e=e;
    }
}

6-2 Java-OOP-定义接口Filter及其实现类WordFilter

定义一个接口 Filter，表示过滤器，其定义的如下：

  1. Filter接口有一个抽象方法：public void doFilter(); 表示进行过滤操作。

定义一个类：WordFilter：

WordFilter表示单词过滤器，该类要实现Filter接口，实现其doFilter()方法，实现过滤单词，将单词的首字母转换为对应的大写字母，剩余的字母全小写；

对于WordFilter类的要求如下：

  1. 一个String类型的成员变量 word，表示待进行过滤的单词，并定义该变量的setter和getter方法；
  2. 带参数的构造方法，实例化过滤器对象时，按参数值初始化成员变量word的值；
  3. 实现doFilter方法，在实现的doFilter方法中，将word字符串的首字母大写，其余字母全小写；
  4. 对于WordFilter类的更多接口细节可参看Main类中的代码。

Main类代码：

import java.util.Scanner;
public class Main {
    public static void main(String[] args) throws ClassNotFoundException {
        Class<?> clazz1 = Class.forName("Filter");
        Class<?> clazz2 = Class.forName("WordFilter");
        System.out.println(clazz1.isInterface()+" "+clazz1.isAssignableFrom(clazz2));
        System.out.println("请输入一个英文单词：");
        Scanner scanner = new Scanner(System.in);
        String input = scanner.next();
        WordFilter filter = new WordFilter(input);
        System.out.println("原单词是："+filter.getWord());
        filter.doFilter();
        System.out.println("过滤处理后："+filter.getWord());
        filter.setWord("programmING");
        System.out.println("原单词是："+filter.getWord());
        filter.doFilter();
        System.out.println("过滤处理后："+filter.getWord());
    }
}

输入样例：

img

footBall

输出样例：

输出原单词和过滤后的单词，例如：

img

true true
请输入一个英文单词：
原单词是：footBall
过滤处理后：Football
原单词是：programmING
过滤处理后：Programming
interface Filter{
        public void doFilter();
}

class WordFilter implements Filter{
        public static String a;
        public WordFilter(String b){
                    a=b;

        }
        public void doFilter() {
                    // TODO Auto-generated method stub
                    a=a.toLowerCase();
                    a=a.substring(0,1).toUpperCase()+a.substring(1);
        }
        public String getWord() {
                    // TODO Auto-generated method stub
       return a;
        }
       public void setWord(String b){
           a=b;
       }
}

6-3 远程通信接口类的定义

定义一个远程通讯类NetCom。包含

变量：

  1. 静态量，连接数：total 整形 公开
  2. 远程主机名：host 字符串 私有
  3. 远程端口：port 整形 私有
  4. 连接状态：connected boolean 私有

方法：

  1. connct：打印连接信息，并改变 connected 值
  2. disconnect：打印断开信息，并改变 connected 值
  3. send 和 receive：打印发送接收信息（字符串）
  4. getState：返回连接状态
  5. toString：以字符串方式返回基本信息
  6. 构造方法、其他的setter或者是getter方法
  7. 覆盖toString方法，详见例程中每个对象输出的System.out.println(netCom.toString()); 语句。

具体内容参考主函数，和输入输出样例。

注意！不用提交主函数，只提交你编写的类!

主函数：

import java.util.ArrayList;
import java.util.Scanner;

public class Main {

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

        ArrayList<NetCom> coms = new ArrayList<>();

        while (scanner.hasNextLine()) {
            String s = scanner.nextLine();
            if (s.length() == 0)
                break;
            String[] rl = s.split(" ");
            NetCom netCom = new NetCom(rl[0], Integer.parseInt(rl[1]));
            coms.add(netCom);
        }

        int i = 1;

        for (NetCom netCom : coms) {

            System.out.printf("Connection %2d host %s port %d connected=%b\n", i, netCom.getHost(), netCom.getPort(),
                    netCom.getState());
            netCom.connect();
            netCom.send("Hello");
            netCom.recevice("Hello to");
            System.out.println(netCom.toString());
            netCom.disconnect();            
            System.out.println("----------------");
            i++;
        }

        System.out.printf("一共有%d个链接对象", NetCom.total);

        scanner.close();

    }

}
/* 请在这里填写答案 */

输入样例：

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

192.168.2.2 433
www.baidu.com 80

输出样例：

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

Connection  1 host 192.168.2.2 port 433 connected=false
Connect to 192.168.2.2 with port 433
Send Msg:Hello
Receive Msg:Hello to
Remote host 192.168.2.2 with port 433 connected true
Disconnect from 192.168.2.2 with port 433
----------------
Connection  2 host www.baidu.com port 80 connected=false
Connect to www.baidu.com with port 80
Send Msg:Hello
Receive Msg:Hello to
Remote host www.baidu.com with port 80 connected true
Disconnect from www.baidu.com with port 80
----------------
一共有2个链接对象
class NetCom{
        public static int total=0;
        private String host;
        private int port;
        private boolean connected;
        public NetCom(String host,int port){
                    this.host=host;
                    this.port=port;
                    total++;
        }
        public void connect(){
                    connected=true;
                    System.out.println("Connect to "+host+" with port "+port);
        }
        public void disconnect(){
                    connected=false;
                    System.out.println("Disconnect from "+host+" with port "+port);
        }
        public void send(String s){
                    System.out.println("Send Msg:"+s);
        }
        public void recevice(String s){
                    System.out.println("Receive Msg:"+s);
        }
        public String toString(){
                    return String.format("Remote host %s with port %d connected %s",host,port,connected);
        }
        public String getHost(){
                    return host;
        }
        public int getPort(){
                    return port;
        }
        public boolean getState(){
                    return connected;
        }
}

6-4 手机类的创建

创建一个手机对象。包含

变量：

  1. 静态量，对象个数：total 整形 公开
  2. 型号：model 字符串 私有
  3. 单价：price double 私有
  4. 数量：amount int 私有

方法：

  1. 返回该对象的总价值：getValue，返回double。
  2. 增减数量方法：addAmount，delAmount，在现有amount的基础上进行增加或者是减少。
  3. toString方法：以字符串方式返基本信息
  4. 构造方法、其他的setter或者是getter方法
  5. 覆盖toString方法，详见例程中每个对象输出的System.out.println(mobile.toString());语句。
  6. toString 方法中请使用 String.format静态函数进行字符串格式化。该函数参数同System.out.printf，但不是打印，而是返回一个字符串。

具体内容参考主函数，和输入输出样例。

注意！不用提交主函数，只提交你编写的类！

主函数：

import java.util.ArrayList;
import java.util.Scanner;

public class Main {

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

        ArrayList<Mobile> mobiles = new ArrayList<>();

        while (scanner.hasNextLine()) {
            String s = scanner.nextLine();
            if (s.length() == 0)
                break;
            String[] rl = s.split(" ");
            Mobile mb = new Mobile(rl[0], Double.parseDouble(rl[1]), Integer.parseInt(rl[2]));
            mobiles.add(mb);
        }

        int i = 1;

        for (Mobile mobile : mobiles) {

            System.out.printf("Item %2d model %s price %.2f amount %d value %.2f\n", i, mobile.getModel(),
                    mobile.getPrice(), mobile.getAmount(), mobile.getValue());
            mobile.addAmount(3);
            mobile.delAmount(2);
            System.out.println(mobile.toString());
            System.out.println("----------------");
            i++;
        }

        System.out.printf("一共有%d种手机", Mobile.total);

        scanner.close();

    }

}

/* 请在这里填写答案 */

输入样例：

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

Xiaomi 2118 3
Apple 4444 5

输出样例：

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

Item  1 model Xiaomi price 2118.00 amount 3 value 6354.00
Model Xiaomi price 2118.00 amount 4 value 8472.00 
----------------
Item  2 model Apple price 4444.00 amount 5 value 22220.00
Model Apple price 4444.00 amount 6 value 26664.00 
----------------
一共有2种手机
class Mobile{
        public static int total=0;
        private String model;
        private double price;
        private int amount;
        public double getValue(){
                    return price*amount;
        }
        public String getModel(){
                    return model;
        }
        public double getPrice(){
                    return price;
        }
        public int getAmount(){
                    return amount;
        }
        public void addAmount(int a){
                    amount=amount+a;
        }
        public String toString(){
                    return String.format("Model %s price %.2f amount %d value %.2f ",model,price,amount,getValue());
        }

        public void delAmount(int a){
                    amount=amount-a;
        }
        public Mobile(String model,double price,int amount){
                    total++;
                    this.model=model;
                    this.price=price;
                    this.amount=amount;
        }
}

6-5 研究生发表论文奖励

分数 20

作者 cd

单位 成都信息工程大学

已知一个学生抽象类（Student）和接口PaperAwardable ,代码如下：

interface PaperAwardable {
    //根据论文等级，计算奖金并返回结果
    int getPaperAward();
}

abstract class Student implements PaperAwardable {
    protected String name;
    protected int age;
    //获取论文名称
    public abstract String getPaper();
    //获取论文级别
    public abstract String getPaperLevel();

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
}

1.包含了姓名，年龄两个属性；

2.包含两个抽象方法getPaper，getPaperLevel；

3.实现PaperAwardable接口，用于计算发表论文奖励；

定义一个研究生类（GraduateStudent），具体要求如下：

1.继承抽象类Student，定义两个私有属性：论文名称（paper）和论文级别（JCR）；

2.定义GraduateStudent(String name, int age, String paper, String JCR)构造函数，用于实例化研究生对象； 【注意：需调用父类的构造器】

3.实现getPaper方法，直接返回论文名称；

4.实现getPaperLevel方法，返回字母大写的等级； 【注意：输入的字母统一返回为大写】

5.实现PaperAwardable接口中定义的getPaperAward方法，返回发表论文的奖金；

序号 论文级别 论文奖励金额
1 Q1 10000
2 Q2 5000
3 Q3 3000
4 Q4 1000
5 （其它值） 0

Main类的代码如下，切记不可修改下列代码：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        String name = scan.next();
        int age = scan.nextInt();
        String paper = scan.next();
        String jcr = scan.next();
        Student s = new GraduateStudent(name, age, paper, jcr);
        System.out.printf("%s,%d岁,%s,%s级别,奖励%d元", s.getName(), s.getAge(), s.getPaper(), s.getPaperLevel(), s.getPaperAward());
    }
}

interface PaperAwardable {
    //根据论文等级，计算奖金并返回结果
    int getPaperAward();
}

abstract class Student implements PaperAwardable {
    protected String name;
    protected int age;
    //获取论文名称
    public abstract String getPaper();
    //获取论文级别
    public abstract String getPaperLevel();

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public int getAge() {
        return age;
    }
}

//开始定义GraduateStudent类，请提交下面书写的代码

只提交自己书写的代码，不要含有包名

输入样例:

李华 19 AAAI q1

输出样例:

李华,19岁,AAAI,Q1级别,奖励10000元
class GraduateStudent extends Student implements PaperAwardable{
    private String paper,JCR;
    public GraduateStudent(String name,int age,String paper,String JCR){
        super(name,age);
        this.paper=paper;
        this.JCR=JCR.toUpperCase();
    }
    public String getPaper(){
        return paper;
    }
    public String getPaperLevel(){
        return JCR;
    }
    public int getPaperAward(){
        if(JCR.equals("Q1"))
        return 10000;
        else if(JCR.equals("Q2"))
              return 5000;
                           else if(JCR.equals("Q3"))
                                              return 3000;
                                              else if(JCR.equals("Q4"))
                                              return 1000;
                                              else return 0;
    }
}
届ける言葉を今は育ててる
最后更新于 2024-02-07
啥也没有呀