Java学习之路----关键字总结

Java中的关键字总结

java中常见的关键字有transient，instanceof，volatile，synchronized，final
，static等，下面将逐一介绍上面提及的6个关键字。

transient关键字

transient关键字用在对象的序列化中，对象的序列化是将对象按照一定的规则转换特定序列的字节，这样就可以在网络中传输这些字节，那么就能够在新的机器上重新创建此对象，从而实现对象的传输。可是在对象序列化的时候，希望某些成员变量不被序列化，那么transient就派上用场了，它的作用就是修饰成员变量，一旦成员变量被transient修饰时，那么在序列化对象时就会忽略被transient修饰的变量。注意：transient不能修饰方法和类，下面是例子：

package learnJava;

import java.io.Serializable;

public class User  implements Serializable{
	private transient String name;
	private int age;
	
	public User(String n, int age) {
		this.name = n;
		this.age = age;
	}
	
	public String getName() {
		return this.name;
	}
	
	public int getAge() {
		return this.age;
	}
	
	public void setName(String name) {
		this.name = name;
	}
	
	public void setAge(int age) {
		this.age = age;
	}
	
	public String toString() {
		return "User" + "{name: " + this.name + ", " + "age: " + this.age + "}";
 	}
}

测试代码：

package learnJava;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class SerializableDemo{
	public static void main(String[] args) {
		User user = new User("小明", 10);
		System.out.println(user);
		ObjectOutputStream oos = null;
		try {
			oos = new ObjectOutputStream(new FileOutputStream("tempFile"));
			oos.writeObject(user);
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				oos.close();
			} catch (Exception e){
				e.printStackTrace();
			}
		}
		
		File file = new File("tempFile");
		ObjectInputStream ois= null;
		try {
			ois = new ObjectInputStream(new FileInputStream(file));
			User user1 = (User) ois.readObject();
			System.out.println(user1);
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} finally {
			try {
				ois.close();
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
		
	}
}

结果为：上面的为对象在内存的状态，下面为反序列化的结果

从结果可以看到，在User类中将name字段加上了transient修饰后，可以看到name字段并没有被持久化，故反序列化后值为默认值。

instanceof关键字

instanceof是一个二元运算符，( Object reference variable ) instanceof (class/interface type) 左边是对象，右边是类，用来判断一个对象是不是类的实例，若是的话，那么就会返回真，否则返回假。null不是所有的类的实例

public class A {}
public class B {}
public interface C {}
public class D extends A, implements  C {}

public class TestClass {
	public static void main(String args[]) {
		D d = new D();
		if ( d instanceof D)  //true, 因为d确实是D的实例
			System.out.println("d is D");
		if ( d instanceof C) { //true， 因为d是D的实例，且D实现了C
			System.out.println("d implements C");
		}
		if (d instanceof B) //false  D跟B不是继承关系，故d不是B的实例
			System.out.println("d is B"):
		}
	}
}

volatile关键字

volatile英语含义上是易变性的，用来标记一个变量是易变的，其作用是让CPU读取或者写此变量时是从主存中读取的，而不是从缓存中读取或者写入。那么什么时候会用到呢？现代计算中大多数都有多个CPU，每个CPU都有一个缓存，如果直接从缓存中取，那么在多线程模型中就容易产生数据不一致性的问题，故利用此关键字可以解决数据不一致的问题，但相应地会增加访问时间，毕竟从缓存中读取数据和从内存中读取还是相差很多个数量级地。

final关键字

final从字面理解表示最后，它的作用就表示所修饰的东西不能再改变了。根据它修饰的对象可以分为修饰变量，修饰方法，修饰类。其中修饰变量的的时候可以分为修饰基本类型变量和对象变量，当修饰基本类型变量时，对应的值是不能改变的，当修饰对象变量的时候，那么对象变量不能改变引用的对象，也就是不能改成引用其他对象，但是引用对象的内容是可以改变的。当修饰一个方法时，那么就表明此方法不能够重写，当修饰一个类时就表明此类不能够被继承。特别注意的是，当修饰一个变量时，由于其不能改变，相当于常量，故必须初始化，要么在定义时就初始化，要么在初始化块或者静态块中初始化。

static关键字

这个关键字大家都比较熟悉，可以修饰成员/变量和成员方法,以及块和类，它们的作用都是表明成员变量和方法是属于类的，独立于对象，当一个变量被声明为static,那么它只会被类创建一次，然后被所有的对象共享，例如当要统计一个类有多个实例对象时，就可以通过静态变量来记录。注意的是当一个方法被修饰为静态时，那么是不能重写的，因为重写是动态绑定，而静态函数在编译时就已经绑定好了