Java类与对象-PTA答案

判断题

作者 刘夏琳
单位 西安邮电大学
在子类中想使用被子类隐藏的实例成员变量或实例方法就需要使用关键字super.(T)

作者 刘霞林
单位 西安邮电大学
子类可以有多个父类（F）

作者 刘霞林
单位 西安邮电大学
如果在子类的构造方法中没有显式地写出super关键字来调用父类的某个构造方法，那么编译器默认有“super();”调用父类的无参数的构造方法，如果父类没有这样的构造方法，代码将出现编译错误。（T）

单选题

以下代码中，this是指(A)。

class bird{
int x,y;
void fly(int x,int y){
this.x=x;
this.y=y;
}
}

A.用bird创建的对象
B.方法fly
C.类bird
D.不一定

作者 郑如滨
单位 集美大学
以下描述正确的有(B)
A.方法的重写应用在一个类的内部
B.方法的重载与返回值类型无关
C.构造方法不能重载
D.构造方法可以重写

作者 周雪芹
单位 山东理工大学
Test类的定义如下，程序的运行结果为下列哪一项？©。

public class Test { 
  public Test() { 
    System.out.println("构造方法一被调用了。。"); 
  } 
  public Test(int x) { 
    System.out.println("构造方法二被调用了。。"); 
   } 
  public Test(boolean b) { 
    System.out.println("构造方法三被调用了。。"); 
   } 
   
     public static void main(String[] args) { 
      Test test=new Test(true); 
   } 
} 

A.构造方法一被调用了。。
B.构造方法二被调用了。。
C.构造方法三被调用了。。
D.构造方法一被调用了。。构造方法二被调用了。。构造方法三被调用了。。

作者 周雪芹
单位 山东理工大学
在Java中，一个类可同时定义许多同名的方法，这些方法的形式参数的个数、类型或顺序各不相同，传回的值也可以不相同，这种面向对象程序特性称为（D）。
A.封装
B.继承
C.覆盖
D.重载

作者 周雪芹
单位 山东理工大学
以下有关构造方法的说法，正确的是(A)。
A.一个类的构造方法可以有多个
B.构造方法在类定义时被调用
C.构造方法只能由对象的其它方法调用
D.构造方法可以和类同名，也可以和类名不同

作者 周雪芹
单位 山东理工大学
在非静态成员方法中，可以使用关键字（A）指代当前对象，访问类的其他非静态成员。
A.this
B.super
C.static
D.public

作者 强彦
单位 太原理工大学
关于类中成员变量的作用范围，下述说法中正确的是（C）。
A.只有用public修饰的变量才能在所有方法中使用
B.用private修饰的成员变量可以在main方法中直接使用
C.类中所有成员变量在所有成员方法中有效
D.用static修饰的成员变量只能在用static修饰的方法中使用

作者 殷伟凤
单位 浙江传媒学院
下面的（C）操作符可以使其修饰的变量只能对同包中的类或子类可见
A.private
B.public
C.protected
D.default

作者 殷伟凤
单位 浙江传媒学院
分析如下代码。

class Circle {
  private double radius;

  public Circle(double radius) {
    radius = radius;
  }
}

如下哪句是正确的？（D）

A.程序有一个编译错误，因为没有main方法。
B.程序可以编译，但没有创建一个特定radius的Circle对象。对象的radius始终为0。
C.程序有一个编译错误，因为不能radius = radius。
D.程序无法编译，因为Circle没有缺省的构造函数。

作者 周雪芹
单位 山东理工大学
某个类的方法中，在成员变量和局部变量重名的情况下，（ ）变量优先使用。如果要使用（ ）变量，必须使用关键字（ ）进行限定。(A)

A.局部 成员 this
B.成员 局部 this
C.类 实例 this
D.实例 类 this

作者 刘霞林
单位 浙江大学
在Java中用什么关键字修饰的方法可以直接通过类名来调用？（A）。
A.static
B.final
C.private
D.void

作者 殷伟凤
单位 浙江传媒学院
以下说法错误的是（B）
A.静态方法可以直接访问本类的静态变量和静态方法
B.静态方法可以直接访问本类的非静态变量和非静态发方法
C.非静态方法可以直接访问本类的静态变量和静态方法
D.非静态方法可以直接访问本类的非静态变量和非静态方法

作者 殷伟凤
单位 浙江传媒学院
下面（C）修饰符修饰的变量是所有同一个类生成的对象共享的。

A.public

B.private

C.static

D.final

作者 殷伟凤
单位 浙江传媒学院
分析如下代码：

public class Test {
  private int t;

  public static void main(String[] args) {
    int x;
    System.out.println(t);
  }
}

©

A.变量t没有初始化，所以会引起错误。
B.变量t是私有的，因此不能在main方法中访问。
C.t是非静态的，不能在静态的main方法中引用。
D.变量x没有初始化，所以会引起错误。

作者 周雪芹
单位 山东理工大学
定义一个Java类时，如果前面使用关键字（B）修饰，它是最终类，该类不可以被继承。
A.private
B.final
C.static
D.public

作者 周雪芹
单位 山东理工大学
有如下程序代码，哪处出现编译错误？（D）

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处

作者 王从银
单位 吉首大学
声明成员变量时,如果不使用任何访问控制符(public, protected, private)，则以下哪种类型的类不能对该成员进行直接访问 (D) .

A.同一类

B.同一包中的子类

C.同一包中的非子类

D.不同包中的子类

作者 刘霞林
单位 重庆邮电大学
Java程序默认引用的包是（C）。

A.java.text包
B.java.awt包
C.java.lang包
D.java.util包
解析:java. lang包提供Java编程语言进行程序设计的基础类。java. lang包是编译器自动导入的。

作者 崔振宇
单位 山东科技大学
下列关于使用包中的类哪个说法是正确的.©
A.类不可以使用其所在包中的private类
B.类可以使用其他包中的所有类
C.类可以使用其他包中的public类
D.以上说法都不正确

作者 王从银
单位 吉首大学
关于以下程序段，正确的说法是© 。

1．  String  s1=”abc”+”def”;
2．  String  s2=new  String（s1）；
3．  if（s1==s2）
4．     System.out.println(“== succeeded”);
5．  if (s1.equals(s2))
6．     System.out.println(“.equals()  succeeded”);

A.行4与行6都将执行
B.行4执行，行6不执行
C.行6执行，行4不执行
D.行4、行6都不执行

解释：
String s1=“abc”+“def”;//等同于语句 String s1 = “abcdef”;编译器对于字面量都直接计算，储存在常量池，
String s2=new String（s1);//使用new关键字创建String 对象 s2 在堆栈中都开辟内存空间，字符串"abcdef"的值存在栈中
s2中存的是指向字符串"abcdef"的地址，存在堆中；
equals 判断内容值相等 此语句返回true 所以接着行6被执行
== 判断的是地址值相等，显然s1==s2为false。所以行4不被执行

作者 王从银
单位 吉首大学
下列哪些语句关于Java内存回收的说明是正确的? （B）
A.程序员必须创建一个线程来释放内存
B.内存回收程序负责释放无用内存
C.内存回收程序允许程序员直接释放内存
D.内存回收程序可以在指定的时间释放内存对象

解释：
A：垃圾回收程序是一般是在堆上分配空间不够的时候会自己进行System.gc()，程序员不需要也不能主动释放内存。
B：Java的内存释放由垃圾回收程序来进行释放无用内存。
C：在Java里，内存的释放由垃圾回收程序进行管理，程序员不能直接进行释放。
D：程序员可以调用System.gc()运行垃圾回收器，但是不能指定时间。

作者 王从银
单位 吉首大学
关于被私有访问控制符private修饰的成员变量，以下说法正确的是（C）
A.可以被三种类所引用：该类自身、与它在同一个包中的其他类、在其他包中的该类的子类
B.可以被两种类访问和引用：该类本身、该类的所有子类
C.只能被该类自身所访问和修改
D.只能被同一个包中的类访问

作者 王从银
单位 吉首大学
类的实例方法表示的是什么？（C）
A.父类对象的行为
B.类的属性
C.类对象的行为
D类的行为

作者 刘霞林
单位 浙江大学
对于实例的清除，下列叙述不正确的是（D）。
A.当不存在对某一对象的引用时，就释放该对象所占用的内存空间。
B.在Java中，对象清除由垃圾回收器自动完成，程序员不需要做任何工作。
C.程序员不能控制垃圾回收器。
D.System.gc()方法能保证垃圾回收器一定执行垃圾回收操作。

作者 仇丽青
单位 山东科技大学
访问修饰符作用范围由大到小是（D）
A.private-default-protected-public
B.public-default-protected-private
C.private-protected-default-public
D.public-protected-default-private
解释：（1）私有权限（private）
private 可以修饰数据成员、构造方法及方法成员，不可以修饰类（此处指外部类，不考虑内部类）。被 private 修饰的成员，只能在定义它们的类中使用，在其他类中不能调用。
（2）默认权限（default）
类、数据成员、构造方法和方法成员等都能够使用默认权限，即不被private、protected和 public 修饰。默认权限即同包权限，同包权限的元素只能在定义它们的类中以及同包的类中被调用。
（3）受保护权限（protected）
protected 可以修饰数据成员、构造方法和方法成员，不可以修饰类（此处指外部类，不考虑内部类）。被 protected 修饰的成员，能在定义它们的类中以及同包的类中被调用。如果有不同包的类想调用它们，那么这个类必须是它的子类。
（4）公共权限（public）
public 可以修饰类、数据成员、构造方法及方法成员。被 public 修饰的成员，可以在任何一个类中被调用，不管同包或不同包，是权限最大的一个修饰符。

作者 刘永福
单位 河北农业大学
已知代码：

class Person{
    private static String country="A城市" ;
    String name;
    public static void sFun(String c){
        System.out.println("name="+name);
        fun(c);}
    public void fun(String c ){
        name="name1";
        country=c;
    }
}

关于static，下面描述错误的是 © 。
A.上述代码在编译时出错，因为在static方法sFun中访问了非static变量name
B.上述代码在编译时出错，因为在static方法sFun中访问了非static方法fun()
C.sFun方法正确
D.fun方法正确
解释：
题目问的是错误的
静态方法中只能调用静态成员，不能调用成员变量和成员方法
普通成员方法可以调用普通成员和静态成员，也可以调用普通成员方法和静态方法

作者 殷伟凤
单位 浙江传媒学院
若在某一个类定义中定义有如下的方法： final void aFinalFunction( ),则该方法属于©。
A.本地方法
B.静态方法
C.最终方法
D.抽象方法

作者 刘霞林
单位 西安邮电大学

class Father {
private int money = 12;
float height;
int seeMoney(){
return money; //A
}
}

class Son extends Father{
float height;
int lookMoney(){
int m = seeMoney(); //B
return m;
}
}

class F{
public static void main(String[] args) {
Son erzi = new Son();
erzi.money = 300; //C
erzi.height =1.78F; //D
}

}

正确的（C）
A
B
C
D

作者 刘霞林
单位 西安邮电大学

class A{
public float getNum(){
return 3.0f;
}
}
public class B {
【代码】
}

正确的（C）
A.public float getNum(){return 4.0f;}
B.public void getNum(){ }
C.public void getNum(double d){ }
D.public double getNum(float d){ return 4.0f; }

单位 西安邮电大学

abstract class Takecare{
protected void speakHello(){} //A
public abstract static void cry(); //B
static int f(){return 0;} //C
abstract float g(); //D

}

正确的（B）
A
B
C
D

作者 刘夏琳
单位 西安邮电大学

abstract class Animal{
int m = 100;
}

class Dog extends Animal{
double m;
}
public class E{

public static void main(String args[]){
    Animal animal = null;      //A
    Dog dog = new Dog();
    animal = dog;     //B
    dog.m = 3.14;   //C
    animal.m = 3.14;  //D
}
}

正确的（D）
A
B
C
D

填空题

1.请写出以下程序运行结果：

public class Note { 
     public static void main(String args[]) { 
          String name[] = {"Killer","Miller"}; 
          String name0 = "Killer"; 
          String name1 = "Miller"; 
          swap(name0,name1); 
          System.out.println(name0 + "," + name1); 
          swap(name); 
          System.out.println(name[0] + "," + name[1]); 
    } 
    public static void swap(String name[]) {
         String temp; 
         temp=name[0]; 
         name[0]=name[1]; 
         name[1]=temp; 
    } 
    public static void swap(String name0,String name1) { 
          String temp; 
          temp=name0; 
          name0=name1; 
          name1=temp; 
     } 
 } // end of Class Note 

结果：

Killer,Miller
Miller,Killer

2.请写出E类中注释语句所在行的输出结果

class A{
double f(double x,double y){
return x+y;
}
}

class B extends A{
double f(int x,int y){
return x*y;
}
}

public class E{
public static void main(String args[]){
B b= new B();
System.out.println(b.f(3,5)); //15.0

System.out.println(b.f(3.0,5.0)); //8.0

}
}

3.请写出E类中注释语句所在行的输出结果。

class A{
int m;
int getM(){
return m;
}
int seeM(){
return m;
}
}

class B extends A{
int m;
int getM(){
return m + 100;
}
}

public class E{
public static void main(String args[]){
B b = new B();
b.m = 20;
System.out.println(b.getM());//120

A a = b;
a.m = -100;
System.out.println(a.getM()); //120

System.out.println(b.seeM()); //-100

}
}

程序填空题

阅读程序，补全以下程序：

public class Main {
    public static void main(String[] args) {
        Test test = new Test(true);
    }
}

class Test {//无参构造函数
    public Test(){
        System.out.println("Constructor one invoked!");
    }
    public Test(int x){//带有int参数的构造函数
     
    this();

     System.out.println("Constructor two invoked!");
    }
    public Test(boolean b){// 带有boolean参数的构造函数
       
    this(0); 

    System.out.println("Constructor three invoked!");
    }
}

使得程序输出结果，如下所示。

Constructor one invoked!
Constructor two invoked!
Constructor three invoked!

解释：
这段代码定义了一个Main类和一个Test类。在Main类的main方法中创建了一个Test对象，并且传入了一个boolean类型的参数true。
Test类中定义了三个构造函数：
1.无参构造函数：当没有参数传入时，会输出"Constructor one invoked!“。
2.带有int参数的构造函数：当传入int类型的参数时，会先调用无参构造函数，然后出"Constructor two invoked!”。
3.带有boolean参数的构造函数：当传入boolean类型的参数时，会先调用带有int参数的构造函数，然后输出"Constructor three invoked!"。

编程题

1.声明图书类，记录图书总册数，利用静态变量赋值。

声明一个图书类，其数据成员为书名、编号（利用静态变量实现自动编号）、书价，并拥有静态数据成员册数，记录图书的总册数；在构造方法中，利用静态变量为对象的编号赋值，在主方法中定义对象数组，并求出总册数。
输出格式:
请输出每本图书对应的书名，书号，书价以及总图书数。
输出样例:

书名：Java程序设计, 书号：1, 书价：34.5
书名：数据结构, 书号：2, 书价：44.8
书名：C++程序设计, 书号：3, 书价：35.0
图书总册数为：3

Java代码：

//Java代码
public class Main{
    public static void main(String[] args) {
        Book[] book = new Book[3];
        
        book[0] = new Book("Java程序设计",34.5);
        book[1] = new Book("数据结构",44.8);
        book[2] = new Book("C++程序设计",35.0);
       
        for(int i=0;i<3;i++){
            book[i].print();
        }
        System.out.print("图书总册数为："+Book.num);
    }
}
 
class Book{
    String name;
    int id;
    double price;
    static int num=0;
 
    public  Book(String name,double price){
        num++;
        this.name=name;
        this.price=price;
        this.id=num;
    }
 
    public void print(){
        System.out.println("书名："+this.name+", 书号："+this.id+", 书价："+this.price);
    }
 
}

c++代码：

//c++代码
#include <iostream>
#include <string>

class Book {
public:
    std::string name;
    int id;
    double price;
    static int num;

    Book(std::string name, double price) {
        num++;
        this->name = name;
        this->price = price;
        this->id = num;
    }

    void print() {
        std::cout << "书名：" << this->name << ", 书号：" << this->id << ", 书价：" << this->price << std::endl;
    }
};

int Book::num = 0;

int main() {
    Book book[3];

    book[0] = Book("Java程序设计", 34.5);
    book[1] = Book("数据结构", 44.8);
    book[2] = Book("C++程序设计", 35.0);

    for (int i = 0; i < 3; i++) {
        book[i].print();
    }
    std::cout << "图书总册数为：" << Book::num << std::endl;

    return 0;
}

2.抽象类 设计一个动物声音模拟器，希望模拟器可以模拟许多动物的叫声，要求如下：

（1） 编写抽象类Animal. Animal类有两个抽象方法cry()和getAnimalName(),即要求各种具体的动物给出自己的叫声和种类名称。
（2） 编写模拟器类Simulator。该类有一个playSound(Animal animal)方法，该方法的参数是Animal类型，即参数animal可以调用Animal的子类重写的cry()方法播放具体动物的声音，调用子类重写的getAnimalName()方法显式动物种类的名称。
(3)编写Animal类的子类Dog和Cat.下图是Simulator、Animal、Dog、Cat类的UML图。

（4） 编写主类Application（用户程序）。在主类Application的main方法中至少包含如下代码：
Simulator simulator = new Simulator();
simulator.playSound(new Dog());
simulator.playSound(new Cat());
输入格式:

无需输入

输出格式:

输出Dog和Cat的名称和行为，具体输出格式见输出样例。（注意：行首没有空格）

输入样例:

输出样例:

a dog!
Dog crying!
a cat!
Cat crying!

Java代码：

//Java代码
interface Animal {
    void cry();
    void getAnimalName();
}

class Simulator {

    public void playSound(Animal animal){
        animal.cry();
        animal.getAnimalName();
    }
}

class Dog implements Animal{
    public void cry(){
        System.out.println("a dog!");
    }
    public void getAnimalName(){
        System.out.println("Dog crying!");
    }
}

class Cat implements Animal{
    public void cry(){
        System.out.println("a cat!");
    }
    public void getAnimalName(){
        System.out.println("Cat crying!");
    }
}

public class Main{

    public static void main(String[] args) {
        Simulator simulator = new Simulator();
        simulator.playSound(new Dog());
        simulator.playSound(new Cat());
    }
}

C++代码

//c++代码
#include <iostream>

class Animal {
public:
    virtual void cry() = 0;
    virtual void getAnimalName() = 0;
};

class Simulator {
public:
    void playSound(Animal* animal){
        animal->cry();
        animal->getAnimalName();
    }
};

class Dog : public Animal {
public:
    void cry(){
        std::cout << "a dog!" << std::endl;
    }
    void getAnimalName(){
        std::cout << "Dog crying!" << std::endl;
    }
};

class Cat : public Animal {
public:
    void cry(){
        std::cout << "a cat!" << std::endl;
    }
    void getAnimalName(){
        std::cout << "Cat crying!" << std::endl;
    }
};

int main() {
    Simulator simulator;
    simulator.playSound(new Dog());
    simulator.playSound(new Cat());
    
    return 0;
}