java笔试面试第一天

　　好久未曾启用我的博客，最近来上海找工作，想将笔试面试的过程做个记录，毕竟有总结才有提高嘛。今天算是笔试面试正式开始第一天吧，以下就是我的笔试总结（没有原题了，只有知识点）：

笔试题1：java static对象的使用：包括静态方法，静态变量，静态代码块，main方法，构造器，普通成员方法等的执行顺序，以代码的形式展现吧。

public class TestMain {

	static {
		System.out.println("执行静态代码块");
	}

	public TestMain(){
		System.out.println("执行构造方法");
	}

	public static void main(String[] args) {
		System.out.println("执行main方法");
		System.out.println("第一次创建类的实例对象");
		System.out.println("------------------");
		new TestMain();
		System.out.println("第二次创建实例对象");
		System.out.println("------------------");
		new TestMain();
		System.out.println("第三次创建实例对象");
		System.out.println("------------------");
		new TestMain().printHello();

	}

	static {
		System.out.println("执行静态代码块2");
	}

	{
		System.out.println("代码块1");
	}

	{
		System.out.println("代码块2");
	}

	public void printHello(){
		System.out.println("执行普通方法");

		{
			System.out.println("执行普通方法里的代码块");
		}
	}

}

　　以下是控制台打印结果：

总结：

1.类的静态代码块执行顺序先于main方法（不论声明位于main前还是main后），并且在类加载完成期间只执行一次。

2.类的普通代码块（相当于类的实例属性）在new实例的时候执行，并且顺序先于构造器，与普通成员方法一样，只有实例存在才能执行，与普通成员方法不一样的是，不显示调用就被执行。

3.被static修饰的方法叫静态方法，也叫类方法，是类被加载后就被存放于内存里的，并且只存一次（公共方法，静态变量同理），静态方法只能调用静态成员（方法与变量），不能调用非静态成员，是因为非静态成员在没有实例化之前是不存在的！所以同理，静态方法里不能出现this或者super；静态方法可以用：类名.方法名的方式调用，也可以用：对象.方法名的方式调用（不推荐）。

笔试题2：java 中 if ()语句，括号里需要的是boolean类型，if (0)是错误的，if语句后面没有花括号时，紧跟的第一句是判断之后是否执行的语句，与花括号内的语句作用相同。

@Test
	public void testFor(){
		if (false)
			System.out.println("true");
		System.out.println("false");
	}

　　控制台打印：

笔试题3：一般for循环：for (int i = 0; true; i++)，这种方式不会报错，会无限执行。for循环里的变量“i”作用域仅限后面的花括号（或者紧跟的第一条语句）。

笔试题4：变量的作用域问题：Java用一对大括号作为语句块的范围，称为作用域。下面是有成员变量的情况下变量作用域的代码分析：

public class TestScope {
	private String name = "name1";
	private static String num = "1";

	public static void main(String[] args) {

		{
			String name = "name2";
			System.out.println(name); // name2
		} // 作用域失效，所以下面的变量为“name”不会报错。

		String name = "name3";
		System.out.println(name); // name3

		System.out.println(new TestScope().name); // name1

		TestScope ts_1 = new TestScope();
		ts_1.setName("name_mod");
		System.out.println(ts_1.getName()); // name_mod

		System.out.println(new TestScope().name); // name1
		System.out.println(new TestScope().getName()); // name1

		// 静态成员变量--相当于共有变量，类加载后只存一次，即位置固定
		TestScope ts_2 = new TestScope();
		System.out.println(ts_2.getNum()); // 不推荐用对象调用静态成员  1
		ts_2.setNum("2");
		System.out.println(ts_2.getNum()); // 2
		System.out.println(new TestScope().getNum()); //2
	}

	public void setName(String name){
		this.name = name;
	}

	public String getName(){
		return this.name;
	}

	public static String getNum() {
		return num;
	}

	public static void setNum(String num) {
		TestScope.num = num;
	}

}

　　控制台输出结果：

总结：以上代码也可以说明静态变量与普通成员变量的区别。普通成员变量的初始化值不能通过实例化对象的方法修改，因为每次生成一个新的对象，句柄指向的都是复制过来的新的成员变量，而不是指向真正的成员变量。通过反射进行修改。

笔试题5：java 重写问题：重写（Overriding）是子类与父类之间的多态性的体现，子类重写父类方法，要求：方法名、返回类型、参数表相同，访问权限大于等于父类。

注意：java重载（Overloading）是一个类多态性的体现，即同一个方法根据传参不同实现不同功能。要求：方法名相同，参数表（类型或者个数）不同（只能根据这两个条件判断是否重载，返回值与访问权限不能作为区分标准）。

笔试题6：java  equals()方法与"=="的区别："=="如果比较两个基本数据类型的时候，是比较数据值，但对于对象来说，"=="比较的就是对象（地址），equals()方法只能被对象调用来进行比较操作，它也是比较对象（地址），只是某些包装类里的equals()方法被重写了，所以看起来像是可以比较对象的值，比如String类就重写了这个方法，所以可以进行以下比较：

public static void main(String[] args) {

		String s1 = "a";
		String s2 = "a";
		String s3 = new String("a");

		System.out.println(s1 == s2); // true
		System.out.println(s1 == s3); // false
		System.out.println(s1.equals(s3)); // true
	}

　　除了String重写了equals()方法外，大部分能用到的类库里的类都重写了，像Integer，Boolean，Float等包装类，还有Vector,Pair,List,HashMap,Collection,Enum,Set等等，如果自定义类需要用到equals()方法，是需要手动重写的，因为自定义类都继承了Object的类，而Object的equals()方法是没有重写过的，即：只能比较对象的地址，不能比较对象的值（可以看一下API里equals方法的代码）。

这里我也自己写了自定义类重写equals()方法的代码：如果两个对象都是TestString的对象，而且name与num的值都相等，则两个对象相等。

public class TestString {

	private String name;
	private int num;

	/**
	 * 重写equals方法：如果是TestString的对象而且name与num的值都相等则两个对象相等
	 */
	public boolean equals(Object obj){
		// 如果是对象自己与自己比较
		if (this == obj){
			return true;
		}
		// 如果对象为空，直接返回false
		if (obj == null){
			return false;
		}
		// 如果不是该自定义类的对象，直接返回false
		if (!(obj instanceof TestString)){
			return false;
		}
		TestString ts = (TestString) obj;
		return this.num == ts.num && this.name == ts.name  ;
	}

	public static void main(String[] args) {

		TestString ts1 = new TestString();
		ts1.setName("a");
		ts1.setNum(1);

		TestString ts2 = new TestString();
		ts2.setName("a");
		ts2.setNum(1);
		System.out.println(ts1 == ts2); // false
		System.out.println(ts1.equals(ts2)); // true
		System.out.println(ts1.equals(new String("a"))); // false
	}

	public void setName(String name){
		this.name = name;
	}
	public String getName(){
		return this.name;
	}
	public int getNum() {
		return num;
	}
	public void setNum(int num) {
		this.num = num;
	}
}

　　控制台输出：

总结：Object类里边有这几个方法：equals()、hashCode()、

笔试题7：String类创建对象的问题，这个问题说实话很让我头疼，从上学那会就对这个“String创建了几个对象”的问题搞的晕头转向，既然笔试到了，那么是时候来个了断了T_T

@Test
	public void testAdd(){
			String str1 = "a";
			String str2 = "a";
			String str3 = "b";
			String str4 = "ab";
			String str = new String("b");
	        final String str5 = "a";
			final String str6;

			{
				str6 = "a";
			}

			String s1 = "a" + "b"; // 运行时没有生成新的对象，编译过的代码里已经存在 "ab",即str4
			String s2 = str2 + str3; // 运行时生成了新的对象，s2编译过之后不能确定值
			String s3 = str5 + "b"; // 运行时没有生成新对象，str5是常量，所以编译之后是"ab",即str4
			String s4 = str6 + "b"; // 运行时生成了新对象，str6是变量，虽然在代码块里赋了值，但是这条语句编译时还是按变量来算的，只有运行后代码块才被执行

			System.out.println(str1 == str2); // true
			System.out.println(s1 == str4); // true
			System.out.println(s2 == str4); // false
			System.out.println(s3 == str4); // true
			System.out.println(s4 == str4); // false
			System.out.println(str3 == str.intern()); // true intern()方法：手动向常量池中添加常量，如果常量池已存在，直接返回地址
			System.out.println(str1 == str6); //ture 说明只要是在代码里出现的，编译时都会被存进常量池里（已知字面量）。
		}

　　

　　总结：在代码中存在的变量的”赋值“叫“已知字面量”，这些已知字面量在编译后会被存到jvm的常量池中（常量池的问题有待深究），栈里存句柄（引用），堆里存数据，常量池里存常量数据，引用在指向数据的时候会先在常量池中查找，如果有，指向常量池的地址，如果没有从堆里找，这样来思考的话，在用"=="进行比较的时候就知道比较的地址是不是一样了。由于常量池里的数据如果存在就不会再复制，所以可以被多个引用指向，而指向同一个地址的引用 "==" 就是true。（仅仅是本人见解，有错误的地方欢迎指出）。

PS：以上说了半天好像是没有解决到底创建了几个对象的问题【捂脸】，例如：String a = new String("a"); 为什么是创建了两个对象呢？  我理解应该是这样的：字面量"a"，在编译后于常量池创建了对象"a"，然后程序运行后，在堆中又new了一个实例对象，所以是两个对象。

String a  = "a" + "b" + "c" + "d"; 创建了一个对象，网上说法众多，但是我觉得其中一种说的有道理，就是因为它是一行定义的对象，编译时只会初始化一次常量池的数据，所以”abcd“是在常量池一次定义的对象。。。欢迎各路大神前来指导。