Java 面试题代码类收集

        long temp=(int)3.9;
        System.out.println(temp);
        temp%=2;
        System.out.println(temp);

3
1

Java里面类的方法名可以与类名一样，与构造函数的区别是方法有返回值，构造函数没有。

public class UserInfo {

    public UserInfo(){

    }

    public String UserInfo(){
        return "adf";
    }
}

这一点与net的不一样。

携程2015年面试题目：

/**
 * Created by qhong on 2017/2/5.
 */
public class Base
{
    private String baseName = "base";
    public Base()
    {
        callName();
    }

    public void callName()
    {
        System. out. println(baseName);
    }

    static class Sub extends Base
    {
        private String baseName = "sub";
        public void callName()
        {
            System. out. println (baseName) ;
        }
    }
    public static void main(String[] args)
    {
        Base b = new Sub();
    }
}

null

public class Main {
    public static void main(String[] args)   {
        Base b = new Base.Sub();
    }
}

class Base
{
    private String baseName = "base";
    public Base()
    {
        System.out.println("fugou");
        callName();
    }

    public void callName()
    {
        System.out.println("fu");
        System. out. println(baseName);
    }

    static class Sub extends Base
    {
        private String baseName = "sub";
        public void callName()
        {
            System.out.println("zhi");
            System. out. println (baseName) ;
        }
    }

}

fugou
zhi
null

可以发现，父类在初始化的时候调用的callName是子类的，这个时候子类中的变量baseName只是被声明，还未被赋值，所以输出null。

构造器的初始化顺序大概是:父类静态块 ->子类静态块 ->父类初始化语句 ->父类构造函器 ->子类初始化语句-> 子类构造器

4.

public class NULL {

    public static void haha(){
        System.out.println("haha");
    }
    public static void main(String[] args) {
      ((NULL)null).haha();

    }
}

输出为haha，因为null值可以强制转换为任何java类类型,(String)null也是合法的。但null强制转换后是无效对象，其返回值还是为null，而static方法的调用是和类名绑定的，不借助对象进行访问所以能正确输出。

反过来，没有static修饰就只能用对象进行访问，使用null调用对象肯定会报空指针错了。这里和C++很类似。

5.

public class Main {
    public static void main(String[] args)   {
        new HelloB();
    }
}

class HelloA {

    public HelloA() {
        System.out.println("HelloA");
    }

    { System.out.println("I'm A class"); }

    static { System.out.println("static A"); }
}

class HelloB extends HelloA {
    public HelloB() {
        System.out.println("HelloB");
    }

    { System.out.println("I'm B class"); }

    static { System.out.println("static B"); }
}

static A
static B
I'm A class
HelloA
I'm B class
HelloB

这题很好，考查静态语句块、构造语句块（就是只有大括号的那块）以及构造函数的执行顺序。

对象的初始化顺序：

（1）类加载之后，按从上到下（从父类到子类）执行被static修饰的语句；

（2）当static语句执行完之后,再执行main方法；

（3）如果有语句new了自身的对象，将从上到下执行构造代码块、构造器（两者可以说绑定在一起）。

6.

public class Main {
    public static void main(String[] args)   {
        String s;

        System.out.println("s=" + s);
    }
}

开始以为会输出null什么的，运行后才发现Java中所有定义的基本类型或对象都必须初始化才能输出值。

7.

public class Main {
    public static void main(String[] args)   {
        Example ex = new Example();

        ex.change(ex.str, ex.ch);

        System.out.print(ex.str + " and ");

        System.out.print(ex.ch);
    }
}

class Example {

    String str = new String("good");

    char[] ch = { 'a', 'b', 'c' };

    public void change(String str, char ch[]) {

        str = "test ok";

        ch[0] = 'g';
    }
}

good and gbc

值参数指的是实参的地址的拷贝，得到这个拷贝地址后，你可以通过它修改这个地址的内容（引用不变），因为此时这个内容的地址和原地址是同一地址

8.

class People {
    String name;

    public People() {
        System.out.print(1);
    }

    public People(String name) {
        System.out.print(2);
        this.name = name;
    }
}

class Child extends People {
    People father;

    public Child(String name) {
        System.out.print(3);
        this.name = name;
        father = new People(name + ":F");
    }

    public Child() {
        System.out.print(4);
    }

}

132

解析：考察的又是父类与子类的构造函数调用次序。在Java中，子类的构造过程中必须调用其父类的构造函数，是因为有继承关系存在时，子类要把父类的内容继承下来。但如果父类有多个构造函数时，该如何选择调用呢？

第一个规则：子类的构造过程中，必须调用其父类的构造方法。一个类，如果我们不写构造方法，那么编译器会帮我们加上一个默认的构造方法（就是没有参数的构造方法），但是如果你自己写了构造方法，那么编译器就不会给你添加了，所以有时候当你new一个子类对象的时候，肯定调用了子类的构造方法，但是如果在子类构造方法中我们并没有显示的调用基类的构造方法，如：super();  这样就会调用父类没有参数的构造方法。

第二个规则：如果子类的构造方法中既没有显示的调用基类构造方法，而基类中又没有无参的构造方法，则编译出错，所以，通常我们需要显示的：super(参数列表)，来调用父类有参数的构造函数，此时无参的构造函数就不会被调用。

总之，一句话：子类没有显示调用父类构造函数，不管子类构造函数是否带参数都默认调用父类无参的构造函数，若父类没有则编译出错。

9.

class Shape {

       public String name;

}

class Circle extends Shape implements Serializable{

       private float radius;

       transient int color;

       public static String type = "Circle";

}

在序列化一个Circle的对象circle到文件时，下面哪个字段会被保存到文件中？

radius

因为父类Shape没有继承Serializable,所以name不能被序列化。

静态类不管是否有transient修饰，都不能序列化

http://www.cnblogs.com/lanxuezaipiao/p/3369962.html

===============================================

10.String,StringBuilder,StringBuffer

package com.qhong.basic;

public class StringTest {
    public static void main(String[] args) {
        String str1="hello";
        String str2="he"+new String("llo");
        System.err.println(str1==str2);

        //jvm对127及其以下的特殊处理
        Integer i1=;
        Integer i2=;
        System.err.println(i1==i2);

        Integer i3=;
        Integer i4=;
        System.err.println(i3==i4);
    }
}

Output:

false
true
false

http://www.cnblogs.com/dolphin0520/p/3778589.html

11.

http://blog.csdn.net/Two_Water/article/details/53891952