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

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

作者:互联网

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

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

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

D

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;
    }
}
10
0
19
编译出错

方法内定义的变量没有初始值,必须要进行初始化。 类中定义的变量可以不需要赋予初始值,默认初始值为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);
0
1
出现异常

    /**  * 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