韩顺平 java 第28讲 面试题

下列代码编译后处出现什么问题？

public class Myclass{

    public static void main(String a[]){
        mymethod(a);
    }

    public void mymethod(String[] a){
        System.out.println(a);
        System.out.println(a[1]);
    }
}

a.错误，不能静态引用mymethod方法
b.错误，main方法不正确
c.错误，数组必须包含参数
d.mymethod方法必须声明为static类型

分析：首先，main方法是静态方法，但是mymethod不是静态方法，所以不能直接调用。数组引用的时候可以直接调用数组名。d中的必须太绝对了。可以通过对象来调用的。

---

下列出错的是？

a)
import java.awt.*;
package MyPackage;
class MyClass{}

b)
package MyPackage;
import java.awt.*;
class MyClass{}

c)
/*this is a comment*/
package MyPackage;
import java.awt.*;
class MyClass{}
d)

分析：a会出错，打包命令得在最前面

---

byte类型的大小是？

-128~127

---

boolean a = null;是错误的

因为只能给个true或者false

---

下列代码在输入下面的命令后会输出什么内容？

命令行：java myproj good morning
代码：

public class myproj{
    public static void main(String a[]){
        System.out.println(a[2]);
    }
}

分析：会报错！因为只有两个参数

---

goto、then都是java的关键字。（×）

then不是，goto是。但是goto一般不会用到。

---

下列哪些是合法的标识符？

a)2v
b)v2
c)_v
d)_3_
e)$v
f)#v

必须是字母、下划线、$开头，可以包含数字、字母、下划线、$

---

试图编译以下代码会出现什么情况？

public class Sort {
    static int i ;
    public static void main(String [] args){
        System.out.println(i);

    }
}

静态变量不给初值也行，初值默认是0，所以输出0

---

试图编译以下代码会出现什么情况？

public class Sort {
    public static void main(String [] args){
        int a[] = new int[]{1,2,3};
        System.out.print(a[1]);
    }
}

会输出2.记住这样赋值也是正确的。其实也等价于：int a[] ={1,2,3};

试图编译以下代码会出现什么情况？

public class Sort {
    public static void main(String [] args){
        int a[] = new int[5];
        System.out.print(a[1]);
    }
}

会输出0，默认是0，但是不建议这么做。

---

下列程序运行后会怎样？

public class MyClass extends a {
    public static void main(String [] args){
        System.out.println("OK");
    }

}

abstract class a{
    abstract void method();
} 

会报错的，解决方法就是：将MyClass 中继承的抽象方法实现；或者将MyClass声明为手抽象方法，也就是：public abstract class MyClass extends a……

---

运行下列程序会输出什么？

        switch (9) {
        case 1:
            System.out.println("1");
        case 2:
        case 9:
            System.out.println("9");
        default:

        }

default后面可以不跟任何东西，case也一样

        switch (9) {
        default:
            System.out.println("default");
        case 1:
            System.out.println("1");
        case 2:
            System.out.println("2");
        case 3:
            System.out.println("3");

        }

这个全部都会出输出！

        switch (9) {
        default:
            System.out.println("default");
        case 1:
            System.out.println("1");
        case 2:
            System.out.println("2");
        case 9:
            System.out.println("9");

        }

这个只会输出9

---

下列代码编译后有错误吗？

if(1){
}

错误！必须是布尔值！（此处与C语言不同）

        int i,j;
        System.out.println(i);

错误，这个必须初始化才能用。静态变量和数组可以不初始化。

        int i=1,j=1;
        if (i == 0 && j == 1) {

        }

正确！两个布尔值在与是可以的

        int i=1,j=1;
        if (i == 0 & j == 1) {

        }

正确！两个布尔值按位与也是可以的！布尔值与后还是布尔值

---

#### 如果在当前目录下不存在a.txt文件，试图编译和运行下面的代码会输出什么？

public class MyClass {
    public static void main(String [] args){
        MyClass m = new MyClass();
        System.out.println(m.method());

    }
    public int method(){
        try {
            FileInputStream dis = new FileInputStream("a.txt");
        } catch (Exception e) {
            System.out.println("No file");
            return -1;
        }finally{
            System.out.println("Doing finally");
        }
        return 0;
    }

}

分析，很明显要先输出No file，然后执行return 语句，此时若直接退出，就违背了finally中的语句一定会被执行的原则，所以这里的return语句先保留一个断点，然后就执行finally中的语句，最后再接着执行return语句。
输出内容是：
No file
Doing finally
-1
假如，返回的值可以改变，也就是修改程序如下：

public class MyClass {
    public static void main(String [] args){
        MyClass m = new MyClass();
        System.out.println(m.method());

    }

    int i = 0;
    public int method(){
        try {
            FileInputStream dis = new FileInputStream("a.txt");
        } catch (Exception e) {
            System.out.println("No file");
            return i;
        }finally{
            i++;
            System.out.println("Doing finally");
        }
        return 11;
    }

}

此时函数的返回值还是0，虽然i已经成了1了。也就是返回的时候已经确定了返回值，之后再改变已经无济于事了。
假如，再次修改程序，在finally中加一个return语句，如下：

public class MyClass {
    public static void main(String [] args){
        MyClass m = new MyClass();
        System.out.println(m.method());

    }

    int i = 0;
    public int method(){
        try {
            FileInputStream dis = new FileInputStream("a.txt");
        } catch (Exception e) {
            System.out.println("No file");
            return i;
        }finally{
            i++;
            System.out.println("Doing finally");
            return i;
        }
        //return 11;
    }

}

此时，最后的return 语句要注释掉，不然就出现了多个return。这时候就会返回1了。此时返回的就是finally中的值了。

---

在下列的注释处插入哪些部分代码是合法的？

class Base{
    public void method (int i){}
}

public class MyClass {
    public static void main(String [] args){

    }
    //注释
}

1 void method (int i) throws Exception{}
2 void method (long i) throws Exception{}
3 void method (long i)
4 public method (int i) throws Exception{}

首先，每个方法后的throws Exception其实是在迷糊人，这个没有什么影响。
1中，显然是想覆盖，但是子类方法不能缩小父类方法的访问权限。
2中，数据类型不一样，这是重载。
3中，同2，也是可以的。
4中，抛出异常了，这是不可的。

---

下列分别输出什么？

        System.out.println(Math.floor(-4.7));
        System.out.println(Math.round(-4.7));
        System.out.println(Math.ceil(-4.7));

        String s = new String ("Bycicle");
        System.out.println(s.substring(2, 4));

输出：
-5.0
-5
-4.0
ci

---

== 和 equals()

java虚拟机中的内存，分为三块：栈区、堆区、代码区（也包括数据区，比如静态变量）
当new一个对象的时候：Cat c=new Cat()；cat这个引用是放在栈区的，但是cat这个对象实际上是在堆区存着。
当int a = 1；那么a的引用和存储都在栈区存着。普通变量都是这样。
想想这样一个问题，当一个类中存在一个静态变量的时候，这时候，不管你new不new对象，这个静态变量都是存在的，这个静态变量和类的信息就存在代码区中。
其实代码区就是指挥中心，堆区和栈区就是存储数据的，根据数据类型不一样来分别存放。
当String s1 = “abc”;这时候，会在堆区中有个字符池。（因为字符的拼接相当频繁，所以创建了个这么个东西。）s1就指向“abc”；当再次执行：String s2 = “abc”；这时候s1和s2的地址是一样的。
==比较的是地址，

        String s1 = "abc";
        String s2 = "abc";
        String s3 = new String("abc");
        String s4 = new String("abc");
        String s = "ab" ;
        String s5 = s + "c";
        String s6 = "ab" + "c";
        System.out.println(s1 == s2);//地址一样，true
        System.out.println(s1 == s3);//地址不一样，false
        System.out.println(s3 == s4);//地址不一样，属于不同对象，false
        System.out.println(s1 == s5);//地址不一样了，false
        System.out.println(s1 == s6);//赋值的一瞬间，这个地址还是一样。

        System.out.println(s1.equals(s2));//true，内容一样
        System.out.println(s1.equals(s3));//true，内容一样
        System.out.println(s3.equals(s4));//true，内容一样
        System.out.println(s1.equals(s5));//true，内容一样
        System.out.println(s1.equals(s6));//true，内容一样

---

给出下列代码，怎样调用构造方法会出输出OK？

public class MyClass extends a {
    public static void main(String [] args){
        MyClass m = new MyClass();
        //one
    }
    public MyClass() {
        //two
    }
}

class a{
    a(int i){
        System.out.println("OK");
    }
    a(){
        System.out.println("NO");
    }
    aa(){
        //three
    }
} 

a)在one后放a(10)；
b)在one后放super(10);
c)在two后放super（10）；
d）three后放super（10）；

分析，a中，完全没有意义。
b中，super方法一般放在构造方法中。如果希望在子类中调用父类的构造方法，就要求在子类的构造方法中调用super（）。括号中为父类的构造方法的参数列表。
c正确
d则不行了