java程序员面试笔试宝典-4.3关键字

4.3.1变量命名有哪些规则？

1. java规定标识符只能是字母，数字，下划线_，和$组成，并且标识符的第一个字符不能是数字。
2. 此外标识符也不能包含空白字符（换行，空格和制表符）
3. java中变量名区分大小写。

4.3.2break,continue,以及return有什么区别？

1. break:用于直接强行跳出当前循环，内层循环。
2. continue:用于停止当次循环，回到循环起始处，进入下一次循环操作。
3. return语句是一个跳转语句，用来标识从一个方法返回。

如何跳出多层循环：在多重循环的外面定义一个标识

package cn.itcast.demo;

public class test {
	public static void main(String[] args) {
		//在多重循环的外面定义一个标识
		out:
		for (int i = 0; i < 5; i++) {
			for (int j = 0; j < 5; j++) {
				if(j >= 2){
					break out;
				}
				System.out.println(j);
			}
		}
		System.out.println("break");
	}
}

引申：java语言中是否存在goto关键字？

虽然关键字goto作为java的 保留字，但目前并没有在java中使用。

4.3.3final,finally和finalize有什么区别？

1. final:用于声明属性,方法和变量，分别标识属性不可变，方法不可覆盖，类不可被继承。

问题:
final属性，被final修饰的变量不可变，那是引用不可变呢还是对象不可变呢？

package cn.itcast.demo;

public class Test1 {
	public static void main(String[] args) {
		final StringBuffer s = new StringBuffer("Hello");
		s.append(" world");
		System.out.println(s);
	}
}

package cn.itcast.demo;

public class Test1 {
	public static void main(String[] args) {
		final StringBuffer s = new StringBuffer(" Hello");
		s = new StringBuffer("Hello wold");//xxxx编译期间错误
	}
}

结论：final指的是引用不可变，即它只能指向初始时指向的那个对象，而不关心对象内容的变化。所以，被final修饰的变量必须被初始化。
注意：一个类不能即被声明为abstract,又被声明为final

2. finally作为异常处理的一部分，只能用在try/catch语句中，并且附带一个语句块，标识这段语句最终一定会被执行，经常用在需要释放资源的情况下。

例1：
    Connection conn;
    Statement stat;
    try{
        conn = DriverManager.getConnection(url1,userName,password);
        stat = conn.createStatement();
        stat.executeUpdate(update);//执行一条update语句，此时出现异常
        stat.close();
        conn.close();
    }catch(Execption e){

    }

如果程序运行过程中没有发生异常，那么数据库的连接能够得到释放，程序运行没有问题。
如果执行update语句时出现异常，后面的close()方法将不会被执行，数据库的连接不会被释放。如果这样的程序长期运行，将会耗光数据库的连接资源。
通过使用finally可以保证在任何情况下数据库的连接资源都能够被释放。

例2：
    Connection conn;
    Statement stat;
    try{
        conn = DriverManager.getConnection(url1,userName,password);
        stat = conn.createStatement();
        stat.executeUpdate(update);//执行一条update语句，此时出现异常
        stat.close();
        conn.close();
    }catch(Execption e){

    }finally{
        if(stat!=null){
            stat.close();
        }
        if(conn!null){
            conn.close();
        }
    }

3. finalize是Object类的一个方法，在垃圾回收器执行时会调用回收对象的finalize()方法。

注意：
一旦垃圾回收器准备好释放对象占用的空间，将首先调用其finalize方法，并且在下一次垃圾回收动作发生时，才会真正回收对象占用的空间。

jdk中哪些类是不能继承的？
用final关键字修饰的类，如String,StringBuffer等。

4.3.4assert有什么作用？

断言（assert）是一种软件调试的方法。
主要作用：对一个boolean表达式进行检查，一个正确运行的程序必须保证boolean表达式的值为true,若boolean表达式的值为false,说明程序已经处于不正常状态，系统需要提供警告信息并退出程序。

assert的两种表达式：

1)assert expression1:
2)assert expression1:expression2
其中expression1表达一个boolean表达式，expression2标识一个基本类型或者一个对象。

public class Test{

    public static void main(String[] args) {
        assert 1+1 ==2;
        System.out.println("assert1 ok");
        assert 1+2 ==3:"assert faild,exit";
        System.out.println("assert2 ok");
    }
}

当执行指令：javac Test.Java和java -ea Test（打开ea开环）时，输出结果：
assert1 ok
Execption in thread “main” Java.lang.AssertionError:assert faild,exit at Test.main(Test.Java:5)

assert的应用范围：

1）检查控制流
2）检查输入参数是否有效
3）检查函数结果是否有效
检查程序不变量。

4.3.5static关键字有哪些作用？

java语言中，static主要有四种使用情况：成员变量，成员方法，代码块和内部类

static成员变量

java中没有全局的概念，但是可以通过static达到全局的效果
对静态变量的引用有两种方法：类.静态变量；对象.静态变量
java语言中不能在方法体中定义static变量。

package cn.itcast.demo;

public class TestAtribute {
	public static int staticInt = 0;
	public int nonStaticInt = 0;
	public static void main(String[] args) {
		TestAtribute t = new TestAtribute();
		System.out.println("t.staticInt=" + t.staticInt);
		System.out.println("TestAtribute.staticInt=" + TestAtribute.staticInt);
		System.out.println("t.nonStaticInt=" + t.nonStaticInt);
		System.out.println("对静态变量和实例变量分别+1");
		t.staticInt++;
		t.nonStaticInt++;
		TestAtribute t1 = new TestAtribute();
		System.out.println("t1.staticInt=" + t1.staticInt);
		System.out.println("TestAtribute.staticInt=" + TestAtribute.staticInt);
		System.out.println("t1.nonStaticInt=" + t1.nonStaticInt);
	}

}

static成员方法：

static方法中不能使用this和super关键字，不能调用非static方法，只能访问所属类的静态成员变量和成员方法。
static一个很重要的用途是实现单例模式，只有一个实例。
为了实现这一功能，必须隐藏类的构造函数，即把类的构造函数声明为private,并提供一个创建对象的方法。
由于构造对象被声明为private,外界无法直接创建这个类型的对象，只能通过该类提供的方法来获取类的对象，
要达到这样的目的，只能把创建对象的方法声明为static,程序示例如下：

package cn.itcast.demo;

public class Singleton {
	private static Singleton instance = null;
	private Singleton(){}
	public static Singleton getInstance(){
		if(instance == null){
			instance = new Singleton();
		}
		return instance;
	}
}

static代码块

static静态代码块经常被用来初始化静态变量。

package cn.itcast.demo;

public class Test3 {
	private static int a;
	static{
		Test3.a=4;
		System.out.println(a);
		System.out.println("static block is called");
	}
	public static void main(String[] args) {
		
	}
}

static内部类

注意：只有内部类才能被定义为static

Java里面static一般用来修饰成员变量或函数。但有一种特殊用法是用static修饰内部类，普通类是不允许声明为静态的，只有内部类才可以。被static修饰的内部类可以直接作为一个普通类来使用，而不需实例一个外部类（见如下代码）

主要是比较 静态内部类 和 非静态内部类 的区别 代码走起

测试静态内部类

package cn.itcast.demo1;

public class OuterClass {
	//静态内部类
	public static class InnerClass{
		InnerClass(){  
	        System.out.println("============= 我是一个内部类'InnerClass' =============");  
	    }  
	}
}

package cn.itcast.demo1;
//测试静态内部类
public class TestStaticClass {

	public static void main(String[] args) {
		// 不需要new一个OutClass  
        new OuterClass.InnerClass(); 
	}

}

如果没有用static修饰InterClass，则只能按如下方式调用

package cn.itcast.demo2;

public class OuterClass {
	//内部类
	public class InnerClass{
		InnerClass(){  
	        System.out.println("============= 我是一个内部类'InnerClass' =============");  
	    }  
	}
}

package cn.itcast.demo2;
//测试静态内部类
public class TestNoStaticClass {

	public static void main(String[] args) {
		 // OutClass需要先生成一个实例  
        OuterClass oc = new OuterClass();  
        oc.new InnerClass();  
	}

}

静态内部类和非静态内部类之间到底有什么不同呢？下面是两者间主要的不同。

（1）内部静态类不需要有指向外部类的引用。但非静态内部类需要持有对外部类的引用。(这一点上面的代码已经表示了)

（2）非静态内部类能够访问外部类的静态和非静态成员。静态类不能访问外部类的非静态成员。他只能访问外部类的静态成员。（这是两种内部类对于内部类的外嵌类的数据访问区别）

（3）一个非静态内部类不能脱离外部类实体被创建（这个跟第一点有些重复，个人感觉），一个非静态内部类可以访问外部类的数据和方法，因为它就在外部类里面。（这个跟第二点也有点重复）

package cn.itcast.demo1;

public class OuterClass {
	private static String msg = "GeeksForGeeks";
	//静态内部类
	public static class InnerClass{
		//静态内部类只能访问外部类的静态成员
		InnerClass(){  
			//试着将msg改成非静态的，这将导致编译错误
	        System.out.println("============= 我是一个静态内部类'InnerClass' =============" + msg);  
	    }  
	}
}

package cn.itcast.demo1;
//测试静态内部类
public class TestStaticClass {

	public static void main(String[] args) {
		// 不需要new一个OutClass  
        new OuterClass.InnerClass(); 
	}

}

试着将msg改成非静态的，这将导致编译错误

package cn.itcast.demo2;

public class OuterClass {
	private static String msg = "GeeksForGeeks";
	private String msg1 = "非静态变量";
	//非静态内部类
	public class InnerClass{
		//不管是静态方法还是非静态方法都可以在非静态内部类中访问
		InnerClass(){  
	        System.out.println("============= 我是一个非静态内部类'InnerClass' =============" + msg
	        					+ "\t" + msg1);  
	    }  
	}
}

package cn.itcast.demo2;
//测试静态内部类
public class TestNoStaticClass {

	public static void main(String[] args) {
		 // OutClass需要先生成一个实例  
        OuterClass oc = new OuterClass();  
        oc.new InnerClass();  
	}

}

引申：

1）什么是实例变量，局部变量，类变量，final变量？

实例变量如果没有显示初始化，则会有一个默认值
局部变量：在方法中定义的变量，在使用前必须初始化
final变量：标识这个变量为常量，不能被修改

2)static和final结合使用表示什么意思？

对于变量，表示一旦赋值不可修改
对于方法，表示不可覆盖

常见笔试题

package cn.itcast.demo3;

public class Test {
	static final int i = 0;
	public static int testStatic(){
		//在java语言中,不能再成员函数内部定义static变量
		//static final int i = 0;
		//System.out.println(i++);//i++错误
		System.out.println(i);
		return 0;
	}
	public static void main(String[] args) {
//		Test test = new Test();
		Test.testStatic();
	}
}

4.3.6使用switch时有哪些注意事项？

switch语句用于多分枝选择，switch(expr)，expr必须是int或能够被隐式转换为int的byte,short,和char类型，
但是long,float,double,String类型除非强制转换，否则会直接报错
例1

public class Test{

    public static void main(String[] args) {
        float a = 0.123f;
        switch (a) {//xxxx编译错误，a不是整型或字符类型变量。
        case 1:

            break;

        default:
            break;
        }
    }
}

switch对应的是case语句：case之后可以是直接的常量数值，1，2，
也可以是常量计算时1+2；
还可以是final型的变量，final int a = 0;
但不能是变量或者带有变量的表达式，例如i*2
更不能是浮点整数1.1或者2.0等。

switch(fromWay){
	case 2-1://正确
				....
	case a-2：//错误
				.....
	case 2.0：//错误
				.....
}

随着java的发展，switch支持String类型了

package cn.itcast.demo3;

public class TestString {
	public void test(String str){
		switch (str) {
		case "hehao":
			System.out.println("hehao");
			break;
			
		case "hehao1":
			System.out.println("hehao1");
			break;
			
		case "hehao2":
			System.out.println("hehao2");
			break;
			
		default:
			System.out.println("default");
			break;
		}
	}
	public static void main(String[] args) {
		TestString t = new TestString();
		t.test("hehao");
	}
}

本质上来讲，switch对字符串的支持，其实是int类型值的匹配。实现原理如下：
通过对case后面的string对象调用hashCode()方法，得到一个Int类型的hashCode值，然后用这个hash值来唯一标识这个case.
当匹配时，首先调用这个字符串的hashCode函数，获取一个hash值，匹配所有的case;如果匹配成功，接着会调用字符串的String.equals方法进行匹配。
所有String不能为null，case语句中的str也不能为null.
注意：
1）必须在case语句后添加break语句，否则会顺序执行。

package cn.itcast.demo3;

public class TestNobreak {
	public static void main(String[] args) {
		int x = 4;
		switch (x) {
			case 1:System.out.println(x);
			case 2:System.out.println(x);
			case 3:System.out.println(x);
			case 4:System.out.println(x);
			case 5:System.out.println(x);
			default:System.out.println(x);
		}
	}
}

4.3.7volatile有什么作用？

java语言中，有时为了提高程序的运行效率，编译器会自动对其进行优化，把经常被访问的变量缓存起来，程序在读取这个变量的时候可能直接从缓存中读取。
问题：多线程编程时候，变量的值可能因为别的线程而改变了，而该缓存的值不会相应改变，造成程序读取的值与实际的值不符。
volatile是一个类型修饰符，被设计用来修饰被不同线程访问和修饰的变量。被volatile类型定义的变量，系统每次使用的时候都是直接从对应的内存中提取，而不会利用缓存。

public class MyThread {
    private volatile Boolean flag;
    public void stop(){
        flag = false;
    }

    public void run(){
        while(flag)
            ;//do something
    }
}

以上示例代码是用来停止线程最常用的一种方法，
如果boolean类型的变量flag没有被声明为volatile,那么run方法判断flag可能使用的是缓存中的值，不能及时获取其他线程对flag的操作，导致线程不能及时地停止。

注意：

1)由于volatile不能保证操作的原子性，因此一般情况下不能使用volatile代替sychronized.
2)会阻止编译器对代码的优化，降低执行效率

4.3.8 instanceof 有什么作用？

判断左边的对象是否是右边对象的实例，返回boolean类型的数据

package cn.itcast.demo3;

public class Test1 {
	public static void main(String[] args) {
		String s = "Hello";
		int[] a = {1,2};
		if(s instanceof String){
			System.out.println("true");
		}
		if(s instanceof Object){			
			System.out.println("true");
		}
		if(a instanceof int[]){
			System.out.println("true");		
		}
	}
}

4.3.9 strictfp有什么作用？

精确浮点：用来确保浮点数运算的准确性。
jvm在执行浮点数运算时，计算结果在不同平台或者厂商的虚拟机上可能有不同的结果，导致错误。
用strictfp来声明一个类，接口或方法，在所声明的范围内，标准是固定的。
注意：
1）当一个类被strictfp修饰时，所有方法都会自动被strictfp修饰。

package cn.itcast.demo3;

public strictfp class Test2{
    public static void main(String[] args) {
        float f = 0.12365f;
        double d = 0.03496421d;
        double sun = f+d;
        System.out.println(sun);
    }
}