Java PTA(5)——类与对象2

770-0

已于 2024-06-11 20:30:20 修改

阅读量879

点赞数 25

文章标签： java 开发语言

于 2023-12-19 13:21:28 首次发布

本文链接：https://blog.csdn.net/m0_61442114/article/details/135073416

版权

1.判断题

1.1 在子类中想使用被子类隐藏的实例成员变量或实例方法就需要使用关键字super。（T）

1.2 子类可以有多个父类。（F）

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

2.单选题

2.1 以下代码中，this是指( )。
class bird{

int x,y;

void fly(int x,int y){

this.x=x;

this.y=y;
}

}

A.用bird创建的对象

B.方法fly

C.类bird

D.不一定

2.2 以下描述正确的有

A.方法的重写应用在一个类的内部

B.方法的重载与返回值类型无关

C.构造方法不能重载

D.构造方法可以重写

2.3 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.构造方法三被调用了。。

构造方法一被调用了。。

构造方法二被调用了。。

构造方法三被调用了。。

2.4 在Java中，一个类可同时定义许多同名的方法，这些方法的形式参数的个数、类型或顺序各不相同，传回的值也可以不相同，这种面向对象程序特性称为（）。

A.封装

B.继承

C.覆盖

D.重载

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

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

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

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

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

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

A.this

B.super

C.static

D.public

2.7 关于类中成员变量的作用范围，下述说法中正确的是（）。

A.只有用public修饰的变量才能在所有方法中使用

B.用private修饰的成员变量可以在main方法中直接使用

C.类中所有成员变量在所有成员方法中有效

D.用static修饰的成员变量只能在用static修饰的方法中使用

2.8 下面的（）操作符可以使其修饰的变量只能对同包中的类或子类可见

A.private

B.public

C.protected

D.default

2.9 分析如下代码。

class Circle {
  private double radius;

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

如下哪句是正确的？

A.程序有一个编译错误，因为没有main方法。

B.程序可以编译，但没有创建一个特定radius的Circle对象。对象的radius始终为0。

C.程序有一个编译错误，因为不能radius = radius。

D.程序无法编译，因为Circle没有缺省的构造函数。

2.10 某个类的方法中，在成员变量和局部变量重名的情况下，（）变量优先使用。

如果要使用（）变量，必须使用关键字（）进行限定。

A.局部成员 this

B.成员局部 this

C.类实例 this

D.实例类 this

2.11 在Java中用什么关键字修饰的方法可以直接通过类名来调用？（）。

A.static

B.final

C.private

D.void

2.12 以下说法错误的是（）

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

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

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

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

2.13 下面（）修饰符修饰的变量是所有同一个类生成的对象共享的。

A.public

B.private

C.static

D.final

2.14 分析如下代码：

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没有初始化，所以会引起错误。*

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

A.private

B.final

C.static

D.public

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

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处

2.17 声明成员变量时,如果不使用任何访问控制符(public, protected, private)，则以下哪种类型的类不能对该成员进行直接访问（） .

A.同一类

B.同一包中的子类

C.同一包中的非子类

D.不同包中的子类

2.18

Java程序默认引用的包是（）。

A.java.text包

B.java.awt包

C.java.lang包

D.java.util包

2.19 下列关于使用包中的类哪个说法是正确的。

A.类不可以使用其所在包中的private类

B.类可以使用其他包中的所有类

C.类可以使用其他包中的public类

D.以上说法都不正确

2.20 关于以下程序段，正确的说法是（）。

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都不执行

2.21 下列哪些语句关于Java内存回收的说明是正确的? （）

A.程序员必须创建一个线程来释放内存

B.内存回收程序负责释放无用内存

C.内存回收程序允许程序员直接释放内存

D.内存回收程序可以在指定的时间释放内存对象*

2.22 关于被私有访问控制符private修饰的成员变量，以下说法正确的是（）

A.可以被三种类所引用：该类自身、与它在同一个包中的其他类、在其他包中的该类的子类

B.可以被两种类访问和引用：该类本身、该类的所有子类

C.只能被该类自身所访问和修改

D.只能被同一个包中的类访问

2.23 类的实例方法表示的是什么？（）

A.父类对象的行为

B.类的属性

C.类对象的行为

D.类的行为

2.24 对于实例的清除，下列叙述不正确的是（）。

A.当不存在对某一对象的引用时，就释放该对象所占用的内存空间。

B.在Java中，对象清除由垃圾回收器自动完成，程序员不需要做任何工作。

C.程序员不能控制垃圾回收器。*

D.System.gc()方法能保证垃圾回收器一定执行垃圾回收操作。

System.gc()无法保证GC一定执行

在默认情况下，通过System.gc()或Runtime.getRuntime()的调用，会显示的触发FullGC，同时对老年代和新生代进行回收，会尝试释放掉被丢弃对象占用的内存
JVM实现者可以通过system.gc()调用来决定JVM的GC行为，而一般情况下，垃圾回收应该是自动进行的，无需手动触发，否则就太过于麻烦了。
然而System.gc()调用附带一个免责声明，无法保证对垃圾收集器的调用(无法保证马上出发GC)

2.25 关于被私有访问控制符private修饰的成员变量，以下说法正确的是（）。

A.可以被三种类所引用：该类自身、与它在同一个包中的其他类、在其他包中的该类的子类

B.可以被两种类访问和引用：该类本身、该类的所有子类

C.只能被该类自身所访问和修改

D.只能被同一个包中的类访问

2.26 访问修饰符作用范围由大到小是（）

A.private-default-protected-public

B.public-default-protected-private

C.private-protected-default-public

D.public-protected-default-private

2.27 已知代码：

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方法正确

2.28 若在某一个类定义中定义有如下的方法： final void aFinalFunction( ),则该方法属于( )。

A.本地方法

B.静态方法

C.最终方法

D.抽象方法

2.29

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
}

}

A.A

B.B

C.C

D.D

2.30

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

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; }

2.31

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

}

A.A

B.B

C.C*

D.D

2.32

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

}
}

A.A*

B.B

C.C

D.D

3.填空题

3.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

3.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)); //2 分—— 15.0
System.out.println(b.f(3.0,5.0)); //2 分—— 8.0
}
}

3.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());//1 分—— 120
A a = b;
a.m = -100;
System.out.println(a.getM()); //2 分—— 120
System.out.println(b.seeM()); //2 分—— -100
}
}

4.程序填空题

4.1 sdut-oop-1-测试对象初始化（构造方法）

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

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){

        this();        //3分

        System.out.println("Constructor two invoked!");
    }
    public Test(boolean b){

        this(1);        //2分

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

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

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

5.编程题

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

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

输出格式:

请输出每本图书对应的书名，书号，书价以及总图书数。

输出样例:

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

代码：


import java.util.Scanner;

class Book {
    private String bookName;  //书名
    private int bookNo;
    private double price;
    private static int bookNum = 1;

    public Book(String bookName, double price) {
        this.bookName = bookName;
        this.price = price;
        this.bookNo = bookNum++;
    }

    public String getBookName() {
        return bookName;
    }

    public void setBookName(String bookName) {
        this.bookName = bookName;
    }

    public int getBookNo() {
        return bookNo;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public static int getBookNum() {  //求成员册数
        return bookNum - 1;
    }
}

public class Main {

    public static void main(String[] args) {
        //Scanner sc = new Scanner(System.in);
        Book[] books = {new Book("Java程序设计", 34.5), new Book("数据结构", 44.8), new Book("C++程序设计", 35.0)};
        for (int i = 0; i < books.length; i++) {
            System.out.println("书名：" + books[i].getBookName() + ", 书号：" + books[i].getBookNo() + ", 书价：" + books[i].getPrice());
        }
        System.out.println("图书总册数为：" + Book.getBookNum());
    }
}

5.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图。

图1 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!

代码：

class Animal{
    String name;
    Animal(){
        
    }
    void cry(){
        System.out.println("Animal crying!");
    }
    String getAnimalName(){
        return name;
    }
}

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

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

class Simulator extends Animal{
    void playSound(Animal a){
        a.cry();
    }
}

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