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);
    }
}


在这里插入图片描述

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值