Java习题1

单选题

（1）关于接口，说法不正确的是（B）。

A．接口不能被实例化，因为它的方法只有定义，没有实现

B．接口中的方法不全是public

C．继承接口接做实现（implements)

D．接口专用于模块之间的解耦

（2）内部匿名类的说法正确的是（A）。

A．是将类的派生与实例创建结合在一起的一种语法

B．匿名类只能从接口派生

C．匿名类中只能实现一个方法

D．匿名类不可以被替换为Lambda

（3）下列哪一个关键字用于实现接口（B）。

A．extends B．implements C．abstract D．interface

（4）在java中，使用（B）关键字来定义一个接口。

A．class B．interface C．extends D．implements

（5）下列关于抽象类的说法四个是正确的？（C）。

A．某个抽象类的父类是抽象类，则达个子类必须里载父类的所有抽象方法

B．接口和抽象类是同一回事

C．绝对不能用抽象类去创建对象

D．抽象类中不可以有非抽象方法

（6）以下代码，描述正确的有（A）。

interface IDemo{

public static final String name; 1

void print(); 2

public void getInfo(); 3

}

abstract class Person implements IDemo{ 4

public void print(){}

}

A．第1行错误，没有给变量赋值

B．第2行错误，方法没有修饰符

C．第4行错误，没有实现接口的全部方法

D．第3行错误，没有方法的实现

（7）关于Class类，说法错误的是（D）。

A．Class是实例中保存了一个类的元数据

B．通过Class实例，可以调用某个类的方法

C．通过Class实例，可以设置某个类的字段的值

D．Class对象与其所描述的类的实例是关连的

多选题

（1）在Java接口中，下列选项中有效的方法声明是（AB）。

A．public void aMethod() B．void aMethod()

C．protected void aMethod() D．private void aMethod()

（2）abstract的作用（ABCD）。

A．可以修饰类和方法

B．不能修饰属性和构造方法

C．abstract修饰的类是抽象类，需要被继承

D．abstract修饰的方法是抽象方法，需要子类被重写

（3）下列关于Object类说法正确的是（ABCD）。

A．Object类是所有Java类的祖先

B．Object类有一个默认构造方法public Object()，在构造子类实例时，都会先调用这个默认构造方法

C．可以使用型为Object的变量指向任何类型的对象

D．Object类的变量只能用作各种值的通用持有者

（4）反射获取类的方式有（ABC）。

A．通过getClass方法获取，通过对象获取

B．通过类名获取

C．通过完整的包名+类名

D．通过关键词new

判断题

（1）匿名内部类没有类名，因此没有构造方法。（T）

（2）静态内部类的创建不需要依赖外部类可以直接创建。（T）

（3）所谓内部类就是在一个类内部进行其他类结构的嵌套操作。（T）

（4）Java类之间并不允许多继承，接口只可以单继承。（F）

（5）一个类只能继承一个父类，但能实现多个接口。（T）

（6）接口与类的区别是，接口中只能定义方法不能实现方法。（T）

填空题

（1）接口的关键字是 interface

（2）基本数据的包装类分别是什么？例：byte -- Byte

short -- Short

int -- Integer

long -- Long

float – Float

double -- Double

char -- Character

boolean -- Boolean

（3）阅读程序回答以下问题：

1）程序输出的第一行是什么 这个人是:学生

2）三次输出的hashCode是否相同（是或否） 是

3）程序输出的第五行是什么 int

4）程序会输出多少行（只写数字） 6

public class Test03 {

public static void main(String[] args) throws ClassNotFoundException {

Person person = new Student();

System.out.println("这个人是:" + person.name);

//方式一:通过对象获得

Class c1 = person.getClass();

System.out.println(c1.hashCode());

//方式二:forName获得

Class c2 = Class.forName("cn.reflectionTest.reflection.Student");

System.out.println(c2.hashCode());

//方式三:通过类名.class获得

Class c3 = Student.class;

System.out.println(c3.hashCode());

//方式四:基本内置类型的包装类都有一个Type属性

Class c4 = Integer.TYPE;

System.out.println(c4);

//获得父类类型

Class c5 = c1.getSuperclass();

System.out.println(c5);

}

}

class Person {

public String name;

public Person() {

}

public Person(String name) {

this.name = name;

}

@Override

public String toString() {

return "Person{" +

"name='" + name + '\'' +

'}';

}

}

class Student extends Person {

public Student() {

this.name = "学生";

}

}

class Teacher extends Person {

public Teacher() {

this.name = "老师";

}

}

简答题

（1）抽象类（abstract class）和接口（interface）有什么异同？

抽象类是用来捕捉子类的通用特性的。它不能被实例化，只能被用作子类的超类。抽象类是被用来创建继承层级里子类的模板。

接口是抽象方法的集合。如果一个类实现了某个接口，那么它就继承了这个接口的抽象方法。这就像契约模式，如果实现了这个接口，那么就必须确保使用这些方法。接口只是一种形式，接口自身不能做任何事情。

相同点：

1.他们都不能生成实例，都有抽象方法。

2.接口是特殊的抽象类。

3.接口和抽象类的继承都使用的关键字是extends。

不同点：

1.接口的定义的变量默认是public static final型，且必须给其赋初值。所以在实现类中不能重新定义，也不能改变其值。而在抽象类中其值在子类中可以重新定义也可以重新赋值。

2.接口的方法默认的都是public abstract类型的。

3.抽象类中可以有构造器，但是接口中除了抽象方法什么都没有。

4.名字不同，接口写的是public interface Shape{}； 而抽象类写的是public abstract class Shape{}。

5.还可以从继承的角度看，接口可以多继承，一个接口可以继承多个接口。但是抽象类却不能，只能是继承一个父类，不能继承多个父类。

6.abstract class和interface所反映出的设计理念不同。其实abstract class表示的是"is-a"关系，interface表示的是"like-a"关系。

7.接口里全部都是抽象方法。而抽象类里可以有抽象方法也可以有其他的方法。

（2）int和Integer有什么区别？

1）Integer是int的包装类，int则是java的一种基本数据类型。

2）Integer变量必须实例化后才能使用，而int变量不需要。

3）Integer实际是对象的引用，当new一个Integer时，实际上是生成一个指针指向此对象；而int则是直接存储数据值。

4）Integer的默认值是null，int的默认值是0。

（3）接口和抽象类有什么区别？

实现：抽象类的子类使用 extends 来继承；接口必须使用 implements 来实现接口。

构造函数：抽象类可以有构造函数；接口不能有。

main方法：抽象类可以有 main 方法，并且我们能运行它；接口不能有 main 方法。

实现数量：类可以实现很多个接口；但是只能继承一个抽象类。

访问修饰符：接口中的方法默认使用public修饰；抽象类中的方法可以是任意访问修饰符。

编程题

（1）编写一个类实现简单的单例模式。

public class Singleton {

private static final Singleton singleton = new Singleton();

private Singleton() {

}

public static Singleton getInstance() {

return singleton;

}

}

（2）定义一个ClassName接口。

描述：接口中只有一个抽象方法getClassName()。设计一个类Company，该类实现接口ClassName中的方法getClassName()，功能是获取该类的类名称。编写应用程序使用Company类。

interface ClassName {

public String getClassName() ;

}

class Company implements ClassName {

public String getClassName() {

return "Company";

}

}

public class TestDemo {

public static void main(String args[]) {

ClassName name = new Company() ;

System.out.println(name.getClassName());

}

}

（3）接口实现计算器。

描述：利用接口做参数，写个计算器，能完成加减乘除运算。

1）定义一个接口Compute含有一个方法int computer(int n, int m)。

2）设计四个类分别实现此接口，完成加减乘除运算。

3）设计一个类UseCompute，类中含有方法：public void useCom(Compute com, int one, int two)，此方法能够用传递过来的对象调用computer方法完成运算，并输出运算的结果。

4）设计一个主类InterFaceTest，调用UseCompute中的方法useCom来完成加减乘除运算。

/**

* 接口

*/

interface ICompute {

int computer(int number1, int number2);

}

/**

* 加法实现类

*/

class Add implements ICompute {

@Override

public int computer(int number1, int number2) {

return number1 + number2;

}

}

/**

* 减法实现类

*/

class Minus implements ICompute {

@Override

public int computer(int number1, int number2) {

return number1 - number2;

}

}

/**

* 乘法实现类

*/

class Multiply implements ICompute {

@Override

public int computer(int number1, int number2) {

return number1 * number2;

}

}

/**

* 除法实现类

*/

class Divide implements ICompute {

@Override

public int computer(int number1, int number2) {

return number1 / number2;

}

}

/**

* 调用类

*/

class UseComputer {

public void useCom(ICompute com, int one, int two) {

System.out.println(com.computer(one, two));

}

}

/**

* 测试类

*/

public class InterFaceTest {

public static void main(String[] number1rgs) {

UseComputer user = new UseComputer();

Add s1 = new Add();

System.out.print("和为：");

user.useCom(s1, 1024, 512);

Minus s2 = new Minus();

System.out.print("差为：");

user.useCom(s2, 1024, 512);

Multiply s3 = new Multiply();

System.out.print("乘积为：");

user.useCom(s3, 1024, 512);

Divide s4 = new Divide();

System.out.print("商为：");

user.useCom(s4, 1024, 512);

}

}

（4）利用接口做参数，写个计算器，完成加减乘除运算的功能。

要求：

1）定义一个接口Compute含有一个方法int computer(int n, int m)。

2）设计四个类分别实现此接口，完成加减乘除运算。

3）设计一个类UseCompute，类中含有方法：public void useCom(Compute com, int one, int two)，此方法能够用传递过来的对象调用computer方法完成运算，并输出运算的结果。

4）设计一个主类Test，调用UseCompute中的方法useCom来完成加减乘除运算。

interface Compute {

int computer(int n, int m);

}

class Jia implements Compute {

@Override

public int computer(int n, int m) {

return n + m;

}

}

class Jian implements Compute {

@Override

public int computer(int n, int m) {

return n - m;

}

}

class Chen implements Compute {

@Override

public int computer(int n, int m) {

return n * m;

}

}

class Chu implements Compute {

@Override

public int computer(int n, int m) {

return n / m;

}

}

public class Calculator {

public void userCom(Compute com, int one, int two) {

System.out.println(com.computer(one, two));

}

public static void main(String[] args) {

Compute jia = new Jia();

Compute jian = new Jian();

Compute chen = new Chen();

Compute chu = new Chu();

Calculator c = new Calculator();

c.userCom(jia, 3, 1);

c.userCom(jian, 3, 1);

c.userCom(chen, 3, 1);

c.userCom(chu, 3, 1);

}

}