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

在执行语句

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[]) {