Java类和对象-PTA答案

判断题

局部变量没有默认值。T

类中的实例变量在用该类创建对象的时候才会被分配内存空间。T

类中的实例方法可以用类名直接调用。F

成员变量的名字不可以和局部变量的相同。F

单选题

在Java中，负责对字节代码解释执行的是 （ B ）

A.
应用服务器

B.
虚拟机

C.
垃圾回收器

D.
编译器

编译Java源程序文件将产生相应的字节码文件，这些字节码文件的扩展名为( B )。

A.
.byte

B.
.class

C.
.html

D.
.exe

下列哪个叙述是正确的? (B)

A.
Java应用程序由若干个类所构成,这些类必须在一个源文件中。

B.
Java应用程序由若干个类所构成,这些类可以在一个源文件中,也可以分布在若干个源文件中,其中必须有一个源文件含有主类。

C.
Java源文件必须含有主类。

D.
Java源文件如果含有主类,主类必须是public类。

Java 类可以作为（ C ）。

A.
类型定义机制

B.
数据封装机制

C.
类型定义机制和数据封装机制

D.
上述都不对

一个*.java文件中可以包含多少个public类？(A)

A.
最多1个

B.
最少1个

C.
只能是0个

D.
不限制

下面的选项中，哪一项不属于“汽车类”的行为（ D ）。

A.
启动

B.
刹车

C.
加速

D.
速度

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

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

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

C.
封装提高了可重用性

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

对于类与对象的关系，以下说法错误的是（D）。

A.
类是对象的类型

B.
对象由类来创建

C.
类是同类对象的抽象

D.
对象是创建类的模板

关于类和对象的关系，下列说法哪种说法是错误的？(A)

A.
类和对象都是具体的。

B.
类是抽象的，对象是具体的。

C.
一般情况下，在定义类之后，能创建无数个对象，可以说，类能化身千万。

D.
类是引用型数据类型。

关于下面的类描述中正确的是：?

class Test{
    void test(int i){
        System.out.println("I am an int.");
    }
    void test(String s){
        System.out.println("I am a char");
    }
    public static void main(String args[]){
        Test t=new Test();
        t.test('a');
    }
}

A.
编译出错

B.
编译通过，运行出错

C.
编译通过，运行时输出“I am an int”

D.
编译通过，运行时输出“I am a char"

有类Person定义如下：

public class Person {
String name ;
int age ;
}
以下操作的结果是：(A)

   Person p = new Person();
   System.out.print(p.name+" "+p.age);
   p.name = "Alice";
   p.age = 12;
   System.out.println(p.name+" "+p.age);

A.
null 0Alice 12

B.
Alice 12Alice 12

C.
null 0null 0

D.
都不对

现有声明Circle x = new Circle()，如下哪句是最确切的。（C）

A.
x包含了一个int型数据。

B.
x包含了一个Circle类型的对象。

C.
x包含了一个Circle对象的引用。

D.
x可将一个int型数据赋值给x。

分析如下代码。

public class Test {
  public static void main(String[] args) {
    double radius;
    final double PI= 3.15169;
    double area = radius * radius * PI;
    System.out.println("Area is " + area);
  }
}

如下说法哪句是正确的？（A）

A.
程序编译错误，因为变量radius没有初始化。

B.
程序编译错误，因为常量PI定义在方法中。

C.
程序没有编译错误但运行时会出错，因为radius没有初始化。

D.
程序编译和运行正确。

下面叙述正确的是（A）。

A.
成员变量有默认值

B.
this可以出现在static方法中

C.
类中的实例方法可以用类名调用

D.
局部变量也可以用范围修饰符：public、protected、private修饰

对于下列Hello类的叙述正确的是（D）。

class Hello {
Hello(int m){
}

int Hello(){
  return 20;
}
hello(){    
}
}

A.
Hello类有两个构造方法

B.
Hello类的int Hello( ) 方法是错误的方法

C.
Hello类没有构造方法

D.
Hello类无法通过编译，因为其中的hello方法的方法头是错误的（没有类型）

填空题

写出下列E类中注释语句所在行的输出结果。

class Fish{
int weight = 1;
}

class Lake{
Fish fish;

void setFish(Fish s){
fish=s;
}

void foodFish(int m){
fish.weight = fish.weight + m;
}
}

public class E{
public static void main(String args[]){
Fish redFish = new Fish();
System.out.println(redFish.weight); //1

Lake lake = new Lake();
lake.setFish(redFish);
lake.foodFish(120);
System.out.println(redFish.weight);//121

System.out.println(lake.fish.weight); //121

}
}

写出注释语句所在行的输出结果

class A{

double f(int x,double y){
return x+y;
}
int f(int x,int y){
return x*y;
}
}

public class E{
public static void main(String args[]){
A a = new A();
System.out.println(a.f(10,10)); //100

System.out.println(a.f(10,10.0)); //20.0

}
}

写出下列程序注释语句所在行的输出结果。

public class E{
public static void main(String args[]){
f(1,2);
f(-1,-2,-3,-4); //-1 -2 -3 -4

f(9,7,6);
}

public static void f(int ...x){
   for (int param: x){
     System.out.print(param+" ");
   }
   System.out.println();
}
}

函数题

设计直线类

两点可以确定一条直线，请设计一个直线类Line，需要通过两个点Point对象来确定。

设计类Point，包含两个坐标值，提供必要的构造函数和其他辅助函数

设计类Line，包含两个点，提供必要的构造函数和其他辅助函数

为Line提供一个getLength方法返回直线的长度

在Main类的main方法中，读入2对Point的坐标，输出2对Point所表示的直线的长度，保留两位小数（可用System.out.printf）

裁判测试程序样例：

import java.util.Scanner;
public class Main{
  public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    Point p1 = new Point(sc.nextDouble(),sc.nextDouble());
    Point p2 = new Point(sc.nextDouble(),sc.nextDouble());
    Line l = new Line(p1,p2);
    System.out.printf("%.2f",l.getLength());
    }
}

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

输入样例：

23.2 22.1 12.2 3.2

输出样例：

21.87

答案：

class Point
{
    public double x;
    public double y;
    public Point(double _x,double _y)
    {
        this.x=_x;
        this.y=_y;
    }
}
class Line
{
    Point p1,p2;
    public Line(Point p1,Point p2)
    {
        this.p1=p1;
        this.p2=p2;
    }
    public double getLength()
    {
        return Math.sqrt(Math.pow((p1.x-p2.x), 2)+Math.pow((p1.y-p2.y), 2));
    }
}

复数类的定义

编写一个复数类，可以进行复数加法和减法运算。编写一个包含main方法的类测试该复数类。要求该复数类至少包含一个无参的构造方法和一个带参的构造方法；数据成员包括复数的实部和虚部，为double类型；包括两个方法，分别实现复数的加法和减法运算。测试代码如下：

    public static void main(String [] args){
            Complex a=new Complex();
            Complex b=new Complex();
            Scanner in=new Scanner(System.in);
            a.setRealPart(in.nextDouble());
            a.setImaginaryPart(in.nextDouble());
            b.setRealPart(in.nextDouble());
            b.setImaginaryPart(in.nextDouble());
            System.out.println(a);
            System.out.println(b);
            System.out.println(a.add(b));
            System.out.println(a.sub(b));      
}

输入格式:
输入两个复数。输入为两行，每一行为一个复数的实部和虚部，用空格隔开。

输出格式:
输出复数加法和减法结果。输出为4行，第一行和第二行输出两个复数，第三行为两个复数的加法运算结果，第四行为减法运算结果。

输入样例:
在这里给出两组输入。例如：

1 2
3 4

-1 2
1 2

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

1.0+2.0i
3.0+4.0i
4.0+6.0i
-2.0-2.0i

-1.0+2.0i
1.0+2.0i
4.0i
-2.0

答案：

import java.util.*;
 
class Complex{
	private double shi;
	private double xu;
	public Complex() {
		
	}
	public Complex(double s,double x) {
		this.shi = s;
		this.xu = x;
	}
	
	public double getShi() {
		return shi;
	}
	public double getXu() {
		return xu;
	}
	public void setRealPart(double s) {
		this.shi = s;
	}
	public void setImaginaryPart(double x) {
		this.xu = x;
	}
	public Complex add(Complex a) {
		Complex complex = new Complex();
		complex.shi = this.shi+a.getShi();
		complex.xu = this.xu+a.getXu();
		return complex;
	}
	public Complex sub(Complex a) {
		Complex complex = new Complex();
		complex.shi = this.shi-a.getShi();
		complex.xu = this.xu-a.getXu();
		return complex;
	}
	@Override
	public String toString() {
		if(shi==0&&xu==0) {
			return 0+"";
		}
		if(shi==0) {
			return xu+"i";
		}
		if(xu>0) {
			return shi + "+" + xu + "i";
		}
		if(xu==0) {
			return shi+"";
		}
		return shi +""+ xu + "i";
	}
}
 
public class Main{
	public static void main(String [] args){
        Complex a=new Complex();
        Complex b=new Complex();
        Scanner in=new Scanner(System.in);
        a.setRealPart(in.nextDouble());
        a.setImaginaryPart(in.nextDouble());
        b.setRealPart(in.nextDouble());
        b.setImaginaryPart(in.nextDouble());
        System.out.println(a);
        System.out.println(b);
        System.out.println(a.add(b));
        System.out.println(a.sub(b));      
	}
}

矩阵类

利用二维数组（int[]）实现一个矩阵类：Matrix。要求提供以下方法：（1）set（int row, int col, int value）：将第row行第col列的元素赋值为value；（2）get（int row，int col）：取第row行第col列的元素；（3）width()：返回矩阵的列数；（4）height()：返回矩阵的行数；（5）Matrix add（Matrix b）：返回当前矩阵与矩阵b相加后的矩阵；（6）Matrix multiply（Matrix b）：返回当前矩阵与矩阵b相乘后的矩阵。（7）Matrix transpose()：返回当前矩阵的转置矩阵；（8）toString()：以行和列的形式打印出当前矩阵。

输入格式:
矩阵的行列数
矩阵的数据
设置矩阵值的行、列和值
获取矩阵值的行、列
待相加矩阵的行列数
待相加矩阵的值
待相乘矩阵的行列数
待相乘矩阵的值

输出格式:
矩阵的行、列数
设置矩阵值后的矩阵
某行某列的矩阵值
矩阵相加结果
矩阵相乘结果
矩阵转置结果

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

3 3
1 2 3
4 5 6
7 8 9
2 3 8
1 3
3 3
1 2 3
4 5 6
7 8 9
3 2
1 2
1 2
1 2

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

row:3 column:3
after set value:
1 2 3
4 5 8
7 8 9
value on (1,3):3
after add:
2 4 6
8 10 14
14 16 18
after multiply:
6 12
17 34
24 48
after transpose:
1 4 7
2 5 8
3 8 9

答案：

import java.util.Scanner;

public class Main {
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        int row =in.nextInt();
        int col =in.nextInt();
        System.out.println("row:"+row+" column:"+col);
        int [][] a1=new int[row][col];//矩阵的行列数
        for (int i=0;i<row;i++){
            for (int j =0;j<col;j++){
                a1[i][j] =in.nextInt();//矩阵的数据
            }
        }
        Matrix m =new Matrix(row,col,a1);
        m.set(in.nextInt()-1,in.nextInt()-1,in.nextInt());// 设置矩阵值的行、列和值
        System.out.println("after set value:");
        System.out.print(m);
        int rowx =in.nextInt();
        int colx =in.nextInt();
        int data= m.get(rowx-1,colx-1);//获取矩阵值的行、列
        System.out.println("value on ("+rowx+","+colx+"):"+data);
        int row2 =in.nextInt();
        int col2 =in.nextInt();
        int [][] b1 =new int[row2][col2];
        for (int i=0;i<row2;i++){
            for (int j=0;j<col2;j++){
                b1[i][j]=in.nextInt();
            }
        }
        Matrix m1 =new Matrix(row2,col2,b1);
        System.out.println("after add:");
        System.out.print(m.add(m1).toString());
        //System.out.println(m.get(0,0));
        int row3 =in.nextInt();
        int col3 =in.nextInt();
        int [][] c1 =new int [row3][col3];
        for (int i=0;i<row3;i++){
            for (int j=0;j<col3;j++){
                c1[i][j]=in.nextInt();
            }
        }
        Matrix m2 =new Matrix(row3,col3,c1);
        System.out.println("after multiply:");
        System.out.print(m.multiply(m2).toString());
        System.out.println("after transpose:");
        System.out.print(m.transpose().toString());
    }
}
class Matrix{
    private int row;
    private int col;
    int[][] a ;
    public Matrix(int row,int col,int[][]a2){
        this.row =row;
        this.col =col;
        a=new int[this.row][this.col];
        a=a2;
    }
    public void set(int row,int col,int value){
            a[row][col]=value;
    }
    public int get(int row,int col) {
        int aa = a[row][col];
        return aa;
    }
    public int width(){
        return col;
    }
    public int height(){
        return row;
    }
    public Matrix add(Matrix b){
        if(this.width()==b.width()&&this.height()==b.height()){
            for(int i=0;i<this.width();i++){
                for (int j=0;j<this.height();j++){
                    b.set(i,j,this.get(i,j)+b.get(i,j));
                }
            }
        }
        return b;
    }
    public Matrix multiply(Matrix b){
        int row4 =this.row;
        int col4 =b.col;
        int [][] d1 =new int[row4][col4];
        for (int i=0;i<row4;i++){
            for (int j=0;j<col4;j++){
                d1[i][j]=0;
            }
        }
        Matrix m3 =new Matrix(row4,col4,d1);
        int sum =0;
        for (int i = 0; i < this.height(); i++) {
            for (int j = 0; j < b.width(); j++) {
                for (int k = 0; k < this.width(); k++) {
                    sum += this.get(i, k) * b.get(k, j);
                }
                m3.set(i, j, sum);
                sum=0;
            }
        }
        return m3;
    }
    public Matrix transpose(){
        int [][] e1 =new int[this.col][this.row];
        for(int i=0;i<this.col;i++){
            for(int j=0;j<this.row;j++){
                e1[i][j] =0;
            }
        }
        Matrix m4 =new Matrix(this.col,this.row,e1);
        for(int i=0;i<this.col;i++){
            for(int j=0;j<this.row;j++){
                m4.set(i,j,this.get(j,i));
            }
        }
        return m4;
    }
    public String toString(){
        String str= "";
        for(int i=0;i<this.row;i++){
            for (int j=0;j<this.col;j++){
                if(j==0)
                str+=this.get(i,j);
                else
                    str+=" "+this.get(i,j);
            }
            str+="\n";
        }
        return str;
    }
}

PC类

用类描述计算机中CPU的速度和硬盘容量，要求Java程序有4个类，名字分别是PC，CPU,HardDisk和Main，其中Main是主类。
PC类和CPU类和HardDisk类关联的UML图如图1所示，其中，CPU类要求getSpeed()返回speed的值，要求setSpeed(int m)方法将参数m的值赋给speed；HardDisk类要求getAmount()返回amount的值，要求setAmount(int m)将参数m的值赋给amount；PC类要求setCPU(CPU c)将参数c的值赋给cpu，要求setHardDisk(HardDisk h)方法将参数h的值赋给HD，要求show()方法能显示CPU的速度和硬盘容量。
搜狗截图22年10月14日1751_1.png

      图1    PC类与CPU类和HardDisk类关联的UML图

主类Main的要求如下：
（1） 在main（）方法中创建一个CPU对象cpu，cpu将自己的speed设置为2200.
（2） 在main（）方法中创建一个HardDisk对象disk，disk将自己的amount设置为200。
（3） 在main（）方法中创建一个PC对象pc。
（4） pc调用setCPU（CPU c）方法，调用时实参是cpu。
（5） pc调用setHardDisk（HardDisk h）方法，调用时实参是disk。
（6） pc调用show（）方法。

输入格式:
无需输入

输出格式:
分别输出CPU的速度和硬盘的容量，具体输出格式见输入输出样例。（注意：行首没有空格；“=”左右各有一个空格；行尾没有空格;CPU的输出和HD的输出各占一行，一共两行）

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

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

CPU = 2200
HD = 200

答案：

class CPU {
    private int speed;

    public int getSpeed() {
        return speed;
    }

    public void setSpeed(int speed) {
        this.speed = speed;
    }
    public  CPU(){};
    public  CPU(int speed){
        this.speed = speed;
    }
}


class HardDisk {
    private int amount;

    public int getAmount() {
        return amount;
    }

    public void setAmount(int amount) {
        this.amount = amount;
    }

    public HardDisk(){}
    public HardDisk(int amount){
        this.amount = amount;
    }
}

class PC {
    CPU cpu;
    HardDisk HD;

    public void setCpu(CPU cpu) {
        this.cpu = cpu;
    }

    public void setHD(HardDisk HD) {
        this.HD = HD;
    }
    public PC(){}
    public PC(CPU cpu,HardDisk HD){
        this.cpu = cpu;
        this.HD = HD;
    }
    void show(){
        System.out.printf("CPU = "+cpu.getSpeed());
        System.out.printf("\n");
        System.out.printf("HD = "+HD.getAmount());
    }
}


public class Main{
    public static void main(String[] args) {
        CPU cpu = new CPU(2200);
        HardDisk HD = new HardDisk(200);
        PC pc = new PC(cpu,HD);
        pc.show();

    }
}