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

1、Java 语言中，负责并发管理的机制是（ ）

垃圾回收

虚拟机

代码安全

多线程

选项A，Java语言中，垃圾回收机制对系统中不使用的内存进行回收，从而使程序员从繁忙的内存管理中解放出来。
选项B，Java编写好的程序首先由编译器转换为标准字节代码，然后由虚拟机执行。虚拟机把字节代码程序与各操作系统和硬件分开，使Java程序独立于平台。
选项C，Java的代码安全检测体现在多个层次上，在编译层、解释层、平台层分别作不同的安全检查。
选项D，多线程是Java程序的并发机制，它能同步共享数、处理不同的事件。

D

2、基本的Java语言函数存储在以下哪个java包中？（）

java.lang

java.io

java.net

java.util

java.lang   提供java基础类，例如：Object\Math\String\StringBuffer\System\Tread等，这是我们最常用的包包，但是我们并不常见到她，因为我们不需要将她手动导入；

java.util     提供包括集合框架、事件模型、日期时间、等等的使用工具类；

java.io       提供通过文件系统、数据流和序列化提供系统的输入输入；

java.net     提供实时网络应用和开发的类；

java.sql     提供使用java语言访问并处理存储在数据源中的数据API；

java.awt  和  java.swing  提供了GUI开发与设计的类，awt提供了创建界面和绘制图形图像的所有类，swing包提供了一组“轻量级”的组件，尽量让这些组件在所有平台上的工作方式相同；

java.text    提供了与自然语言无关的方式来处理文本日期、数字和消息的类和接口。

A

3、给出以下代码

public class TestObj{ 
    public static void main(String[] args){
        Object o=new Object(){
            public boolean equals(Object obj){
                return true;
            }
        }; 
        System.out.println(o.equals("Fred"));
    }
} 

运行时抛出异常

true

Fred

第三行编译错误

public class TestObj {
	public static void main(String
[] args){
        Object o=new Object(){
        	//重写了equals(),不管参数是什么，都是返回true
            public boolean equals(Object obj){
                return true;
            }
        };
        System.out.println(o.equals("Fred"));
    }
}

本题涉及匿名内部类、多态和覆盖三个知识点。 语句

Object o=new Object(){
            public boolean equals(Object obj){
                return true;
            }
        };

创建了一个匿名内部类，并将所创建的匿名对象赋给 Object (多态：子类对象赋给超类引用)。同时，该匿名内部类重写了 Object 类的 equals 方法。

在执行语句

o.equals(“Fred”)

时，根据多态及覆盖原则，会调用匿名内部类重写后的 equals 方法。

B

4、根据下面的程序代码，哪些选项的值返回true？

public class Square {  
    long width;  
    public Square(long l) {   
        width = l;  
    }  
    public static void main(String arg[]) {   
        Square a, b, c;   
        a = new Square(42L);   
        b = new Square(42L);   
        c = b;   
        long s = 42L;  
    } 
}

a == b

s == a

b == c

a.equals(s)

这题考的是引用和内存。

//声明了3个Square类型的变量a, b, c

//在stack中分配3个内存，名字为a, b, c

Square a, b, c; 

//在heap中分配了一块新内存，里边包含自己的成员变量width值为48L，然后stack中的a指向这块内存

a = new Square(42L);

//在heap中分配了一块新内存，其中包含自己的成员变量width值为48L，然后stack中的b指向这块内存

b = new Square(42L);   

//stack中的c也指向b所指向的内存

c = b;

//在stack中分配了一块内存，值为42

long s = 42L;

A: a == b

由图可以看出a和b指向的不是同一个引用，故A错

B：s == a

一个Square类型不能与一个long型比较，编译就错误，故B错

c：b == c

由图可以看出b和c指向的是同一个引用，故C正确

d：a equal s

程序会把s封装成一个Long类型，由于Square没有重写Object的equals方法， 所以调用的是Object类的equals方法，源码如下

 public boolean equals(Object obj) {
     return (this == obj);
 }

其实就是判断两个引用是否相等，故D也错误。

C

5、请问以下代码运行结果是：

try catch

try finally  catch

try finally

try catch finally

throws：写在方法声明之后，表示方法可能抛出异常，调用者需要处理这个异常。

throw：写在方法体中，表示方法一定会抛出一个异常，要么try...catch处理，要么throws抛出。

本题正是有了throw，所以才会顺序执行，否则不执行catch块中的语句。

finally块中的代码，不论在try中是否抛出异常，都会执行。但是一旦在try中跑出异常，fianlly块后的代码不再执行

 D

6、以下代码运行输出的是

public class Person{
	private String name = "Person";
	int age=0;
}
public class Child extends Person{
	public String grade;
	public static void main(String[] args){
		Person p = new Child();
		System.out.println(p.name);
	}
}

输出：Person

没有输出

编译出错

运行出错

首先不能两个public类，其次child类中无法访问父类的私有变量  

1.一个java文件里，public 的类只能出现一个，只能出现一个，只能出现一个，否则，不管你用哪一个类名命名文件名编译器都会报错

2.关于多态。子类继承了父类的所有成员，包括private权限的成员变量，但是继承的子类具有私有变量的拥有权但是没有使用权。

3.private的成员变量，根据权限修饰符的访问控制范围，只有在类内部才能被访问，就算是他的子类，也不能访问。

C

7、假定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");
   }
}

ABDC

AB

ABCD

ABC

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

 只要是被子类重写的方法，不被super调用都是调用子类方法

A

7、面向对象的基本特征是（）

封装

继承

重载

多态

三大基本特征

封装、继承、多态

五大基本原则

1.单一职责原则

就一个类而言，应该仅有一个引起它变化的原因。

2.开放-封闭原则

一个软件实体应当对扩展开放，对修改关闭

3.里氏代换原则

子类型(subtype)必须能够替换它们的基（父）类型

4.依赖倒转（置）原则

要依赖于抽象，不要依赖于具体

5.接口隔离原则

使用多个专门的接口比使用单一的总接口总要好

ABD

8、单例模式中，两个基本要点是

构造函数私有

静态工厂方法

以上都不对

唯一实例

单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。

特点：

• 1、单例类只能有一个实例。
• 2、单例类必须自己创建自己的唯一实例。
• 3、单例类必须给所有其他对象提供这一实例。

AD

9、Java7特性中,abstract class和interface有什么区别

抽象类可以有构造方法，接口中不能有构造方法

抽象类中可以有普通成员变量，接口中没有普通成员变量

抽象类中不可以包含静态方法，接口中可以包含静态方法

一个类可以实现多个接口，但只能继承一个抽象类

含有abstract修饰符的class即为抽象类，abstract类不能创建的实例对象。含有abstract方法的类必须定义为abstract class，abstract class类中的方法不必是抽象的。abstract class类中定义抽象方法必须在具体(Concrete)子类中实现，所以，不能有抽象构造方法或抽象静态方法。如果的子类没有实现抽象父类中的所有抽象方法，那么子类也必须定义为abstract类型。 
接口（interface）可以说成是抽象类的一种特例，接口中的所有方法都必须是抽象的。接口中的方法定义默认为public abstract类型，接口中的成员变量类型默认为public static final。 
下面比较一下两者的语法区别： 
1.抽象类可以有构造方法，接口中不能有构造方法。 
2.抽象类中可以有普通成员变量，接口中没有普通成员变量 
3.抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。 
4. 抽象类中的抽象方法的访问类型可以是public，protected和（默认类型,虽然 
eclipse下不报错，但应该也不行），但接口中的抽象方法只能是public类型的，并且默认即为public abstract类型。 
5. 抽象类中可以包含静态方法，接口中不能包含静态方法 
6. 抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型。 
7. 一个类可以实现多个接口，但只能继承一个抽象类。

ABD

10、以下那些代码段能正确执行

public static void main(String args[]) {
byte a = 3;
byte b = 2;
b = a + b;
System.out.println(b);
}

public static void main(String args[]) {
byte a = 127;
byte b = 126;
b = a + b;
System.out.println(b);
}

public static void main(String args[]) {
byte a = 3;
byte b = 2;
a+=b;
System.out.println(b);
}

public static void main(String args[]) {
byte a = 127;
byte b = 127;
a+=b;
System.out.println(b);
}

byte类型的变量在做运算时被会转换为int类型的值，故A、B左为byte，右为int，会报错；而C、D语句中用的是a+=b的语句，此语句会将被赋值的变量自动强制转化为相对应的类型。

CD