java笔试练习题笔记（12）

关于抽象类和接口叙述正确的是？ ( )


A.抽象类和接口都能实例化的
B.抽象类不能实现接口
C.抽象类方法的访问权限默认都是public
D.接口方法的访问权限默认都是public

答案解析：

抽象类

特点:
1.抽象类中可以构造方法
2.抽象类中可以存在普通属性，方法，静态属性和方法。
3.抽象类中可以存在抽象方法。
4.如果一个类中有一个抽象方法，那么当前类一定是抽象类；抽象类中不一定有抽象方法。
5.抽象类中的抽象方法，需要有子类实现，如果子类不实现，则子类也需要定义为抽象的。
6,抽象类不能被实例化，抽象类和抽象方法必须被abstract修饰

关键字使用注意：
抽象类中的抽象方法（其前有abstract修饰）不能用private、static、synchronized、native访问修饰符修饰。

接口

1.在接口中只有方法的声明，没有方法体。
2.在接口中只有常量，因为定义的变量，在编译的时候都会默认加上public static final
3.在接口中的方法，永远都被public来修饰。
4.接口中没有构造方法，也不能实例化接口的对象。（所以接口不能继承类）
5.接口可以实现多继承
6.接口中定义的方法都需要有实现类来实现，如果实现类不能实现接口中的所有方法则实现类定义为抽象类。
7，接口可以继承接口，用extends

---

执行完以下代码 int [ ]  x = new int[10] ；后，以下哪项说明是正确的（ ）

A.x[9]为0
B.x[9]未定义
C.x[10]为0
D.x[0]为空

答案解析：

数组引用类型的变量的默认值为 null。当数组变量的实例后，如果没有没有显示的为每个元素赋值，Java 就会把该数组的所有元素初始化为其相应类型的默认值。

int型的默认值为0

---

以下会产生精度丢失的类型转换是( ）

A.float a=10
B.int a=（int）8846.0
C.byte a=10； int b=-a
D.double d=100

答案解析：精度丢失只会发生在从大范围到小范围的转换

---

java中提供了哪两种用于多态的机制
A.通过子类对父类方法的覆盖实现多态
B.利用重载来实现多态.即在同一个类中定义多个同名的不同方法来实现多态。
C.利用覆盖来实现多态.即在同一个类中定义多个同名的不同方法来实现多态。
D.通过子类对父类方法的重载实现多态

答案解析：重载和重写是多态的表现

---

以下说法错误的是（）
A.其他选项均不正确
B.java线程类优先级相同
C.Thread和Runnable接口没有区别
D.如果一个类继承了某个类，只能使用Runnable实现线程

答案解析：

实现线程的方式有：继承Thread类，重现run()方法；

                                 实现Runable接口，实现run()方法；

                                 实现Callable接口，线程结束后有返回值

---

关于下面程序，哪些描述是正确的: (  )
 public class While {
    public void loop() {
        int x= 10;
        while ( x )  {
            System.out.print("x minus one is " + (x - 1));
            x -= 1;
        }
    }
}

A.行1有语法错误
B.行4有语法错误
C.行5有语法错误
D.行6有语法错误
E.行2有语法错误,loop是关键字
F.程序能够正常编译和运行

答案解析：while（）中表达式的判断，在C语言中大于0的int值都会被认为是true，而java中没有这个机制，必须是boolean类型的。

---

给出以下代码,请给出结果.
class Two{
    Byte x;
}
class PassO{
    public static void main(String[] args){
        PassO p=new PassO();
        p.start();
    }
    void start(){
        Two t=new Two();
        System.out.print(t.x+””);
        Two t2=fix(t);
        System.out.print(t.x+” ” +t2.x);
    }
    Two fix(Two tt){
        tt.x=42;
        return tt;
    }
}

A.null null 42
B.null 42 42
C.0 0 42
D.0 42 42
E.An exception is thrown at runtime
F.Compilation

答案解析：Byte是byte的包装类型，初始化为null而不是0

---

Java语言中，方法的重写（Overriding）和重载（Overloading）是多态性的不同表现。下边哪些说法是对的？
A.重写是父类与子类之间多态性的一种表现
B.重写是一个类中多态性的一种表现
C.重载是一个类中多态性的一种表现
D.重载是父类与子类之间多态性的一种表现

---

关于抽象类与接口，下列说法正确的有？

A.为了降低模块的耦合性，应优先选用接口，尽量少用抽象类
B.抽象类可以被声明使用，接口不可以被声明使用
C.抽象类和接口都不能被实例化。
D.以上说法都不对

答案解析：

A选项，接口体现的是一种规范和实现分离的设计哲学，代码编写过程中充分利用接口可以很大程度的降低程序各个模块之间的耦合，从而提高系统的可扩展性和可维护性。基于这一原则，很多软件架构更提倡面向接口编程而不是实现类编程。

接口和抽象类都可以被声明使用，因此B选项错误。

C选项，抽象类到底能不能被实例化是初学者很容易犯的错误，抽象类确实有构造方法，但这个构造方法是用来被子类调用的，因为任何子类都必须调用从Object开始的所有父亲的构造方法，才算完成初始化工作。如果抽象类被实例化，就会报错，编译无法通过。而接口里不包含构造器，自然无法被实例化。选项C正确。

---

在使用super和this关键字时，以下描述正确的是（）
A.在子类构造方法中使用 super() 显示调用父类的构造方法，super() 必须写在子类构造方法的第一行，否则编译不通过
B.super() 和 this() 不一定要放在构造方法内第一行
C.this() 和 super() 可以同时出现在一个构造函数中
D.this() 和 super() 可以在static环境中使用，包括static方法和static语句块

答案解析：使用super()或者this()方法是必须放在构造函数的第一行 由于this函数指向的构造函数默认有super()方法，所以规定this()和super()不能同时出现在一个构造函数中。 因为staic方法或者语句块没有实例时可以使用，而此时不需要构造实例，所以不能用this()和super()

---

与未加访问控制符的缺省情况相比，public和protected修饰符扩大了属性和方法的被访问范围，private修饰符则缩小了这种范围。
A.正确
B.错误

答案解析：public>protected>缺省>private

---

下列是合法的 Java 标识符的有？（ ）
A.Tree&Glasses
B.FirstJavaApplet
C._FirstApplet
D.273.5

答案解析：

1. 标识符的第一个字符必须是字母（大写或小写）、下划线（_）或者美元符号（$）。
2. 标识符的其余字符可以是字母、数字、下划线（_）或者美元符号（$）。
3. 标识符不能是 Java 的保留关键字。
4. 标识符不能包含空格或特殊字符，如 &、#、%、* 等。

---

以下代码段执行后的输出结果为

public class Test {
    public static void main(String args[]) {
        int x = -5;
        int y = -12;
        System.out.println(y % x);
    }
}


A.-1
B.2
C.1
D.-2

答案解析： 在java中，%为取余操作，Math.floorMod为取模操作 取余的结果是与被除数的符号保持一致； 取模的结果是与除数的符号保持一致。

---

下列方法中哪个是执行线程的线程体的方法？ （）
A.run()
B.start()
C.sleep()
D.suspend()

答案解析：

run()方法用来执行线程体中具体的内容

start()方法用来启动线程对象，使其进入就绪状态

sleep()方法用来使线程进入睡眠状态

suspend()方法用来使线程挂起，要通过resume()方法使其重新启动

Java多线程（超详细！）-优快云博客

---

高优先级的线程比低优先级的线程运行得更快。

A.对
B.错

答案解析：高优先级的线程与低优先级 的线程只是运行的优先级，和速度没关系

---

一个类中，有两个方法名、形参类型、顺序和个数都完全一样，返回值不一样的方法,这种现象叫覆盖。（  ）

A.正确
B.错误

答案解析：覆盖是子类和父类之间的，重载是一个类中方法的参数类型，顺序个数不同，如果全相同    就报错

---

关于匿名内部类叙述正确的是？ ( )


A.匿名内部类可以继承一个基类，不可以实现一个接口
B.匿名内部类不可以定义构造器
C.匿名内部类不能用于实参
D.以上说法都不正确

答案解析：

      1、使用匿名内部类时，我们必须是继承一个类或者实现一个接口，但是两者不可兼得，同时也只能继承一个类或者实现一个接口。

     2、匿名内部类中是不能定义构造函数的。

     3、匿名内部类中不能存在任何的静态成员变量和静态方法。

      4、匿名内部类为局部内部类，所以局部内部类的所有限制同样对匿名内部类生效。

     5、匿名内部类不能是抽象的，它必须要实现继承的类或者实现的接口的所有抽象方法。

Java 匿名类(匿名内部类)-优快云博客

---

下面哪些描述是正确的：（  ）
public class Test {
    public static class A {
        private B ref;
        public void setB(B b) {
            ref = b;
        }
    }
    public static Class B {
        private A ref;
        public void setA(A a) {
            ref = a;
        }
    }
    public static void main(String args[]) {
    …
        start();
    ….
    }
    public static void start() { A a = new A();
        B b = new B();
        a.setB(b);
        b = null; //
        a = null;
    …
    }
}
 
    

A.b = null执行后b可以被垃圾回收
B.a = null执行后b可以被垃圾回收
C.a = null执行后a可以被垃圾回收
D.a,b必须在整个程序结束后才能被垃圾回收
E.类A和类B在设计上有循环引用，会导致内存泄露
F.a, b 必须在start方法执行完毕才能被垃圾回收

 答案解析：

---

子类A继承父类B, A a = new A(); 则父类B构造函数、父类B静态代码块、父类B非静态代码块、子类A构造函数、子类A静态代码块、子类A非静态代码块 执行的先后顺序是？
A.父类Ｂ静态代码块->父类Ｂ构造函数->子类Ａ静态代码块->父类Ｂ非静态代码块->子类Ａ构造函数->子类Ａ非静态代码块
B.父类Ｂ静态代码块->父类Ｂ构造函数->父类Ｂ非静态代码块->子类Ａ静态代码块->子类Ａ构造函数->子类Ａ非静态代码块
C.父类Ｂ静态代码块->子类Ａ静态代码块->父类Ｂ非静态代码块->父类Ｂ构造函数->子类Ａ非静态代码块->子类Ａ构造函数
D.父类Ｂ构造函数->父类Ｂ静态代码块->父类Ｂ非静态代码块->子类Ａ静态代码块->子类Ａ构造函数->子类Ａ非静态代码块

答案解析：父类Ｂ静态代码块->子类Ａ静态代码块->父类Ｂ非静态代码块->父类Ｂ构造函数->子类Ａ非静态代码块->子类Ａ构造函数 也就是说非静态初始化块的执行顺序要在构造函数之前

---

以下程序运行的结果为 (   )
public class Example extends Thread{
@Override

public void run(){

try {

Thread.sleep(1000);

} catch (InterruptedException e){

e.printStackTrace();

}

System. out .print( "run" );

}

public static void main(String[] args){

Example example= new Example();

example.run();

System. out .print( "main" );

}
}
A.run main
B.main run
C.main
D.run
E.不能确定

答案解析：example.run()是对象对普通方法的调用，并没有启动线程，那么程序在运行过程中依然只有一条线程，当程序运行到Thread.sleep(1000);时，这条线程进入阻塞状态，sleep时间到，程序继续向下执行，打印"run"，此时run()方法执行结束，程序继续向下运行，打印"main"。

---

以下哪些继承自 Collection 接口（）

A.List
B.Set
C.Map
D.Array

答案解析：

 

---

以下哪些方法是Object类中的方法
A.clone()
B.toString()
C.wait()
D.finalize()

 答案解析：

---

java中下面哪个能创建并启动线程（）

public class MyRunnable implements Runnable { 
     public void run() { 
         //some code here 
     } 
 }
A.new Runnable(MyRunnable).start()
B.new Thread(MyRunnable).run()
C.new Thread(new MyRunnable()).start()
D.new MyRunnable().start()

 答案解析：

---

static String str0="0123456789";
static String str1="0123456789";
String str2=str1.substring(5);
String str3=new String(str2);
String str4=new String(str3.toCharArray());
str0=null;
假定str0,...,str4后序代码都是只读引用。
Java 7中，以上述代码为基础，在发生过一次FullGC后，上述代码在Heap空间（不包括PermGen）保留的字符数为（）
A.5
B.10
C.15
D.20

 答案解析：

1. str0 和 str1 是两个字符串常量，它们被存储在字符串常量池中。

2. str2 是通过 str1.substring(5) 创建的，这会创建一个新的字符串对象，包含 str1 从索引5开始的子串 "56789"。

3. str3 是通过 new String(str2) 创建的，这会创建一个新的字符串对象，包含与 str2 相同的字符。

4. str4 是通过 new String(str3.toCharArray()) 创建的，这同样会创建一个新的字符串对象，包含与 str3 相同的字符。

在Full GC之后，str0 被设置为 null，所以它指向的字符串常量池中的字符串可以被垃圾回收。但是，str1、str2、str3 和 str4 都仍然有引用，所以它们不会被回收。

由于 str2、str3 和 str4 都是通过 new 或 substring 创建的新对象，它们各自占用独立的内存空间。str1 也占用独立的内存空间，因为它是一个字符串常量。

因此，每个字符串对象都占用10个字符的空间（因为它们都是 "0123456789" 的子串），总共是40个字符。但由于 str2、str3 和 str4 都指向相同的字符串内容 "56789"，它们实际上只占用5个字符的空间。因此，总共占用的字符数是 str1 的10个字符加上 str2、str3 和 str4 共享的5个字符，总共是15个字符。

【JVM基础篇】Java垃圾回收介绍（包含可达性分析、五种引用对象的回收）_java 对象回收-优快云博客

---

在如下所示的类Test中，共有（）个构造方法。

public class Test
{
    private int x;
    public Test()
    {
        x = 35;
    }
 
    public void Test(double f)
    {
        this.x = (int)f;
    }
 
    public Test(double f)
    {
        this.x = (int)f;
    }
 
    public Test(String s) {}
}
A.0
B.1
C.2
D.3

 答案解析：

1.构造函数必须是public

2.构造函数必须是无返回值的，void也不行

3.构造函数必须是和类名一直的，方法名不按照小驼峰的规则

4.参数列表不同，可以构造多个构造方法，是方法的重载

publicTest()

    {

        x = 35;

    }

    publicTest(doublef)

    {

        this.x = (int)f;

    }

    publicTest(String s) {}

---

对于JVM内存配置参数：
-Xmx10240m -Xms10240m -Xmn5120m -XXSurvivorRatio=3
,其最小内存值和Survivor区总大小分别是（）
A.5120m，1024m
B.5120m，2048m
C.10240m，1024m
D.10240m，2048m

答案解析：

-Xmx10240m：代表最大堆

 -Xms10240m：代表最小堆

 -Xmn5120m：代表新生代

 -XXSurvivorRatio=3：代表Eden:Survivor = 3    根据Generation-Collection算法(目前大部分JVM采用的算法)，一般根据对象的生存周期将堆内存分为若干不同的区域，一般情况将新生代分为Eden ，两块Survivor；    计算Survivor大小， Eden:Survivor = 3，总大小为5120,3x+x+x=5120  x=1024

新生代大部分要回收，采用Copying算法，快！

老年代 大部分不需要回收，采用Mark-Compact算法

常见配置汇总

1. 堆设置
   • -Xms:初始堆大小
   • -Xmx:最大堆大小
   • -XX:NewSize=n:设置年轻代大小
   • -XX:NewRatio=n:设置年轻代和年老代的比值。如:为3，表示年轻代与年老代比值为1：3，年轻代占整个年轻代年老代和的1/4
   • -XX:SurvivorRatio=n:年轻代中Eden区与两个Survivor区的比值。注意Survivor区有两个。如：3，表示Eden：Survivor=3：2，一个Survivor区占整个年轻代的1/5
   • -XX:MaxPermSize=n:设置持久代大小
2. 收集器设置
   • -XX:+UseSerialGC:设置串行收集器
   • -XX:+UseParallelGC:设置并行收集器
   • -XX:+UseParalledlOldGC:设置并行年老代收集器
   • -XX:+UseConcMarkSweepGC:设置并发收集器
3. 垃圾回收统计信息
   • -XX:+PrintGC
   • -XX:+PrintGCDetails
   • -XX:+PrintGCTimeStamps
   • -Xloggc:filename
4. 并行收集器设置
   • -XX:ParallelGCThreads=n:设置并行收集器收集时使用的CPU数。并行收集线程数。
   • -XX:MaxGCPauseMillis=n:设置并行收集最大暂停时间
   • -XX:GCTimeRatio=n:设置垃圾回收时间占程序运行时间的百分比。公式为1/(1+n)
5. 并发收集器设置
   • -XX:+CMSIncrementalMode:设置为增量模式。适用于单CPU情况。
   • -XX:ParallelGCThreads=n:设置并发收集器年轻代收集方式为并行收集时，使用的CPU数。并行收集线程数。

---

下面有关java的instanceof、?、&、&&说法正确的有？
A.instanceof 可用来判断某个实例变量是否属于某种类的类型。
B."?："  三目运算符
C.&在逻辑运算中是非短路逻辑与，在位运算中是按位与
D.&& 逻辑运算：逻辑与

答案解析：

1、三目运算是右结合的。

2、&不短路，&&短路。

---

类之间存在以下几种常见的关系：
A.“USES-A”关系
B.“HAS-A”关系
C.“IS-A”关系
D.“INHERIT-A”关系

答案解析：

use-a 是依赖关系

has-a   一般是组合关系

is-a   一般是继承关系