enum是java关键字吗？

所有的小数都要保留。一般用BigDecimal比较好

精准 strictfp 超精准 Mega-precision 精准度 accuracy 精准地 precisely

在 Java 语言中，Math 类是位于 java.lang 包下的一个数学计算类，主要提供了一些基本的数学运算方法，如三角函数、指数、对数、平方根等。对于 Math 类的声明，可以使用以下修饰符关键字：1. public：表示该类是公共类，可以被其他类访问。2. final：表示该类是最终类，不能被其他类继承。3. abstract：表示该类是抽象类，不能直接实例化，只能被继承。4. strictfp：表示该类的浮点运算采用严格的浮点计算规则，保证在不同平台上计算结果的一致性。通常情况下，Math 类的声明不需要使用修饰符关键字，因为它已经默认使用了 public 和 final 修饰符。也就是说，Math 类是一个公共且最终的类，不能被其他类继承，但可以通过该类提供的静态方法进行数学计算。例如，可以使用以下代码调用 Math 类的静态方法求正弦值：```double x = Math.sin(30);```

accurate: adj.

私有的，即本类可见

public private protected final abstract friendly

访问控制: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 transientsynchronized 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变量的主副本（或者至少总是保持一些私有的最新的主副本的拷贝，反之亦然），同时，对主变量的获取必须以简洁次序执行，就像执行私有拷贝一样。

abstract :表明类或类中的方法是抽象的；assert ：声明断言；boolean ：基本数据类型之一，布尔类型；break ：提前跳出一个块；byte ：基本数据类型之一，字节类型；case ：在switch语句中，表明其中的一个分支catch ：用于处理例外情况，用来捕捉异常；char ：基本数据类型之一，字符类型；class ：类；continue ：回到一个块的开始处；default ：用在switch语句中，表明一个默认的分支；do ：用在“do while”循环结构中；double ：基本数据类型之一，双精度浮点数类型；else ：在条件语句中，表明当条件不成立时的分支；extends ：用来表明一个类是另一个类的子类；final ：用来表明一个类不能派生出子类，或类中的方法不能被覆盖，或声明一个变量是常量；finally ：用于处理异常情况，用来声明一个肯定会被执行到的块；float ：基本数据类型之一，单精度浮点数类型；for ：一种循环结构的引导词；if ：条件语句的引导词；implements ：表明一个类实现了给定的接口；import ：表明要访问指定的类或包；instanceof ：用来测试一个对象是否是一个指定的类的实例；int ：基本数据类型之一，整数类型；interface ：接口；long ：基本数据类型之一，长整数类型；native ：用来声明一个方法是由与机器相关的语言（如C/C++/FORTRAN语言）实现的；new ：用来申请新的对象；package ：包；private ：一种访问模式：私有模式；protected ：一种访问模式：保护模式；public ：一种访问模式：公共模式；return ：从方法中返回值；short ：基本数据类型之一，短整数类型；static ：表明域或方法是静态的，即该域或方法是属于类的；strictfp ：用来声明FP-strict（双精度或单精度浮点数）表达式；算术规范：super ：当前对象的父类对象的引用；switch ：分支结构的引用词；synchronized ：表明一段代码的执行需要同步；this ：当前对象的引用；throw ：抛出一个异常；throws ：声明方法中抛出的所有异常；thansient ：声明不用序列化的域；try ：尝试一个可能抛出异常的程序块；void ：表明方法不返回值；volatile ：表明两个或多个变量必须同步地发生变法；while ：用在循环结构中；enum ：声明枚举类型；说明：⑴Java的关键字也是随新的版本发布在不断变动中的，不是一成不变的。⑵所有关键字都是小写的。⑶除这些关键字外，Java还定义了一些保留字，也就是说Java保留了它们，但是没有使用它们，这些词不 能作为标识符使用。cast、goto、future、generic、inner、operator、outer、rest、var⑷true和false不是关键字，而是boolean类型直接量。⑸null也不是关键字。⑹无sizeof运算符；所有类型的长度和表示是固定的，不依赖执行。

先找本基础的教材来看看吧。

C、D都不是，属于java字面常量java关键字是电脑语言里事先定义的，有特别意义的标识符，有时又叫保留字，还有特别意义的变量。Java的关键字对java的编译器有特殊的意义，他们用来表示一种数据类型，或者表示程序的结构等，关键字不能用作变量名、方法名、类名、包名和参数。以下是java 关键字分类列表：（共50个，供大家参考）访问控制: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 短整型变量引用super 父类,超类this 本类void 无返回值Java Language KeywordsHere"s a list of keywords in the Java programming language. You cannot use any of the following as identifiers in your programs. The keywords const and goto are reserved, even though they are not currently used. true, false, and null might seem like keywords, but they are actually literals; you cannot use them as identifiers in your programs.abstractcontinuefornewswitchassert***defaultgoto*packagesynchronizedbooleandoifprivatethisbreakdoubleimplementsprotectedthrowbyteelseimportpublicthrowscaseenum****instanceofreturntransientcatchextendsintshorttrycharfinalinterfacestaticvoidclassfinallylongstrictfp**volatileconst*floatnativesuperwhile*not used**added in 1.2***added in 1.4****added in 5.0

保留字以后可能用。 x0dx0a关键字现在就已经使用。x0dx0ax0dx0aJava 关键字列表 (依字母排序 共51组): x0dx0aabstract, assert,boolean, break, byte, case, catch, char, class, const, continue, default, do, double, else, enum,extends, final, finally, float, for, if, implements, import, instanceof, int, interface, long, native, new, package, private, protected, public, return, short, static, strictfp, super, switch, synchronized, this, throw, throws, transient, try, void, volatile, while x0dx0aJava 保留字列表 (依字母排序 共14组) : Java保留字是指现有Java版本尚未使用 但以后版本可能会作为关键字使用。 x0dx0abyValue, cast, false, future, generic, inner, operator, outer, rest, true, var ， goto ，const,null

恕我愚钝 方法声明为String后还能在声明为byte吗。。。

-include filename 递归引入目录的配置文件 -basedirectory directoryname -injars class_path 指定应用程序要处理的jars包（或者wars、ears、zip、或者目录结构），它们里面的class文件会被处理并被写入到输出jars里面。它们里面的任何非class文件会被直接复制过去但是不会处理。（需要注意过滤调一些IDE自动生成的文件）； -outjars class_path 指定输出jars(wars、ears、zip、目录结构)的名称；由-injars 指定的被处理的jars将被写入到指定的输出jars里。如果不指定outjars将不会有class文件被写入。 -libraryjars class_path 不混淆指定的jar库(android 项目中一般不混淆引入的第三方类库) -skipnonpubliclibraryclasses 不混淆指定jars中的非public calsses -dontskipnonpubliclibraryclasses 不忽略指定jars中的非public calsses （默认选项）和上面的选手想对 -dontskipnonpubliclibraryclassmembers 不忽略指定类库的public类成员（变量和方法），默认情况下，ProGuard会忽略他们 -keepdirectories [ directory_filter ] 指定要保持的目录结构，默认情况下会删除所有目录以减小jar的大小。 -target version 指定java版本号。 版本号可以是1.0,1.1,1.2,1.3,1.4,1.5（或仅5），1.6（或仅6）或1.7（或仅7）中的一个。 默认情况下，类文件的版本号保持不变。 例如，您可能想要将类文件升级到Java 6，通过更改其版本号并对其进行预验证。 -forceprocessing 强制处理输入（-injars）jars。即使输出jars是最新的。通过指定的输入，输出和配置文件或者目录的时间戳判断是否最新。 -keep [, modifier，... ] class_specification 指定需要保留的类和类成员（作为公共类库，应该保留所有可公开访问的public方法） -keepclassmembers [, modifier，... ] class_specification 指定需要保留的类成员:变量或者方法 -keepclasseswithmembers [, modifier，... ] class_specification 指定保留的类和类成员，条件是所指定的类成员都存在（既在压缩阶段没有被删除的成员，效果和keep差不多） -keepnames class_specification [-keep allowshrinking class_specification 的简写] 指定要保留名称的类和类成员，前提是在压缩阶段未被删除。仅用于模糊处理 -keepclassmembernames class_specification [-keepclassmembers allowshrinking class_specification 的简写] 指定要保留名称的类成员，前提是在压缩阶段未被删除。仅用于模糊处理 -keepclasseswithmembernames class_specification [-keepclasseswithmembers allowshrinking class_specification 的简写] 指定要保留名称的类成员，前提是在压缩阶段后所指定的类成员都存在。仅用于模糊处理 -printseeds [ filename ] 指定详尽列出由各种-keep选项匹配的类和类成员。 列表打印到标准输出或给定文件。 该列表可用于验证是否真的找到了预期的类成员，特别是如果您使用通配符。 例如，您可能想要列出所有应用程序或您保存的所有小程序。 可用在 keep、keepclassmembers、keepclasseswithmembers 命令后面 rt.jar(java/ .class,javax/ class) input.jar(! .gif,images/ ) input.war(lib/ .jar,support/ jar; .class, .gif) -injars classes -injars in1.jar -injars in2.jar -injars in3.jar -outjars out.jar -injars in1.jar -injars in2.jar -injars in3.jar -outjars out -injars base_in1.jar -injars base_in2.jar -injars base_in3.jar -outjars base_out.jar -injars extra_in.jar -outjars extra_out.jar -injars in.jar(!images/**) -outjars out.jar -libraryjars <java.home>/lib/rt.jar(java/ ,javax/ ) -injars in.jar -outjars code_out.jar(**.class) -outjars resources_out.jar "<java.home>/lib/rt.jar" 将被解释为 "/usr/local/java/jdk/jre/lib/rt.jar." "<user.home>" 解释为用户的Home目录 "<user.dir>"解释为当前的工作目录 java/ .class,javax/ .class //匹配java和javax目录以及其子目录下的所有.class文件 -keep class org.codehaus.jackson.* //保持org.codehaus.jackson下面的类文件，不包括其子包里面类文件 -keep class org.codehaus.jackson. //保持org.codehaus.jackson下面所有类文件，包括其子包里面类文件 ! .gif,images/** 匹配images目录下面所有文件，但不包括.gif文件 -injars in.jar(!images/**) //指定输入jar包，但移除images目录下面的所有文件 "foo, bar"匹配foo文件，和所有以bar结尾的名称。 "!foobar, bar 匹配所有bar结尾名称，foobar除外。 [@annotationtype] [[!]public|final|abstract|@ ...] [!]interface|class|enum classname [extends|implements [@annotationtype] classname] [{ [@annotationtype] [[!]public|private|protected|static|volatile|transient ...] <fields> | (fieldtype fieldname); [@annotationtype] [[!]public|private|protected|static|synchronized|native|abstract|strictfp ...] <methods> | <init>(argumenttype,...) | classname(argumenttype,...) | (returntype methodname(argumenttype,...)); [@annotationtype] [[!]public|private|protected|static ... ] *; ... }] -keepclassmembernames class com.dev.demo.one.ClassOneOne { public *; } -keep class com.dev.demo.ClassOne { public <init>(); } -keep class com.dev.demo.two.ClassTwoTwo { public <init>(int); } -keepclassmember class com.dev.demo.two.ClassTwoThree { public <methods>; private <fields>; } -keep class * extends com.dev.demo.two.ClassTwoThree {*;} -keepnames class com.dev.demo.one.ClassOne { ;} -keep class com.dev.demo.two.ClassTwoTwo$ClassTwoTwoInner{*;}

内部类一、 定义：在一个类内部定义的类。二、 类型：成员内部类、局部内部类（也叫方法内部类）、匿名内部类、静态嵌套类。三、 用法a) 四种内部类的共性i. 内部类仍然是一个独立的类，在编译后内部类会被编译成独立的.class文件，只是在前面加上外部类的类名和$符号。ii. 内部类不能用普通的方式访问。内部类是外部类的一个成员，因此内部类可以自由访问外部类的成员变量，无论是否是private的。iii. 内部类的this引用：内部类中同样使用this.成员变量，如要使用外部类的成员变量，则使用外部类名.this.成员变量。b) 四种内部类的区别i. 成员内部类：它相当于外部类的一个成员变量或方法，可用修饰符为final、abstract、public、private、protected、strictfp和static。形式如下class Outer { class Inner{}}编译上述代码会产生两个文件，Outer.class和Outer$Inner.class。成员内部类内不允许有任何静态声明！能够访问成员内部类的途径是通过外部类的对象或外部类中非静态的方法。//外部类class Outer { //内部类 class Inner { //内部类的方法 public void myInner() { System.out.println(“Inner class”); } } //非静态方法访问内部类 public void getInner() { Inner in = new Inner(); in.myInner(); } //外部访问内部类 pulblic static void main(String args[]) { Outer out = new Outer(); Outer.Inner in = out.new Inner(); in.myInner(); }}ii. 局部内部类（方法内部类）：在外部类的某个方法内定义的类，与成员内部类不同，它相当于外部类的一个局部变量，修饰符只有final和abstract。1. 只能在定义该内部类的方法内实例化，不可以在此方法外对其实例化。2. 局部内部类对象不能使用该内部类所在方法的非final局部变量。因为方法的局部变量位于栈上，只存在于该方法的生命期内。当一个方法结束，其栈结构被删除，局部变量成为历史。但是该方法结束后，在方法内创建的内部类对象可能仍然存在于堆中！例如，如果对它的引用被传递到其他某些代码，并存储在一个成员变量内。正因为不能保证局部变量的存活期和方法内部类对象的一样长，所以内部类对象只能使用所在方法中被定义为final的局部变量。3. 静态方法内的局部内部类没有this的引用。a) 示例：class Outer { public void doSomething() { final int a = 10; class Inner { public void myInner() { System.out.println(a); } } }}iii. 匿名内部类：没有名字的内部类。1. 继承式的匿名内部类class Car { public void drive() { System.out.println(“Driving a car!”); }}class Temp { public static void main(String[] args) { Car car = new Car() { pulbic void drive() { System.out.println(“Driving another car!”); } }; car.drive(); }}2. 接口式的匿名内部类interface Face { public void drive();}class Temp { public static void main(String[] args) { Face face = new Face() { public void drive() { System.out.println(); } }; face.drive(); }}3. 参数匿名内部类：顾名思义，将匿名内部类当成参数使用。iv. 静态嵌套类：从技术上讲，静态嵌套类不属于内部类。因为内部类与外部类共享一种特殊关系，更确切地说是对实例的共享关系。而静态嵌套类则没有上述关系。它只是位置在另一个类的内部。因此也被称为顶级嵌套类。静态的含义是该内部类可以像其他静态成员一样，没有外部类对象时，也能够访问它。静态嵌套类不能访问外部类的成员和方法。class Outer { static class Inner{}}class Temp { public static void main(String[] args) { Outer.Inner n = new Outer.Inner(); }}

goto反正是写在关键字里面但是没有用到，我就找到这一个

如下 是在哪里？？

属性说明basedir代码所在的位置AbstractClassNameformat: 定义抽象类的命名规则PackageNameformat: 定义包名的命名规则TypeNameformat: 定义类和接口的命名规则tokens: 定义规则适用的类型，例如：CLASS_DEF表示类，INTERFACE_DEF 表示接口ParameterNameformat: 定义参数名的命名规则ParameterNumbermax: 定义最多有多少个参数tokens: 定义检查的类型StaticVariableNameformat: 定义静态变量的命名规则MethodNameformat: 定义方法名的命名规则LeftCurlyoption: 定义左大括号"{"显示位置，eol在同一行显示，nl在下一行显示maxLineLength: 大括号"{"所在行行最多容纳的字符数tokens: 该属性适用的类型，例：CLASS_DEF,INTERFACE_DEF,METHOD_DEF,CTOR_DEFLineLengthmax: 定义一行所能容许的字符数ignorePattern: 定义可以忽略的格式MethodLength检查方法的行数max: 最多容许的行数countEmpty: 是否计算空行tokens: 定义检查的类型RightCurlyoption: 右大括号是否单独一行显示tokens: 定义检查的类型PackageHtml检查对每一个包是否生成了package.html文件fileExtensions: 指定要检查的文件的类型，如果只包含java文件，就不必指定JavadocType检查类或者接口的javadoc注释authorFormat: 检查author标签的格式versionFormat: 检查version标签的格式scope: 可以检查的类的范围，例如：public只能检查public修饰的类，private可以检查所有的类excludeScope: 不能检查的类的范围，例如：public，public的类将不被检查，但访问权限小于public的类仍然会检查，其他的权限以此类推tokens: 该属性适用的类型，例如：CLASS_DEF,INTERFACE_DEFJavadocMethod检查方法的javadoc的注释scope: 可以检查的方法的范围，例如：public只能检查public修饰的方法，private可以检查所有的方法allowMissingParamTags: 是否忽略对参数注释的检查allowMissingThrowsTags: 是否忽略对throws注释的检查allowMissingReturnTag: 是否忽略对return注释的检查JavadocVariable检查类变量的注释scope: 检查变量的范围，例如：public只能检查public修饰的变量，private可以检查所有的变量JavadocStylescope: excludeScope: checkFirstSentence: checkEmptyJavadoc: checkHtml: tokens:LocalVariableNameformat: 定义局部变量的命名规则LocalFinalVariableNameformat: 定义局部常量的命名规则ConstantNameformat: 定义全局常量的命名规则MemberNameformat: 定义非静态成员变量的命名规则applyToPublic: 是否适用于public的成员变量applyToProtected: 是否适用于protected的成员变量applyToPackage: 是否适用于package的成员变量applyToPrivate: 是否适用于private的成员变量AvoidStarImport必须导入类的完整路径，即不能使用*导入所需的类excludes: 定义可以使用*导入的包ImportOrder定义导入包的顺序groups: 定义导入包的顺序，默认以字母顺序导入ordered: 定义包是否必须按规定的顺序显示separated: 定义包与包之间是否应添加空白行caseSensitive: 是否区分包名的大小写IllegalImport检查是否从非法的包中导入了类illegalPkgs: 定义非法的包名称UnusedImports检查是否导入的包没有使用RedundantImport检查是否导入了不必显示导入的类EmptyForInitializerPad检查for语句初始化变量的格式option: 定义初始化语句中是否使用空格，例如：space表示使用空格，则for(int i = 0; i < 100; i++)就是符合格式要求的，而for(int i=0; i<100;i++)就不符合要求EmptyForIteratorPad检查for iterator语句是否使用空格option: 定义初始化语句是否使用空格，例如：space表示使用空格，则for(Iterator iterator = List.iterator(); iterator.hasNext(); iterator.next())就是形式合理的，否则就是形式不合理的ExecutableStatementCount检查要执行的语句的数目max: 定义所能容许的语句的最多数目tokens: 定义可以检查的类型，例如：CTOR_DEF,METHOD_DEF,STATIC_INIT,INSTANCE_INITFileLengthmax: 定义一个文件所能容许的行数AnonInnerLength检查匿名内部类max: 定义匿名内部类最多容许的行数MethodParamPad检查方法参数的格式allowLineBreaks: 参数是否允许在不同行（注：没有作用）option: 在参数和括号、参数和标识符之间是否包含空格OperatorWrap检查运算符是否在应在同一行option: 定义运算符的位置，eol在同一行，nl在下一行tokens: 定义检查的类型ParenPad检查左小括号"("后边和右小括号")"前边是否有空格option: space表示有空格，nospace表示没有空格tokens: 定义检查的类型TypecastParenPad暂不清楚TabCharacter检查源码中是否包含 WhitespaceAfter检查类型后是否包含空格tokens: 检查的类型WhitespaceAround暂不清楚ModifierOrder检查修饰符的顺序，默认是 public,protected,private,abstract,static,final,transient,volatile,synchronized,native,strictfp（注：定义不起作用）RedundantModifierRedundantModifier检查是否有多余的修饰符，例如：接口中的方法不必使用public、abstract修饰tokens: 检查的类型EmptyBlock检查是否有空代码块option: 定义代码块中应该包含的内容，例如：stmt表示语句tokens: 检查的类型NeedBraces检查是否应该使用括号的地方没有加括号tokens: 定义检查的类型AvoidNestedBlocks检查是否有嵌套的代码块allowInSwitchCase: 定义是否允许switch case中使用嵌套的代码块ArrayTrailingComma检查初始化数祖时，最后一个元素后面是否加了逗号，如果左右大括号都在同一行，则可以不加逗号AvoidInlineConditionals检查是否在同一行初始化， 例如：private int Age = nGe==1 ? 100 : 0; 就应该避免CovariantEquals暂不清楚ModifiedControlVariable检查循环控制变量是否被修改SimplifyBooleanExpression检查是否有boolean使用冗余的地方，例如：b == true、b || true，应该简化为 b、bSimplifyBooleanReturn检查是否在返回boolean值时是否有使用冗余的地方，例如：if(valid()) return true; else return false;应该改为： return valid();StringLiteralEquality检查在判断字符串是否相等时是否使用了正确的形式EqualsHashCode检查在重写了equals方法后是否重写了hashCode方法FinalLocalVariable检查变量值没有改动的情况下，该变量是否定义成了finalMissingSwitchDefault检查switch语句是否忘记了default标签RedundantThrows检查是否抛出了多余的异常DefaultComesLast检查switch中default是否在所有case的后面MissingCtor检查类中是否显式定义了构造器FallThrough检查switch中case后是否加入了跳出语句，例如：return、break、throw、continueMultipleStringLiterals检查一个字符串变量在不改变变量值的情况下或者字符串出现的次数allowedDuplicates: 定义在类中一个字符串变量在不改变变量值的情况下或者字符串所能使用的最多次数MultipleVariableDeclarations检查一次声明多个变量时，变量是否在同一行或者在同一个语句中RequireThis检查是否使用了thischeckFields: 是否检查变量引用checkMethods: 是否检查方法调用UnnecessaryParentheses检查是否使用了多余的小括号VisibilityModifier检查变量是否对外部可见packageAllowed: 变量包内成员可以访问protectedAllowed: 变量是受保护的publicMemberPattern: 可以公开访问的变量所匹配的命名形式FinalClass只有私有构造器的类必须声明为finalInterfaceIsType检查接口是否只定义了变量而没有定义方法，因为接口应该用来描述一个类型，所以只定义变量而不定义方法是不恰当的allowMarkerInterfaces: 是否检查空接口HideUtilityClassConstructor只定义了静态方法的类不应该定义一个公有的构造器DesignForExtension检查类是否被设计为可扩展的，如果是，则方法应该abstract、final或者是空的ThrowsCount检查抛出异常的数量max: 定义抛出异常的最大数目StrictDuplicateCode检查类中是否有代码复制的问题min: 允许代码重复的最小行数charset: 文件所用的字符集BooleanExpressionComplexitymax: 布尔运算符在一条语句中允许出现的最大数目GenericIllegalRegexp检查代码中是否有不合适的引用形式或者字符format: 定义检查所匹配的类型ignoreCase: 是否区分大小写ignoreComments: 是否忽略注释message: 出现问题应该显示给用户的信息NewlineAtEndOfFile检查文件是否以一个新行结束lineSeparator: 行分隔符的类型，windows是crlfUncommentedMain检查是否有没有被注掉或者删除的main方法excludedClasses: 定义可以带main方法的类所匹配的名字形式UpperEll检查初始化长整型变量时，数字後是加了大写字母"L"而不是小写字母"l"ArrayTypeStyle检查再定义数组时，采用java风格还是c风格，例如：int[] num是java风格，int num[]是c风格javaStyle: 定义是否采用java风格定义数组FinalParameters检查参数是否是常量tokens: 定义检查的类型Indentation检查代码的缩进是否符合要求basicOffset: 定义代码体相对于所属的代码体的缩进量braceAdjustment: 定义括号的缩进量caseIndent: 定义case的缩进量RequiredRegexp检查文件中是否存在相应的文字format: 定义所匹配的形式usage.OneMethodPrivateField检查是否只有一个方法访问了私有变量ignoreFormat: 定义可以忽略的变量所匹配的命名形式usage.UnusedLocalVariable检查是否有命名後没有使用的变量ignoreFormat: 定义可以忽略的变量所匹配的命名形式usage.UnusedParameter检查是否有没有使用的参数ignoreFormat: 定义可以忽略的变量所匹配的命名形式ignoreCatch: 是否忽略catch中的参数ignoreNonLocal: 是否忽略非本地的变量usage.UnusedPrivateField检查是否存在未被使用的私有成员变量ignoreFormat: 定义可以忽略的变量所匹配的命名形式usage.UnusedPrivateMethod检查是否存在未被使用的私有方法ignoreFormat: 定义可以忽略的变量所匹配的命名形式

可以是数字、字母、下划线的组合，但不能以数字开头

用strictfp（精确浮点）修饰变量

重载:函数或者方法有同样的名称，但是参数列表不相同例子:public void func(String s) {...} / public void func(int i) {...}覆盖:也称重写，函数的签名完全相同，但函数体不同例子:public void func(String s) {...} / public void func(String s) {...}理解重载的话，你可以认为这是两个不同的函数而重写，你可以认为是同一个函数，但在不同的对象实例中做了不同的工作

C 正确写法为null

留个邮箱，我发给你……

可以用strictfp修饰类，就能解决了！

abstract //抽象方法，抽象类的修饰符assert //断言条件是否满足boolean //布尔数据类型break //跳出循环或者label代码段byte //8-bit 有符号数据类型case //switch语句的一个条件catch //和try搭配扑捉异常信息char //16-bit Unicode字符数据类型class //定义类const //未使用continue //不执行循环体剩余部分default //switch语句中的默认分支do //循环语句，循环体至少会执行一次double //64-bit双精度浮点数else //if条件不成立时执行的分支enum //枚举类型extends //表示一个类是另一个类的子类final //表示一个值在初始化之后就不能再改变了//表示方法不能被重写，或者一个类不能有子类finally //try 语句不管是否发生异常都要执行的语句块float //32-bit单精度浮点数for //for循环语句goto //未使用if //条件语句implements //表示一个类实现了接口import //导入类instanceof //测试一个对象是否是某个类的实例int //32位整型数interface //接口，一种抽象的类型，仅有方法和常量的定义long //64位整型数native //表示方法用非java代码实现new //分配新的类实例package //一系列相关类组成一个包private //表示私有字段，或者方法等，只能从类内部访问protected //表示字段只能通过类或者其子类访问//子类或者在同一个包内的其他类public //表示共有属性或者方法return //方法返回值short //16位数字static //表示在类级别定义，所有实例共享的strictfp //浮点数比较使用严格的规则super //表示基类switch //选择语句synchronized //表示同一时间只能由一个线程访问的代码块this //表示调用当前实例//或者调用另一个构造函数throw //抛出异常throws //定义方法可能抛出的异常transient //修饰不要序列化的字段try //表示代码块要做异常处理或者和finally配合表示是否抛出异常都执行finally中的代码void //标记方法不返回任何值volatile //标记字段可能会被多个线程同时访问，而不做同步while //while循环

x+y=?求和函数sum（需要整型x、y参数，返回整型结果）：public int sum(int x, int y){return x+y;}调用方法：public void test(){//定义函数返回结果变量，并且初始化int result =0;//求和函数调用result=sum(3,5);} 上面只是简单的例子，希望能帮到你。

c语言中的关键字和保留字的区别？ 在C语言中，关键字与保留字表示同一个概念，都是表示C语言提供的特殊识别符号，不能用作变数名。 C语言一共有32个关键字（或称保留字），各关键字及其含义如下： auto：指定变数的储存型别，是预设值 break：跳出回圈或switch语句 case：定义switch中的case子句 char：定义字元型变数或指标 const：定义常量或引数 continue：在回圈语句中，回到回圈体的开始处重新执行回圈 default：定义switch中的default子句 do：定义do-while语句 double：定义双精度浮点数变数 else：与if连用 enum：定义列举型别 extern：宣告外部变数或函式 float：定义浮点型变数或指标 for：定义for语句 goto：定义goto语句 if：定义if语句或if-else语句 int：定义整型变数或指标 long：定义长整型变数或指标 register：指定变数的储存型别是暂存器变数，Turbo c中用自动变数代替 return：从函式返回 short：定义短整型变数或指标 signed：定义有符号的整型变数或指标 sizeof：获取某种型别的变数或资料所占记忆体的大小，是运算子 static：指定变数的储存型别是静态变数，或指定函式是静态函式 struct：定义结构体型别 switch：定义switch语句 typedef：为资料型别定义别名 union：定义联合体型别 unsigned：定义无符号的整型变数或资料 void：定义空型别变数或空型别指标，或指定函式没有返回值 volatile：变数的值可能在程式的外部被改变 while：定义while或do-while语句 oracle的关键字和保留字的区别 Reserved Words Oracle SQL Reserved Words 如果不加转移字元是无法用作定义符的，比如说表名，列名，trigger名称等。 KeyWord Oracle SQL keyword 为非保留字，oracle内部使用， 是可以用作定义符的，但是不推荐，因为可读性差，维护体验差。 不建议过分纠结这个问题，多看官方文件就好了。 V$RESERVED_WORDS 这个视图里面详细介绍了Oracle资料库里面的保留字相关资讯，根据场景不同，限制条件也不同。记住一些常用的即可。 保留字是关键字，关键字不一定是保留字。保留字是指在Oracle的新版本已经弃用，但还是会出现在Oracle的新版本中。 mysql关键字和保留字的区别 但是这里要提一下的是mysql是支援使用关键字做栏位名的，但是针对保留关键字是必须要加引用。mysql官网提供了三个例子是可以很好的说明这些的。 interval begin、end都是关键字，interval是保留关键字，因此会报错 mysql> CREATE TABLE interval (begin INT, end INT); ERROR 1064 (42000): You have an error in your SQL syntax ... near "interval (begin INT, end INT)" 当给interval加上引用""后便可以正确执行该sql语句，也不会报begin、end的错，因为这是mysql允许的，但是不推荐这个用法，谁知道升级之后会不会变成保留字。。。。。。 mysql> CREATE TABLE `interval` (begin INT, end INT); Query OK, 0 rows affected (0.01 sec) （这个可以略过，，，，，反正不推荐使用关键字做这些事，）还有一种情况——内建函式的名字，官网是这样说的： Names of built-in functions are permitted as identifiers but may require care to be used as such mysql> CREATE TABLE mydb.interval (begin INT, end INT); Query OK, 0 rows affected (0.01 sec) JAVA中的关键字和保留字 找本书 看看 太多了 请问，c语言中，关键字和保留字是一个意思么？ c语言中的关键字和保留字含义是一样的，共有 32 个保留字或关键字，这些保留字或关键字是不能用来作为c程式中的识别符号的。 由ANSI标准定义的C语言关键字共32个 : auto double int struct break else long switchcase enum register typedef char extern return unionconst float short unsigned continue for signed voiddefault goto sizeof volatile do if while static Java中保留字和关键字的区别 Java的关键字对java的编译器有特殊的意义，他们用来表示一种资料型别，或者表示程式的结构等。保留字是为java预留的关键字，他们虽然现在没有作为关键字，但在以后的升级版本中有可能作为关键字。 Java 关键字列表 (依字母排序 共50组): abstract, assert,boolean, break, byte, case, catch, char, class, continue, default, do, double, else, enum,extends, final, finally, float, for, if, implements, import, instanceof, int, interface, long, native, new, package, private, protected, public, return, short, static, strictfp, super, switch, synchronized, this, throw, throws, transient, try, void, volatile, while Java 保留字列表 (依字母排序 共14组) : Java保留字是指现有Java版本尚未使用 但以后版本可能会作为关键字使用。 byValue, cast, false, future, generic, inner, operator, outer, rest, true, var，goto，const, null C++保留字 关键字区别 两者其实差不了多少，可以当一个概念理解 “保留字”和“ 关键字”的区别与联络？ 保留字: 系统留用(可能永远也不会用, 但是你不能用)。 关键字: 系统规定有特殊意义的词。 关键字, 一定是保留字。 保留字一般是等同于关键字的。 从字面含义上理解，保留字是语言中已经定义过的字，使用者不能再将这些字作为变数名或过程名使用。而关键字则指在语言中有特定含义，成为语法中一部分的那些字。在一些语言中，一些保留字可能并没有应用于当前的语法中，这就成了保留字与关键字的区别。

abstract assert boolean break byte case catch char class const continue default do double else enum extends final finally float for if goto implements import instanceof int interface long native new package private protected public return short static strictfp super switch synchronized this throw throws transient try void volatile while保留字const,goto

转的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和continuecontinue语句与break语句相关，但较少用到。continue语句用于使其所在的for、while或do-while语句开始下一次循环。在while与do-while语句中，continue语句的执行意味着立即执行测试部分；在for循环语句中，continue语句的执行则意味着使控制传递到增量部分。

问题一：什么叫关键词 关键词源于英文“keywords”，特指单个媒体在制作使用索引时，所用到的词汇。是图书馆学中的词汇。关键词搜索是网络搜索索引主要方法之一，就是希海访问者了解的产品或服务或者公司等的具体名称的用语。 问题二：关键词是什么 30分 关键词的概念 关键词英文为keywords，就是希望访问者了解的产品或服务或者公司等的具体名称的用语。 键词包括 一、核心关键词的确定（主体词）行业常用关键词：鲜花 二、关键词的拓展（拓展词）可分为: 地域扩充关键词：荷兰鲜花 行为扩充关键词：运送鲜花 譬如，有一个客户想在网上买鲜花，他将会在搜索框中输入关键词“鲜花”，寻找相关信息。 关键词内容功以是：人名、网站、新闻、小说、软件、游戏、星座、工作、购物、论文等等 关键词格式可以是任何中文、英文、数字，或中文英文数字的混合体。例如，您可以搜索[大话西游]、[windows]、[911]、[F-1赛车]。 关键词组合：您可以输入一个，也可以输入两个、三个、四个，您甚至可以输入一句话。例如，您可以搜索[爱]、[美女]、[mp3 下载]、[游戏 攻略 大全]、[蓦然回首，那人却在灯火阑珊处]。 输入多个关键词搜索，可以获得更精确更丰富的搜索结果。例如，在百度搜索引擎中搜索[北京 暂住证]，可以找到几万篇资料。而搜索[北京暂住证]，则只有严格含有北京暂住证连续5个字的网页才能被找出来，不但找到的资料只有几百篇，资料的准确性也比前者差得多。 因此，当你要查的关键词较为冗长时，建议将它拆成几个关键词来搜索，词与词之间用空格隔开。 多数情况下，输入两个关键词搜索，就已经有很好的搜索结果 问题三：什么是java关键字 关键字是电脑语言里事先定义的,有特别意义的标识符,有时又叫保留字 问题四：网络关键词是什么？ 网络关键词，是继IP地址和域名之后的第三代互联网名称资源，网络用户可以通过在浏览器地址栏输入中文关键词来直接访问目标网站。 问题五：C语言关键字是什么 所谓关键字就是已被 C语言编辑工具本身使用, 不能作其它用途使用的字。 auto ：声明自动变量 一般不使用 double ：声明双精度变量或函数 int： 声明整型变量或函数 struct：声明结构体变量或函数 break：跳出当前循环 else ：条件语句否定分支（与 if 连用） long ：声明长整型变量或函数 switch :用于开关语句 case：开关语句分支 enum ：声明枚举类型 register：声明积存器变量 typedef：用以给数据类型取别名（当然还有其他作用） char ：声明字符型变量或函数 extern：声明变量是在其他文件正声明（也可以看做是引用变量） return ：子程序返回语句（可以带参数，也看不带参数） union：声明联合数据类型 const ：声明只读变量 float：声明浮点型变量或函数 short ：声明短整型变量或函数 unsigned：声明无符号类型变量或函数 continue：结束当前循环，开始下一轮循环 for：一种循环语句(可意会不可言传） signed：生命有符号类型变量或函数 void ：声明函数无返回值或无参数，声明无类型指针（基本上就这三个作用） default：开关语句中的“其他”分支 goto：无条件跳转语句 sizeof：计算数据类型长度 volatile：说明变量在程序执行中可被隐含地改变 do ：循环语句的循环体 while ：循环语句的循环条件 static ：声明静态变量 if:条件语句 问题六：『关键词』是什么意思啊？ 关键词就是你想表达这句话里面最关键的一句词...比如说你想搜索我感冒了吃什么药,感冒药就是关键词,,,,你想浏览一些拳击方面的教程,拳击教程就是关键词 问题七：工商银行的行名关键字是什么 在选定了收款银行行别（工商银行，中国银行、建设银行、信用社等）的前提下，关键字一般用XX市，中的XX就行了，注意输入关键字的时候不要带“市”、“县”、“镇”等字眼。 举个例子，广东省广州市天河区某某支行，关键字一般输入“广州”就行了，没必要定位得太准确，有时定位得太准确的话还可能查找不到（有些分行或支行没有申请支付系统行号），但是比较大的分行一般都会有支付系统行号。你要转账到广州某某支行，你只要汇款到广州分行就行，他自然会帮你转到收款人的开户行的。 问题八：关键字是什么意思？ 能代表你所写文字或者报道或者事件阐述等的几个字。比如一篇公务员考试的复习试题，无论写的是什么，搜索公务员考试题就能搜到。找到那几个关键字，就能找到你那件事情，揣就是关键字的作用。 问题九：计算机c语言关键字是什么 auto ：声明自动变量 一般不使用 double ：声明双精度变量或函数 int： 声明整型变量或函数 struct：声明结构体变量或函数 break：跳出当前循环 else ：条件语句否定分支（与 if 连用） long ：声明长整型变量或函数 switch :用于开关语句 case：开关语句分支 enum ：声明枚举类型 register：声明积存器变量 typedef：用以给数据类型取别名（当然还有其他作用） char ：声明字符型变量或函数 extern：声明变量是在其他文件正声明（也可以看做是引用变量） return ：子程序返回语句（可以带参数，也看不带参数） union：声明联合数据类型 const ：声明只读变量 float：声明浮点型变量或函数 short ：声明短整型变量或函数 unsigned：声明无符号类型变量或函数 continue：结束当前循环，开始下一轮循环 for：一种循环语句(可意会不可言传） signed：生命有符号类型变量或函数 void ：声明函数无返回值或无参数，声明无类型指针（基本上就这三个作用） default：开关语句中的“其他”分支 goto：无条件sizeof：计算数据类型长度 volatile：说明变量在程序执行中可被隐含地改变 do ：循环语句的循环体 while ：循环语句的循环条件 static ：声明静态变量 if:条件语句注：关键字auto用于说明自动变量，通常不用；volatile（易变的）表示该变量不经过赋值，其值也可能被改变（例如表示时钟的变量、表示通信端口的变量等）。 问题十：什么是关键字？有什么特点？ 关键字：就是被java赋予了特殊含义的英文单词。在editplus编辑器中书写时字体颜色会变。 (1)用于定义权限修饰的关键字 private protected public （2）用来定义类函数变量修饰符的关键字 abstract final static synchronized （3）用来定义类与类之间的关键字 extends implements （4）用来定义建立实例及引用实例，判断实力的关键字 new this super instanceof （5）用于艺术处理的关键字 try catch finally throw throws (6)用于包的关键字 package import (7)其他修饰符关键字 native strictfp transient volatile assert

分类: 电脑/网络 >> 程序设计 >> 其他编程语言 解析: Java编程基础 原创：EOC_ZX 2002年10月4日 Java语言由语法规则和类库两部分组成，其中语法规则确定了Java程序的书写规范，学习好语法规则是Java语言，也是所有编程语言的基本功。本文主要向大家简单介绍一下Java的语法规则。 Java语言与C/C++语言有着紧密的联系，Java中的许多术语来自于C++，起语法也来自于C++。因此Java的语法和c++的语法计划一模一样。下面简单介绍一下Java的具体语法。 一、Java的词法1、标识符 标识符是类、变量和方法等的名字，作用是让编译器能够识别它们。在Java语言中，标识符可以包含数字、字母、下划线(_)和美圆符号($)，但是不能以数字作为开头。与C/C++语言不同的是，Java语言还可以将一些非拉丁字母包含在标识符中，这是因为Java语言使用的是Unicode字符，所有的十六进制00C0以上的Unicode字符都可以用在标识符中。但是Java语言的关键字是不能用来作为标识符的。 我们在使用标识符的时候应该尽量表达所要表示的类、变量、方法等的含义。另外，标识符中可以使用下划线，我们应该充分利用这一点以提高程序的可读性。 2、关键字 以下是Java的全部关键字： abstract double int strictfp** boolean else interface super break extends long switch byte final native synchronized case finally new this catch float package throw char for private throws class goto* protected transient const* if public try continue implements return void default import short volatile do instanceof static while * 尚未使用的关键字 ** 为Java 2增加的关键字 3、注释 Java有三种形式的注释： 第一种是C语言的传统注释方式，即将“/*”和“*/”之间的文本都视为注释，这种注释可以跨越多行。 第二种是C++风格的注释，即将“”之后直到行尾的文本都视为注释，这种注释只能包含一行。 第三种是Java新增加的注释方式，即将“/**”和“*/”之间的文本都视为注释，这种注释也可以夸耀多行。注意，这种注释方式生成的注释将作为Javadoc文档保存。 二、操作符 1、算术操作符 操作符 用途 优先级 结合性 ++，-- 自动递增，自动递减 2(仅次于括号) 从右到左 +，- 一元加，一元减 2 从右到左 *，/ 乘，除 3 从左到右 % 取余(求模) 3 从左到右 +，- 加，减 4 从左到右 2、布尔运算与关系运算符 操作符 用途 优先级 结合性 >,<,>=,<= 测试相对大小 6 从左到右 == 测试相等性 7 从左到右 != 测试不等性 7 从左到右 ?: 根据第一个操作数返回后两个操作数之一 13 从左到右 ! 非 2 从右到左 & 布尔与 8 从左到右 ^ 异或 9 从左到右 | 布尔或 10 从左到右 && 条件与 11 从左到右 || 条件或 12 从左到右 3、位操作符 操作符 用途 优先级 结合性 ~ 非(位求补) 2 从右到左 <<,>> 左移，右移 5 从左到右 >>> 当作无符号右移 5 从左到右 & 位和 8 从左到右 ^ 位异或 9 从左到右 | 位或 10 从左到右 4、赋值操作符 操作符 用途 优先级 结合性 = 赋值 14 从右到左 *= 操作同时赋值 14 从右到左 /= 操作同时赋值 14 从右到左 %= 操作同时赋值 14 从右到左 += 操作同时赋值 14 从右到左 -= 操作同时赋值 14 从右到左 >>= 操作同时赋值 14 从右到左 <<= 操作同时赋值 14 从右到左 >>>= 操作同时赋值 14 从右到左 ^= 操作同时赋值 14 从右到左 |= 操作同时赋值 14 从右到左 &= 操作同时赋值 14 从右到左 5、特殊操作符 cast操作符将一种数据类型转换成为另一种数据类型，cast应写成把要校正操作数的类型名放在括号中。 例如： int i; long l; l=7876547; i=(int)l; 如果给高精度的变量赋予一个低精度值，则不需校正。类型校正操作符的优先级为2，结合性为从右到左结合。 将以上讲到的操作符的优先级总结如下： 优先级 运算符 结合顺序 1 []数组运算 .点运算符 （）调用方法 从左到右 2 ! ~ ++ -- +(一元加) -(一元减) （）强制类型转换 new 从右到左 3 * / % 从左到右 4 +(二元加) -(二元减) 从左到右 5 >> << >>> 从左到右 6 < <= > >= instanceof 从左到右 7 == != 从左到右 8 & 从左到右 9 ^ 从左到右 10 | 从左到右 11 && 从左到右 12 || 从左到右 13 ?: 从左到右 14 = += -= *= /= %= &= |= ^= <<= >>= >>>= 从右到左 三、常量 1、整型常量 在Java语言中，整型常量有三种形式，它们分别是：十进制、八进制、十六进制。 需要注意的是十进制数不能以0开头，这是因为八进制的数是以0开头的，而十六进制数以0x或0X开头。 2、浮点型常量 浮点数只能表示十进制数。浮点数有两种表示方法，即标准表示法和科学记数法。浮点数又分为单精度数和双精度数。 3、布尔型常量 布尔型常量有两个值：ture(或TURE)和false(或FALSE)它们分别表示真和假，这两个值用来表示事物的状态，它们必居其一。通过测量布尔值可以判断是否执行某个步骤。 4、字符型常量 字符型常量是一个单一的字符，其形式是由两个单引号引起来的一个字符。但是两个单引号引起来的不能是单引号和反斜杠，即‘""和‘"是不正确的写法。 大家一定要记住，Java语言中的字符是16位的Unicode字符，这与C/C++等语言是不一样的。 同C/C++语言一样，Java语言也有转意序列。Java中的转意序列的功能见下表： 转义序列 标准形式 功能描述 继续 NL 回车换行 HT 水平制表符  BS 后退一格 CR 回车不换行 f FF 换页 " " 单引号 \ 反斜杠 " " 双引号 ddd 0ddd 八进制模式 xddd 0xddd 十六进制模式 udddd 0xdddd Unicode双字节字符 字符串常量 字符串常量是由双引号引起来的一系列字符，与C/C++语言中不同的是，Java语言中的字符串不是通过字符数组来实现的，而是通过字符串类（即String类）来实现的。 四、变量和数据类型 在Java中，数据的类型可以分为四种：基本数据类型、数组类型、类和接口类型。任何数据都一定是上述数据类型的一种。 其中基本数据类型可以分为四大类：布尔型、字符型、整数型和浮点型。这些类型的数据与前面介绍的常量的类型基本相同，在此不再多说。下面将整数型和浮点型变量的取值范围列出： 表一、 类型 宽度 取值范围 byte 8位 -256到256 short 16位 -32768到32767 int 32位 -***********到*********** long 64位 -9223372036854775808到9223372036854775807 表二、 进制 整数 长整数 十进制 最大正整数 ***********(2的31次方减1) 923372036854775807L(2的63次方减1) 八进制 最大正整数 077777777777(2的31次方减1) 07777777777777777777L(2的63次方减1) 最小负整数 020000000000(-2的31次方) 04000000000000000000L(-2的63次方) 十六进制 最大正整数 0x7fffffff(2的31次方减1) 0x7fffffffffffffffL(2的63次方减1) 最小负整数 0x***********(-2的31次方) 0x8000000000000000L(-2的63次方) 浮点数能表示的数值从小到大分别是：负无穷大、负有限值、负零、正零、正有限值及正无穷大。其中正零和负零在进行数值比较的时候是相等的，但仍有办法分辨这两个值，例如在进行1.0/0.0的时候会得到正无穷大的结果。其它非零非无穷大的有限值是以s*m*(2^e)来表示的，s和m的取值范围见下表： 表三、 类型 s m e float +1或-1 小于2的24次方的正整数 149到104的整数 double +1或-1 小于2的53次方的正整数 1045到1000的整数 表四、float 最大值 ***********e+38f 非零最小值 1.***********e-45f double 最大值 1.79769313486231570e+308 非零最小值 4.940656458412465334e-324 另外浮点数还有一些特殊值，见下表：float 最大值 Float.MAX_VALUE 最小值 Float.MIN_VALUE 正无穷大 Float.POSITIVE_INFINITY 负无穷大 Float.NEGATIVE_INFINITY NaN Float.NaN double 最大值 Double.MAX_VALUE 最小值 Double.MIN_VALUE 正无穷大 Double.POSITIVE_INFINITY 负无穷大 Double.NEGATIVE_INFINITY NaN Double.NaN 与C/C++语言中不同的是，在Java语言中，所有的基本数据类型都有预设值，就是说当我们声明一个变量时，即使我们没有对它赋值，它的值也是一定的，而不像在C/C++中那样是不可预测的。具体个类型的预设值见下表： 基本数据类型 预设值 Boolean false Char "u000" Byte (byte)0 Short (short)0 Int 0 Long 0L Float 0.0L Double 0.0d 五、Java与C/C++的比较 由于Java的语法直接来源于C/C++,所以Java的程序控制语句与C/C++一模一样，在此不再多说。以下重点介绍一下Java与C/C++的不同。 指针 大家在使用C语言编程的时候想必都曾经因为指针的复杂计算而烦恼，在C/C++语言编程过程中，指针可能引起许多错误，这些复杂的指针算法所产生的错误常常让人迷惑不解，导致C/C++程序员在此浪费了大量的时间。考虑到这种原因，Java中取消了指针。指针的功能由参考(reference)所取代，这使得Java中对复杂数据结构的实现更加容易，因为用对象和对象数组实现复杂的数据结构更可靠。 函数 在Java中没有C/C++中应用广泛的函数，C/C++中通过函数实现的功能在Java中都是通过类和方法来实现的。 继承 C++支持多重继承，这是一个从多个父类中派生一个类的有效办法，但这种派生很复杂，也很容易产生问题。因此，Java中没有采用多重继承，但Java的Objective C协议接口能完成C++中多重继承的所有功能。 goto语句 大家知道，在使用高级语言编程时过多的使用goto语句会使程序变得十分混乱，因此Java中也没有使用goto语句。但是不可否认，当程序比较容易控制的时候，适当使用goto语句能使程序的运行更快捷，因此Java中使用了多重break和continue语句(允许break和continue语句使用标签)实现C++种goto语句的功能。 联合和结构 在C++中有三种数据结构：联合、结构和类；Java中只有类，它可以实现上述三者的功能。 字符串 在C/C++中，字符串是通过字符数组实现的，但是由于数组的空间不是动态分配的，这容易出现越界错误，例如：常有预先设定的字符数组不能容纳后输入的字符串。在Java中，字符串是一类特定的对象，这使得字符串更具有一致性和可预见性。 Typedef、Define和预处理器 Java中不需要#define语句、预处理器或者typedef，但需要头文件。在Java中一个类的信息必须包含在一个文件中，而C/C++中有关类的信息可能分散在多个文件中。 数据类型的自动强制转换 在Java中强制一种类型的数据元素变成一种不太精确的数据类型需要编程人员采用预测方法。

英语不好完全可以学JAVA的哦，JAVA不需要记很多的词汇量，学习Java主要是需要很大的毅力，Java学习是一个漫长的过程，换算成时间每天如果学8小时的话，大概需要4个月左右，涉及到的内容非常多，简单的网页制作，简单的js脚本，数据库，各种常用的框架等。

static

Java是一种广泛使用的计算机编程语言，拥有跨平台、面向对象、泛型编程的特性，广泛应用于企业级Web应用开发和移动应用开发。任职于太阳微系统的詹姆斯·高斯林等人于1990年代初开发Java语言的雏形，最初被命名为Oak，目标设置在家用电器等小型系统的程序语言，应用在电视机、电话、闹钟、烤面包机等家用电器的控制和通信。由于这些智能化家电的市场需求没有预期的高，Sun公司放弃了该项计划。随着1990年代互联网的发展，Sun公司看见Oak在互联网上应用的前景，于是改造了Oak，于1995年5月以Java的名称正式发布。Java伴随着互联网的迅猛发展而发展，逐渐成为重要的网络编程语言。Java编程语言的风格十分接近C语言。继承了C语言面向对象技术的核心，Java舍弃了C语言中容易引起错误的指针，改以引用取代，同时移除原C与原来运算符重载，也移除多重继承特性，改用接口取代，增加垃圾回收器功能。在JavaSE1.5版本中引入了泛型编程、类型安全的枚举、不定长参数和自动装/拆箱特性。太阳微系统对Java语言的解释是：“Java编程语言是个简单、面向对象、分布式、解释性、健壮、安全与系统无关、可移植、高性能、多线程和动态的语言”Java不同于一般的编译语言或直译语言。它首先将源代码编译成字节码，然后依赖各种不同平台上的虚拟机来解释执行字节码，从而实现了“一次编写，到处运行”的跨平台特性。在早期JVM中，这在一定程度上降低了Java程序的运行效率。但在J2SE1.4.2发布后，Java的运行速度有了大幅提升。与传统类型不同，Sun公司在推出Java时就将其作为开放的技术。全球数以万计的Java开发公司被要求所设计的Java软件必须相互兼容。“Java语言靠群体的力量而非公司的力量”是Sun公司的口号之一，并获得了广大软件开发商的认同。这与微软公司所倡导的注重精英和封闭式的模式完全不同，此外，微软公司后来推出了与之竞争的.NET平台以及模仿Java的C语言。后来Sun公司被甲骨文公司并购，Java也随之成为甲骨文公司的产品。现时，移动操作系统Android大部分的代码采用Java编程语言编程。早期的JavaJava的发明人詹姆斯·高斯林Duke，Java语言的吉祥物语言最开始只是Sun计算机（Sun）公司在1990年12月开始研究的一个内部项目。Sun计算机公司的一个叫做帕特里克·诺顿的工程师被公司自己开发的C和C语言编译器搞得焦头烂额，因为其中的API极其难用。帕特里克决定改用NeXT，同时他也获得了研究公司的一个叫做“Stealth计划”的项目的机会。“Stealth计划”后来改名为“Green计划”，詹姆斯·高斯林和麦克·舍林丹也加入了帕特里克的工作小组。他们和其他几个工程师一起在加利福尼亚州门罗帕克市沙丘路的一个小工作室里面研究开发新技术，瞄准下一代智能家电（如微波炉）的程序设计，Sun公司预料未来科技将在家用电器领域大显身手。团队最初考虑使用C语言，但是很多成员包括Sun的首席科学家比尔·乔伊，发现C和可用的API在某些方面存在很大问题。工作小组使用的是嵌入式系统，可以用的资源极其有限。很多成员发现C太复杂以至很多开发者经常错误使用。他们发现C缺少垃圾回收系统，还有可移植的安全性、分布程序设计、和多线程功能。最后，他们想要一种易于移植到各种设备上的平台。根据可用的资金，乔伊决定开发一种集C语言和Mesa语言大成的新语言，在一份报告上，乔伊把它叫做“未来”，他提议Sun公司的工程师应该在C的基础上，开发一种面向对象的环境。最初，高斯林试图修改和扩展C的功能，他自己称这种新语言为C--，但是后来他放弃了。他将要创造出一种全新的语言，被他命名为“Oak”（橡树），以他的办公室外的橡树命名。就像很多开发新技术的秘密工程一样，工作小组没日没夜地工作到了1993年的夏天，他们能够演示新平台的一部分了，包括Green操作系统，Oak的程序设计语言，类库及其硬件。最初的尝试是面向一种类PDA设备，被命名为Star7，这种设备有鲜艳的图形界面和被称为“Duke”的智能代理来帮助用户。1992年12月3日，这台设备进行了展示。同年11月，Green计划被转化成了“FirstPerson有限公司”，一个Sun公司的全资子公司，团队也被重新安排到了帕洛阿尔托。FirstPerson团队对建造一种高度交互的设备感兴趣，当时代华纳发布了一个关于电视机顶盒的征求提议书时（Requestforproposal），FirstPerson改变了他们的目标，作为对征求意见书的响应，提出了一个机顶盒平台的提议。但是有线电视业界觉得FirstPerson的平台给予用户过多的控制权，因此FirstPerson的投标败给了SGI。与3DO公司的另外一笔关于机顶盒的交易也没有成功，由于他们的平台不能在电视工业产生任何效益，公司被并回Sun公司。Java和互联网1994年6月，在经历了一场历时三天的脑力激荡的讨论后，约翰·盖吉、詹姆斯·高斯林、比尔·乔伊、帕特里克·诺顿、韦恩·罗斯因和埃里克·斯库米，团队决定再一次改变了努力的目标，这次他们决定将该技术应用于万维网。他们认为随着Mosaic浏览器的到来，因特网正在向同样的高度互动的远景演变，而这一远景正是他们在有线电视网中看到的。作为原型，帕特里克·诺顿写了一个小型万维网浏览器，WebRunner，后来改名为HotJava[12]。1994年10月，HotJava和Java平台为公司高层进行演示。1994年，Java1.0a版本已经可以提供下载，但是Java和HotJava浏览器的第一次公开发布却是在1995年3月23日SunWorld大会上进行的。升阳公司的科学指导约翰·盖吉宣告Java技术。这个发布是与网景公司的执行副总裁马克·安德森的惊人发布一起进行的，宣布网景将在其浏览器中包含对Java的支持。1996年1月，升阳公司成立了Java业务集团，专门开发Java技术。Java和“Java”由于商标搜索显示，Oak已被一家显示卡制造商注册。于是同年，Oak被改名为Java。当使用十六进制编辑器打开由Java源代码编译出的二进制文件（.class文件）的话，最前面的32位将显示为CAFEBABE，即词组“CAFEBABE”（咖啡屋宝贝）。Java近况一套Java编辑器软件J2SE环境与CDC的关连JVM的所在角色JSPX网页的概念在流行几年之后，Java在浏览器中的地位被逐步侵蚀。它在简单交互性动画方面的用途已经完全被Adobe公司的Flash排挤，2005年Java倾向只被用于雅虎游戏那样的更为复杂的应用程序。Java同时遭受到来自微软的反对，他们决定在新版本的InternetExplorer和Windows中不再附带Java平台。与此相反。在万维网的服务器端和手持设备上，Java变得更加流行。很多网站在后端使用JSP和其他的Java技术。在桌面系统上，独立的Java程序还是相对少见，这是因为Java平台的运行开销较大，而许多人的电脑上没有安装Java，由于网络带宽在以前较小，下载Java曾经是个耗时的事情。但是随着计算机计算能力、网络带宽在10年中获取了很大的进步，同时虚拟机和编译器的质量得到了提高，许多应用程序得到了广泛的使用，包括：开源软件：NetBeans和Eclipse等软件开发工具Android操作系统JEditAzureusBitTorrent客户端。JNode操作系统Apache软件基金会的Ant、Derby、Hadoop、Jakarta、POI和TomcatJBoss和GlassFish应用服务器商业软件：EIOffice（永中Office）Minecraft纯Java3D游戏合金战士ChromeIBMWebsphere、ColdFusion和WebLogicIntelliJIDEA还有许多用Java写的软件，可以在www.java找到。在以下网页可以看到非常多用Java写的程序：java.sun/procts/下面有大量用JavaSwing开发的桌面Java程序java.sun/procts/jfc/tsc/sightings/目前Java提供以下三个版本：JavaPlatform,EnterpriseEdition（JavaEE：Java平台企业版）JavaPlatform,StandardEdition（JavaSE：Java平台标准版）JavaPlatform,MicroEdition（JavaME：Java平台微型版）JavaPlatform,CardEditionJava开放源代码项目2006年SUN在JavaOne公布Java开放源代码项目，并推出OpenJDK项目。[13]Java虚拟机、Java编译器和Java类库以GNU通用公共许可证公开。版本历史主条目：Java版本历史1995年5月23日，Java语言诞生1996年1月，第一个JDK-JDK1.0诞生1996年4月，10个最主要的操作系统供应商申明将在其产品中嵌入JAVA技术1996年9月，约8.3万个网页应用了JAVA技术来制作1997年2月18日，JDK1.1发布1997年4月2日，JavaOne会议召开，参与者逾一万人，创当时全球同类会议规模之纪录1997年9月，社区成员超过十万1998年2月，JDK1.1被下载超过2,000,000次1998年12月8日，JAVA2企业平台J2EE发布1999年6月，SUN公司发布Java的三个版本：标准版（J2SE）、企业版（J2EE）和微型版（J2ME）2000年5月8日，JDK1.3发布2000年5月29日，JDK1.4发布2001年6月5日，NOKIA宣布，到2003年将出售1亿部支持Java的手机2001年9月24日，J2EE1.3发布2002年2月26日，J2SE1.4发布，自此Java的计算能力有了大幅提升2004年9月30日18:00PM，J2SE1.5发布，成为Java语言发展史上的又一里程碑。为了表示该版本的重要性，J2SE1.5更名为JavaSE5.02005年6月，JavaOne大会召开，SUN公司公开JavaSE6。此时，Java的各种版本已经更名，以取消其中的数字“2”：J2EE更名为JavaEE，J2SE更名为JavaSE，J2ME更名为JavaME2006年12月，SUN公司发布JRE6.02009年12月，SUN公司发布JavaEE62010年11月，由于Oracle公司对于Java社区的不友善，因此Apache扬言将退出JCP[14]2011年7月28日，Oracle公司发布JavaSE72014年3月18日，Oracle公司发表JavaSE8语言特性Java之所以被开发，是要达到以下五个目的：应当使用面向对象程序设计方法学应当允许同一程序在不同的计算机平台执行应当包括内建的对计算机网络的支持应当被设计成安全地执行远端代码应当易于使用，并借鉴以前那些面向对象语言（如C）的长处。Java技术主要分成几个部分：Java语言、Java运行环境、类库。一般情况下说Java时并不区分指的是哪个部分。Java在1.5版本时，做了重大改变，Sun公司并1.5版本重命名为Java5.0。面向对象Java的特点之一就是面向对象，是程序设计方法的一种。“面向对象程序设计语言”的核心之一就是开发者在设计软件的时候可以使用自定义的类型和关联操作。代码和数据的实际集合体叫做“对象”。一个对象可以想象成绑定了很多“行为（代码）”和“状态（数据）”的物体。对于数据结构的改变需要和代码进行通信然后操作，反之亦然。面向对象设计让大型软件工程的计划和设计变得更容易管理，能增强工程的健康度，减少失败工程的数量。跨平台性Java语言的第二个特性就是跨平台性，也就是说使用Java语言编写的程序可以在编译后不用经过任何更改，就能在任何硬件设备条件下运行。这个特性经常被称为“一次编译，到处运行”。执行Java应用程序必须安装爪哇运行环境（JavaRuntimeEnvironment，JRE），JRE内部有一个Java虚拟机（JavaVirtualMachine，JVM）以及一些标准的类库（ClassLibrary）。通过JVM才能在电脑系统执行Java应用程序（JavaApplication），这与.NetFramework的情况一样，所以电脑上没有安装JVM，那么这些程序将不能够执行。实现跨平台性的方法是大多数编译器在进行Java语言程序的编码时候会生成一个用字节码写成的“半成品”，这个“半成品”会在Java虚拟机（解释层）的帮助下运行，虚拟机会把它转换成当前所处硬件平台的原始代码。之后，Java虚拟机会打开标准库，进行数据（图片、线程和网络）的访问工作。主要注意的是，尽管已经存在一个进行代码翻译的解释层，有些时候Java的字节码代码还是会被JIT编译器进行二次编译。有些编译器，比如GCJ，可以自动生成原始代码而不需要解释层。但是这些编译器所生成的代码只能应用于特定平台。并且GCJ目前只支持部分的JavaAPI。甲骨文公司对于Java的许可是“全兼容的”，这也导致了微软和升阳关于微软的程序不支持RMI和JNI接口、并且增加特性为己所用的法律争端。升阳最终赢得了官司，获得了大约两千万美元的赔偿，法院强制要求微软执行升阳公司关于Java的许可要求。作为回应，微软不再在Windows系统中捆绑Java，最新的Windows版本，WindowsVista和InternetExplorer7.0版本也不再提供对于Java应用程序和控件的支持。但是升阳公司和其他使用Java运行时系统的公司在Windows操作系统下对用户提供无偿的第三方插件和程序支持。Java语言使用解释层最初是为了轻巧性。所以这些程序的运行效率比C语言和C要低很多，用户也对此颇有微词。很多最近的调查显示Java的程序运行速度比几年前要高出许多，有些同样功能的程序的效率甚至超过了C和C语言编写的程序[来源请求]。Java语言在最开始应用的时候是没有解释层的，所有需要编译的代码都直接转换成机器的原始代码。这样做的后果就是获得了最佳的性能，但是程序臃肿异常。从JIT技术开始，Java的程序都经过一次转换之后才变成机器码。很多老牌的第三方虚拟机都使用一种叫做“动态编译”的技术，也就是说虚拟机实时监测和分析程序的运行行为，同时选择性地对程序所需要的部分进行编译和优化。所有这些技术都改善了代码的运行速度，但是又不会让程序的体积变得失常。程序的轻便性事实上是软件编写很难达到的一个目标，Java虽然成功地实现了“一次编译，到处运行”，但是由于平台和平台之间的差异，所编写的程序在转换代码的时候难免会出现微小的、不可察觉的错误和意外。有些程序员对此非常头疼，他们嘲笑Java的程序不是“一次编译，到处运行”，而是“一次编译，到处调试”。以JavaAWT为例，早期JavaAWT内提供的按钮、文字区等均是以计算机系统所默认的样式而显示。这令Java程序在有些没有提供图案的计算机系统产生错误（在MicrosoftWindows设有窗口管理器，在一些Linux则没有）。后来SUN公司针对JavaAWT一些问题而推出JavaSwing。平台无关性让Java在服务器端软件领域非常成功。很多服务器端软件都使用Java或相关技术建立。自动垃圾回收（GarbageCollection）C语言被用户诟病的原因之一是大多数C编译器不支持垃圾收集机制。通常使用C编程的时候，程序员于程序中初始化对象时，会在主机内存堆栈上分配一块内存与地址，当不需要此对象时，进行析构或者删除的时候再释放分配的内存地址。如果对象是在堆栈上分配的，而程序员又忘记进行删除，那么就会造成内存泄漏（MemoryLeak）。长此以往，程序运行的时候可能会生成很多不清除的垃圾，浪费了不必要的内存空间。而且如果同一内存地址被删除两次的话，程序会变得不稳定，甚至崩溃。因此有经验的C程序员都会在删除之后将指针重置为NULL，然后在删除之前先判断指针是否为NULL。C中也可以使用“智能指针”（SmartPointer）或者使用C托管扩展编译器的方法来实现自动化内存释放，智能指针可以在标准类库中找到，而C(题主你怎么可以问这么沙比的问题！)托管扩展被微软的VisualC7.0及以上版本所支持。智能指针的优点是不需引入缓慢的垃圾收集机制，而且可以不考虑线程安全的问题，但是缺点是如果不善使用智能指针的话，性能有可能不如垃圾收集机制，而且不断地分配和释放内存可能造成内存碎片，需要手动对堆进行压缩。除此之外，由于智能指针是一个基于模板的功能，所以没有经验的程序员在需要使用多态特性进行自动清理时也可能束手无策。Java语言则不同，上述的情况被自动垃圾收集功能自动处理。对象的创建和放置都是在内存堆栈上面进行的。当一个对象没有任何引用的时候，Java的自动垃圾收集机制就发挥作用，自动删除这个对象所占用的空间，释放内存以避免内存泄漏。注意程序员不需要修改finalize方法，自动垃圾收集也会发生作用。但是内存泄漏并不是就此避免了，当程序员疏忽大意地忘记解除一个对象不应该有的引用时，内存泄漏仍然不可避免。不同厂商、不同版本的JVM中的内存垃圾回收机制并不完全一样，通常越新版本的内存回收机制越快，IBM、BEA、SUN等等开发JVM的公司都曾宣称过自己制造出了世界上最快的JVM[来源请求]，JVM性能的世界纪录也在不断的被打破并提高。IBM有一篇有关Java内存回收机制比不激活垃圾收集机制的C内存处理快数倍的技术文章[15]，而著名的Java技术书籍《Java编程思想》（ThinkinginJava）也有一段论述Java内存及性能达到甚至超过C的章节[16]。基本语法编写Java程序前应注意以下几点：大小写敏感：Java是大小写敏感的，这就意味着标识符Hello与hello是不同的。类名：对于所有的类来说，类名的首字母应该大写。如果类名由若干单词组成，那么每个单词的首字母应该大写，例如。方法名：所有的方法名都应该以小写字母开头。如果方法名含有若干单词，则后面的每个单词首字母大写，例如。源文件名：源文件名必须和类名相同。当保存文件的时候，你应该使用类名作为文件名保存（切记Java是大小写敏感的），文件名的后缀为.java。（如果文件名和类名不相同则会导致编译错误）。主方法入口：所有的Java程序由publicstaticvoidmain（String[]args）方法开始执行。Java关键字关键字下面列出了Java关键字。这些关键字不能用于常量、变量、和任何标识符的名称。关键字描述abstract抽象方法，抽象类的修饰符assert断言条件是否满足continue不执行循环体剩余部分defaultswitch语句中的默认分支do-while循环语句，循环体至少会执行一次double64-bit双精度浮点数elseif条件不成立时执行的分支enum枚举类型extends表示一个类是另一个类的子类final表示定义常量finally无论有没有异常发生都执行代码float32-bit单精度浮点数forfor循环语句goto用于流程跳转（不可用，意即不可随意跳转）if条件语句implements表示一个类实现了接口import导入类instanceof测试一个对象是否是某个类的实例int32位整型数interface接口，一种抽象的类型，仅有方法和常量的定义long64位整型数native表示方法用非java代码实现new分配新的类实例package一系列相关类组成一个包private表示私有字段，或者方法等，只能从类内部访问protected表示保护类型字段public表示共有属性或者方法return方法返回值short16位数字static表示在类级别定义，所有实例共享的strictfp浮点数比较使用严格的规则super表示基类switch选择语句表示同一时间只能由一个线程访问的代码块this调用当前实例或者调用另一个构造函数throw抛出异常throws定义方法可能抛出的异常transient修饰不要序列化的字段try表示代码块要做异常处理void标记方法不返回任何值volatile标记字段可能会被多个线程同时访问，而不做同步whilewhile循环注释注释作用：标识程序是干什么的，以及它是如何构建的。注释帮助程序员进行相互沟通以及理解程序。注释不是程序设计语言，所以编译器编译程序时忽略它们。接口和类别Java自带了创建接口的类别，可以这样使用：publicinterfaceDeleteab

关键字是用来标识文件中各个记录的特定数据项目的值。关键字是电脑语言里事先定义的，有特别意义的标识符，有时又叫保留字。系统定义了以下关键字：Const（常数） Dim（定义） As（为） Mod（取模）And（并且） Or（或者） Not（非）If （如果） Else（否则）Stop（停止） End（结束）Select（选择） Case（条件） Is （是）For（计数） To（到） Step（步长）Byref（传址） Byval（传值）Sub（子程序） Function（函数） Exit（退出）Do（做） Loop（循环） Until（除非） While（当） Wend（当结束）Let（让） Call（调用）Rem（注释）Integer(整数） Long（长整数) Single（单精度小数） Double(双精度，小数) Boolean(布尔) String（字符串，文字）Me（我） Private（私有） Public（公共）注意：vb里名称与关键字不区分字母的大小写；在c语言里，一切都是小写字母C，C++，java语言关键字调查统计：C，C++,JAVA共有的关键字-----22个int char float double short longif elseswitch case defaultfor while dovoid returncontinue breakconst goto (JAVA中未用，但是保留字）volatile staticC和C++共有的关键字（除三者共有）----10个unsigned signedstruct enum unionauto register externsizeof typedefC++和JAVA共有的关键字----11个（9个）class new public private protected this try throw catch (true false)C++特有的关键字（除JAVA和其共有的）----20个asm bool explicit export friend inline mutable operator templatetypeid virtual warch_t delete namespace typename usingconst_castdynamic_cast reinterpret_cast static_castJAVA特有的关键字（除C++和其共有的）----17个abstract boolean byte extends final finally implements import instanceof interfacenative package super synchronized throws transient strictfpnull （仅在java用，类似true和false不是关键字）所以说：C有22+10 = 32个关键字C++ 有22+10+11+20 = 63 个关键字JAVA 有22+ 9+ 17 = 48 个关键字

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中的语法是指java中的规则，即java的命名规则：包的命名　 （全部小写，由域名定义）Java包的名字都是由小写单词组成。但是由于Java面向对象编程的特性，每一名Java程序员都 可以编写属于自己的Java包，为了保障每个Java包命名的唯一性，在最新的Java编程规范中，要求程序员在自己定义的包的名称之前加上唯一的前缀。 由于互联网上的域名称是不会重复的，所以程序员一般采用自己在互联网上的域名称作为自己程序包的唯一前缀。例如：net.frontfree.javagroup 类的命名 （单词首字母大写）根据约定，Java类名通常以大写字母开头，如果类名称由多个单词组成，则每个单词的首字母均应为大 写例如TestPage；如果类名称中包含单词缩写，则这个所写词的每个字母均应大写，如：XMLExample,还有一点命名技巧就是由于类是设计用来 代表对象的，所以在命名类时应尽量选择名词。例如： Graphics 方法的命名 （首字母小写，字母开头大写）方法的名字的第一个单词应以小写字母作为开头，后面的单词则用大写字母开头。 例如：drawImage 常量的命名 （全部大写 ，常加下划线） 常量的名字应该都使用大写字母，并且指出该常量完整含义。如果一个常量名称由多个单词组成，则应该用下划线来分割这些单词。 例如：MAX_VALUE 参数的命名参数的命名规范和方法的命名规范相同，而且为了避免阅读程序时造成迷惑，请在尽量保证参数名称为一个单词的情况下使参数的命名尽可能明确。知识扩展： 在变量命名时要注意以下几点： 1.选择有意义的名字，注意每个单词首字母要大写。 2.在一段函数中不使用同一个变量表示前后意义不同的两个数值。 3.i、j、k等只作为小型循环的循环索引变量。 4.避免用Flag来命名状态变量。 5.用Is来命名逻辑变量，如：blnFileIsFound。通过这种给布尔变量肯定形式的命名方式，使得其它开发人员能够更为清楚的理解布尔变量所代表的意义。 6.如果需要的话，在变量最后附加计算限定词，如：curSalesSum。 7.命名不相包含，curSales和curSalesSum。 8.static final 变量(常量)的名字应该都大写，并且指出完整含义。 9.如果需要对变量名进行缩写时，一定要注意整个代码中缩写规则的一致性。例如， 如果在代码的某些区域中使用intCnt，而在另一些区域中又使用intCount，就会给代码增加不必要的复杂性。建议变量名中尽量不要出现缩写。 10.通过在结尾处放置一个量词，就可创建更加统一的变量，它们更容易理解，也更容易搜索。例如，请使用 strCustomerFirst和strCustomerLast，而不要使用strFirstCustomer和strLastCustomer。常 用的量词后缀有：First（一组变量中的第一个）、Last（一组变量中的最后一个）、Next（一组变量中的下一个变量）、Prev（一组变量中的上 一个）、Cur（一组变量中的当前变量）。 11.每个变量选择最佳的数据类型，这样即能减少对内存的需求量，加快代码的执行速度，又会降低出错的可能性。用于变量的数据类型可能会影响该变量进行计算所产生的结果。在这种情况下，编译器不会产生运行期错误，它只是迫使该值符合数据类型的要求。这类问题极难查找。 12.尽量缩小变量的作用域。如果变量的作用域大于它应有的范围，变量可继续存在，并且在不再需要该变量后的很长时间内仍然占用资源。它们的主要问题是，任何类 中的任何方法都能对它们进行修改，并且很难跟踪究竟是何处进行修改的。占用资源是作用域涉及的一个重要问题。对变量来说，尽量缩小作用域将会对应用程序的 可靠性产生巨大的影响。 关于常量的命名方法，在JAVA代码中，无论什么时候，均提倡应用常量取代数字、固定字符串。也就是 说，程序中除0，1以外，尽量不应该出现其他数字。常量可以集中在程序开始部分定义或者更宽的作用域内，名字应该都使用大写字母，并且指出该常量完整含 义。如果一个常量名称由多个单词组成，则应该用下划线“_”来分割这些单词如：NUM_DAYS_IN_WEEK、MAX_VALUE。

不知道你问的那个版本的C呀,所以不能具体回答你的问题

转的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和continuecontinue语句与break语句相关，但较少用到。continue语句用于使其所在的for、while或do-while语句开始下一次循环。在while与do-while语句中，continue语句的执行意味着立即执行测试部分；在for循环语句中，continue语句的执行则意味着使控制传递到增量部分。

上具体代码。

没人教怎么都不行啊

Java是一种广泛使用的计算机编程语言，拥有跨平台、面向对象、泛型编程的特性，广泛应用于企业级Web应用开发和移动应用开发。任职于太阳微系统的詹姆斯·高斯林等人于1990年代初开发Java语言的雏形，最初被命名为Oak，目标设置在家用电器等小型系统的程序语言，应用在电视机、电话、闹钟、烤面包机等家用电器的控制和通信。由于这些智能化家电的市场需求没有预期的高，Sun公司放弃了该项计划。随着1990年代互联网的发展，Sun公司看见Oak在互联网上应用的前景，于是改造了Oak，于1995年5月以Java的名称正式发布。Java伴随着互联网的迅猛发展而发展，逐渐成为重要的网络编程语言。Java编程语言的风格十分接近C++语言。继承了C++语言面向对象技术的核心，Java舍弃了C++语言中容易引起错误的指针，改以引用取代，同时移除原C++与原来运算符重载，也移除多重继承特性，改用接口取代，增加垃圾回收器功能。在Java SE 1.5版本中引入了泛型编程、类型安全的枚举、不定长参数和自动装/拆箱特性。太阳微系统对Java语言的解释是：“Java编程语言是个简单、面向对象、分布式、解释性、健壮、安全与系统无关、可移植、高性能、多线程和动态的语言”Java不同于一般的编译语言或直译语言。它首先将源代码编译成字节码，然后依赖各种不同平台上的虚拟机来解释执行字节码，从而实现了“一次编写，到处运行”的跨平台特性。在早期JVM中，这在一定程度上降低了Java程序的运行效率。但在J2SE1.4.2发布后，Java的运行速度有了大幅提升。与传统类型不同，Sun公司在推出Java时就将其作为开放的技术。全球数以万计的Java开发公司被要求所设计的Java软件必须相互兼容。“Java语言靠群体的力量而非公司的力量”是 Sun公司的口号之一，并获得了广大软件开发商的认同。这与微软公司所倡导的注重精英和封闭式的模式完全不同，此外，微软公司后来推出了与之竞争的.NET平台以及模仿Java的C#语言。后来Sun公司被甲骨文公司并购，Java也随之成为甲骨文公司的产品。现时，移动操作系统Android大部分的代码采用Java 编程语言编程。早期的JavaJava的发明人詹姆斯·高斯林Duke，Java语言的吉祥物语言最开始只是Sun计算机（Sun MicroSystems）公司在1990年12月开始研究的一个内部项目。Sun计算机公司的一个叫做帕特里克·诺顿的工程师被公司自己开发的C++和C语言编译器搞得焦头烂额，因为其中的API极其难用。帕特里克决定改用NeXT，同时他也获得了研究公司的一个叫做“Stealth计划”的项目的机会。“Stealth计划”后来改名为“Green计划”，詹姆斯·高斯林和麦克·舍林丹也加入了帕特里克的工作小组。他们和其他几个工程师一起在加利福尼亚州门罗帕克市沙丘路的一个小工作室里面研究开发新技术，瞄准下一代智能家电（如微波炉）的程序设计，Sun公司预料未来科技将在家用电器领域大显身手。团队最初考虑使用C++语言，但是很多成员包括Sun的首席科学家比尔·乔伊，发现C++和可用的API在某些方面存在很大问题。工作小组使用的是嵌入式系统，可以用的资源极其有限。很多成员发现C++太复杂以至很多开发者经常错误使用。他们发现C++缺少垃圾回收系统，还有可移植的安全性、分布程序设计、和多线程功能。最后，他们想要一种易于移植到各种设备上的平台。根据可用的资金，乔伊决定开发一种集C语言和Mesa语言大成的新语言，在一份报告上，乔伊把它叫做“未来”，他提议Sun公司的工程师应该在C++的基础上，开发一种面向对象的环境。最初，高斯林试图修改和扩展C++的功能，他自己称这种新语言为C++ ++ --，但是后来他放弃了。他将要创造出一种全新的语言，被他命名为“Oak”（橡树），以他的办公室外的橡树命名。就像很多开发新技术的秘密工程一样，工作小组没日没夜地工作到了1993年的夏天，他们能够演示新平台的一部分了，包括Green操作系统，Oak的程序设计语言，类库及其硬件。最初的尝试是面向一种类PDA设备，被命名为Star7，这种设备有鲜艳的图形界面和被称为“Duke”的智能代理来帮助用户。1992年12月3日，这台设备进行了展示。同年11月，Green计划被转化成了“FirstPerson有限公司”，一个Sun公司的全资子公司，团队也被重新安排到了帕洛阿尔托。FirstPerson团队对建造一种高度交互的设备感兴趣，当时代华纳发布了一个关于电视机顶盒的征求提议书时（Request for proposal），FirstPerson改变了他们的目标，作为对征求意见书的响应，提出了一个机顶盒平台的提议。但是有线电视业界觉得FirstPerson的平台给予用户过多的控制权，因此FirstPerson的投标败给了SGI。与3DO公司的另外一笔关于机顶盒的交易也没有成功，由于他们的平台不能在电视工业产生任何效益，公司被并回Sun公司。Java和互联网1994年6月，在经历了一场历时三天的脑力激荡的讨论后，约翰·盖吉、詹姆斯·高斯林、比尔·乔伊、帕特里克·诺顿、韦恩·罗斯因和埃里克·斯库米，团队决定再一次改变了努力的目标，这次他们决定将该技术应用于万维网。他们认为随着Mosaic浏览器的到来，因特网正在向同样的高度互动的远景演变，而这一远景正是他们在有线电视网中看到的。作为原型，帕特里克·诺顿写了一个小型万维网浏览器，WebRunner，后来改名为HotJava[12]。1994年10月，HotJava和Java平台为公司高层进行演示。1994年，Java 1.0a版本已经可以提供下载，但是Java和HotJava浏览器的第一次公开发布却是在1995年3月23日SunWorld大会上进行的。升阳公司的科学指导约翰·盖吉宣告Java技术。这个发布是与网景公司的执行副总裁马克·安德森的惊人发布一起进行的，宣布网景将在其浏览器中包含对Java的支持。1996年1月，升阳公司成立了Java业务集团，专门开发Java技术。Java和“Java”由于商标搜索显示，Oak已被一家显示卡制造商注册。于是同年，Oak被改名为Java。当使用十六进制编辑器打开由Java源代码编译出的二进制文件（.class文件）的话，最前面的32位将显示为CA FE BA BE，即词组“CAFE BABE”（咖啡屋宝贝）。Java近况一套Java编辑器软件J2SE环境与CDC的关连JVM的所在角色JSPX网页的概念在流行几年之后，Java在浏览器中的地位被逐步侵蚀。它在简单交互性动画方面的用途已经完全被Adobe公司的Flash排挤，2005年Java倾向只被用于雅虎游戏那样的更为复杂的应用程序。Java同时遭受到来自微软的反对，他们决定在新版本的Internet Explorer和Windows中不再附带Java平台。与此相反。在万维网的服务器端和手持设备上，Java变得更加流行。很多网站在后端使用JSP和其他的Java技术。在桌面系统上，独立的Java程序还是相对少见，这是因为Java平台的运行开销较大，而许多人的电脑上没有安装Java，由于网络带宽在以前较小，下载Java曾经是个耗时的事情。但是随着计算机计算能力、网络带宽在10年中获取了很大的进步，同时虚拟机和编译器的质量得到了提高，许多应用程序得到了广泛的使用，包括：开源软件：NetBeans和Eclipse等软件开发工具Android操作系统JEditAzureus BitTorrent客户端。JNode操作系统Apache软件基金会的Ant、Derby、Hadoop、Jakarta、POI和TomcatJBoss和GlassFish应用服务器商业软件：EIOffice（永中Office）Minecraft纯Java 3D游戏合金战士ChromeIBM Websphere、ColdFusion和WebLogicIntelliJ IDEA还有许多用Java写的软件，可以在http://www.java.com 找到。在以下网页可以看到非常多用Java写的程序：http://java.sun.com/products/ 下面有大量用Java Swing开发的桌面Java程序 http://java.sun.com/products/jfc/tsc/sightings/ 目前Java提供以下三个版本：Java Platform, Enterprise Edition（Java EE：Java平台企业版）Java Platform, Standard Edition（Java SE：Java平台标准版）Java Platform, Micro Edition（Java ME：Java平台微型版）Java Platform, Card EditionJava开放源代码项目2006年SUN在JavaOne公布Java 开放源代码项目，并推出OpenJDK项目。[13]Java虚拟机、Java编译器和Java类库以GNU通用公共许可证公开。版本历史主条目：Java版本历史1995年5月23日，Java语言诞生1996年1月，第一个JDK-JDK1.0诞生1996年4月，10个最主要的操作系统供应商申明将在其产品中嵌入JAVA技术1996年9月，约8.3万个网页应用了JAVA技术来制作1997年2月18日，JDK1.1发布1997年4月2日，JavaOne会议召开，参与者逾一万人，创当时全球同类会议规模之纪录1997年9月，JavaDeveloperConnection社区成员超过十万1998年2月，JDK1.1被下载超过2,000,000次1998年12月8日，JAVA2企业平台J2EE发布1999年6月，SUN公司发布Java的三个版本：标准版（J2SE）、企业版（J2EE）和微型版（J2ME）2000年5月8日，JDK1.3发布2000年5月29日，JDK1.4发布2001年6月5日，NOKIA宣布，到2003年将出售1亿部支持Java的手机2001年9月24日，J2EE1.3发布2002年2月26日，J2SE1.4发布，自此Java的计算能力有了大幅提升2004年9月30日18:00PM，J2SE1.5发布，成为Java语言发展史上的又一里程碑。为了表示该版本的重要性，J2SE1.5更名为Java SE 5.02005年6月，JavaOne大会召开，SUN公司公开Java SE 6。此时，Java的各种版本已经更名，以取消其中的数字“2”：J2EE更名为Java EE，J2SE更名为Java SE，J2ME更名为Java ME2006年12月，SUN公司发布JRE6.02009年12月，SUN公司发布Java EE 62010年11月，由于Oracle公司对于Java社区的不友善，因此Apache扬言将退出JCP[14]2011年7月28日，Oracle公司发布Java SE 72014年3月18日，Oracle公司发表Java SE 8语言特性Java之所以被开发，是要达到以下五个目的：应当使用面向对象程序设计方法学应当允许同一程序在不同的计算机平台执行应当包括内建的对计算机网络的支持应当被设计成安全地执行远端代码应当易于使用，并借鉴以前那些面向对象语言（如C++）的长处。Java技术主要分成几个部分：Java语言、Java运行环境、类库。一般情况下说Java时并不区分指的是哪个部分。Java在1.5版本时，做了重大改变，Sun公司并1.5版本重命名为Java 5.0。面向对象Java的特点之一就是面向对象，是程序设计方法的一种。“面向对象程序设计语言”的核心之一就是开发者在设计软件的时候可以使用自定义的类型和关联操作。代码和数据的实际集合体叫做“对象”。一个对象可以想象成绑定了很多“行为（代码）”和“状态（数据）”的物体。对于数据结构的改变需要和代码进行通信然后操作，反之亦然。面向对象设计让大型软件工程的计划和设计变得更容易管理，能增强工程的健康度，减少失败工程的数量。跨平台性Java语言的第二个特性就是跨平台性，也就是说使用Java语言编写的程序可以在编译后不用经过任何更改，就能在任何硬件设备条件下运行。这个特性经常被称为“一次编译，到处运行”。执行Java应用程序必须安装爪哇运行环境（Java Runtime Environment，JRE），JRE内部有一个Java虚拟机（Java Virtual Machine，JVM）以及一些标准的类库（Class Library）。通过JVM才能在电脑系统执行Java应用程序（Java Application），这与.Net Framework的情况一样，所以电脑上没有安装JVM，那么这些程序将不能够执行。实现跨平台性的方法是大多数编译器在进行Java语言程序的编码时候会生成一个用字节码写成的“半成品”，这个“半成品”会在Java虚拟机（解释层）的帮助下运行，虚拟机会把它转换成当前所处硬件平台的原始代码。之后，Java虚拟机会打开标准库，进行数据（图片、线程和网络）的访问工作。主要注意的是，尽管已经存在一个进行代码翻译的解释层，有些时候Java的字节码代码还是会被JIT编译器进行二次编译。有些编译器，比如GCJ，可以自动生成原始代码而不需要解释层。但是这些编译器所生成的代码只能应用于特定平台。并且GCJ目前只支持部分的Java API。甲骨文公司对于Java的许可是“全兼容的”，这也导致了微软和升阳关于微软的程序不支持RMI和JNI接口、并且增加特性为己所用的法律争端。升阳最终赢得了官司，获得了大约两千万美元的赔偿，法院强制要求微软执行升阳公司关于Java的许可要求。作为回应，微软不再在Windows系统中捆绑Java，最新的Windows版本，Windows Vista和Internet Explorer 7.0版本也不再提供对于Java应用程序和控件的支持。但是升阳公司和其他使用Java运行时系统的公司在Windows操作系统下对用户提供无偿的第三方插件和程序支持。Java语言使用解释层最初是为了轻巧性。所以这些程序的运行效率比C语言和C++要低很多，用户也对此颇有微词。很多最近的调查显示Java的程序运行速度比几年前要高出许多，有些同样功能的程序的效率甚至超过了C++和C语言编写的程序[来源请求]。Java语言在最开始应用的时候是没有解释层的，所有需要编译的代码都直接转换成机器的原始代码。这样做的后果就是获得了最佳的性能，但是程序臃肿异常。从JIT技术开始，Java的程序都经过一次转换之后才变成机器码。很多老牌的第三方虚拟机都使用一种叫做“动态编译”的技术，也就是说虚拟机实时监测和分析程序的运行行为，同时选择性地对程序所需要的部分进行编译和优化。所有这些技术都改善了代码的运行速度，但是又不会让程序的体积变得失常。程序的轻便性事实上是软件编写很难达到的一个目标，Java虽然成功地实现了“一次编译，到处运行”，但是由于平台和平台之间的差异，所编写的程序在转换代码的时候难免会出现微小的、不可察觉的错误和意外。有些程序员对此非常头疼，他们嘲笑Java的程序不是“一次编译，到处运行”，而是“一次编译，到处调试”。以JavaAWT为例，早期Java AWT内提供的按钮、文字区等均是以计算机系统所默认的样式而显示。这令Java程序在有些没有提供图案的计算机系统产生错误（在Microsoft Windows设有窗口管理器，在一些Linux distribution则没有）。后来SUN公司针对Java AWT一些问题而推出Java Swing。平台无关性让Java在服务器端软件领域非常成功。很多服务器端软件都使用Java或相关技术建立。自动垃圾回收（Garbage Collection）C++语言被用户诟病的原因之一是大多数C++编译器不支持垃圾收集机制。通常使用C++编程的时候，程序员于程序中初始化对象时，会在主机内存堆栈上分配一块内存与地址，当不需要此对象时，进行析构或者删除的时候再释放分配的内存地址。如果对象是在堆栈上分配的，而程序员又忘记进行删除，那么就会造成内存泄漏（MemoryLeak）。长此以往，程序运行的时候可能会生成很多不清除的垃圾，浪费了不必要的内存空间。而且如果同一内存地址被删除两次的话，程序会变得不稳定，甚至崩溃。因此有经验的C++程序员都会在删除之后将指针重置为NULL，然后在删除之前先判断指针是否为NULL。C++中也可以使用“智能指针”（Smart Pointer）或者使用C++托管扩展编译器的方法来实现自动化内存释放，智能指针可以在标准类库中找到，而C++(题主你怎么可以问这么沙比的问题！)托管扩展被微软的VisualC++ 7.0及以上版本所支持。智能指针的优点是不需引入缓慢的垃圾收集机制，而且可以不考虑线程安全的问题，但是缺点是如果不善使用智能指针的话，性能有可能不如垃圾收集机制，而且不断地分配和释放内存可能造成内存碎片，需要手动对堆进行压缩。除此之外，由于智能指针是一个基于模板的功能，所以没有经验的程序员在需要使用多态特性进行自动清理时也可能束手无策。Java语言则不同，上述的情况被自动垃圾收集功能自动处理。对象的创建和放置都是在内存堆栈上面进行的。当一个对象没有任何引用的时候，Java的自动垃圾收集机制就发挥作用，自动删除这个对象所占用的空间，释放内存以避免内存泄漏。注意程序员不需要修改finalize方法，自动垃圾收集也会发生作用。但是内存泄漏并不是就此避免了，当程序员疏忽大意地忘记解除一个对象不应该有的引用时，内存泄漏仍然不可避免。不同厂商、不同版本的JVM中的内存垃圾回收机制并不完全一样，通常越新版本的内存回收机制越快，IBM、BEA、SUN等等开发JVM的公司都曾宣称过自己制造出了世界上最快的JVM[来源请求]，JVM性能的世界纪录也在不断的被打破并提高。IBM有一篇有关Java内存回收机制比不激活垃圾收集机制的C++内存处理快数倍的技术文章[15]，而著名的Java技术书籍《Java编程思想》（Thinking in Java）也有一段论述Java内存及性能达到甚至超过C++的章节[16]。基本语法编写Java程序前应注意以下几点：大小写敏感：Java是大小写敏感的，这就意味着标识符Hello与hello是不同的。类名：对于所有的类来说，类名的首字母应该大写。如果类名由若干单词组成，那么每个单词的首字母应该大写，例如MyFirstJavaClass。方法名：所有的方法名都应该以小写字母开头。如果方法名含有若干单词，则后面的每个单词首字母大写，例如myFirstJavaMethod。源文件名：源文件名必须和类名相同。当保存文件的时候，你应该使用类名作为文件名保存（切记Java是大小写敏感的），文件名的后缀为.java。（如果文件名和类名不相同则会导致编译错误）。主方法入口：所有的Java程序由public static void main（String[] args）方法开始执行。Java关键字关键字 下面列出了Java关键字。这些关键字不能用于常量、变量、和任何标识符的名称。关键字 描述 abstract 抽象方法，抽象类的修饰符 assert 断言条件是否满足 continue 不执行循环体剩余部分 default switch语句中的默认分支 do-while 循环语句，循环体至少会执行一次 double 64-bit双精度浮点数 else if条件不成立时执行的分支 enum 枚举类型 extends 表示一个类是另一个类的子类 final 表示定义常量 finally 无论有没有异常发生都执行代码 float 32-bit单精度浮点数 for for循环语句 goto 用于流程跳转（不可用，意即不可随意跳转） if 条件语句 implements 表示一个类实现了接口 import 导入类 instanceof 测试一个对象是否是某个类的实例 int 32位整型数 interface 接口，一种抽象的类型，仅有方法和常量的定义 long 64位整型数 native 表示方法用非java代码实现 new 分配新的类实例 package 一系列相关类组成一个包 private 表示私有字段，或者方法等，只能从类内部访问 protected 表示保护类型字段 public 表示共有属性或者方法 return 方法返回值 short 16位数字 static 表示在类级别定义，所有实例共享的 strictfp 浮点数比较使用严格的规则 super 表示基类 switch 选择语句 synchronized 表示同一时间只能由一个线程访问的代码块 this 调用当前实例或者调用另一个构造函数 throw 抛出异常 throws 定义方法可能抛出的异常 transient 修饰不要序列化的字段 try 表示代码块要做异常处理 void 标记方法不返回任何值 volatile 标记字段可能会被多个线程同时访问，而不做同步 while while循环 注释注释作用：标识程序是干什么的，以及它是如何构建的。注释帮助程序员进行相互沟通以及理解程序。注释不是程序设计语言，所以编译器编译程序时忽略它们。接口和类别Java自带了创建接口的类别，可以这样使用：public interface Deleteable {void delete();}这段代码的意思是任何实现（implement）Deleteable接口的类别都必须实现delete()方法。每个类别对这个方法的实现可以自行定制。由此概念可以引出很多种使用方法，下面是一个类别的例子：

Java是一种广泛使用的计算机编程语言，拥有跨平台、面向对象、泛型编程的特性，广泛应用于企业级Web应用开发和移动应用开发。任职于太阳微系统的詹姆斯·高斯林等人于1990年代初开发Java语言的雏形，最初被命名为Oak，目标设置在家用电器等小型系统的程序语言，应用在电视机、电话、闹钟、烤面包机等家用电器的控制和通信。由于这些智能化家电的市场需求没有预期的高，Sun公司放弃了该项计划。随着1990年代互联网的发展，Sun公司看见Oak在互联网上应用的前景，于是改造了Oak，于1995年5月以Java的名称正式发布。Java伴随着互联网的迅猛发展而发展，逐渐成为重要的网络编程语言。Java编程语言的风格十分接近C++语言。继承了C++语言面向对象技术的核心，Java舍弃了C++语言中容易引起错误的指针，改以引用取代，同时移除原C++与原来运算符重载，也移除多重继承特性，改用接口取代，增加垃圾回收器功能。在Java SE 1.5版本中引入了泛型编程、类型安全的枚举、不定长参数和自动装/拆箱特性。太阳微系统对Java语言的解释是：“Java编程语言是个简单、面向对象、分布式、解释性、健壮、安全与系统无关、可移植、高性能、多线程和动态的语言”Java不同于一般的编译语言或直译语言。它首先将源代码编译成字节码，然后依赖各种不同平台上的虚拟机来解释执行字节码，从而实现了“一次编写，到处运行”的跨平台特性。在早期JVM中，这在一定程度上降低了Java程序的运行效率。但在J2SE1.4.2发布后，Java的运行速度有了大幅提升。与传统类型不同，Sun公司在推出Java时就将其作为开放的技术。全球数以万计的Java开发公司被要求所设计的Java软件必须相互兼容。“Java语言靠群体的力量而非公司的力量”是 Sun公司的口号之一，并获得了广大软件开发商的认同。这与微软公司所倡导的注重精英和封闭式的模式完全不同，此外，微软公司后来推出了与之竞争的.NET平台以及模仿Java的C#语言。后来Sun公司被甲骨文公司并购，Java也随之成为甲骨文公司的产品。现时，移动操作系统Android大部分的代码采用Java 编程语言编程。早期的JavaJava的发明人詹姆斯·高斯林Duke，Java语言的吉祥物语言最开始只是Sun计算机（Sun MicroSystems）公司在1990年12月开始研究的一个内部项目。Sun计算机公司的一个叫做帕特里克·诺顿的工程师被公司自己开发的C++和C语言编译器搞得焦头烂额，因为其中的API极其难用。帕特里克决定改用NeXT，同时他也获得了研究公司的一个叫做“Stealth计划”的项目的机会。“Stealth计划”后来改名为“Green计划”，詹姆斯·高斯林和麦克·舍林丹也加入了帕特里克的工作小组。他们和其他几个工程师一起在加利福尼亚州门罗帕克市沙丘路的一个小工作室里面研究开发新技术，瞄准下一代智能家电（如微波炉）的程序设计，Sun公司预料未来科技将在家用电器领域大显身手。团队最初考虑使用C++语言，但是很多成员包括Sun的首席科学家比尔·乔伊，发现C++和可用的API在某些方面存在很大问题。工作小组使用的是嵌入式系统，可以用的资源极其有限。很多成员发现C++太复杂以至很多开发者经常错误使用。他们发现C++缺少垃圾回收系统，还有可移植的安全性、分布程序设计、和多线程功能。最后，他们想要一种易于移植到各种设备上的平台。根据可用的资金，乔伊决定开发一种集C语言和Mesa语言大成的新语言，在一份报告上，乔伊把它叫做“未来”，他提议Sun公司的工程师应该在C++的基础上，开发一种面向对象的环境。最初，高斯林试图修改和扩展C++的功能，他自己称这种新语言为C++ ++ --，但是后来他放弃了。他将要创造出一种全新的语言，被他命名为“Oak”（橡树），以他的办公室外的橡树命名。就像很多开发新技术的秘密工程一样，工作小组没日没夜地工作到了1993年的夏天，他们能够演示新平台的一部分了，包括Green操作系统，Oak的程序设计语言，类库及其硬件。最初的尝试是面向一种类PDA设备，被命名为Star7，这种设备有鲜艳的图形界面和被称为“Duke”的智能代理来帮助用户。1992年12月3日，这台设备进行了展示。同年11月，Green计划被转化成了“FirstPerson有限公司”，一个Sun公司的全资子公司，团队也被重新安排到了帕洛阿尔托。FirstPerson团队对建造一种高度交互的设备感兴趣，当时代华纳发布了一个关于电视机顶盒的征求提议书时（Request for proposal），FirstPerson改变了他们的目标，作为对征求意见书的响应，提出了一个机顶盒平台的提议。但是有线电视业界觉得FirstPerson的平台给予用户过多的控制权，因此FirstPerson的投标败给了SGI。与3DO公司的另外一笔关于机顶盒的交易也没有成功，由于他们的平台不能在电视工业产生任何效益，公司被并回Sun公司。Java和互联网1994年6月，在经历了一场历时三天的脑力激荡的讨论后，约翰·盖吉、詹姆斯·高斯林、比尔·乔伊、帕特里克·诺顿、韦恩·罗斯因和埃里克·斯库米，团队决定再一次改变了努力的目标，这次他们决定将该技术应用于万维网。他们认为随着Mosaic浏览器的到来，因特网正在向同样的高度互动的远景演变，而这一远景正是他们在有线电视网中看到的。作为原型，帕特里克·诺顿写了一个小型万维网浏览器，WebRunner，后来改名为HotJava[12]。1994年10月，HotJava和Java平台为公司高层进行演示。1994年，Java 1.0a版本已经可以提供下载，但是Java和HotJava浏览器的第一次公开发布却是在1995年3月23日SunWorld大会上进行的。升阳公司的科学指导约翰·盖吉宣告Java技术。这个发布是与网景公司的执行副总裁马克·安德森的惊人发布一起进行的，宣布网景将在其浏览器中包含对Java的支持。1996年1月，升阳公司成立了Java业务集团，专门开发Java技术。Java和“Java”由于商标搜索显示，Oak已被一家显示卡制造商注册。于是同年，Oak被改名为Java。当使用十六进制编辑器打开由Java源代码编译出的二进制文件（.class文件）的话，最前面的32位将显示为CA FE BA BE，即词组“CAFE BABE”（咖啡屋宝贝）。Java近况一套Java编辑器软件J2SE环境与CDC的关连JVM的所在角色JSPX网页的概念在流行几年之后，Java在浏览器中的地位被逐步侵蚀。它在简单交互性动画方面的用途已经完全被Adobe公司的Flash排挤，2005年Java倾向只被用于雅虎游戏那样的更为复杂的应用程序。Java同时遭受到来自微软的反对，他们决定在新版本的Internet Explorer和Windows中不再附带Java平台。与此相反。在万维网的服务器端和手持设备上，Java变得更加流行。很多网站在后端使用JSP和其他的Java技术。在桌面系统上，独立的Java程序还是相对少见，这是因为Java平台的运行开销较大，而许多人的电脑上没有安装Java，由于网络带宽在以前较小，下载Java曾经是个耗时的事情。但是随着计算机计算能力、网络带宽在10年中获取了很大的进步，同时虚拟机和编译器的质量得到了提高，许多应用程序得到了广泛的使用，包括：开源软件：NetBeans和Eclipse等软件开发工具Android操作系统JEditAzureus BitTorrent客户端。JNode操作系统Apache软件基金会的Ant、Derby、Hadoop、Jakarta、POI和TomcatJBoss和GlassFish应用服务器商业软件：EIOffice（永中Office）Minecraft纯Java 3D游戏合金战士ChromeIBM Websphere、ColdFusion和WebLogicIntelliJ IDEA还有许多用Java写的软件，可以在http://www.java.com 找到。在以下网页可以看到非常多用Java写的程序：http://java.sun.com/products/ 下面有大量用Java Swing开发的桌面Java程序 http://java.sun.com/products/jfc/tsc/sightings/ 目前Java提供以下三个版本：Java Platform, Enterprise Edition（Java EE：Java平台企业版）Java Platform, Standard Edition（Java SE：Java平台标准版）Java Platform, Micro Edition（Java ME：Java平台微型版）Java Platform, Card EditionJava开放源代码项目2006年SUN在JavaOne公布Java 开放源代码项目，并推出OpenJDK项目。[13]Java虚拟机、Java编译器和Java类库以GNU通用公共许可证公开。版本历史主条目：Java版本历史1995年5月23日，Java语言诞生1996年1月，第一个JDK-JDK1.0诞生1996年4月，10个最主要的操作系统供应商申明将在其产品中嵌入JAVA技术1996年9月，约8.3万个网页应用了JAVA技术来制作1997年2月18日，JDK1.1发布1997年4月2日，JavaOne会议召开，参与者逾一万人，创当时全球同类会议规模之纪录1997年9月，JavaDeveloperConnection社区成员超过十万1998年2月，JDK1.1被下载超过2,000,000次1998年12月8日，JAVA2企业平台J2EE发布1999年6月，SUN公司发布Java的三个版本：标准版（J2SE）、企业版（J2EE）和微型版（J2ME）2000年5月8日，JDK1.3发布2000年5月29日，JDK1.4发布2001年6月5日，NOKIA宣布，到2003年将出售1亿部支持Java的手机2001年9月24日，J2EE1.3发布2002年2月26日，J2SE1.4发布，自此Java的计算能力有了大幅提升2004年9月30日18:00PM，J2SE1.5发布，成为Java语言发展史上的又一里程碑。为了表示该版本的重要性，J2SE1.5更名为Java SE 5.02005年6月，JavaOne大会召开，SUN公司公开Java SE 6。此时，Java的各种版本已经更名，以取消其中的数字“2”：J2EE更名为Java EE，J2SE更名为Java SE，J2ME更名为Java ME2006年12月，SUN公司发布JRE6.02009年12月，SUN公司发布Java EE 62010年11月，由于Oracle公司对于Java社区的不友善，因此Apache扬言将退出JCP[14]2011年7月28日，Oracle公司发布Java SE 72014年3月18日，Oracle公司发表Java SE 8语言特性Java之所以被开发，是要达到以下五个目的：应当使用面向对象程序设计方法学应当允许同一程序在不同的计算机平台执行应当包括内建的对计算机网络的支持应当被设计成安全地执行远端代码应当易于使用，并借鉴以前那些面向对象语言（如C++）的长处。Java技术主要分成几个部分：Java语言、Java运行环境、类库。一般情况下说Java时并不区分指的是哪个部分。Java在1.5版本时，做了重大改变，Sun公司并1.5版本重命名为Java 5.0。面向对象Java的特点之一就是面向对象，是程序设计方法的一种。“面向对象程序设计语言”的核心之一就是开发者在设计软件的时候可以使用自定义的类型和关联操作。代码和数据的实际集合体叫做“对象”。一个对象可以想象成绑定了很多“行为（代码）”和“状态（数据）”的物体。对于数据结构的改变需要和代码进行通信然后操作，反之亦然。面向对象设计让大型软件工程的计划和设计变得更容易管理，能增强工程的健康度，减少失败工程的数量。跨平台性Java语言的第二个特性就是跨平台性，也就是说使用Java语言编写的程序可以在编译后不用经过任何更改，就能在任何硬件设备条件下运行。这个特性经常被称为“一次编译，到处运行”。执行Java应用程序必须安装爪哇运行环境（Java Runtime Environment，JRE），JRE内部有一个Java虚拟机（Java Virtual Machine，JVM）以及一些标准的类库（Class Library）。通过JVM才能在电脑系统执行Java应用程序（Java Application），这与.Net Framework的情况一样，所以电脑上没有安装JVM，那么这些程序将不能够执行。实现跨平台性的方法是大多数编译器在进行Java语言程序的编码时候会生成一个用字节码写成的“半成品”，这个“半成品”会在Java虚拟机（解释层）的帮助下运行，虚拟机会把它转换成当前所处硬件平台的原始代码。之后，Java虚拟机会打开标准库，进行数据（图片、线程和网络）的访问工作。主要注意的是，尽管已经存在一个进行代码翻译的解释层，有些时候Java的字节码代码还是会被JIT编译器进行二次编译。有些编译器，比如GCJ，可以自动生成原始代码而不需要解释层。但是这些编译器所生成的代码只能应用于特定平台。并且GCJ目前只支持部分的Java API。甲骨文公司对于Java的许可是“全兼容的”，这也导致了微软和升阳关于微软的程序不支持RMI和JNI接口、并且增加特性为己所用的法律争端。升阳最终赢得了官司，获得了大约两千万美元的赔偿，法院强制要求微软执行升阳公司关于Java的许可要求。作为回应，微软不再在Windows系统中捆绑Java，最新的Windows版本，Windows Vista和Internet Explorer 7.0版本也不再提供对于Java应用程序和控件的支持。但是升阳公司和其他使用Java运行时系统的公司在Windows操作系统下对用户提供无偿的第三方插件和程序支持。Java语言使用解释层最初是为了轻巧性。所以这些程序的运行效率比C语言和C++要低很多，用户也对此颇有微词。很多最近的调查显示Java的程序运行速度比几年前要高出许多，有些同样功能的程序的效率甚至超过了C++和C语言编写的程序[来源请求]。Java语言在最开始应用的时候是没有解释层的，所有需要编译的代码都直接转换成机器的原始代码。这样做的后果就是获得了最佳的性能，但是程序臃肿异常。从JIT技术开始，Java的程序都经过一次转换之后才变成机器码。很多老牌的第三方虚拟机都使用一种叫做“动态编译”的技术，也就是说虚拟机实时监测和分析程序的运行行为，同时选择性地对程序所需要的部分进行编译和优化。所有这些技术都改善了代码的运行速度，但是又不会让程序的体积变得失常。程序的轻便性事实上是软件编写很难达到的一个目标，Java虽然成功地实现了“一次编译，到处运行”，但是由于平台和平台之间的差异，所编写的程序在转换代码的时候难免会出现微小的、不可察觉的错误和意外。有些程序员对此非常头疼，他们嘲笑Java的程序不是“一次编译，到处运行”，而是“一次编译，到处调试”。以JavaAWT为例，早期Java AWT内提供的按钮、文字区等均是以计算机系统所默认的样式而显示。这令Java程序在有些没有提供图案的计算机系统产生错误（在Microsoft Windows设有窗口管理器，在一些Linux distribution则没有）。后来SUN公司针对Java AWT一些问题而推出Java Swing。平台无关性让Java在服务器端软件领域非常成功。很多服务器端软件都使用Java或相关技术建立。自动垃圾回收（Garbage Collection）C++语言被用户诟病的原因之一是大多数C++编译器不支持垃圾收集机制。通常使用C++编程的时候，程序员于程序中初始化对象时，会在主机内存堆栈上分配一块内存与地址，当不需要此对象时，进行析构或者删除的时候再释放分配的内存地址。如果对象是在堆栈上分配的，而程序员又忘记进行删除，那么就会造成内存泄漏（MemoryLeak）。长此以往，程序运行的时候可能会生成很多不清除的垃圾，浪费了不必要的内存空间。而且如果同一内存地址被删除两次的话，程序会变得不稳定，甚至崩溃。因此有经验的C++程序员都会在删除之后将指针重置为NULL，然后在删除之前先判断指针是否为NULL。C++中也可以使用“智能指针”（Smart Pointer）或者使用C++托管扩展编译器的方法来实现自动化内存释放，智能指针可以在标准类库中找到，而C++(题主你怎么可以问这么沙比的问题！)托管扩展被微软的VisualC++ 7.0及以上版本所支持。智能指针的优点是不需引入缓慢的垃圾收集机制，而且可以不考虑线程安全的问题，但是缺点是如果不善使用智能指针的话，性能有可能不如垃圾收集机制，而且不断地分配和释放内存可能造成内存碎片，需要手动对堆进行压缩。除此之外，由于智能指针是一个基于模板的功能，所以没有经验的程序员在需要使用多态特性进行自动清理时也可能束手无策。Java语言则不同，上述的情况被自动垃圾收集功能自动处理。对象的创建和放置都是在内存堆栈上面进行的。当一个对象没有任何引用的时候，Java的自动垃圾收集机制就发挥作用，自动删除这个对象所占用的空间，释放内存以避免内存泄漏。注意程序员不需要修改finalize方法，自动垃圾收集也会发生作用。但是内存泄漏并不是就此避免了，当程序员疏忽大意地忘记解除一个对象不应该有的引用时，内存泄漏仍然不可避免。不同厂商、不同版本的JVM中的内存垃圾回收机制并不完全一样，通常越新版本的内存回收机制越快，IBM、BEA、SUN等等开发JVM的公司都曾宣称过自己制造出了世界上最快的JVM[来源请求]，JVM性能的世界纪录也在不断的被打破并提高。IBM有一篇有关Java内存回收机制比不激活垃圾收集机制的C++内存处理快数倍的技术文章[15]，而著名的Java技术书籍《Java编程思想》（Thinking in Java）也有一段论述Java内存及性能达到甚至超过C++的章节[16]。基本语法编写Java程序前应注意以下几点：大小写敏感：Java是大小写敏感的，这就意味着标识符Hello与hello是不同的。类名：对于所有的类来说，类名的首字母应该大写。如果类名由若干单词组成，那么每个单词的首字母应该大写，例如MyFirstJavaClass。方法名：所有的方法名都应该以小写字母开头。如果方法名含有若干单词，则后面的每个单词首字母大写，例如myFirstJavaMethod。源文件名：源文件名必须和类名相同。当保存文件的时候，你应该使用类名作为文件名保存（切记Java是大小写敏感的），文件名的后缀为.java。（如果文件名和类名不相同则会导致编译错误）。主方法入口：所有的Java程序由public static void main（String[] args）方法开始执行。Java关键字关键字 下面列出了Java关键字。这些关键字不能用于常量、变量、和任何标识符的名称。关键字 描述 abstract 抽象方法，抽象类的修饰符 assert 断言条件是否满足 continue 不执行循环体剩余部分 default switch语句中的默认分支 do-while 循环语句，循环体至少会执行一次 double 64-bit双精度浮点数 else if条件不成立时执行的分支 enum 枚举类型 extends 表示一个类是另一个类的子类 final 表示定义常量 finally 无论有没有异常发生都执行代码 float 32-bit单精度浮点数 for for循环语句 goto 用于流程跳转（不可用，意即不可随意跳转） if 条件语句 implements 表示一个类实现了接口 import 导入类 instanceof 测试一个对象是否是某个类的实例 int 32位整型数 interface 接口，一种抽象的类型，仅有方法和常量的定义 long 64位整型数 native 表示方法用非java代码实现 new 分配新的类实例 package 一系列相关类组成一个包 private 表示私有字段，或者方法等，只能从类内部访问 protected 表示保护类型字段 public 表示共有属性或者方法 return 方法返回值 short 16位数字 static 表示在类级别定义，所有实例共享的 strictfp 浮点数比较使用严格的规则 super 表示基类 switch 选择语句 synchronized 表示同一时间只能由一个线程访问的代码块 this 调用当前实例或者调用另一个构造函数 throw 抛出异常 throws 定义方法可能抛出的异常 transient 修饰不要序列化的字段 try 表示代码块要做异常处理 void 标记方法不返回任何值 volatile 标记字段可能会被多个线程同时访问，而不做同步 while while循环 注释注释作用：标识程序是干什么的，以及它是如何构建的。注释帮助程序员进行相互沟通以及理解程序。注释不是程序设计语言，所以编译器编译程序时忽略它们。接口和类别Java自带了创建接口的类别，可以这样使用：public interface Deleteable {void delete();}这段代码的意思是任何实现（implement）Deleteable接口的类别都必须实现delete()方法。每个类别对这个方法的实现可以自行定制。由此概念可以引出很多种使用方法，下面是一个类别的例子：

import java.util.Scanner;public class topic5{ public static void main(String args[]) { topic5 t5 = new topic5(); t5.guessNum(0,100); } public void guessNum(int minN,int maxN) { int minNum = minN; //所猜数字的下限 int maxNum = maxN; //所猜数字的上限 int guessTimes = 10; //剩余猜测机会 int randomNum = (int)(Math.random()*(maxNum-minNum))+minNum; //生成随机数 Scanner s = new Scanner(System.in); while(true) //死循环 { if(guessTimes==0) //机会用完退出 { System.out.println("很遗憾，10次机会已经用完，您没有猜出正确的数字。 正确的数字是："+randomNum); System.out.println(" 若要重新游戏，请输入Y。否则输入任意键退出..."); Object restart = s.nextLine(); if(restart.equals("Y")||restart.equals("y")) { minNum = minN; maxNum = maxN; guessTimes = 10; randomNum = (int)(Math.random()*(maxNum-minNum))+minNum; } else break; } System.out.print("猜数字游戏（"+minNum+" - "+maxNum+"）您还有"+guessTimes+"次机会 请输入一个您要猜的数字："); String input = s.nextLine(); //取得输入值 //输入检测 char[] inArr = input.toCharArray(); for(int i=0;i<inArr.length;i++) { if(!Character.isDigit(inArr[i])) { System.out.print("输入有误，请重新输入:"); input = s.nextLine(); //取得输入值 inArr = input.toCharArray(); i=0; } } int in = Integer.valueOf(input); if(in==0) break; //输入0退出 else if(in==randomNum) //猜中后退出 { System.out.println(" 恭喜您！猜对了！答案就是："+in); System.out.println(" 若要重新游戏，请输入Y。否则输入任意键退出..."); Object restart = s.next(); if(restart.equals("Y")||restart.equals("y")) { minNum = minN; maxNum = maxN; guessTimes = 10; randomNum = (int)(Math.random()*(maxNum-minNum))+minNum; } else break; } else if(in>randomNum) //输入数过大 { System.out.println(" 您猜的数字过大。 "); if(in<maxNum) maxNum = in; } else if(in<randomNum) //输入数过小 { System.out.println(" 您猜的数字过小。 "); if(in>minNum) minNum = in; } guessTimes--; //剩余猜测机会自减 } }}

Java的关键字对java的编译器有特殊的意义，他们用来表示一种数据类型，或者表示程序的结构等。保留字是为java预留的关键字，他们虽然现在没有作为关键字，但在以后的升级版本中有可能作为关键字。Java 关键字列表 (依字母排序 共50组): abstract, assert,boolean, break, byte, case, catch, char, class, continue, default, do, double, else, enum,extends, final, finally, float, for, if, implements, import, instanceof, int, interface, long, native, new, package, private, protected, public, return, short, static, strictfp, super, switch, synchronized, this, throw, throws, transient, try, void, volatile, whileJava 保留字列表 (依字母排序 共14组) : Java保留字是指现有Java版本尚未使用 但以后版本可能会作为关键字使用。byValue, cast, false, future, generic, inner, operator, outer, rest, true, var，goto，const, null

http://dict.baidu.com

自学的java主要是自律的，你有计算机基础，学java没问题

关键字含义abstract表明类或者成员方法具有抽象属性assert用来进行程序调试boolean基本数据类型之一，布尔类型break提前跳出一个块byte基本数据类型之一，字节类型case用在switch语句之中，表示其中的一个分支　　catch用在异常处理中，用来捕捉异常char基本数据类型之一，字符类型class类const保留关键字，没有具体含义continue回到一个块的开始处default默认，例如，用在switch语句中，表明一个默认的分支do用在do-while循环结构中double基本数据类型之一，双精度浮点数类型else用在条件语句中，表明当条件不成立时的分支enum枚举extends表明一个类型是另一个类型的子类型，这里常见的类型有类和接口final用来说明最终属性，表明一个类不能派生出子类，或者成员方法不能被覆盖，或者成员域的值不能被改变finally用于处理异常情况，用来声明一个基本肯定会被执行到的语句块float基本数据类型之一，单精度浮点数类型for一种循环结构的引导词goto保留关键字，没有具体含义if条件语句的引导词implements表明一个类实现了给定的接口import表明要访问指定的类或包instanceof用来测试一个对象是否是指定类型的实例对象int基本数据类型之一，整数类型interface接口long基本数据类型之一，长整数类型native用来声明一个方法是由与计算机相关的语言（如C/C++/FORTRAN语言）实现的new用来创建新实例对象package包private一种访问控制方式：私用模式protected一种访问控制方式：保护模式public一种访问控制方式：共用模式return从成员方法中返回数据short基本数据类型之一,短整数类型static表明具有静态属性strictfp用来声明FP_strict（单精度或双精度浮点数）表达式遵循IEEE 754算术规范super表明当前对象的父类型的引用或者父类型的构造方法switch分支语句结构的引导词synchronized表明一段代码需要同步执行this指向当前实例对象的引用throw抛出一个异常throws声明在当前定义的成员方法中所有需要抛出的异常transient声明不用序列化的成员域try尝试一个可能抛出异常的程序块void声明当前成员方法没有返回值volatile　　表明两个或者多个变量必须同步地发生变化while　　用在循环结构中

网页链接Java中的关键字，保留字，标识符

JavaScript和Java根本不是一回事，

不是很清楚你问的是什么 在JSP中<% %>之间都是JAVA的内容啊~~如果说是关键字的话，都是JAVA的关键字。Java的关键字有：abstract default if private this boolean do implements protected throw break double import public throws byte else instanceof return transient case extends int short try catch final interface static void char finally long strictfp volatile class float native super while const for new switch continue goto package synchronized 具体有什么用途的话，随便找本Java基础的书都有啊。