transient关键字作用,java全部关键字及其每个用法解释
transient关键字作用,java全部关键字及其每个用法解释详细介绍
本文目录一览： transient在java中的有什么作用？
java 的transient关键字的作用是需要实现Serilizable接口，将不需要序列化的属性前添加关键字transient，序列化对象的时候，这个属性就不会序列化到指定的目的地中。\x0d\x0a transient使用小结\x0d\x0a1）一旦变量被transient修饰，变量将不再是对象持久化的一部分，该变量内容在序列化后无法获得访问。\x0d\x0a2）transient关键字只能修饰变量，而不能修饰方法和类。注意，本地变量是不能被transient关键字修饰的。变量如果是用户自定义类变量，则该类需要实现Serializable接口。\x0d\x0a3）被transient关键字修饰的变量不再能被序列化，一个静态变量不管是否被transient修饰，均不能被序列化。
transient在java中的作用
你好，这个关键字的意思主要是用于在序列化中会不序列化（也就是所谓的忽视）你用这个关键字修饰的属性。这个应用在以前直接用关键字声明变量的情况，可以运用在返回json数据的情况，返回需要的指定的json数据。希望能帮到你。
java有个特点就是序列化，简单地来说就是可以将这个类存储在物理空间（当然还是以文件的形式存在），那么当你从本地还原这个文件时，你可以将它转换为它本身。这可以极大地方便网络上的一些操作，但同时，因为涉及到安全问题，所以并不希望把类里面所有的东西都能存储（因为那样，别人可以通过序列化知道类里面的内容），那么我们就可以用上transient这个关键字，它的意思是临时的，即不会随类一起序列化到本地，所以当还原后，这个关键字定义的变量也就不再存在。
通常,我们写的程序都要求特定信息能持久存在或保存到磁盘上,以供一个程序使用或用在同一个程序的另一次运行上.这种持久性可以通过几种方式来实现,包括写到数据库中或是利用JAVA为对象序列化提供的支持.不管我们选用什么方法,类实例的持久性都是通过保存类的域的状态来完成的,保存这些状态,以便以后可以对它们进行访问或使用它们来创建相同的实例.然而,有可能并不是所有的域都需要被保存起来.当一个实例被持久化时,其内部的一些域却不需要持久化,则可以用trainsient修饰符告诉编译器指定的域不需要被持久保存.
首先，让我们看一些Java serialization的代码：
public class LoggingInfo implements java.io.Serializable { private Date loggingDate = new Date(); private String uid; private transient String pwd; LoggingInfo(String user, String password){ uid = user; pwd = password; } public String toString(){ String password=null; if(pwd == null){ password = "NOT SET"; }else{ password = pwd; } return "logon info: \n " + "user: " + uid + "\n logging date : " + loggingDate.toString() + "\n password: " + password; } }现在我们创建一个这个类的实例，并且串行化(serialize)它 ,然后将这个串行化对象写入磁盘。
LoggingInfo logInfo = new LoggingInfo("MIKE", "MECHANICS"); System.out.println(logInfo.toString()); try{ ObjectOutputStream o = new ObjectOutputStream( new FileOutputStream("logInfo.out")); o.writeObject(logInfo); o.close(); }catch(Exception e) {//deal with exception} To read the object back, we can write try { ObjectInputStream in =new ObjectInputStream( new FileInputStream("logInfo.out")); LoggingInfo logInfo = (LoggingInfo)in.readObject(); System.out.println(logInfo.toString()); } catch(Exception e) {//deal with exception} 如果我们运行这段代码，我们会注意到从磁盘中读回(read——back (de-serializing))的对象打印password为"NOT SET"。这是当我们定义pwd域为transient时，所期望的正确结果。 现在，让我们来看一下粗心对待transient域可能引起的潜在问题。假设我们修改了类定义，提供给transient域一个默认值， 代码如下：
public class GuestLoggingInfo implements java.io.Serializable { private Date loggingDate = new Date(); private String uid; private transient String pwd; GuestLoggingInfo(){ uid = "guest"; pwd = "guest"; } public String toString() { //same as above } } 现在，如果我们穿行化GuestLoggingInfo的一个实例，将它写入磁盘，并且再将它从磁盘中读出，我们仍然看到读回的对象打印password 为 "NOT SET"。 当从磁盘中读出某个类的实例时，实际上并不会执行这个类的构造函数， 而是载入了一个该类对象的持久化状态，并将这个状态赋值给该类的另一个对象。
java 序列化怎么标记为不可序列化的字段？
通过在属性前加上transient关键字，可以指定java序列化是无须理会该属性值。如这里的o对象，可以将无需序列化的字段属性前加上transient即可。假设有个age属性，
则：private transient int age;
在你不要的字段加上修饰符transient
java序列化中如果要标记为不可序列化的字段，可以使用关键字：tranisant修饰。
Java的serialization提供了一种持久化对象实例的机制。当持久化对象时，可能有一个特殊的对象数据成员，我们不想 用serialization机制来保存它。为了在一个特定对象的一个域上关闭serialization，可以在这个域前加上关键字transient。
transient是Java语言的关键字，用来表示一个域不是该对象串行化的一部分。当一个对象被串行化的时候，transient型变量的值不包括在串行化的表示中，然而非transient型的变量是被包括进去的。
java中final和static修饰变量有什么好处
用final 修饰的变量就是常量,是程序运行的过程是不可以改变的
用static修饰的变量是公用变量,所有的实例都使用一个
如果一个对象修改了static变量,其它对象里这个变量的值也会改变
Stastic为静态变量，在一个类中的任何地方都可以调用，而final表示这个变量不能被修改。
final修饰的对象或者变量，在内存中是不可修改，如果是对象则不可继承该对象。
static修饰的对象或者变量，在内存有且只有1个备份，可以修改。
例，String对象是final修饰的，则你新建任何的java类不可继承String对象。
final修饰的对象或者变量，在内存中不能修改，如果修饰对象表示该对象不允许被继承。final修饰主要是从数据安全性上考虑的；
static修饰的对象或者变量，不管该对象是否被实例化，都会在内存创建且始终只有1个备份，不过可以进行修改。
举个例子：
假设一个班级类，它有一个变量统计班级学生数量，这个班级的学生数量变量就应该是static，另外班级的名称应该是final，应为班级名称是不变的。
class Classroom{
static int studentcount;
final String classroomName;//注意final成员变量必须在定义时或者初始化块或者构造器里初始化
}
final : 常量
static : 所属级别----类
补充一点，后面的回答部分有些误导，不是我说他们的不对，只是他们看的资料上写的不规范。
去看看Thinking in Java / C++ 中都讲到了修改常量的问题，
C++：const Thinking in C++中讲了三种策略
Java: final Thinking in Java 中讲了2个
但这两者修饰的都是可以改的，不要被误导。
Java transient关键字
Volatile修饰的成员变量在每次被线程访问时，都强迫从主内存中重读该成员变量的值。而且，当成员变量发生变化时，强迫线程将变化值回写到主内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。
Java语言规范中指出：为了获得最佳速度，允许线程保存共享成员变量的私有拷贝，而且只当线程进入或者离开同步代码块时才与共享成员变量的原始值对比。
这样当多个线程同时与某个对象交互时，就必须要注意到要让线程及时的得到共享成员变量的变化。
而volatile关键字就是提示VM：对于这个成员变量不能保存它的私有拷贝，而应直接与共享成员变量交互。
使用建议：在两个或者更多的线程访问的成员变量上使用volatile。当要访问的变量已在synchronized代码块中，或者为常量时，不必使用。
由于使用volatile屏蔽掉了VM中必要的代码优化，所以在效率上比较低，因此一定在必要时才使用此关键字。
java里面 implements Serializable有什么作用？
serialization 允许将实现了Serializable接口的对象转换为字节序列，这些字节序列可以被完全存储以备以后重新生成原来的对象。 serialization不但可以在本机做，而且可以经由网络操作（就是猫小说的RMI）。这个好处是很大的----因为它自动屏蔽了操作系统的差异，字节顺序等。比如，在Window平台生成一个对象并序列化之，然后通过网络传到一台Unix机器上，然后可以在这台Unix机器上正确地重构这个对象。
import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.io.Serializable; import java.net.ServerSocket; import java.net.Socket;//定义序列化(object)class Student implements Serializable { private int sno; private String sname; public Student(int sno, String sname) { this.sno = sno; this.sname = sname; } public int getSno() { return sno; } public void setSno(int sno) { this.sno = sno; } public String getSname() { return sname; } public void setSname(String sname) { this.sname = sname; } @Override public String toString() { return "学号:" + sno + ";姓名:" + sname; } } //(object)的反序列化过程class MyClient extends Thread { @Override public void run() { try { Socket s = new Socket("localhost", 9999); ObjectInputStream ois = new ObjectInputStream(s.getInputStream()); Student stu = (Student) ois.readObject(); System.out.println("客户端程序收到服务器端程序传输过来的学生对象>> " + stu); ois.close(); s.close(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (ClassNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } //(object)的序列化过程class MyServer extends Thread { @Override public void run() { try { ServerSocket ss = new ServerSocket(9999); Socket s = ss.accept(); ObjectOutputStream ops = new ObjectOutputStream(s.getOutputStream()); Student stu = new Student(1, "赵本山"); ops.writeObject(stu); ops.close(); s.close(); ss.close(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } //测试public class TestTransfer { public static void main(String[] args) { new MyServer().start(); new MyClient().start(); } }
有很多网络传输使用的都是Serializable
它可以先将代码保存为io，然后在反序列化回来了。
如果是android，实现这个接口，可以实现对象的传递。
通过实现这个接口可以实现序列化
对象的串行化（Serialization）
一、串行化的概念和目的 1.什么是串行化 对象的寿命通常随着生成该对象的程序的终止而终止。有时候，可能需要将对象的状态保存下来，在需要时再将对象恢复。我们把对象的这种能记录自己的状态以便将来再生的能力。叫作对象的持续性(persistence)。对象通过写出描述自己状态的数值来记录自己 ，这个过程叫对象的串行化(Serialization) 。串行化的主要任务是写出对象实例变量的数值。如果交量是另一对象的引用，则引用的对象也要串行化。这个过程是递归的，串行化可能要涉及一个复杂树结构的单行化，包括原有对象、对象的对象、对象的对象的对象等等。对象所有权的层次结构称为图表(graph)。 2.串行化的目的 Java对象的单行化的目标是为Java的运行环境提供一组特性，如下所示： 1) 尽量保持对象串行化的简单扼要 ，但要提供一种途径使其可根据开发者的要求进行扩展或定制。 2) 串行化机制应严格遵守Java的对象模型 。对象的串行化状态中应该存有所有的关于种类的安全特性的信息。 3) 对象的串行化机制应支持Java的对象持续性。 4) 对象的串行化机制应有足够的 可扩展能力以支持对象的远程方法调用(RMI)。 5) 对象串行化应允许对象定义自身 的格式即其自身的数据流表示形式，可外部化接口来完成这项功能。
二、串行化方法 从JDK1.1开始，Java语言提供了对象串行化机制 ，在java.io包中，接口Serialization用来作为实现对象串行化的工具 ，只有实现了Serialization的类的对象才可以被串行化。 Serializable接口中没有任何的方法。当一个类声明要实现Serializable接口时，只是表明该类参加串行化协议，而不需要实现任何特殊的方法。下面我们通过实例介绍如何对对象进行串行化。 1.定义一个可串行化对象 一个类，如果要使其对象可以被串行化，必须实现Serializable接口。我们定义一个类Student如下：
import java.io.Serializable; public class Student implements Serializable { int id;// 学号 String name;// 姓名 int age;// 年龄 String department; // 系别 public Student(int id, String name, int age, String department) { this.id = id; this.name = name; this.age = age; this.department = department; } }2.构造对象的输入／输出流 要串行化一个对象，必须与一定的对象输出／输入流联系起来，通过对象输出流将对象状态保存下来，再通过对象输入流将对象状态恢复。 java.io包中，提供了ObjectInputStream和ObjectOutputStream将数据流功能扩展至可读写对象 。在ObjectInputStream 中用readObject()方法可以直接读取一个对象，ObjectOutputStream中用writeObject()方法可以直接将对象保存到输出流中。
import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; public class ObjectSer { public static void main(String args[]) throws IOException, ClassNotFoundException { Student stu = new Student(981036, "LiuMing", 18, "CSD"); FileOutputStream fo = new FileOutputStream("data.ser"); ObjectOutputStream so = new ObjectOutputStream(fo); try { so.writeObject(stu); so.close(); } catch (IOException e) { System.out.println(e); } stu = null; FileInputStream fi = new FileInputStream("data.ser"); ObjectInputStream si = new ObjectInputStream(fi); try { stu = (Student) si.readObject(); si.close(); } catch (IOException e) { System.out.println(e); } System.out.println("Student Info:"); System.out.println("ID:" + stu.id); System.out.println("Name:" + stu.name); System.out.println("Age:" + stu.age); System.out.println("Dep:" + stu.department); } }运行结果如下：
Student Info: ID:981036 Name:LiuMing Age:18 Dep:CSD
在这个例子中，我们首先定义了一个类Student，实现了Serializable接口 ，然后通过对象输出流的writeObject()方法将Student对象保存到文件 data.ser中 。之后，通过对家输入流的readObjcet()方法从文件data.ser中读出保存下来的Student对象 。从运行结果可以看到，通过串行化机制，可以正确地保存和恢复对象的状态。 三、串行化的注意事项 1.串行化能保存的元素 串行化只能保存对象的非静态成员交量，不能保存任何的成员方法和静态的成员变量，而且串行化保存的只是变量的值，对于变量的任何修饰符都不能保存。 2.transient关键字 对于某些类型的对象，其状态是瞬时的，这样的对象是无法保存其状态的。例如一个Thread对象或一个FileInputStream对象 ，对于这些字段，我们必须用transient关键字标明，否则编译器将报措。 另外 ，串行化可能涉及将对象存放到 磁盘上或在网络上发达数据，这时候就会产生安全问题。因为数据位于Java运行环境之外，不在Java安全机制的控制之中。对于这些需要保密的字段，不应保存在永久介质中 ，或者不应简单地不加处理地保存下来 ，为了保证安全性。应该在这些字段前加上transient关键字。
下面是java规范中对transient关键字的解释： The transient marker is not fully specified by The Java Language Specification but is used in object serialization to mark member variables that should not be serialized.
以下是transient的一个应用举例:
//LoggingInfo.javaimport java.io.FileInputStream;import java.io.FileOutputStream;import java.io.ObjectInputStream;import java.io.ObjectOutputStream;import java.util.Date;public class LoggingInfo implements java.io.Serializable { private static final long serialVersionUID = 1L; private Date loggingDate = new Date(); private String uid; private transient String pwd; LoggingInfo(String user, String password) { uid = user; pwd = password; } public String toString() { String password = null; if (pwd == null) { password = "NOT SET"; } else { password = pwd; } return "logon info: \n " + "user: " + uid + "\n logging date : "+ loggingDate.toString() + "\n password: " + password; } public static void main(String[] args) { LoggingInfo logInfo = new LoggingInfo("MIKE", "MECHANICS"); System.out.println(logInfo.toString()); try { ObjectOutputStream o = new ObjectOutputStream(new FileOutputStream("logInfo.out")); o.writeObject(logInfo); o.close(); } catch (Exception e) {// deal with exception } // To read the object back, we can write try { ObjectInputStream in = new ObjectInputStream(new FileInputStream("logInfo.out")); LoggingInfo logInfo1 = (LoggingInfo) in.readObject(); System.out.println(logInfo1.toString()); } catch (Exception e) {// deal with exception } }}
在Java类中对变量或方法的访问有哪些访问控制的关键字？他们各有什么作用，举例说明。
public protected private 为了积分 给你写个例子
比如 class hello{
public int aaa;
private int bbb ;
protected int ccc ;
public void set bbb(int b){
this.bbb = b ;
}
}
public就是公开的喽 你可以通过 hello.aaa = 15 ; 类似这样的赋值
private就不可以地 需要类内部的public方法来控制 hello.setbbb(15);这样的
protected可在子类中使用的
什么都没有的话,行为类似private，区别是在同一个包下都能调用，作用范围比private大
有public，表示任何地方都可以访问，不写和internal一样，表示同一个包内可以访问，protected表示只用本类方法及继承类方法可以访问，private表示只有本类方法可以访问。
根本没有楼上说的friendly这个关键字，我想楼上要说的是internal。
作用域 当前类 同一package 子孙类 其他package
public √ √ √ √
protected √ √ √ ×
friendly √ √ × ×
private √ × × ×
不写时默认为friendly
public 谁都能调用(除非不是一个工程下的)
private 只有本类可以调用 他的儿子们也不可以
default 默认的 比如： int i = 0; 虽然没有写default int i = 0; 但是java默认写上了。
protect 最多允许儿子们可以调用 其他不想干的不能调用
java类声明的完整格式 [public][abstract|final]class ClassName[extends SuperClassName][implements InterfaceNameList]{……}
其中修饰符public表示任意类均可以访问这个类，如果没有public，则只有与该类定义在同一个包中的类才可以访问这个类。abstract表示这个类是个抽象类。final表示无法被任何人继承的，那也就意味着此类在一个继承树中是一个叶子类，并且此类的设计已被认为很完美而不需要进行修改或扩展。extends关键词表示类继承了以SuperClassName为类名的父类，implements关键词表示类实现了InterfaceNameList中列出的各个接口。
java变量的完整的声明格式 [public|protected|private][static][final][transient][volatile]type varibleName;
其中修饰符public表示该方法没有访问限制，protected只能被自身或者子类(在同一个包或不在同一个包)以及同一个包下的其他类可以访问到，private只能被自身访问。如果不加任何权限限定成员则是默认访问权限default，即只能被和这个类在同一个包中的类访问。访问权限时在类级别上的而不是对象级别。static表示这个变量时类变量3中初始化方法方法一:在声明中赋值 方法二:在构造函数中赋值方 法三:初始化块 。final表示这个变量一旦被初始化便不可改变，这里不可改变的意思对基本类型来说是其值不可变，而对于对象变量来说其引用不可再变。其初始化可以在两个地方，一是其定义处，也就是说在final变量定义时直接给其赋值，二是在构造函数中。这两个地方只能选其一，要么在定义时给值，要么在构造函数中给值，不能同时既在定义时给了值，又在构造函数中给另外的值。transient用来声明一个暂时性变量，在默认情况下，类中所有变量都是对象永久状态的一部分，当对象被保存到外存时，这些变量必须同时被保存，用transient限定的变量指示JAVA虚拟机，该变量并不属于对象的永久状态，从而不能被永久存储。volatile修饰的变量，在被多个线程共享时，系统将采取更优化的控制方法提高线程并发控制方法提高线程并发效率。
java方法的完整的声明格式[
][static][final|abstract][native][synchronized]
([
])[throws
]{
}
其中accessLevel与成员变量相同。static限定它为类方法，而实例方法不需要static限定词。abstract表明方法时抽象方法，没有实现体。final指明方法布恩能够被重写。native表示方法用其他语言实现。synchronized用来控制多个并发线程对共享数据的访问。throws
表示可能抛出的异常。
JAVA关键字具体的作用和用法
分类: 电脑/网络 >> 程序设计 >> 其他编程语言
问题描述:
本人是JAVA自学者，刚开始学习JAVA，对JAVA的关键字的作用和用法都不是很清楚，所以学习进度一直很慢，希望有高手可以帮助一下，谢谢了阿。只要常用的关键字就可以了啊！
解析:
Abstract 抽象的
一个Java语言中的关键字，用在类的声明中来指明一个类是不能被实例化的，但是可以被其它类继承。一个抽象类可以使用抽象方法，抽象方法不需要实现，但是需要在子类中被实现
break
一个Java的关键字，用来改变程序执行流程，立刻从当前语句的下一句开始执行从。如果后面跟有一个标签，则从标签对应的地方开始执行
case
Java语言的关键字，用来定义一组分支选择，如果某个值和switch中给出的值一样，就会从该分支开始执行。
catch
Java的一个关键字，用来声明当try语句块中发生运行时错误或非运行时异常时运行的一个块。
char
Java语言的一个关键字，用来定义一个字符类型
continue
一个Java的关键字，用来打断当前循环过程，从当前循环的最后重新开始执行，如果后面跟有一个标签，则从标签对应的地方开始执行。
do
一个Java语言的关键字，用来声明一个循环，这个循环的结束条件可以通过while关键字设置
double
一个Java语言的关键字，用来定义一个double类型的变量
else
一个Java语言的关键字，如果if语句的条件不满足就会执行该语句。
final
一个Java语言的关键字。你只能定义一个实体一次，以后不能改变它或继承它。更严格的讲：一个final修饰的类不能被子类化，一个final修饰的方法不能被重写，一个final修饰的变量不能改变其初始值。
finally
一个Java语言的关键字，用来执行一段代码不管在前面定义的try语句中是否有异常或运行时错误发生。
float
一个Java语言的关键字，用来定义一个浮点数变量
for
一个Java语言的关键字，用来声明一个循环。程序员可以指定要循环的语句，推出条件和初始化变量。
if
Java编程语言的一个关键字，用来生成一个条件测试，如果条件为真，就执行if下的语句。
implements
Java(TM)编程语言的一个关键字，在类的声明中是可选的，用来指明当前类实现的接口。
import
Java(TM)编程语言的一个关键字，在源文件的开始部分指明后面将要引用的一个类或整个包，这样就不必在使用的时候加上包的名字。
instanceof
一个二操作数的Java(TM)语言关键字，用来测试第一个参数的运行时类型是否和第二个参数兼容。
int
Java(TM)的一个关键字，用来定义一个整形变量
Java(TM)的一个关键字，用来定义一系列的方法和常量。它可以被类实现，通过implements关键字。
long
Java语言的一个关键字，用来定义一个long类型的变量。
private
Java语言的一个关键字，用在方法或变量的声中。它表示这个方法或变量只能被这个类的其它元素所访问。
protected
Java语言的一个关键字，在方法和变量的声明中使用，它表示这个方法或变量只能被同一个类中的，子类中的或者同一个包中的类中的元素所访问。
public
Java语言的一个关键字，在方法和变量的声明中使用，它表示这个方法或变量能够被其它类中的元素访问。
return
Java语言的一个关键字，用来结束一个方法的执行。它后面可以跟一个方法声明中要求的值。
short
Java语言的关键字，用来定义一个short类型的变量。
static
Java语言的关键字，用来定义一个变量为类变量。类只维护一个类变量的拷贝，不管该类当前有多少个实例。"static" 同样能够用来定义一个方法为类方法。类方法通过类名调用而不是特定的实例，并且只能操作类变量。
this
Java语言的关键字，用来代表它出现的类的一个实例。this可以用来访问类变量和类方法。
throw
Java语言的关键字，允许用户抛出一个exception对象或者任何实现throwable的对象
throws
Java语言的关键字，用在方法的声明中来说明哪些异常这个方法是不处理的，而是提交到程序的更高一层。
transient
Java语言的关键字，用来表示一个域不是该对象串行化的一部分。当一个对象被串行化的时候，transient型变量的值不包括在串行化的表示中，然而非transient型的变量是被包括进去的。
try
Java语言的关键字，用来定义一个可能抛出异常语句块。如果一个异常被抛出，一个可选的catch语句块会处理try语句块中抛出的异常。同时，一个finally语句块会被执行，无论一个异常是否被抛出。
void
Java语言的关键字，用在Java语言的方法声明中说明这个方法没有任何返回值。"void"也可以用来表示一句没有任何功能的语句。
volatile
Java语言的关键字，用在变量的声明中表示这个变量是被同时运行的几个线程异步修改的。
while
Java语言的一个关键字，用来定义一段反复执行的循环语句。循环的退出条件是while语句的一部分。
关于break和continue。
continue语句与break语句相关，但较少用到。continue语句用于使其所在的for、while或do-while语句开始下一次循环。在while与do-while语句中，continue语句的执行意味着立即执行测试部分；在for循环语句中，continue语句的执行则意味着使控制传递到增量部分。
java全部关键字及其每个用法解释
abstract do implement private this
boolean double import protected throw
break else instanceof public throws
byte extend int return transient
case false interface short true
catch final long static try
char fianlly native strictfp void
class float new super volatile
continue for null switch while
default if package synchronized
注：java 无sizeof ,goto, const 关键字，但不能用goto const作为变量名 楼主,每个用法都给你解释估计太耗时间了.楼主我推荐你多去看看JDK API.有看不懂的关键字就去API里面搜一下很容易给你解释的...学会看API很重要.如果满意,请采纳
Abstract 抽象的
一个Java语言中的关键字，用在类的声明中来指明一个类是不能被实例化的，但是可以被其它类继承。一个抽象类可以使用抽象方法，抽象方法不需要实现，但是需要在子类中被实现
break
一个Java的关键字，用来改变程序执行流程，立刻从当前语句的下一句开始执行从。如果后面跟有一个标签，则从标签对应的地方开始执行
case
Java语言的关键字，用来定义一组分支选择，如果某个值和switch中给出的值一样，就会从该分支开始执行。
catch
Java的一个关键字，用来声明当try语句块中发生运行时错误或非运行时异常时运行的一个块。
char
Java语言的一个关键字，用来定义一个字符类型
continue
一个Java的关键字，用来打断当前循环过程，从当前循环的最后重新开始执行，如果后面跟有一个标签，则从标签对应的地方开始执行。
do
一个Java语言的关键字，用来声明一个循环，这个循环的结束条件可以通过while关键字设置
double
一个Java语言的关键字，用来定义一个double类型的变量
else
一个Java语言的关键字，如果if语句的条件不满足就会执行该语句。
final
一个Java语言的关键字。你只能定义一个实体一次，以后不能改变它或继承它。更严格的讲：一个final修饰的类不能被子类化，一个final修饰的方法不能被重写，一个final修饰的变量不能改变其初始值。
finally
一个Java语言的关键字，用来执行一段代码不管在前面定义的try语句中是否有异常或运行时错误发生。
float
一个Java语言的关键字，用来定义一个浮点数变量
for
一个Java语言的关键字，用来声明一个循环。程序员可以指定要循环的语句，推出条件和初始化变量。
if
Java编程语言的一个关键字，用来生成一个条件测试，如果条件为真，就执行if下的语句。
implements
Java(TM)编程语言的一个关键字，在类的声明中是可选的，用来指明当前类实现的接口。
import
Java(TM)编程语言的一个关键字，在源文件的开始部分指明后面将要引用的一个类或整个包，这样就不必在使用的时候加上包的名字。
instanceof
一个二操作数的Java(TM)语言关键字，用来测试第一个参数的运行时类型是否和第二个参数兼容。
int
Java(TM)的一个关键字，用来定义一个整形变量
Java(TM)的一个关键字，用来定义一系列的方法和常量。它可以被类实现，通过implements关键字。
long
Java语言的一个关键字，用来定义一个long类型的变量。
private
Java语言的一个关键字，用在方法或变量的声中。它表示这个方法或变量只能被这个类的其它元素所访问。
protected
Java语言的一个关键字，在方法和变量的声明中使用，它表示这个方法或变量只能被同一个类中的，子类中的或者同一个包中的类中的元素所访问。
public
Java语言的一个关键字，在方法和变量的声明中使用，它表示这个方法或变量能够被其它类中的元素访问。
return
Java语言的一个关键字，用来结束一个方法的执行。它后面可以跟一个方法声明中要求的值。
short
Java语言的关键字，用来定义一个short类型的变量。
static
Java语言的关键字，用来定义一个变量为类变量。类只维护一个类变量的拷贝，不管该类当前有多少个实例。"static" 同样能够用来定义一个方法为类方法。类方法通过类名调用而不是特定的实例，并且只能操作类变量。
this
Java语言的关键字，用来代表它出现的类的一个实例。this可以用来访问类变量和类方法。
throw
Java语言的关键字，允许用户抛出一个exception对象或者任何实现throwable的对象
throws
Java语言的关键字，用在方法的声明中来说明哪些异常这个方法是不处理的，而是提交到程序的更高一层。
transient
Java语言的关键字，用来表示一个域不是该对象串行化的一部分。当一个对象被串行化的时候，transient型变量的值不包括在串行化的表示中，然而非transient型的变量是被包括进去的。
try
Java语言的关键字，用来定义一个可能抛出异常语句块。如果一个异常被抛出，一个可选的catch语句块会处理try语句块中抛出的异常。同时，一个finally语句块会被执行，无论一个异常是否被抛出。
void
Java语言的关键字，用在Java语言的方法声明中说明这个方法没有任何返回值。"void"也可以用来表示一句没有任何功能的语句。
volatile
Java语言的关键字，用在变量的声明中表示这个变量是被同时运行的几个线程异步修改的。
while
Java语言的一个关键字，用来定义一段反复执行的循环语句。循环的退出条件是while语句的一部分。
关于break和continue。
continue语句与break语句相关，但较少用到。continue语句用于使其所在的for、while或do-while语句开始下一次循环。在while与do-while语句中，continue语句的执行意味着立即执行测试部分；在for循环语句中，continue语句的执行则意味着使控制传递到增量部分。
java中的关键字是什么？
访问控制:
private 私有的
protected 受保护的
public 公共的
类、方法和变量修饰符
abstract 声明抽象
class 类
extends 扩允,继承
final 终极,不可改变的
implements实现
interface 接口
native 本地
new 新,创建
static 静态
strictfp 严格,精准
synchronized 线程,同步
transient 短暂
volatile 易失
程序控制语句
break 跳出循环
continue 继续
return 返回
do 运行
while 循环
if 如果
else 反之
for 循环
instanceof 实例
switch 开关
case 返回开关里的结果
default 默认
错误处理
catch 处理异常
finally 有没有异常都执行
throw 抛出一个异常对象
throws 声明一个异常可能被抛出
try 捕获异常
包相关
import 引入
package 包
基本类型
boolean 布尔型
byte 字节型
char 字符型
double 双精度,
float 浮点
int 整型
long 长整型
short 短整型
null 空
true 真
false 假
变量引用
super 父类,超类
this 本类
void 无返回值
---------------------------------------------------------------------
Java语言有51个保留关键字，其中const和goto虽然被保留但未被使用。你不能使用保留关键字来命名类、方法或变量。
一、保留关键字
数据类型：
Boolean int long short byte float double char class interface
流程控制：
if else do while for switch case default break continue return try catch finally
修饰符：
public protected private final void static strictfp abstract transient
synchronized volatile native
动作：
package import throw throws extends implements this Super instanceof new
保留字：
true false null goto const
二、访问修饰符：
访问修饰符： public , protected , private
* 只能应用于类的成员变量。（局部变量只能在函数的范围内可见，不能使用访问修饰符）
* 能够用来修饰类本身。（protected , private 不能用于顶级类，只能用于内部类）
* 能够应用于成员方法和构造函数。
下面是一个例子：
package Examples;
public class HelloWorld02{
//以下定义了三个了类成员变量
public String str1="Hello"; //可被你程序中的任何其他代码访问
protected String str2="World!"; //程序中同一包的成员和不同包中的该类子类可以访问
private String str3=" "; //仅该类中的成员可以访问
String str=str1+str3+str2; //不使用修饰符的话，变量的访问控制在所在包内为public，
// 不能被所在包外的代码存取
//以下定义了三个使用不同修饰符和不同参数的构造方法。
public HelloWorld(){
System.out.println(str);
}
protected HelloWorld(long l){
System.out.print("Use \"protected\" constructor! And l is ["+l+"] ");
System.out.println(str);
}
private HelloWorld(float f){
System.out.print("Use \"private\" constructor! And f is ["+f+"] ");
System.out.println(str);
}
//声明构造方法为void类型是合法的.不过因为没有返回值,所以不能用来创建新对象.
public void HelloWorld(){
System.out.println(str +" Use the void constructor!");
}
public static void main(String[] args){
HelloWorld hw1=new HelloWorld(); //使用无参数的构造方法
HelloWorld hw2=new HelloWorld(5); // 虽然5是int类型，但会自动提升成long类型
HelloWorld hw3=new HelloWorld(5L);
HelloWorld hw5=new HelloWorld(3.14f); // 但float类型则必须指明，否则会出错
hw5.HelloWorld(); // 无返回值的构造方法只能这样调用
(new HelloWorld()).HelloWorld(); //这里创建了一个匿名类对象并调用无返回值的构造方法
}
}
总结：
请认真思考一下：
（1）public、protected、private 可用来修饰哪些成员？
使用这些修饰符的成员的访问控制是怎样的？
没有指定访问修饰符的成员的访问控制是怎样的？
* public、protected和private可以用来修饰类成员变量、方法、构造方法和内部类；
public可以用来修饰顶级类，但protected和private则不行。
注意事项：
* 每一个java文件中可以包含多个类，但只能存在一个public顶级类，如果声明了两个顶级类的话，则会出现编译错误。
二、部分其他修饰符
this：
Java中定义了this关键字来访问当前对象实例内的成员。当局部变量和类实例内的类变量同名时，在这个局部变量所作用区域内类变量就被隐藏了，必须使用this来指明。
static：
有时你希望定义一个类成员，使它的使用完全独立于该类的任何对象。通常情况下，类成员必须通过它的类的对象访问，但是可以创建这样一个成员，它能够被它所在类使用，而不必引用所在类的实例。将类中的成员声明为static就能实现这样的效果。声明为static的变量实质就是全局变量。当声明一个对象（某个类的实例）时，并不产生static变量的拷贝，而是该类所有的实例变量共用同一个static变量。
声明为static的方法有以下三条限制：
* 它们只能访问static数据
* 它们仅能调用其他的static方法
* 它们不能以任何方式引用this或super
实例分析：
package Examples;
public class StaticDemo{
public static void main(String[] args){
System.out.println(MyStaticClass.str); //不用创建MyStaticClass的实例就能访问它的str变量
// System.out.println(MyStaticClass.str2); 这句是错误的。
MyStaticClass msc=new MyStaticClass(); //这里创建MyStaticClass的一个实例
System.out.println("After create instance:");
msc.printString();
}
}
class MyStaticClass{
static String str="Hello World!";
String str2;
void setString(String s){
str2=s;
}
static void setNewString(String s){
str=s;
}
static void printString(){
//setString(str); 在static方法中调用非static方法是错误的
//System.out.println(str2); 也不能访问非static变量
//Java中是先检测static变量再检测static方法的
System.out.println(str); // 可以正常访问static变量
setNewString("Static method is OK!"); //正常调用static方法
System.out.println(str);
}
}
final：
一个变量可以被声明为final，这样做的目的是阻止它的内容被修改。这意味着在声明final变量的时候，你必须初始化它。一个final变量实质上是一个常数，为final变量的所有字母选择大写是一个普遍的编码约定。声明为final的变量在实例中不占用内存。
声明成final的方法不能被重载。通常，Java在运行时动态的调用方法，这叫做后期绑定（late binding）；由于被声明为final的方法不能被重载，那么对final方法的调用可以在编译时解决，这叫做早期绑定（early bingding）。
声明为final的类不能被其他类继承。声明一个final类含蓄的宣告了它的所有方法也都是final的。所以，声明一个既是abstract的，又是final的类是不合法的，因为抽象类本身是不完整的，它依靠它的子类提供完整的实现。
strictfp：
Java2向Java语言增加了一个新的关键字strictfp。与Java2同时产生的浮点运算计算模型很轻松的使某些处理器可以以较快速度进行浮点运算（例如奔腾处理器）。这个浮点运算计算模型在计算过程中，不需要切断某些中介值。如果用strictfp来修饰类或方法，可以确保浮点运算（以及所有切断）正如它们在早期Java版本中那样准确（即使用原始的浮点运算模型）。切断只影响某些操作的指数。当一个类被strictfp修饰，所有该类的方法都自动被strictfp修饰。坦白说，很多程序员从未用过strictfp，因为它只对非常少的问题有影响。
native：
有时你希望调用不是用Java语言写的子程序，或者你希望调用一个专用的第三方的库，例如统计学包。虽然这种情况比较少，但Java提供了native关键字，该关键字用来声明本机代码方法。
为声明一个本机方法，在该方法之前用native修饰符，但是不要定义任何方法体。例如：
public native int meth();
声明本机方法后，必须编写本机方法并要执行一系列复杂的步骤使它与Java代码链接。很多本机方法是用C写的。把C代码结合到Java程序中的机制是调用Java Native Interface（JNI）。
transient：
如果用transient声明一个实例变量，当对象储存时，它的值不需要维持。例如：
class T{
transient int a; // will not persist
int b; // will persist
}
这里，如果T类的一个对象被写入一个持久的存储区域，a的内容不被保存，但b将被保存。
volatile：
volatile修饰符告诉编译器被volatile修饰的变量可以被程序的其他部分改变。一种 这样的情形是多线程程序。在多线程程序里，有时两个或更多的线程共享一个相同的实例变量。考虑效率的问题，每个线程可以自己保存该共享变量的私有拷贝。实际的（或主要的）变量副本在不同的时候更新，例如当进入synchronized方法时。当这种方法运行良好时，它在时间上会是低效的。在某些情况下，真正要紧的是变量主副本的值会体现当前的状态。为保证这点，仅需把变量定义成volatile型，它告诉编译器它必须总是使用volatile变量的主副本（或者至少总是保持一些私有的最新的主副本的拷贝，反之亦然），同时，对主变量的获取必须以简洁次序执行，就像执行私有拷贝一样。
final在Java中是一个保留的关键字，可以声明成员变量、方法、类以及本地变量。一旦你将引用声明作final，你将不能改变这个引用了，编译器会检查代码，如果你试图将变量再次初始化的话，编译器会报编译错误。
Java是一种可以撰写跨平台应用软件的面向对象的程序设计语言。Java 技术具有卓越的通用性、高效性、平台移植性和安全性，广泛应用于PC、数据中心、游戏控制台、科学超级计算机、移动电话和互联网，同时拥有全球最大的开发者专业社群。