Java小题精炼训练营(篇一)
Posted /少司命
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了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());
-
24
-
16
-
15
-
8
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小题精炼训练营(篇一)的主要内容，如果未能解决你的问题，请参考以下文章