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

1、关于AOP错误的是？

AOP将散落在系统中的“方面”代码集中实现

AOP有助于提高系统可维护性

AOP已经表现出将要替代面向对象的趋势

AOP是一种设计模式，Spring提供了一种实现

AOP 和 OOP的区别：

1. 面向方面编程****AOP 偏重业务处理过程的某个步骤或阶段，强调降低模块之间的耦合度，使代码拥有更好的移植性。

2. 面向对象编程(oop) 则是对业务分析中抽取的实体进行方法和属性的封装。

也可以说AOP是面向业务中的动词领域，OOP面向名词领域。

AOP 的一个很重要的特点是源代码无关性，也就是说如果我们的系统中引用了 AOP 组件，即使我们把该组件去掉，系统代码也应该能够编译通过。要实现这一点，可以使用动态 proxy 模式。

AOP和OOP都是一套方法论，也可以说成设计模式、思维方式、理论规则等等。
AOP不能替代OOP，OOP是obejct abstraction，而AOP是concern abstraction，前者主要是对对象的抽象，诸如抽象出某类业务对象的公用接口、报表业务对象的逻辑封装，更注重于某些共同对象共有行为的抽象，如报表模块中专门需要报表业务逻辑的封装，其他模块中需要其他的逻辑抽象 ，而AOP则是对分散在各个模块中的共同行为的抽象，即关注点抽象。一些系统级的问题或者思考起来总与业务无关又多处存在的功能，可使用AOP，如异常信息处理机制统一将自定义的异常信息写入响应流进而到前台展示、行为日志记录用户操作过的方法等，这些东西用OOP来做，就是一个良好的接口、各处调用，但有时候会发现太多模块调用的逻辑大都一致、并且与核心业务无大关系，可以独立开来，让处理核心业务的人专注于核心业务的处理，关注分离了，自然代码更独立、更易调试分析、更具好维护。

核心业务还是要OOP来发挥作用，与AOP的侧重点不一样，前者有种纵向抽象的感觉，后者则是横向抽象的感觉， AOP只是OOP的补充，无替代关系。

C

2、类A1和类A2在同一包中，类A2有个protected的方法testA2，类A1不是类A2的子类（或子类的子类），类A1可以访问类A2的方法testA2。（ ）

正确

错误

这个子类指的是 不同包下的子类

public：可以被所有其他类所访问

private：只能被自己访问和修改

protected：自身、子类及同一个包中类可以访问

default：同一包中的类可以访问，声明时没有加修饰符，认为是friendly。

A

3、下列关于异常处理的描述中，错误的是()。

程序运行时异常由Java虚拟机自动进行处理

使用try-catch-finally语句捕获异常

可使用throw语句抛出异常

捕获到的异常只能在当前方法中处理，不能在其他方法中处理

捕获到的异常不仅可以在当前方法中处理，还可以将异常抛给调用它的上一级方法来处理。

编译时异常必须显示处理，运行时异常交给虚拟机。

运行时异常可以不处理。当出现这样的异常时，总是由虚拟机接管。比如我们从来没有人去处理过Null Pointer Exception异常，它就是运行时异常，并且这种异常还是最常见的异常之一。出现运行时异常后，系统会把异常一直往上层抛，一直遇到处理代码。如果没有处理块，到最上层，如果是多线程就由Thread.run()抛出，如果是单线程就被main()抛出。抛出之后，如果是线程，这个线程也就退出了。如果是主程序抛出的异常，整个程序也就退出了。运行时异常是Exception的子类，也有一般异常的特点，是可以被Catch块处理的。只不过往往不对它处理罢了。也就是说，如果不对运行时异常进行处理，那么出现运行时异常之后，要么是线程中止，要么是主程序终止。

D

4、下列程序的运行结果

public static void main(String args[]) {
    Thread t = new Thread() {
        public void run() {
            pong();
        }
    };
    t.run();
    System.out.print("ping");
}
static void pong() {
    System.out.print("pong");
}

pingpong

pongping

pingpong和pongping都有可能

都不输出

这里需要注意Thread的start和run方法

用start方法才能真正启动线程，此时线程会处于就绪状态，一旦得到时间片，则会调用线程的run方法进入运行状态。

而run方法只是普通方法，如果直接调用run方法，程序只会按照顺序执行主线程这一个线程。

在第7行的时候，调用的是t.run();方法，之间调用run方法就是普通的方法调用而已，所以肯定是先执行pong()再执行System.out.print("ping");

如果第7行换成t.start()方法，答案就应该选择c，因为t.start()后，线程变为就绪状态，什么时候开始执行时不确定的，可能是主程序先继续执行，也可能是新线程先执行。

B

5、在Java中，以下数据类型中,需要内存最多的是()

byte

long

Object

int

Object 是引用数据类型，只申明而不创建实例，只会在栈内存中开辟空间，默认为空，空占1 bit.

byte：8位，最大存储数据量是255，存放的数据范围是-128127之间。
short：16位，最大数据存储量是65536，数据范围是-3276832767之间。
int：32位，最大数据存储容量是2的32次方减1，数据范围是负的2的31次方到正的2的31次方减1。
long：64位，最大数据存储容量是2的64次方减1，数据范围为负的2的63次方到正的2的63次方减1。
float：32位，数据范围在3.4e-451.4e38，直接赋值时必须在数字后加上f或F。
double：64位，数据范围在4.9e-3241.8e308，赋值时可以加d或D也可以不加。
boolean：只有true和false两个取值。
char：16位，存储Unicode码，用单引号赋值。

B

6、以下多线程对int型变量x的操作，哪个不需要进行同步（ ）

x=y;

x++;

++x;

x=1;

A.由于y的值不确定，所以要加锁；

B,C 两个在多线程情况下是必须要加锁的，因为他们是先被读入寄存器，然后再进行+1操作，如果没有加锁，那么可能会出现数据异常；

D 原子操作，所以不需要加锁

原子性：指该操作不能再继续划分为更小的操作。

Java中的原子操作包括：     

    1、除long和double之外的基本类型的赋值操作

    2、所有引用reference的赋值操作

    3、java.concurrent.Atomic.* 包中所有类的一切操作

D

7、如果一个接口Glass有个方法setColor()，有个类BlueGlass实现接口Glass，则在类BlueGlass中正确的是？ ( )

protected void setColor() { …}

void setColor() { …}

public void setColor() { …}

以上语句都可以用在类BlueGlass中

接口中只能有常量，是public static final的，方法不写默认是 public abstract的

这题就考了两个点：

1. 虽然JDK8接口中可以有static或者default修饰的方法，但是这两种方法必须有方法体。同时接口中的方法默认还是public abstract的
2. 类对接口的实现，其实体现了多态性，因为类需要重写接口中所有的抽象方法。而重写需要满足两同两小一大：
3. 方法名和形参列表一致。
4. 重写方法的返回值（引用类型）和抛出的异常，必须是被重写方法的子类或者和被重写方法一样。一旦返回值是基本数据类型，那么重写方法和被重写方法必须一致。
5. 重写方法的访问修饰符大于等于被重写方法的访问修饰符。

C

8、下面论述正确的是（）？

如果两个对象的hashcode相同，那么它们作为同一个HashMap的key时，必然返回同样的值

如果a,b的hashcode相同，那么a.equals(b)必须返回true

对于一个类，其所有对象的hashcode必须不同

如果a.equals(b)返回true，那么a,b两个对象的hashcode必须相同

hashcode和equals的约定关系如下：

1.equals()相等的两个对象他们的hashCode()肯定相等，也就是用equals()对比是绝对可靠的。

2.hashCode()相等的两个对象他们的equal()不一定相等，也就是hashCode()不是绝对可靠的。

D

9、protected访问权限要小于包访问权限。（ ）

正确

错误

Java类成员的访问控制权限：

public > protected > 同包（default） > private

B

11、下列说法错误的是

虚拟机中没有泛型，只有普通类和普通方法

所有泛型类的类型参数在编译时都会被擦除

创建泛型对象时请指明类型，让编译器尽早的做参数检查

泛型的类型擦除机制意味着不能在运行时动态获取List<T>中T的实际类型

1、创建泛型对象的时候，一定要指出类型变量T的具体类型。争取让编译器检查出错误，而不是留给JVM运行的时候抛出类不匹配的异常。 2、JVM如何理解泛型概念 —— 类型擦除。事实上，JVM并不知道泛型，所有的泛型在编译阶段就已经被处理成了普通类和方法。 处理方法很简单，我们叫做类型变量T的擦除(erased) 。 总结：泛型代码与JVM ① 虚拟机中没有泛型，只有普通类和方法。 ② 在编译阶段，所有泛型类的类型参数都会被Object或者它们的限定边界来替换。(类型擦除) ③ 在继承泛型类型的时候，桥方法的合成是为了避免类型变量擦除所带来的多态灾难。 无论我们如何定义一个泛型类型，相应的都会有一个原始类型被自动提供。原始类型的名字就是擦除类型参数的泛型类型的名字。

D

12、下面哪些情况会引发异常：

数组越界

指定URL不存在

使用throw语句抛出

使用throws语句

throws 和 throw：

throws出现在方法头，表示可能会出现异常；

throw是在方法体，抛出了异常，执行throw则一定抛出了某种异常

throws表示出现异常的一种可能性，并不一定会发生异常；throw则是抛出了异常，执行throw则一定抛出了某种异常。两者都是消极的异常处理方式，只是抛出或者可能抛出异常，是不会由函数处理，真正的处理异常由它的上层调用处理。

ABC

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

一个类可以实现多个接口

抽象类必须有抽象方法

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

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

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

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

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

ACDF

14、有关线程的叙述正确的是()

可以获得对任何对象的互斥锁定

通过继承Thread类或实现Runnable接口，可以获得对类中方法的互斥锁定

线程通过使用synchronized关键字可获得对象的互斥锁定

线程调度算法是平台独立的

线程的互斥锁机制：synchronized，lock，condition

线程调度分为协同式调度和抢占式调度，Java使用的是抢占式调度，也就是每个线程将由操作系统来分配执行时间，线程的切换不由线程本身来决定（协同式调度）。这就是平台独立的原因。

CD

15、下列代码片段中，存在编译错误的语句是()

byte b1=1,b2=2,b3,b6,b8;
final byte b4=4,b5=6,b7;
b3=(b1+b2);  /*语句1*/
b6=b4+b5;    /*语句2*/
b8=(b1+b4);  /*语句3*/
b7=(b2+b5);  /*语句4*/
System.out.println(b3+b6);

语句2

语句1

语句3

语句4

Java表达式转型规则由低到高转换：

1、所有的byte,short,char型的值将被提升为int型；

2、如果有一个操作数是long型，计算结果是long型；

3、如果有一个操作数是float型，计算结果是float型；

4、如果有一个操作数是double型，计算结果是double型；

5、被fianl修饰的变量不会自动改变类型，当2个final修饰相操作时，结果会根据左边变量的类型而转化。

语句1错误：b3=(b1+b2);自动转为int，所以正确写法为b3=(byte)(b1+b2);或者将b3定义为int；

语句2正确：b6=b4+b5;b4、b5为final类型，不会自动提升，所以和的类型视左边变量类型而定，即b6可以是任意数值类型；

语句3错误：b8=(b1+b4);虽然b4不会自动提升，但b1仍会自动提升，所以结果需要强转，b8=(byte)(b1+b4);

语句4错误：b7=(b2+b5); 同上。同时注意b7是final修饰，即只可赋值一次，便不可再改变。

BCD

16、Java（）中的静态方法是什么

它是属于类而不是对象（实例）的方法

静态方法只能访问静态数据。它无法访问非静态数据（实例变量）

静态方法只能调用其他静态方法，不能从中调用非静态方法。

静态方法不能通过类名直接访问，并且不需要任何对象

静态方法可以直接用类名访问

ABC

17、下述有关c++的虚类和java接口的描述，说法错误的是？

c++虚类相当与java里面的抽象类

c++中没有接口的概念，与之对应的是纯虚类，对应的是java的接口

纯虚函数和虚函数的区别在于前者只包含定义，而后者还可以包含函数体。

一个抽象类和接口中的方法必须是抽象方法

**1、一个子类只能继承一个抽象类（虚类），但能实现多个接口；
2、一个抽象类可以有构造方法，接口没有构造方法；
3、一个抽象类中的方法不一定是抽象方法，即其中的方法可以有实现（有方法体），接口中的方法都是抽象方法，不能有方法体，只有声明；
4、一个抽象类可以是public、private、protected、default,
   接口只有public;
5、一个抽象类中的方法可以是public、private、protected、default，
   接口中的方法只能是public和default**

CD