java面试笔试题基础笔记1

girhub上看到的某人的博客，学习java基础的题

http://blog.csdn.net/lanxuezaipiao/article/details/16753743

做个笔记

1、String基础，结果是

false

true

package test;
public class TestMain {
    public static void main(String[] args) {
        String str1 = "hello";
        String str2 = "he" + new String("llo");
        System.out.println(str1 == str2); 
        System.out.println(str1.equals(str2)); 
    }
}

2、守护线程概念：

jvm里有种线程叫做守护线程，比如垃圾回收gc就是一个守护线程

只要jvm中有任何一个非守护线程没有停止，守护线程就全部工作，

当jvm中没有非守护线程在工作时，守护线程随着jvm一起停止工作。

3、volatile关键字不能保证线程安全，因为它的操作不是原子的，它能保证从内存中读取的数据是

同步的，即能保证读取的可见性，不能保证写操作时安全性。所以它被称为synchronized的轻量级实现

4、0.2234变量是double类型，float类型0.2234f

5、字节流字符流

以inputStream outputStream为后缀的是字节流

以Reader writer为后缀的为字符流

6、java创建对象的几种方式:

1.运用new语句创建对象

2.利用反射手段

3.调用对象的clone方法

4.运用反序列化手段，调用objectInputStream对象的readObject()方法

7、构造语句块，静态代码块，构造函数的执行顺序

package test;
public class HelloA {
    public HelloA() {
        System.out.println("HelloA");
    }
    { System.out.println("I'm A class"); }
    static { System.out.println("static A"); }
}

package test;
public class HelloB extends HelloA {
    //构造函数
    public HelloB() {
        System.out.println("HelloB");
    }
    //类的代码块
    { System.out.println("I'm B class"); }
    //类的静态代码块
    static { System.out.println("static B"); }
    
    public static void main(String[] args) { 
        HelloB sss= new HelloB();
    }
}

代码的输出结果：

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

结论：

（1）类加载之后，按从上到下（从父类到子类）执行被static修饰的语句；（2）当static语句执行完之后,再执行main方法；（3）如果有语句new了自身的对象，将从上到下执行构造代码块、构造器（两者可以说绑定在一起）。

8、catch语句块，当捕获的异常有集成关系是，把父类异常放在最后面。

9、java经典的传值传引用问题：例子：

package test;

//还是不是很懂，结论：
//不管是对象、基本类型还是对象数组、基本类型数组，
//在函数中都不能改变其实际地址但能改变其中的内容
public class Example {  
    String str = new String("good");  
    char[] ch = { 'a', 'b', 'c' };  
    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);  
    }  
    public void change(String str, char ch[]) {  
        str = "test ok";  
        ch[0] = 'g';  
    }  
}

输出结果：good and gbc

结论是：不管是对象、基本类型还是数组、基本类型的数组，在函数中都不能改变其实际地址，但能改变其中的内容。（好吧，依旧很迷惑）

10、switch case语句控制语法：

1.default就是如果没有符合的case就执行它,default并不是必须的. 
2.case后的语句可以不用大括号. 
3.switch语句的判断条件可以接受int,byte,char,short,不能接受其他类型. 
4.一旦case匹配,就会顺序执行后面的程序代码,而不管后面的case是否匹配,直到遇见break,利用这一特性可以让好几个case执行统一语句. 
例子：（1）

int year=2005; 
int month=3; 
int day; 
switch(month) 
{ 
   case 1: 
   case 3: 
   case 5: 
   case 7: 
   case 8: 
   case 10: 
   case 12: 
         day=31; 
         break; 
   case 2: 
         day=28; 
         break; 
   case 4: 
   case 6: 
   case 9: 
   case 11: 
          day=30; 
          break; 
} 
这里 day=31; 
（2）
int i=1; 
switch(i) 
{ 
   case 1: 
       System.out.println(1); 
    default: 
       System.out.println("default"); 
   case 2: 
       System.out.println(2); 
       break; 
   case 3: 
       System.out.println(3); 
       break; 
} 
输出结果: 
         1 
         default 
         2

11、子类和父类构造函数的执行顺序问题：

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

package test;

public 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);
    }
    
    public static void main(String[] args){
        new Child("mike");
    }
}

输出结果：

132

结论：子类调用构造方法是，如果不显示的调用父类的构造函数super，就会先调用父类的无参构造函数，若父类没有无参构造函数，则报错。

然后再调用自己的构造函数。

一个class可以有1个以上的构造函数，默认没写 的话是有一个无参的构造函数。