首页 > 编程语言> > Java小题精炼训练营(篇一)

Java小题精炼训练营(篇一)

2022-01-01 10:32:58 作者：互联网

1、类Person和类Student的关系是（）

class  Person {}
class  Student  extends  Person {
public int id;     //学号
public int score;  //总分
public String  name;   // 姓名
public int getScore(){return  score;}
}

包含关系

继承关系

关联关系

无关系，上述类定义有语法错误

Java中类之间的六种关系：

第一种：继承关系，例如：子类继承父类，子接口继承父接口。

第二种：实现关系，例如：类实现接口。

第三种：依赖关系，例如：一个类作为另一个类中方法的参数存在，这种关系具有偶然性和临时性。

第四种：关联关系，例如：一个类作为另一个类中的成员变量存在，它是一种强依赖关系。

第五种：聚合关系，例如：整体和部分之间，他们是可以分离的拥有各自的生命周期，并且部分是相同的。像鸟群和鸟。

第六种：组合关系，它是一种强聚合，并且整体和部分之间不可分离，具有相同的生命周期，整体包含该部分，也包含其他部分，其他部分和该部分是不相同的，像cpu和计算机，计算机除了包括cpu还有键盘和显示器等。

B

2、以下关于java封装的描述中，正确的是：

封装的主要作用在于对外隐藏内部实现细节，增强程序的安全性

封装的意义不大，因此在编码中尽量不要使用

如果子类继承父类，对于父类中进行封装的方法，子类仍然可以直接调用

只能对一个类中的方法进行封装，不能对属性进行封装

封装主要是隐藏内部代码；

继承主要是复用现有代码；

多态主要是改写对象行为。

封装就是将属性私有化，提供公有的方法访问私有属性。------------------- 所以CD错误。

做法就是：修改属性的可见性来限制对属性的访问，并为每个属性创建一对取值（ getter ）方法和赋值（ setter ）方法，用于对这些属性的访问。

通过封装，可以实现对属性的数据访问限制，同时增加了程序的可维护性。

由于取值方法和赋值方法隐藏了实现的变更，因此并不会影响读取或修改该属性的类，避免了大规模的修改，程序的可维护性增强

A

3、下面关于 new 关键字的表述错误的是（）

new关键字在生成一个对象时会为对象开辟内存空间

new关键字在生成一个对象时会调用类的构造方法

new关键字在生成一个对象时会将生成的对象的地址返回

Java中只能通过new关键字来生成一个对象

使用new关键字来生成对象只是最常用的方式；除此之外，还可以：
1，使用反射创建对象，调用java.lang.Class或者java.lang.reflect.Constructor类的new Instance()实例方法；
2，调用对象的clone()方法（要拷贝的对象需要实现Cloneable接口，并重写clone()方法）；
3，使用反序列化方式，通过让类实现Serializable接口，然后使用new ObjectInputStream().readObject()来创建对象

D

4、一个类可以有多个不同名的构造函数（不考虑内部类的情况）。（）

正确

错误

只有与类名相同的方法可以叫构造函数
java 构造函数，可以被访问修饰符修饰，而不能被特殊修饰符修饰；（在编译器经过测试）访问修饰符： public （最常用，其他类的任何位置都可以访问） protected（能够在同一包中被子类访问）什么都不写，""(能够被同一包里的类访问) private（经常使用的单例模式中）特殊修饰符： static (静态) final(最终) abstract(抽象) synchronized(同步) 这些都不能够放在构造函数前使用

B

5、在为传统面向对象语言的程序做单元测试的时候,经常用到mock对象。Mock对象通过反射数。请问反射最大程度破坏了面向对象的以下哪个特性？

封装

多态

继承

抽象

mock对象：也成为伪对象，在测试中的利用mock对象来代替真实对象，方便测试的进行。

java的封装性：指的是将对象的状态信息隐藏在对象内部，不允许外部程序直接访问对象内部信息，通过该类提供的方法实现对内部信息的操作访问。

反射机制：在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法;对于任意一个对象，都能够调用它的任意一个方法和属性

反射可以访问原类的私有方法，私有成员变量，因此，反射破坏了Java的A

A

6、abstract和final可以同时作为一个类的修饰符。（）

正确

错误

abstract修饰的类需要被继承，而final修饰的类不可被继承，自相矛盾。

拓展：

一、抽象类的使用原则如下：
（1）抽象方法必须为public或者protected（因为如果为private，则不能被子类继承，子类便无法实现该方法），缺省情况下默认为public；
（2）抽象类不能直接实例化，需要依靠子类采用向上转型的方式处理；
（3）抽象类必须有子类，使用extends继承，一个子类只能继承一个抽象类；
（4）子类（如果不是抽象类）则必须覆写抽象类之中的全部抽象方法（如果子类没有实现父类的抽象方法，则必须将子类也定义为为abstract类。

二、final关键字：

（1）修饰变量：变量不可修改；

（1）修饰方法：方法不可重写；

（1）修饰类：类不可继承。

7、以下代码的输出的正确结果是

public class Test {
    public static void main(String args[]) {
        String s = "祝你考出好成绩！";
        System.out.println(s.length());
    }
}

```
24
```
```
16
```
```
15
```
```
8
```

length得到的是字符，不是字节。

中文和英文一样的，看作一个字符。

8、instanceof运算符能够用来判断一个对象是否为:

```
一个类的实例
```
```
一个实现指定接口的类的实例
```
```
全部正确
```
```
一个子类的实例
```

instanceof是JAVA中的关键字，用来判断一个对象是不是一个类的实例，是不是一个类的子类，是不是一个接口的实现类

C

9、下列程序test 类中的变量c 的最后结果为

public class Test {
    public static void main(String args[]) {
        int a = 10;
        int b;
        int c;
        if (a > 50) {
             b = 9;
        }
        c = b + a;
    }
}

编译出错

方法内定义的变量没有初始值，必须要进行初始化。类中定义的变量可以不需要赋予初始值，默认初始值为0。

D

10、顺序执行下列程序语句后，则b的值是（）

String a="Hello";

String b=a.substring(0,2);

Hello

Hel

He

null

substring 方法将返回一个包含从 start 到最后（不包含end）的子字符串的字符串。

C

11、输出结果为：

String str = "";
System.out.print(str.split(",").length);

出现异常


    /**  * String split 这个方法默认返回一个数组，  * 如果没有找到分隔符，  * 会把整个字符串当成一个长度为1的字符串数组  * 返回到结果， 所以此处结果就是1  
*/  private static void testSpringSpilte(){
        String str = "12,3";
        String str2 = "123";
        System.out.print(str.split(",").length);
        System.out.print(str2.split(",").length);
    }
}
结果  2  1

B

12、下面字段声明中哪一个在interface主体内是合法的? （）

private final static int answer = 42;

public static int answer = 42;

final static answer = 42;

int answer;

在接口中，属性都是默认public static final修饰的，所以：

A（错误）：不能用private修饰；

B（正确）：在接口中，属性默认public static final，这三个关键字可以省略；

C（错误）：没写属性的类型；

D（错误）：final修饰的属性必须赋值；

接口中的属性在不提供修饰符修饰的情况下，会自动加上public static final

注意（在1.8的编译器下可试）：

（1）属性不能用private，protected,default 修饰，因为默认是public

（2）如果属性是基本数据类型，需要赋初始值，若是引用类型，也需要初始化，因为默认有final修饰，必须赋初始值；

（3）接口中常规的来说不能够定义方法体，所以无法通过get和set方法获取属性值，所以属性不属于对象，属于类（接口），因为默认使用static修饰。

B

13、以下代码执行的结果显示是多少（）？

 public static void main(String[] args) {
        int count = 0;
        int num = 0;
        for (int i = 0; i <= 100; i++){
            num = num + i;
            count = count++;
        }
        System.out.println("bcz=" + (num*count));
    }

num * count = 505000

num * count = 0

运行时错误

num * count = 5050

count=count++就是先把局部变量表中count的值0放入操作数栈中，然后直接对局部变量表中的count加1，然后再把操作数栈中的0出栈赋值给局部变量表中的count，最终局部变量表中的count值仍为0

count = count ++;这个先将count这个值0暂存起来，然后count自加1变成1，最后将暂存的值赋值给count，count最终的值为0

B

14、假定Base b = new Derived（）; 调用执行b.methodOne（）后，输出结果是什么？

public class Base
{
   public void methodOne()
   {
      System.out.print("A");
      methodTwo();
   }
 
   public void methodTwo()
   {
      System.out.print("B");
   }
}
 
public class Derived extends Base
{
   public void methodOne()
   {
      super.methodOne();
      System.out.print("C");
   }
 
   public void methodTwo()
   {
      super.methodTwo();
      System.out.print("D");
   }
}

向上转型：父类只能调用父类方法或者子类覆写后的方法,而子类中的单独方法则是无法调用的。

因此：

调用的顺序是：(1)、(2)、(3)、(4)、(5)、(6)、(7) ; 得到的结果是：ABDC

  public class Base
    {
        public void methodOne()  //3
        {
            System.out.print("A");
            methodTwo();        //4 执行到这里的时候调用子类的覆盖方法

        }

        public void methodTwo()   //7
        {
            System.out.print("B");
        }
    }

    public class Derived extends Base
    {
        public void methodOne()  //1
        {
            super.methodOne();//2
            System.out.print("C");
        }

        public void methodTwo()    //执行到这里的时候调用子类的覆盖方法 5
        {
            super.methodTwo();     //6
            System.out.print("D");
        }
    }

15、在Web应用程序中，( )负责将HTTP请求转换为HttpServletRequest对象

Servlet对象

HTTP服务器

Web容器

JSP网页

web容器是一种服务程序，在服务器一个端口就有一个提供相应服务的程序，而这个程序就是处理从客户端发出的请求，如JAVA中的Tomcat容器，ASP的IIS或PWS都是这样的容器。一个服务器可以多个容器。

Apache就是一个Http服务器，Tomcat是一个web容器，静态的htmlApache还可以处理，但是动态的需要转发给Tomcat去处理了，比如jsp页面，请求先经由Apache转发给Tomcat再由Tomcat解析请求。所以应该是web容器去解析成request对象。

C

16、在创建派生类对象，构造函数的执行顺序（）

基类构造函数，派生类对象成员构造函数，派生类本身的构造函数

派生类本身的构造函数，基类构造函数，对象成员构造函数

基类构造函数，派生类本身的构造函数，派生类对象成员构造函数

对象成员构造函数，基类构造函数，派生类本身的构造函数

public class ExtendsTest {

        public static void main(String[] args) {
            
            C c = new  D();
        }

    }
    class C {
        static
        {
            System.out.println("C 基类静态域 ");
        }
        {
            System.out.println("C 基类对象成员构造函数");
        }
        public C(){
            System.out.println("C 基类本身的构造函数");
        }
    }
    class D extends C{
        static
        {
            System.out.println("D 派生类静态域");
        }
        {
            System.out.println("D 派生类对象成员构造函数");
        }
        public D(){
            System.out.println("D 派生类本身的构造函数");
        }
    }
运行结果：
C 基类静态域
D 派生类静态域
C 基类对象成员构造函数
C 基类本身的构造函数
D 派生类对象成员构造函数
D 派生类本身的构造函数

规律就是父类先于子类静态的先于非静态的

其中静态域包含静态代码块与静态方法，这个谁在前面，则先执行谁。

父类静态域——》子类静态域——》父类成员初始化——》父类构造块——》1父类构造方法——》2子类成员初始化——》子类构造块——》3子类构造方法；

A

17、下面哪些Java中的流对象是字节流?

FileInputStream

BufferedInputStream

PushbackInputStream

ByteArrayInputStream

ABCD

18、下面有关Java的说法正确的是（）

一个类可以实现多个接口

抽象类必须有抽象方法

protected成员在子类可见性可以修改

通过super可以调用父类构造函数

final的成员方法实现中只能读取类的成员变量

String是不可修改的，且java运行环境中对string对象有一个常量池保存

A对：java类单继承，多实现
B错：被abstract修饰的类就是抽象类，有没有抽象方法无所谓
C对：描述有问题。protected成员在子类的可见性，子类（不继承父类protected成员方法）获取父类被protected修饰的成员属性或方法，可见性是不可能变的，因为修饰符protected就是描述可见性的。
这道题应该是要考察子类继承父类，并重写父类的protected成员方法，该方法的可见性可以修改，这是对的，因为子类继承父类的方法，访问权限可以相同或往大了改
D对。
E错：final修饰的方法只是不能重写，static修饰的方法只能访问类的成员变量
F对。

ACDF

19、下面哪些赋值语句是正确的（）

long test=012

float f=-412

int other =(int)true

double d=0x12345678

byte b=128

选ABD

A和B中long和float，正常定义需要加l和f，但是long和float属于基本类型，会进行转化，所以不会报出异常。AB正确

boolean类型不能和任何类型进行转换，会报出类型异常错误。所以C错。

D选项可以这样定义，D正确。

E选项中，byte的取值范围是-128—127。报出异常： cannot convert from int to byte.所以E选项错误。

标签：Java,对象,子类,训练营,System,小题,out,public,构造函数
来源： https://blog.csdn.net/qq_50156012/article/details/122265177