2019/7/16 Java面试题笔记详解

最新推荐文章于 2022-04-29 18:34:35 发布

@富士山下

最新推荐文章于 2022-04-29 18:34:35 发布

阅读量3.3k

点赞数 2

本文链接：https://blog.csdn.net/qq_41097354/article/details/96188756

版权

学习笔记专栏收录该内容

45 篇文章 0 订阅

订阅专栏

1．java程序的执行过程中用到一套JDK工具，其中javac.exe指（ B ）【北控三兴笔试题】
A．java解释器
B．java编译器
C．java文档生成器
D．java类分析器
解析：javac.exe 是编译器。 javadoc.exe 是文档生成器。javap.exe 是反编译器。

2.在Java中语句：37.2%10的运算结果为( A)
A．7.2 B．7 C．3 D．0.2
解析：当表达式中有一个数为double类型，运算结果就是double,%为求余符号，因此余数为7.2

3.0.6332 的数据类型是（B）【公财数据笔试题】
A．float B．double C．Float D．Double
解析：默认是double类型的，如果是float类型的需要加上f显示说明，即0.6332f.

4．下列语句中，属于多分支语句的是（B）
A．if语句
B．switch语句
C．do while语句
D．for语句
解析：if属于分支结构，do while语句跟for语句都属于循环结构。

5．下列程序执行的结果是__C___。
public class Ex6 {
public static void main(String[] args) {
char ch=‘8’;
int r=10;
switch(ch+l) {
case ‘7’: r=r+3;
case ‘8’: r=r+5;
case ‘9’: r=r+6;
break;
default: ;
}
System.out.print®;
}
}
A．14 B．13 C．16 D．10
解析：char类型数据在运算时会转换成int类型值，该int值为字符在ascii码表中的位置，字符‘8’ ascii值为56，参与运算后为57，它代表的字符是‘9’

6.．下列数组声明中错误的是（D）
A．int[] a B．int a[]
C．int[][] a D．int a[10]
解析：java中不允许在声明时指定数组的大小，即写int a[10]…, 区别于int a[]=new int[10] 包含了声明和初始化两步操作。

7.执行完代码"int[] x=new int[25];"后以下( A )说明正确的
A．x[24]为0
B．x[24]未定义
C．x[25]为0
D．x[0]为空
解析：数组声明后会根据类型默认赋值，int类型的数组每个空间默认赋值0 ，数组的长度为25，那么数组下标最大为24

8.方法methodA返回类型是（D）
public class ReturnIt{
returnType methodA(byte x, double y) {
return (short) x/y * 2;
}
}
A．int B．byte C．long D．double
解析：表达式的结果取决于精度范围最大的数据类型，short / double * int 将（精度向上靠拢）化成 double 型，所以 return “returnType” 是 double

9．下面程序运行的结果是（A）
public class X {
private static int a;
public static void main(String [] args) {
modify(a);
System.out.println(a);
}
public static void modify(int a) {
a++;
}
}
A．0 B．1 C．程序编译失败 D．程序抛出异常
解析：基本数据类型在进行参数传递时属于值传递既值得copy，因此在方法内部对a做的任何操作都不会影响成员变量a

10．下列语句正确的是（A）
A．形式参数可以被视为local variable
B．形式参数可被字段修饰符修饰
C．形式参数为方法被调用时，真正被传递的参数
D．形式参数不可以是对象
解析：
A:形式参数可被视为local variable。形参和局部变量一样都不能离开方法
B:对于形式参数只能用final修饰符，其它任何修饰符都会引起编译器错误
C:形参的值在调用时根据调用者更改，实参则用自身的值更改形参的值，也就是说真正被传递的是实参
D:形式参数可以是对象

11.在某个类中存在一个方法：void getSort(int x),以下能作为这个方法的重载声明的是（C）
A．public getSort(float x)
B．int getSort(int y)
C．double getSort(int x,int y)
D．void get(int x, int y)
解析：java对重载的定义是方法名相同参数不同，其中参数不同包含1.参数类型 2参数个数 3参数顺序
A．没有返回类型一定是构造函数不能重载
B. 参数一样不是重载
D. 方法名不一样不属于重载

12.given the following
String d=”bookkeeper”；
d.substring(2,9);
d = “u”+d;
System.out.println(d);
What is the result （B）
A．uookkeewoo
B．ubookkeeper
C．ubookkeepertoo
D．An exception is thrown at runtime
解析：String类使用final修饰，不可对String对象进行修改，因此d.substring(2,9); 并未对字符串d做任何修改

13.下面程序运行的结果是（A）
public class Test1{
public static void main(String args[]){
String a=“1234”;
String b=“1234”;
String c = new String(“1234”);
System.out.println(ab);
System.out.println(ac);
System.out.println(a.equals©);
}
}
A．true false true
B．true true false
C．true false false
D．true true true
解析：String的equals做内容判断，因为String类重写了这个方法
判断两个引用是否指向同一个地址
通过String a = "1234"这种方式产生的字符串,如果在字符串常量池中存在字符串“1234”则会直接引用，
因此String b = "1234"并未创建新对象而是直接引用常量池中的对象。
而String c = new String(“1234”)，一定会创建新的对象。因此ac因地址不同结果false，由于a和c的值都
是"1234"因此a.equals©的结果为true

14.下列数组定义及赋值，错误的是（B ）【北京九恒星科技】
A、int intArray[];
B、int[2][2] c = new int[2][2];
c[0] = new int[3];
c[1] = new int[3];
C、int a[] = {1,2,3,4,5};
D、int[][] a = new int[2][];
a[0] = new int[3];
a[1] = new int[3];
解析：c[0] = new int[3];代表的是为第一行分配3列，而前面定义的c数组是2行2列的，此时超出数组大小了。

15.下面的代码执行结果是（A）
public class TT{
public static void main(String[]args){
String a=”A”;
StringBuffer b=new StringBuffer(“B”);
StringBuffer c=new StringBuffer(“C”);
change(a,b,c);
System.out.println(a+”,”+b+”,”+c);
}
Static void change(String s,StringBuffer s1,StringBuffer s2){
s=s+”1”;
s1.append(“1”);
s2=new StringBuffer(“C1”);
}
}
A．A,B1,C
B．A1,B1,C1
C．A,B,C
D. A,B1,C1
解析：String是final类型修饰不可对其进行修改，虽是引用类型但表现出的是值传递
StringBuffer可对其值进行修改,因此a = A b=C1 s2引用指向了新的对象并没有改变c的值所以c=C

16.下列说法正确的有（C）
A．class中的constructor不可省略
B．constructor必须与class同名，但方法不能与class同名
C．constructor在一个对象被new时执行
D．一个class只能定义一个constructor
解析：这里可能会有误区，其实普通的类方法是可以和类名同名的，和构造方法唯一的区分就是，构造方法没有返回值。
17.．下面isEmptyString函数写法正确的是？【公财数据笔试题】D
A、public boolean isEmptyString(String str){
return str.length0||strnull;
}
B、public boolean isEmptyString(String str){
return strnull||str.length0;
}
C、public boolean isEmptyString(String str){
return str==""||str.length0;
}
D、public boolean isEmptyString(String str){
return str.equals("")||str.length0;
}
解析：字符对象的的判空，要先判非null，否则当字符串为null时访问对象的成员会得到NullPointException

18.下列哪一种叙述是正确的（ D）【赞同科技笔试题】
A. abstract修饰符可修饰字段、方法和类
B. 抽象方法的body部分必须用一对大括号{}包住
C. 声明抽象方法，大括号可有可无
D. 声明抽象方法不可写出大括号
解析：抽象方法必须声明在抽象类中，但抽象类也可以包含具体方法，可以有或没有抽象方法，在抽象类中还可以声明变量；父类中的抽象方法需要在子类中实现，如果子类没有实现抽象方法，则子类也成为抽象类；抽象类不能用new来进行实例化，否则会出现编译错误；但可以声明抽象类的引用，用来指向其具体子类的实例；构造方法和 static 方法都不能声明为抽象的（因为构造方法定义成抽象无法new实例化，static不用实例化就可以直接调用，abstact需要继承实现，冲突）

19.．如下代码
public class Test {
public int aMethod() {
static int i = 0;
i++;
return i;
}

public static void main(String args[]) {
    Test test = new Test();
    test.aMethod();
    int j = test.aMethod();
    System.out.println(j);
}

}
输出的结果是什么（D）【赞同科技笔试题】
A.0 B.1 C.2 D.编译失败
解析：静态变量在类中以static关键字声明，但必须在方法、构造方法和语句块之外。无论一个类创建了多少个对象，类只拥有类变量的一份拷贝。

20.．以下程序的输出结果为（D）
public class Base {
public Base(String s) {
System.out.println(“B”);
}
}
public class Derived extends Base {
public Derived(String s) {
System.out.println(“D”);
}
public static void main(String[] args) {
new Derived(“C”);
}
}
A．BD
B．DB
C．C
D．编译错误
解析：子类（Derived）在不显示继承父类（Base）构造函数地情况下（super（s）），子类构造函数第一行会默认调用父类无参构造函数；但是在本题中父类提供了有参构造函数，编译器不会再提供默认的无参构造函数。

21.在使用super 和this关键字时，以下描述正确的是（A）
A．在子类构造方法中使用super（）显示调用父类的构造方法，super（）必须写在子类构造方法的第一行，否则编译不通过
B．super（）和this（）不一定要放在构造方法内第一行
C．this（）和super（）可以同时出现在一个构造函数中
D．this（）和super（）可以在static环境中使用，包括static方法和static语句块
解析：super()代表父类构造函数，this()代表当前类的构造函数，使用super()或者this()方法是必须放在构造函数的第一行；由于this函数指向的构造函数默认有super()方法，所以规定this()和super()不能同时出现在一个构造函数中；因为static方法或者语句块没有实例时可以使用，而此时还未构造实例，所以不能用this()和super()

22.阅读下列程序，选择哪一个是正确的输出结果（C）
在这里插入图片描述
A．static A I’m A class static B I’m B class
B．I’m A class I’m B class static A static B
C．static A static B I’m A class I’m B class
D．I’m A class static A I’m B class static B
解析：
类的初始化顺序：
1.父类静态代码块
2.子类静态代码块
3.父类普通代码块
4.父类构造函数
5.子类普通代码块
6.子类构造函数

23.下列程序的运行结果是（ C ）。
class Parent{
int i=20;
int j=30;
void f(){
System.out.print(" “+i);
}
}
class Child extends Parent {
int i=30;
int k=40;
void f(){
System.out.print(” “+i);
}
void g(){
System.out.print(” “+k);
}
public static void main(String args[]){
Parent x=new Child();
System.out.print(x.i);
x.f();
Child x1=(Child)x;
System.out.print(” "+x1.i);
x1.f();
}
}
A．30 30 30 30 B．20 20 20 20 C．20 30 30 30 D．都不对
解析：成员变量不具有多态性，不可以被覆盖。Parent x=new Child();代表向上转型，x.i此时取的是父类中的i,然后在子类中已经重写了父类的f方法，此时调用子类的f方法中的i只是子类的成员变量i.

24.．有以下代码：
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”));
}
}
请给出结果：（B）
A．运行时抛出异常
B．true
C．Fred
D．第三行编译错误
解析：实例化的对象重写了equals（）方法，无论输入什么都会输出true。实际上new后面的类并不是Object，而是一个继承Object的类，但它没有名字，是一个匿名的内部类

25.．有以下代码：C

interface C {
```
 String name = "";
```
```
 void f();
```
```
 abstract void g();
```
```
 void h(){};
```
}
A．第2行编译错误
B．第4行编译错误
C．第5行编译错误
D．没有错误,正确
解析：接口只能有抽象的方法

26.．关于String，StringBuilder以及StringBuffer，描述错误的是（B）
A. 对String对象的任何改变都不影响到原对象，相关的任何change操作都会生成新的对象
B. StringBuilder是线程安全
C. StringBuffer是线程安全
D. 可以修改StringBuilder和StringBuffer的内容
解析：StringBuffer是线程安全的，StringBuilder不是线程安全的。

27.Consider the following code:
Integer s = new Integer(9) ;
Integer t = new Integer(9) ;
Long u = new Long(9) ;
Which test would return true? （CDE ）【广电运通, 通铭派瑞笔试题】
A、(su)
B、(st)
C、(s.equals(t))
D、(s.equals(9))
E、(s.equals(new Integer(9)))
解析：A两个不同类型的包装类不可直接作””判断，B包装类型间的相等判断应该用equals,而不是””

28.下列标识符不合法的有（ACD ）
A．new B． $Usdollars C．1234 D．car.taxi 解析：1.java标识符由字母、数字、_ 、$ 组成，并且首字母不能是数字
2.标识符不能包含java已有的关键字

下列说法错误的有（AC ）【广电运通、长安通信笔试题】
A．在类方法中可用this来调用本类的类方法
B．在类方法中调用本类的类方法时可直接调用
C．在类方法中只能调用本类中的类方法
D．在类方法中绝对不能调用实例方法
解析：A.在类方法中不可以使用this，因为this代表当前对象，类方法是在创建对象之前就分配了内存，C在类方法中可以调用其他类的方法

30.下列描述错误的是？（BD ）
A．类只能继承一个父类，但是可以实现多个接口
B．抽象类自身可以定义成员而接口不可以
C．抽象类和接口都不能被实例化
D．一个类可以有多个基类和多个基接口
解析：A、java为单继承，多实现。可以实现多个接口。
B、接口允许定义成员，但必须是常量。
C、抽象类和接口类的无法实例化，任何编译器中直接使用new会报错。
D、同A，单继承，多实现。

31.which won’t cause a compiler warning or error?（BDE ）【长安通信笔试题】
A. float f=1.3;
B. char c=‘a’;
C. byte b=257;
D. Boolean b=null;
E. int i=10;

32.已知：int a=8,b=6; 则：表达式++a-b++的值为_3__
解析：++在前，先执行+1，++在后，先运算后执行+1
++a-b++ 相当于是 9-6，执行完后b才+1，所以整个式子值为3

33.说明overload和override的区别, Overloaded的方法是否可以改变返回值的类型？【北控三兴笔试题】
override（重写）
（1）方法名、参数、返回值相同。
（2）子类方法不能缩小父类方法的访问权限。
（3）子类方法不能抛出比父类方法更多的异常(但子类方法可以不抛出异常)。
（4）存在于父类和子类之间。
（5）方法被定义为final不能被重写。
（6）被覆盖的方法不能为private，否则在其子类中只是新定义了一个方法，并没有对其进行覆盖。
overload（重载）
（1）参数类型、个数、顺序至少有一个不相同。
（2）不能重载只有返回值不同的方法名。
（3）针对于一个类而言。
（4）不能通过访问权限、返回类型、抛出的异常进行重载；
（5）方法的异常类型和数目不会对重载造成影响；

方法重载可以改变方法的返回值类型，因为方法的返回值类型不作为方法签名的一部分。

34.说明String,StringBuffer,StringBuilder三者的区别以及联系。【大麦网、用友笔试题】

首先说运行速度，或者说是执行速度，在这方面运行速度快慢为：StringBuilder > StringBuffer > String
String最慢的原因：
String为字符串常量，而StringBuilder和StringBuffer均为字符串变量，即String对象一旦创建之后该对象是不可更改的，但后两者的对象是变量，是可以更改的。
再来说线程安全
在线程安全上，StringBuilder是线程不安全的，而StringBuffer是线程安全的
如果一个StringBuffer对象在字符串缓冲区被多个线程使用时，StringBuffer中很多方法可以带有synchronized关键字，所以可以保证线程是安全的，但StringBuilder的方法则没有该关键字，所以不能保证线程安全，有可能会出现一些错误的操作。所以如果要进行的操作是多线程的，那么就要使用StringBuffer，但是在单线程的情况下，还是建议使用速度比较快的StringBuilder。

35.abstract class和interface的区别。【博彦科技、京天威笔试题】

a) abstract class 在 Java 语言中表示的是一种继承关系，一个类只能使用一次继承关系。但是，一个类却可以实现多个interface。接口弥补了类的多继承问题。
b) 在abstract class 中可以有自己的数据成员，也可以有非abstract的成员方法，而在interface中，只能够有静态的不能被修改的数据成员（即常量：也就是必须是static final的），所有的成员方法都是abstract的。
c) abstract class和interface所反映出的设计理念不同。其实abstract class表示的是"is-a"概念，interface表示的是"has-a"概念。注意：当一个行为与一个类的所属行为方法不相关联时，应该采用接口来实现这个行为，不能使用抽象类，否则违反面向对象的ISP(Interface Segregation Principle)接口隔离原则和OCP（Open Close Principle）开闭原则。
d) 接口中的方法默认都是 public abstract的; 属性默认是public final static。
e) 不管是抽象类还是接口都可以实现多态性，开发设计中一般优先使用接口，其次才考虑抽象类和继承。

36.请说明final，finally，finalize的区别。【拓尔思、中科宇图笔试题】
答：final—修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。被声明为final的方法也同样只能使用，不能重载。
finally—再异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常，那么相匹配的 catch 子句就会执行，然后控制就会进入 finally 块（如果有的话）。
finalize—方法名。Java 技术允许使用 finalize() 方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在 Object 类中定义的，因此所有的类都继承了它。子类覆盖 finalize() 方法以整理系统资源或者执行其他清理工作。finalize() 方法是在垃圾收集器删除对象之前对这个对象调用的。

37.编写一个函数用来实现输入任意字符串,实现对该字符串的反转,并返回反转后的字符串(不要使用开发语言现有的反转方法).例如:输入:ABCD123 返回值为:321DCBA

package wrapper;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Stack;

public class Test {
public static void main(String[] args) {
// 第一种，我最先能想得到的，利用下标倒序把字符取出来重组
System.out.println(reverse1(“ABCD123”));

    // 第二种 循环依然是从0到length-1，只不过是将先取出来的放在后取出来的后面
    System.out.println(reverse2("ABCD123"));

    // 第三种，利用Collections类的反转list的方式，比较麻烦了
    System.out.println(reverse3("ABCD123"));

    // 第四种，这种比第三种更加简洁一些，不过我自己倒是对Collections的反转方法记忆比较深刻
    // 而对于StringBuilder或者StringBuffer的记忆不是很深刻，那么现在我记住了
    System.out.println(reverse4("ABCD123"));

    // 第五种，利用堆栈，所谓的先进后出
    // 当然，首先你先从API中了解一下stack吧，它是对vector的扩展，通过push进行放入操作，然后通过pop方法进行弹出
    // 我认为stack还是很有必要进行深入的研究，看看源码是怎么扩展的，我一定要掌握
    System.out.println(reverse5("ABCD123"));

    // 第六种，
    System.out.println(reverse6("ABCD123"));
    System.out.println(reverse6("1234"));
    System.out.println(reverse6("123"));
}

public static String reverse1(String old) {
    String result = "";
    for (int i = old.length() - 1; i >= 0; i--) {
        result += String.valueOf(old.charAt(i));
    }
    return result;
}

public static String reverse2(String old) {
    String result = "";
    for (int i = 0; i < old.length(); i++) {
        result = old.charAt(i) + result;
    }

    return result;
}

public static String reverse3(String old) {
    String result = "";
    List<string> olds = Arrays.asList(old.split(""));
    Collections.reverse(olds);

    for (String s : olds) {
        result += s;
    }
    return result;
}

public static String reverse4(String old) {
    return new StringBuffer(old).reverse().toString();
    // return new StringBuilder(old).reverse().toString();
}

public static String reverse5(String old) {
    char[] chars = old.toCharArray();

    Stack<character> oldStack = new Stack<character>();
    for (Character c : chars) {
        oldStack.push(c);
    }

    String result = "";

    while (!oldStack.empty()) {
        result += oldStack.pop();
    }

    return result;
}

public static String reverse6(String old) {
    char[] chars = old.toCharArray();
    int n = chars.length - 1;

    for (int i = 0; i <= n / 2; i++) {
        char temp = chars[i];

        chars[i] = chars[n - i];
        chars[n - i] = temp;
    }

    return new String(chars);
}

}

@富士山下

关注

2
点赞
踩
18

收藏

觉得还不错? 一键收藏
1
评论
2019/7/16 Java面试题笔记详解

1．java程序的执行过程中用到一套JDK工具，其中javac.exe指（ B ）【北控三兴笔试题】A．java解释器B．java编译器C．java文档生成器D．java类分析器解析：javac.exe 是编译器。 javadoc.exe 是文档生成器。javap.exe 是反编译器。2.在Java中语句：37.2%10的运算结果为( A)A．7.2 B．7 C．3 D．...
复制链接

扫一扫

专栏目录