java

javascript实现不了，要用css：<style type="text/css" media="print"> @page { size: landscape; }</style>

引用自：http://www.amazon.cn/gp/help/customer/display.html?nodeId=200698750如何启用浏览器的JAVA Script(活动脚本) 功能对于IE浏览器 在IE浏览器的“工具”菜单中选择“internet选项”，在弹出命令对话框中选择“安全”选项卡，在该选项卡下的“该区域的安全级别”板块选择“自定义安全级别”，然后在新的对话框中的“脚本> 活动脚本”部分选中“启用”。然后选择“确定”及“应用”即可。对于Firefox 浏览器 在Firefox浏览器的“工具”菜单中选择“选项”，在新弹出页面中选择“内容”选项卡，接着选择“启用JavaScript”，然后确定即可。对于Safari浏览器 点击屏幕左上角的Safari, 点击“预置”，选择“安全”图标，确保选中“启用Java Script”，然后关闭即可。对于Chrome浏览器 在Chrome浏览器菜单中选择“Customize and control Google Chrome”。 选择“options”。 在左栏中选择“Under the Hood”。 在“Privacy”板块点击 “content settings”按钮。 在弹出新页面中的“JavaScript”板块选择“Allow all sites to run JavaScript(recommended)”。 关闭“Chrome Options”页面。 选择浏览器上的“Reload this page”。

1.基于对象和面向对象 Java是一种真正的面向对象的语言，即使是开发简单的程序，必须设计对象。JavaScript是种脚本语言，它可以用来制作与网络无 关的，与用户交互作用的复杂软件。它是一种基于对象（Object Based）和事件驱动（Event Driver）的编程语言。因而它本身 提供了非常丰富的内部对象供设计人员使用。 2.解释和编译 两种语言在其浏览器中所执行的方式不一样。Java的源代码在传递到客户端执行之前，必须经过编译，因而客户端上必须具有 相应平台上的仿真器或解释器，它可以通过编译器或解释器实现独立于某个特定的平台编译代码的束缚。 JavaScript是一种解释性编程语言，其源代码在发往客户端执行之前不需经过编译，而是将文本格式的字符代码发送给客户编 由浏览器解释执行。 3.强类型和弱类型 两种语言都定义的变量。Java必须声明变量的类型。如: Integer x; //这里的封装类型Integer必须予以声明 String y; x=1234; y="4321"; 其中X=1234说明是一个整数，Y=4321说明是一个字符串。 而JavaScript中变量声明，采用其弱类型。即变量在使用前不需作声明，而是由解释器根据后面字面量的类型是哪种类型而分配 相应的空间一般用户不用为此担心!@，如： x=1234; y＝"4321"; 前者说明x为其数值型变量，而后者说明y为字符型变量。 4.代码格式不一样 Java是一种与HTML无关的格式，必须通过像HTML中引用外媒体那么进行装载，其代码以字节代码的形式保存在独立的文档中。 JavaScript的代码是一种文本字符格式，可以直接嵌入HTML文档中，并且可动态装载。编写HTML文档就像编辑文本文件一样 方便。 5.嵌入方式不一样 在HTML文档中，两种编程语言的标识不同，JavaScript使用 <Script>... </Script>来标识，而Java使用 <applet>... </applet> 来标识。 6.静态联编和动态联编 Java采用静态联编，即Java的对象引用必须在编译时的进行，以使编译器能够实现强类型检查。JavaScript采用动态联编， 即JavaScript的对象引用在运行时进行检查，如不经编译则就无法实现对象引用的检查。

如果不是web开发的话 可以不学

可怜的娃

脚本错误！兼容性问题可能~~~~死孩子你就不会换台电脑或者换个系统或者别的浏览器~~~

这个跟 Java script 是什么有关系吗

JavaScript是一种基于对象和事件驱动并具有相对安全性的客户端脚本语言。同时也是一种广泛用于客户端Web开发的脚本语言，常用来给HTML网页添加动态功能，比如响应用户的各种操作。它最初由网景公司的Brendan Eich设计，是一种动态、弱类型、基于原型的语言，内置支持类。JavaScript是Sun公司的注册商标。[1] Ecma国际以JavaScript为基础制定了ECMAScript标准。JavaScript也可以用于其他场合，如服务器端编程。完整的JavaScript实现包含三个部分：ECMAScript，文档对象模型，字节顺序记号。　　　Netscape公司在最初将其脚本语言命名为LiveScript。在Netscape在与Sun合作之后将其改名为JavaScript。JavaScript最初受Java启发而开始设计的，目的之一就是“看上去像Java”[2]，因此语法上有类似之处，一些名称和命名规范也借自Java。但JavaScript的主要设计原则源自Self和Scheme[3].JavaScript与Java名称上的近似，是当时网景为了营销考虑与Sun公司达成协议的结果。为了取得技术优势，微软推出了JScript来迎战JavaScript的脚本语言。为了互用性，Ecma国际（前身为欧洲计算机制造商协会）创建了ECMA-262标准（ECMAScript）。现在两者都属于ECMAScript的实现。尽管JavaScript作为给非程序人员的脚本语言，而非作为给程序人员的编程语言来推广和宣传，但是JavaScript具有非常丰富的特性。

java和javascript 的区别实际上是一个很大的问题。先明确一点，我对JAVASCRIPT并没有像JAVA那样熟悉，所以错误时难免的。供大家讨论现在主要从语言角度加以区别：当然，java和javascript是有相同点的，javascript是一种基于java基本语句和控制流之上的简单简化，所以java和javascript在许多语法上是一致的，并且javascript也具有面向对象，事件驱动和安全性的特性，只是没有java那么完整而已。1.语言产生的目的不同：javascript 是netscape 公司为了扩展netscape navigatior 功能而设计的一种插入html中的脚本语言，它的主要目的是为了提供浏览器端的动态交互性质，它的前生是live script；java 是sun 公司开发的一种自然的网络面向对象语言，目的是开发分布式应用，它的前生是OAK,它几乎应用于分布式应用的各个部分，在浏览器端有JAVA APPLET,在应用程序端有J2SE,在服务器端有J2EE,还有再小终端上有J2ME等；2.语言的执行过程和环境不一样：JAVASCRIPT 是有浏览器端解释执行的，它不需要编译。java是需要通过jdk进行编译生成字节流，然后通过代码装载器在java虚拟机执行。它可以在有虚拟机的任何地方加载运行。比如java applet ,尽管它是在浏览器端执行的，但是它是有浏览器的java插件执行的，如果没有java虚拟机的浏览器，不能执行java applet.3.JAVA SCRIPT 是内嵌在HTML 网页中的，当然也可以动态转载（它是解释性），而JAVA同HTML是没有关系的，当然JAVA APPLET 是需要在网页中嵌代码。4. JAVA SCRIPT 主要是在浏览器端提供动态交互作用的,除了可以调用URL之外，不能同WEB SERVER (服务端）进行交互。而JAVA (JAVA APPLET)可以同WEB SERVER 建立各种联系和交互。5.许多语法特性都有很大区别，比如变量的强类型检查，面向对象特性（继承性）等，都是不一样的，具体的语法的特性区别，希望大家自己去比较。另外，JAVASCRIPT 同 JAVA APPLET 是可以进行交互的。JAVASCRIPT 在语法和语言的基本特性有很大的相似性。如果你是一个JAVA初学者，并且想从事动态网页设计，我建议可以从JAVA SE和JAVA APPLET入手学习JAVA

浏览器设置问题：有些应用程序或网页可能需要 JavaScript 来运行，如果您的浏览器未启用 JavaScript 或者设置有误，则可能导致错误。请检查您的浏览器设置，确保已启用 JavaScript 并且没有被阻止。软件问题：某些软件可能会出现 JavaScript 错误，这可能是由于软件本身存在漏洞或者错误引起的。您可以尝试升级或重新安装软件，或者联系软件供应商获取支持。病毒或恶意软件感染：某些病毒或恶意软件可能会修改系统文件或浏览器设置，导致 JavaScript 错误。您可以运行杀毒软件和恶意软件清除工具来扫描您的计算机，确保您的系统没有被感染。根据您提供的错误信息，可能是因为缺少所需的文件或目录，导致程序无法正常运行。具体解决方法如下：重新安装软件：尝试卸载原先的软件，并重新下载、安装软件。如果是在程序安装过程中出现的问题，这个方法有可能会解决问题。检查文件完整性：请检查是否存在缺少的文件或目录。可以尝试查看程序的安装目录是否存在完整的文件和文件夹，特别是是否存在 meta-inf(win32ia32.node) 这个文件。如果确实缺少该文件，可以尝试重新安装程序或者从可靠的来源获取该文件。检查权限：请确保您的计算机上具有执行该程序所需的适当权限。有时候权限不足会导致程序无法访问所需文件或目录。如果上述方法都无法解决问题，请尝试联系软件供应商或开发者获取技术支持。他们可能能够更好地了解该程序的问题并提供解决方案。

前端脚本。。。

public File(String pathname)通过将给定路径名字符串转换为抽象路径名来创建一个新 File 实例。如果给定字符串是空字符串，那么结果是空抽象路径名。参数：pathname - 路径名字符串抛出：NullPointerException - 如果 pathname 参数为 null上面是API中的介绍，“.”表示是一个抽象路径

　File类与InputStream / OutputStream类同属于一个包，它不允许访问文件内容。　　File类主要用于命名文件、查询文件属性和处理文件目录。

File表示一个目录或文件

public class Birthday { private int year; private int month; private int day; public Birthday(int y, int m, int d) { year = y; month = m; day = d; } public void isLeapYear() { boolean leapyear = ((year % 400 == 0) || (year % 100 != 0 && year % 4 == 0)) ? true : false; System.out.println("您所输入的年份是闰年吗？" + (leapyear ? "是" : "不是")); } public static void main(String[] args) { Birthday Bri1 = new Birthday(1986, 10, 7); Bri1.isLeapYear(); }}

f.getAbsolutePath()+f.getFileName();上面的结果是: c:abc.jpg

File file;filename=file.getName();//获取文件名

public class test1 { public static void main(String[] args) { File file=new File("D:/gai.jpg"); //指定文件名及路径 String name="123"; //新文件名字String filename=file.getAbsolutePath(); if(filename.indexOf(".")>=0) {filename = filename.substring(0,filename.lastIndexOf(".")); } file.renameTo(new File(name+".jpg")); //改名 } }

取到文件名后，用split进行差分

使用java poi package webservice;import java.io.FileInputStream;import java.io.FileNotFoundException;import java.io.FileOutputStream;import java.io.IOException;import org.apache.poi.hssf.usermodel.HSSFCell;import org.apache.poi.hssf.usermodel.HSSFRow;import org.apache.poi.hssf.usermodel.HSSFSheet;import org.apache.poi.hssf.usermodel.HSSFWorkbook;public class ExcelController {@SuppressWarnings("deprecation")public void excel() throws FileNotFoundException, IOException{String filename = "d:\excel.xls"; HSSFWorkbook workbook = new HSSFWorkbook(new FileInputStream(filename)); //按名引用excel工作表// HSSFSheet sheet = workbook.getSheet("JSP"); //也可以用以下方式来获取excel的工作表，采用工作表的索引值 HSSFSheet sheet = workbook.getSheetAt(0); HSSFRow row ; HSSFCell cell1; int rows=sheet.getLastRowNum(); for(int icount=0;icount<rows;icount++){ row = sheet.getRow(icount); int line=row.getPhysicalNumberOfCells(); for(int j=0;j<line;j++){ cell1= row.getCell(j); System.out.println(cell1+"--"+icount+"---"+j); } } //打印读取值// System.out.println(cell.getStringCellValue()); //新建一输出流 FileOutputStream fout = new FileOutputStream(filename); //PS：filename 是你另存为的路径，不处理直接写入模版文件 //存盘 workbook.write(fout); fout.flush(); //结束关闭 fout.close();}public HSSFCell getCell(HSSFRow row, int index) {// 取得分发日期单元格HSSFCell cell = row.getCell(index);// 如果单元格不存在if (cell == null) {// 创建单元格cell = row.createCell(index);}// 返回单元格return cell;}public static void main(String[] args) { ExcelController ec = new ExcelController(); try { ec.excel(); } catch (FileNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); }}

filename.lastIndexOf("")

看API，FileOutPutStream 及其它的 XXXXXXXXXXXOutPutStream、XXXXXWriter等

不可以String只是字符串File可以因为它是文件类

三个虽然很相似 但是完全出于不同的概念和领域，也就是风马牛不相及的三个东西.final修饰符 修饰常量finally 用于捕获异常的最后输出finalize是垃圾回收机制里面的方法，目前基本所有公司都不用

查字典”是通常的评论的时候，人们在对意义或一个单词拼写的怀疑。词典是对这些问题的最终权威以及关于一个字发音和其他的事实。几百年前，然而，人们不可能“查”，因为没有英语词典。古希腊和古罗马和中世纪的学者作了拉丁和希腊词汇列表。G。但直到1604，一本罕见的英文字出现。）第一个伟大的英语词典列出常见和不常见的词是由塞缪尔约翰逊写的1755。在美国，编写词典最著名的名字是诺亚韦伯斯特。他强调美国而不是英国的方式说话。他的大词典，它首先出现在1828，已再版多次。每一次，它已被更新。）的最新版本仍然被认为是“词典。它定义了超过450000字，包括雷达，电视和其他许多人想象不到韦伯斯特。E.字典列表中的所有类型的话，被称为一般字典。），图书馆在休息站被称为完整的巨大的，意思是“不缩短。”他们告诉不只有一个字的意义和拼写而且它的发音，起源，历史的一部分，语音，语法形式，并利用途径。小企业不提供所有这些信息。B.一般字典是不是唯一的一种）的双语词典，如西班牙语英语词典，翻译成另一种语言的话。一个词库列表换句话说，每一列字是相同的。一个地名列表地名，和一个词汇是在这本书中的一本书定义技术词小词典。也有科学术语的许多其他主题词典。甚至有一个俚语词典。（C，因此有许多种特殊词典）词典是我们最宝贵的语言工具。

final 修饰的类和变量， 都不能被继承

这是基础知识 貌似我全部忘了

final变量定义的时候，可以先声明，而不给初值，这中变量也称为空白final，无论什么情况，编译器都确保空白final在使用之前必须被初 始化。但是，空白final在final关键字final的使用上提供了更大的灵活性，为此，一个类中的final数据成员就可以实现依对象而有所不同， 却有保持其恒定不变的特征。4、final参数 当函数参数为final类型时，你可以读取使用该参数，但是无法改变该参数的值。public classTest1 { public static void main(String[] args) { new Test1().f1(1); } public voidf1( final int i){ //i++; i是final类型的,值不允许改变的. System.out.print(i); } } static和final一块用表示什么 static final用来修饰成员变量和成员方法，可简单理解为“全局常量”！ 对于变量，表示一旦给值就不可修改，并且通过类名可以访问。 对于方法，表示不可覆盖，并且可以通过类名直接访问。就这么多，希望能给您些许帮助

定义常量，不可修改。

如果只是使用final 那你如果想使用这个属性 需要实例化对象 才能使用 如果加上static

final 定义常量，不能再被赋值，定义一些固定的值，但不以值的形式出现

一、final 　根据程序上下文环境，Java关键字final有“这是无法改变的”或者“终态的”含义，它可以修饰非抽象类、非抽象类成员方法和变量。你可能出于两种理解而需要阻止改变：设计或效率。 final类不能被继承，没有子类，final类中的方法默认是final的。 final方法不能被子类的方法覆盖，但可以被继承。 final成员变量表示常量，只能被赋值一次，赋值后值不再改变。 final不能用于修饰构造方法。 注意：父类的private成员方法是不能被子类方法覆盖的，因此private类型的方法默认是final类型的。 1、final类 　final类不能被继承，因此final类的成员方法没有机会被覆盖，默认都是final的。在设计类时候，如果这个类不需要有子类，类的实现细节不允许改变，并且确信这个类不会载被扩展，那么就设计为final类。 2、final方法 如果一个类不允许其子类覆盖某个方法，则可以把这个方法声明为final方法。 使用final方法的原因有二： 第一、把方法锁定，防止任何继承类修改它的意义和实现。 第二、高效。编译器在遇到调用final方法时候会转入内嵌机制，大大提高执行效率。 例如： public class Test1 { public static void main(String[] args) { // TODO 自动生成方法存根 } public void f1() { System.out.println("f1"); } //无法被子类覆盖的方法 public final void f2() { System.out.println("f2"); } public void f3() { System.out.println("f3"); } private void f4() { System.out.println("f4"); } } public class Test2 extends Test1 { public void f1(){ System.out.println("Test1父类方法f1被覆盖!"); } public static void main(String[] args) { Test2 t=new Test2(); t.f1(); t.f2(); //调用从父类继承过来的final方法 t.f3(); //调用从父类继承过来的方法 //t.f4(); //调用失败，无法从父类继承获得 } } 3、final变量（常量） 　用final修饰的成员变量表示常量，值一旦给定就无法改变！ 　final修饰的变量有三种：静态变量、实例变量和局部变量，分别表示三种类型的常量。 　从下面的例子中可以看出，一旦给final变量初值后，值就不能再改变了。 　另外，final变量定义的时候，可以先声明，而不给初值，这中变量也称为final空白，无论什么情况，编译器都确保空白final在使用之前必须被初始化。但是，final空白在final关键字final的使用上提供了更大的灵活性，为此，一个类中的final数据成员就可以实现依对象而有所不同，却有保持其恒定不变的特征。package org.leizhimin; public class Test3 { private final String S="final实例变量S"; private final int A=100; public final int B=90; public static final int C=80; private static final int D=70; public final int E; //final空白,必须在初始化对象的时候赋初值 public Test3(int x){ E=x; } /** * @param args */ public static void main(String[] args) { Test3 t=new Test3(2); //t.A=101; //出错,final变量的值一旦给定就无法改变 //t.B=91; //出错,final变量的值一旦给定就无法改变 //t.C=81; //出错,final变量的值一旦给定就无法改变 //t.D=71; //出错,final变量的值一旦给定就无法改变 System.out.println(t.A); System.out.println(t.B); System.out.println(t.C); //不推荐用对象方式访问静态字段 System.out.println(t.D); //不推荐用对象方式访问静态字段 System.out.println(Test3.C); System.out.println(Test3.D); //System.out.println(Test3.E); //出错,因为E为final空白,依据不同对象值有所不同. System.out.println(t.E); Test3 t1=new Test3(3); System.out.println(t1.E); //final空白变量E依据对象的不同而不同 } private void test(){ System.out.println(new Test3(1).A); System.out.println(Test3.C); System.out.println(Test3.D); } public void test2(){ final int a; //final空白,在需要的时候才赋值 final int b=4; //局部常量--final用于局部变量的情形 final int c; //final空白,一直没有给赋值. a=3; //a=4; 出错,已经给赋过值了. //b=2; 出错,已经给赋过值了. } } 4、final参数 当函数参数为final类型时，你可以读取使用该参数，但是无法改变该参数的值。public class Test4 { public static void main(String[] args) { new Test4().f1(2); } public void f1(final int i){ //i++; //i是final类型的,值不允许改变的. System.out.print(i); } }

出于安全性的考虑，将一些类修饰为final类。例如，Java提供的String类，它对于编译器和解释器的正常运行有很重要的作用，对它不能轻易改变，因此它被修饰为final类。 如果一个方法被修饰为final方法，则这个方法不能被重写，如果一个成员变量被修饰为final的，就是常量。 final 修饰的类不能继承。没有子类，final类中的方法默认是final的。 final 修饰的方法不能重写。但可以被继承。 父类的private修饰的方法是不能被子类方法覆盖的，因此private类型的方法默认是final类型的。 JVM会对final方法自动优化，其执行效率会比普通方法更高。 final 修饰的成员变量不能修改。该变量不能被修改,也就是常量。

不能从这个类继承，或者不答应其他任何对象采取这种操作

1，修饰类　　当用final修饰一个类时，表明这个类不能被继承。也就是说，如果一个类你永远不会让他被继承，就可以用final进行修饰。final类中的成员变量可以根据需要设为final，但是要注意final类中的所有成员方法都会被隐式地指定为final方法。　　在使用final修饰类的时候，要注意谨慎选择，除非这个类真的在以后不会用来继承或者出于安全的考虑，尽量不要将类设计为final类。2，修饰方法被final修饰的方法将不能被子类覆盖，主要用于1，把方法锁定，以防任何继承类修改它的含。2，在早期的Java实现版本中，会将final方法转为内嵌调用，所以效率能够提升3，修饰变量对于一个final变量，如果是基本数据类型的变量，则其数值一旦在初始化之后便不能更改；如果是引用类型的变量，则在对其初始化之后便不能再让其指向另一个对象。　当用final作用于类的成员变量时，成员变量（注意是类的成员变量，局部变量只需要保证在使用之前被初始化赋值即可）必须在定义时或者构造器中进行初始化赋值，而且final变量一旦被初始化赋值之后，就不能再被赋值了。

final方法将方法声明为final，那就说明你已经知道这个方法提供的功能已经满足你要求，不需要进行扩展。final是JAVA的一个关键字有：final类final类不能被继承，因此final类的成员方法没有机会被覆盖，默认都是final的。解析如下：另外有一种被称为inline的机制，它会使你在调用final方法时，直接将方法主体插入到调用处，而不是进行例行的方法调用，例如保存断点，压栈等，这样可能会使你的程序效率有所提高，然而当你的方法主体非常庞大时，或你在多处调用此方法，那么你的调用主体代码便会迅速膨胀，可能反而会影响效率，所以你要慎用final进行方法定义。当你将final用于类身上时，你就需要仔细考虑，因为一个final类是无法被任何人继承的，那也就意味着此类在一个继承树中是一个叶子类，并且此类的设计已被认为很完美而不需要进行修改或扩展。

final是不能再改变的，修饰的变量是常量，修饰的类不能被继承，

final在java中的意思是表示最终的，无法改变的意思。1.final定义数值表示这个数值是最终的，不可改变的，一旦改变是会出错的，当用final作用于类的成员变量时，成员变量（注意是类的成员变量，局部变量只需要保证在使用之前被初始化赋值即可）必须在定义时或者构造器中进行初始化赋值，而且final变量一旦被初始化赋值之后，就不能再被赋值了。。2.final定义方法表示这个方法是不能被重写和重载的只能够被子类继承使用，使用final方法的原因有两个。第一个原因是把方法锁定，以防任何继承类修改它的含义；第二个原因是效率。在早期的Java实现版本中，会将final方法转为内嵌调用。但是如果方法过于庞大，可能看不到内嵌调用带来的任何性能提升。在最近的Java版本中，不需要使用final方法进行这些优化了。3.final定义类便是这个类是最终的，是不能够被继承的，类中的方法也都是默认修饰了final方法，注意final类中的成员变量可以根据需要设为final。

根据程序上下文环境，Java关键字final有“这是无法改变的”或者“终态的”含义，它可以修饰非抽象类、非抽象类成员方法和变量。你可能出于两种理解而需要阻止改变：设计或效率。final类不能被继承，没有子类，final类中的方法默认是final的。final方法不能被子类的方法覆盖，但可以被继承。final成员变量表示常量，只能被赋值一次，赋值后值不再改变。final不能用于修饰构造方法。注意：父类的private成员方法是不能被子类方法覆盖的，因此private类型的方法默认是final类型的。

final—修饰符（关键字）如果一个类被声明为final，意味着它不能再派生出新的子类，不能作为父类被继承。因此一个类不能既被声明为 abstract的，又被声明为final的。将变量或方法声明为final，可以保证它们在使用中不被改变。被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取，不可修改。被声明为final的方法也同样只能使用，不能重载。finally—在异常处理时提供 finally 块来执行任何清除操作。如果抛出一个异常，那么相匹配的 catch 子句就会执行，然后控制就会进入 finally 块（如果有的话）

异常处理 中必须执行的代码放在finally{}里面

finally常用来处理java一些后续的工作.在java的的finally首先必须使用在所有catch的最后位置,其次它是必须执行的,无条件执行,甚至即使前面的try-catch语句中已经存在异常了,它仍然会执行.不管try语句块正常结束还是异常结束,finally语句块是保证要执行的.如果try语句块正常结束,那么在try语句块中的语句都执行完之后,再执行finally语句块.

查看了jdk 1.6 doc，String对象并无offset的属性或方法。那是自己定义的变量

拿好

qps表示每秒查询率，是一台服务器每秒能够响应的查询次数。只要知道服务器台数和指定时间内的查询次数，就可以计算了。

这并不是java标准的注解，而是谷歌GSON的注解，表示它所注解的字段不支持序列化。

使用正则表达式正则表达式的编译表示形式。 指定为字符串的正则表达式必须首先被编译为此类的实例。然后，可将得到的模式用于创建 Matcher 对象，依照正则表达式，该对象可以与任意字符序列匹配。执行匹配所涉及的所有状态都驻留在匹配器中，所以多个匹配器可以共享同一模式。 因此，典型的调用顺序是 Pattern p = Pattern.compile("a*b"); Matcher m = p.matcher("aaaaab"); boolean b = m.matches();在仅使用一次正则表达式时，可以方便地通过此类定义 matches 方法。此方法编译表达式并在单个调用中将输入序列与其匹配。语句 boolean b = Pattern.matches("a*b", "aaaaab");等效于上面的三个语句，尽管对于重复的匹配而言它效率不高，因为它不允许重用已编译的模式。 此类的实例是不可变的，可供多个并发线程安全使用。Matcher 类的实例用于此目的则不安全。 正则表达式的构造摘要 构造 匹配 字符 x 字符 x \ 反斜线字符 n 带有八进制值 0 的字符 n (0 <= n <= 7) nn 带有八进制值 0 的字符 nn (0 <= n <= 7) mnn 带有八进制值 0 的字符 mnn（0 <= m <= 3、0 <= n <= 7） xhh 带有十六进制值 0x 的字符 hh uhhhh 带有十六进制值 0x 的字符 hhhh 制表符 ("u0009") 新行（换行）符 ("u000A") 回车符 ("u000D") f 换页符 ("u000C") a 报警 (bell) 符 ("u0007") e 转义符 ("u001B") cx 对应于 x 的控制符 字符类 [abc] a、b 或 c（简单类） [^abc] 任何字符，除了 a、b 或 c（否定） [a-zA-Z] a 到 z 或 A 到 Z，两头的字母包括在内（范围） [a-d[m-p]] a 到 d 或 m 到 p：[a-dm-p]（并集） [a-z&&[def]] d、e 或 f（交集） [a-z&&[^bc]] a 到 z，除了 b 和 c：[ad-z]（减去） [a-z&&[^m-p]] a 到 z，而非 m 到 p：[a-lq-z]（减去） 预定义字符类 . 任何字符（与行结束符可能匹配也可能不匹配） d 数字：[0-9] D 非数字： [^0-9] s 空白字符：[ x0Bf ] S 非空白字符：[^s] w 单词字符：[a-zA-Z_0-9] W 非单词字符：[^w] POSIX 字符类（仅 US-ASCII） p{Lower} 小写字母字符：[a-z] p{Upper} 大写字母字符：[A-Z] p{ASCII} 所有 ASCII：[x00-x7F] p{Alpha} 字母字符：[p{Lower}p{Upper}] p{Digit} 十进制数字：[0-9] p{Alnum} 字母数字字符：[p{Alpha}p{Digit}] p{Punct} 标点符号：!"#$%&"()*+,-./:;<=>?@[]^_`{|}~ p{Graph} 可见字符：[p{Alnum}p{Punct}] p{Print} 可打印字符：[p{Graph}x20] p{Blank} 空格或制表符：[ ] p{Cntrl} 控制字符：[x00-x1Fx7F] p{XDigit} 十六进制数字：[0-9a-fA-F] p{Space} 空白字符：[ x0Bf ] java.lang.Character 类（简单的 java 字符类型） p{javaLowerCase} 等效于 java.lang.Character.isLowerCase() p{javaUpperCase} 等效于 java.lang.Character.isUpperCase() p{javaWhitespace} 等效于 java.lang.Character.isWhitespace() p{javaMirrored} 等效于 java.lang.Character.isMirrored() Unicode 块和类别的类 p{InGreek} Greek 块（简单块）中的字符 p{Lu} 大写字母（简单类别） p{Sc} 货币符号 P{InGreek} 所有字符，Greek 块中的除外（否定） [p{L}&&[^p{Lu}]] 所有字母，大写字母除外（减去） 边界匹配器 ^ 行的开头 $ 行的结尾  单词边界 B 非单词边界 A 输入的开头 G 上一个匹配的结尾  输入的结尾，仅用于最后的结束符（如果有的话） z 输入的结尾 Greedy 数量词 X? X，一次或一次也没有 X* X，零次或多次 X+ X，一次或多次 X{n} X，恰好 n 次 X{n,} X，至少 n 次 X{n,m} X，至少 n 次，但是不超过 m 次 Reluctant 数量词 X?? X，一次或一次也没有 X*? X，零次或多次 X+? X，一次或多次 X{n}? X，恰好 n 次 X{n,}? X，至少 n 次 X{n,m}? X，至少 n 次，但是不超过 m 次 Possessive 数量词 X?+ X，一次或一次也没有 X*+ X，零次或多次 X++ X，一次或多次 X{n}+ X，恰好 n 次 X{n,}+ X，至少 n 次 X{n,m}+ X，至少 n 次，但是不超过 m 次 Logical 运算符 XY X 后跟 Y X|Y X 或 Y (X) X，作为捕获组 Back 引用 任何匹配的 nth 捕获组 引用 Nothing，但是引用以下字符 Q Nothing，但是引用所有字符，直到 E E Nothing，但是结束从 Q 开始的引用 特殊构造（非捕获） (?:X) X，作为非捕获组 (?idmsux-idmsux) Nothing，但是将匹配标志i d m s u x on - off (?idmsux-idmsux:X) X，作为带有给定标志 i d m s u x on - off 的非捕获组 (?=X) X，通过零宽度的正 lookahead (?!X) X，通过零宽度的负 lookahead (?<=X) X，通过零宽度的正 lookbehind (?<!X) X，通过零宽度的负 lookbehind (?>X) X，作为独立的非捕获组 --------------------------------------------------------------------------------反斜线、转义和引用 反斜线字符 ("") 用于引用转义构造，如上表所定义的，同时还用于引用其他将被解释为非转义构造的字符。因此，表达式 \ 与单个反斜线匹配，而 { 与左括号匹配。 在不表示转义构造的任何字母字符前使用反斜线都是错误的；它们是为将来扩展正则表达式语言保留的。可以在非字母字符前使用反斜线，不管该字符是否非转义构造的一部分。 根据 Java Language Specification 的要求，Java 源代码的字符串中的反斜线被解释为 Unicode 转义或其他字符转义。因此必须在字符串字面值中使用两个反斜线，表示正则表达式受到保护，不被 Java 字节码编译器解释。例如，当解释为正则表达式时，字符串字面值 "" 与单个退格字符匹配，而 "\b" 与单词边界匹配。字符串字面值 "(hello)" 是非法的，将导致编译时错误；要与字符串 (hello) 匹配，必须使用字符串字面值 "\(hello\)"。 字符类 字符类可以出现在其他字符类中，并且可以包含并集运算符（隐式）和交集运算符 (&&)。并集运算符表示至少包含其某个操作数类中所有字符的类。交集运算符表示包含同时位于其两个操作数类中所有字符的类。 字符类运算符的优先级如下所示，按从最高到最低的顺序排列： 1 字面值转义 x 2 分组 [...] 3 范围 a-z 4 并集 [a-e][i-u] 5 交集 [a-z&&[aeiou]] 注意，元字符的不同集合实际上位于字符类的内部，而非字符类的外部。例如，正则表达式 . 在字符类内部就失去了其特殊意义，而表达式 - 变成了形成元字符的范围。 行结束符行结束符 是一个或两个字符的序列，标记输入字符序列的行结尾。以下代码被识别为行结束符： 新行（换行）符 (" ")、 后面紧跟新行符的回车符 (" ")、 单独的回车符 (" ")、 下一行字符 ("u0085")、 行分隔符 ("u2028") 或 段落分隔符 ("u2029)。 如果激活 UNIX_LINES 模式，则新行符是唯一识别的行结束符。 如果未指定 DOTALL 标志，则正则表达式 . 可以与任何字符（行结束符除外）匹配。 默认情况下，正则表达式 ^ 和 $ 忽略行结束符，仅分别与整个输入序列的开头和结尾匹配。如果激活 MULTILINE 模式，则 ^ 在输入的开头和行结束符之后（输入的结尾）才发生匹配。处于 MULTILINE 模式中时，$ 仅在行结束符之前或输入序列的结尾处匹配。 组和捕获 捕获组可以通过从左到右计算其开括号来编号。例如，在表达式 ((A)(B(C))) 中，存在四个这样的组： 1 ((A)(B(C))) 2 A 3 (B(C)) 4 (C) 组零始终代表整个表达式。 之所以这样命名捕获组是因为在匹配中，保存了与这些组匹配的输入序列的每个子序列。捕获的子序列稍后可以通过 Back 引用在表达式中使用，也可以在匹配操作完成后从匹配器获取。 与组关联的捕获输入始终是与组最近匹配的子序列。如果由于量化的缘故再次计算了组，则在第二次计算失败时将保留其以前捕获的值（如果有的话）例如，将字符串 "aba" 与表达式 (a(b)?)+ 相匹配，会将第二组设置为 "b"。在每个匹配的开头，所有捕获的输入都会被丢弃。 以 (?) 开头的组是纯的非捕获 组，它不捕获文本，也不针对组合计进行计数。 Unicode 支持 此类符合 Unicode Technical Standard #18:Unicode Regular Expression Guidelines 第 1 级和 RL2.1 Canonical Equivalents。 Java 源代码中的 Unicode 转义序列（如 —）是按照 Java Language Specification 的 第 3.3 节中的描述处理的。这样的转义序列还可以由正则表达式解析器直接实现，以便在从文件或键盘击键读取的表达式中使用 Unicode 转义。因此，可以将不相等的字符串 "—" 和 "—" 编译为相同的模式，从而与带有十六进制值 0x2014 的字符匹配。 与 Perl 中一样，Unicode 块和类别是使用 p 和 P 构造编写的。如果输入具有属性 prop，则与 p{prop} 匹配，而输入具有该属性时与 P{prop} 不匹配。块使用前缀 In 指定，与在 InMongolian 中一样。可以使用可选前缀 Is 指定类别：p{L} 和 p{IsL} 都表示 Unicode 字母的类别。块和类别在字符类的内部和外部都可以使用。 受支持的类别是由 Character 类指定版本中的 The Unicode Standard 的类别。类别名称是在 Standard 中定义的，即标准又丰富。Pattern 所支持的块名称是 UnicodeBlock.forName 所接受和定义的有效块名称。 行为类似 java.lang.Character boolean 是 methodname 方法（废弃的类别除外）的类别，可以通过相同的 p{prop} 语法来提供，其中指定的属性具有名称 javamethodname。 与 Perl 5 相比较 Pattern 引擎用有序替换项执行传统上基于 NFA 的匹配，与 Perl 5 中进行的相同。 此类不支持 Perl 构造： 条件构造 (?{X}) 和 (?(condition)X|Y)、 嵌入式代码构造 (?{code}) 和 (??{code})、嵌入式注释语法 (?#comment) 和 预处理操作 l u、L 和 U。此类支持但 Perl 不支持的构造： Possessive 数量词，它可以尽可能多地进行匹配，即使这样做导致所有匹配都成功时也如此。 字符类并集和交集，如上文所述。与 Perl 的显著不同点是： 在 Perl 中，1 到 9 始终被解释为 Back 引用；如果至少存在多个子表达式，则大于 9 的反斜线转义数按 Back 引用对待，否则在可能的情况下，它将被解释为八进制转义。在此类中，八进制转义必须始终以零开头。在此类中，1 到 9 始终被解释为 Back 引用，较大的数被接受为 Back 引用，如果在正则表达式中至少存在多个子表达式的话；否则，解析器将删除数字，直到该数小于等于组的现有数或者其为一个数字。 Perl 使用 g 标志请求恢复最后匹配丢失的匹配。此功能是由 Matcher 类显式提供的：重复执行 find 方法调用可以恢复丢失的最后匹配，除非匹配器被重置。 在 Perl 中，位于表达式顶级的嵌入式标记对整个表达式都有影响。在此类中，嵌入式标志始终在它们出现的时候才起作用，不管它们位于顶级还是组中；在后一种情况下，与在 Perl 中类似，标志在组的结尾处还原。 Perl 允许错误匹配构造，如在表达式 *a 中，以及不匹配的括号，如在在表达式 abc] 中，并将其作为字面值对待。此类还接受不匹配的括号，但对 +、? 和 * 不匹配元字符有严格限制；如果遇到它们，则抛出 PatternSyntaxException。 有关正则表达式构造行为更准确的描述，请参见 Mastering Regular Expressions, 2nd Edition，该书由 Jeffrey E. F. Friedl、O"Reilly 和 Associates 合著，于 2002 年出版。

public class Box { private double length; private double width; private double height; public void setD() { this.length=3; this.width=4; this.height=5; } public double cal_volume() { return(this.length*this.width*this.height); } public static void main(String[] args) { Box b=new Box(); b.setD(); System.out.println("the volume of the cuboid is "+b.cal_volume());}}

抽象类可以声明对象，但是不能使用自身的构造方法创建对象，但是可以使用子类的构造方法进行创建。public abstract class A{}public class B extends A{}A a = new B();

猜拳游戏行吗？

public Car(){this.color="黑";this.door=4;this.speed=100;}编写一个具有3个参数的构造方法public Car(String color,int door,float speed){this.color=color;this.door=door;this.speed=speed;}public void start(){//汽车启动。输出汽车已启动，并输出汽车的各个属性System.out.println("汽车启动");System.out.println("颜色："+this.color+"车门数量："+this.door+"速度"+this,speed);}public void speedUp(float speed){//加速//传入的为增加的速度this.speed=this.speed+speed;//传入的为增加后的速度this.speed=speed;}public void shutDown(float speed){//减速//传入的为的速度this.speed=this.speed-speed;//传入的为增加后的速度this.speed=speed;}public void brake(){//刹车this.speed=0;}

手机百度不方便，＋694379422帮你写

void speedUp(int s){ speed=speed+s; if(speed>200) {System.out.println("加速后你已经超过200，不能加速"); speed=speed-s; return; }

variant ？这不是java的变量类型吧。

可能要Variant的SafeArray s=v.toSafeArray();//得到安全数组再String[] texts=s.toStringArray();获得字符串数组..

它们的关系很简单，简单的说： c是面向过程语言，c++与java都是由c发展进化来的面向对象语言，c++与java大同小异

Dervied extends Base 继承Dervied复写两个方法 所以印出来的都一样!!Dervied.classBase.class 两个方法是一样的所以内容被复写了!!!这样你知道了吗???

在C1中重写（override）test方法

public class Base{ public void baseA(){ System.out.println("this is BaseA!!!!!!!!!!!"); } public void baseB(){ System.out.println("this is BaseB -----"); this.baseA(); }}public class Derived{ public void baseB(){ System.out.println("this is Derived"s BaseB--------"); }}public class TestClass{ public static void main(String[] args){ Derived d = new Derived(); Base b = d; b.baseA(); }}

一个例子：Java代码 class Base{ public void foo(Base x){ System.out.println("Base.Base"); } public void foo(Derived x){ System.out.println("Base.Derived"); } } class Base{ public void foo(Base x){ System.out.println("Base.Base"); } public void foo(Derived x){ System.out.println("Base.Derived"); }}Java代码 class Derived extends Base{ public void foo(Base x){ System.out.println("Derived.Base"); } public void foo(Derived x){ System.out.println("Derived.Derived"); } } class Derived extends Base{ public void foo(Base x){ System.out.println("Derived.Base"); } public void foo(Derived x){ System.out.println("Derived.Derived"); }}Java代码 class Main{ public static void whichFoo(Base arg1, Base arg2){ arg1.foo(arg2); } public static void main(String[] args)}{ Base b = new Base(); Derived d = new Derived(); whichFoo(b,b); whichFoo(b,d); whichFoo(d,b); whichFoo(d,d); } } class Main{ public static void whichFoo(Base arg1, Base arg2){ arg1.foo(arg2); } public static void main(String[] args)}{ Base b = new Base(); Derived d = new Derived(); whichFoo(b,b); whichFoo(b,d); whichFoo(d,b); whichFoo(d,d); }}因为参数通常在编译阶段被匹配，在whichFoo方法中，形式参数arg2的类型是Base, 因此不管arg2实际引用的是什么类型，arg1.foo(arg2)匹配的foo都将是：public void foo(Base x)惟一的问题在于用Base还是Derived版本中的foo(Base x)函数？当知道arg1引用的对象时，这是在运行阶段要决定的。精确使用的方法是编译器绑定，在编译阶段，最佳方法名依赖于参数的静态和控制引用的静态类型所适合的方法。在这一点上，设置方法的名称，这一步叫静态重载。决定方法是哪一个类的版本，这通过由虚拟机推断出这个对象的运行时类型来完成，一旦知道运行时类型，虚拟机就唤起继承机制，寻找方法的最终版本。这叫做动态绑定。在方法whichFoor的调用arg1.foo(arg2)，将根据arg1的运行时类型是Base还是Derived来调用Base类或者Derived类中的foo(Base x)版本函数。由此理解方法的覆盖和重载。重载函数的实际调用版本由编译器绑定决定，而覆盖函数的实际调用版本由动态绑定决定。

java中flip是反转缓冲区。首先将限制设置为当前位置，然后将位置设置为 0。如果已定义了标记，则丢弃该标记。 常与compact方法一起使用。通常情况下，在准备从缓冲区中读取数据时调用flip方法。

必须有用呀，请参考http://walsh.iteye.com/blog/450114

1、D 2、A 3、C 4、A 5、D 6、B 7、B 8、C 9、A 10、A 11、A 12、B 13、A 14、D 15、C 16、C 17、A 18、D 19、D 20、D

好。教学质量高、课程设置合理。1、教学质量高：编程猫的Java课程由一支经验丰富、技术过硬的教学团队授课，课程设置合理、内容丰富、难度适中。2、课程设置合理：编程猫的Java课程是针对所有人开发的，采用了趣味性强、易于理解的教学方式。

你要返回什么值？你可以重新写方法，然后再actionListener中调用返回你想返回的数值；actionListener是不支持返回数值的；

flush，是将缓冲区的数据强制写入，其实在close的时候，也会进行一次flush的，因此close之前其实可以不用专门做flush的但是在某些情况下，流比较大，在写的过程中，可以进行阶段性的flush（话说我也不知道这样做会有什么好处……）

需要关闭。 输入输出流是要关闭的 ，用来释放运行过程中保存的资源。Java通过系统类System实现标准输入/输出的功能，定义了3个流变量in,out,和err。这3个流在Java中都定义为静态变量，可以直接通过system进行调用。System.in表示标准输入，通常指从键盘输入数据，System.out表示标准输出，通常指把数据输出到控制台或者屏幕，System.err表示标准错误输出，通常指把数据输出到控制台或者屏幕，最后这些流运行完毕后都要将其关闭释放资源。

flush刷新缓冲区, 例如你向文件中输出内容, 当你调用write后, byte可能还在缓冲区, 并没有真正的写入到文件中, 只有flush后会立即写入到文件

在这之前需搞清楚一个问题，BufferedReader是将文件读取到内存中,而BufferedWriter使将文件从内存中写入本地文件中，两者区别不言而喻。Flush（）是清空，而不是刷新主要用在IO中，即清空缓冲区数据，如果在Reader以后你来个flush()，你想想看，刚读取到内存中的数据就会被清空掉。而Writer以后，数据已经被保存到文件中，这时flush()就可以清空不再需要的缓存数据

试试：writer.println(msg); writer.flush(); writer.close();

Close的时候会执行Fluah不需要单独flush

dos.writeUTF(str);dos.flush();或者dos.flush();dos.close();就是说在1.你向输出流写入东西之后,执行flush(),目的是把缓冲区里的东西强行写入输出流.因为有些带缓冲区的输出流要缓冲区满的时候才输出.2.关闭流的时候这样也可以防止在关闭流时候抛出某个异常

主要用在IO中，即清空缓冲区数据，就是说你用读写流的时候，其实数据是先被读到了内存中，然后用数据写到文件中，当你数据读完的时候不代表你的数据已经写完了，因为还有一部分有可能会留在内存这个缓冲区中。这时候如果你调用了Close()方法关闭了读写流，那么这部分数据就会丢失，所以应该在关闭读写流之前先Flush()，先清空数据。就是说在1.你向输出流写入东西之后,执行flush(),目的是把缓冲区里的东西强行写入输出流.因为有些带缓冲区的输出流要缓冲区满的时候才输出.2.关闭流的时候这样也可以防止在关闭流时候抛出某个异常应该不用再举例子了吧，也不好举，O(∩_∩)O。

得看到具体的代码才能知道。光这样说无法确定。

flush刷新此输出流并强制写出所有缓冲的输出字节。flush 的常规协定是：如果此输出流的实现已经缓冲了以前写入的任何字节，则调用此方法指示应将这些字节立即写入它们预期的目标。 如果此流的预期目标是由基础操作系统提供的一个抽象（如一个文件），则刷新此流只能保证将以前写入到流的字节传递给操作系统进行写入，但不保证能将这些字节实际写入到物理设备（如磁盘驱动器）。 OutputStream 的 flush 方法不执行任何操作。

强制将输出流缓冲区的数据送出~~

FileOutPutStream继承outputStream,并不提供flush方法的重写，所以无论内容多少，write都会将二进制流直接传递给底层操作系统的I/O,flush无效果而Buffered系列的输入输出流函数单。从Buffered这个单词就可以看出他们是使用缓冲区的,应用程序每次IO都要和设备进行通信，效率很低，因此缓冲区为了提高效率，当写入设备时，先写入缓冲区，等到缓冲区有足够多的数据时，就整体写入设备使用BufferedXXXStream。默认缓冲区大小是8K。读的时候会一直填满缓冲区（或者文件读取完毕），写的时候也是等缓冲区满了之后（或者执行flush操作）才将内容送入内核缓冲区。效率高的原因就是避免了每读一个字节都要陷入操作系统内核（这是个耗时的操作）。flush（）方法是输出储存在内存中全部的内容（批量输出）。 常用比如FileWriter类中就是一个典型，除了可以使用flush输出，最后调用close方法也会批量输出。

flush()方法：冲走。意思是把缓冲区的内容强制的写出。因为操作系统的某些机制，为了防止一直不停地磁盘读写，所以有了延迟写入的概念。在网络web服务器上也是，为了防止写一个字节就发送一个消息，所以有缓冲区的概念，比如64K的内存区域，缓冲区写满了再一次性写入磁盘之中（或者发送给客户端浏览器）。flush方法一般是程序写入完成时执行。随后跟着close方法。例如：// 取得输出流。当然，看具体环境。PrintWriter out = Util.getWriter();out.println("输出一些信息，可能很多");out.flush();out.close();

flush() 是清空，而不是刷新啊。一般主要用在IO中，即清空缓冲区数据，就是说你用读写流的时候，其实数据是先被读到了内存中，然后用数据写到文件中，当你数据读完的时候不代表你的数据已经写完了，因为还有一部分有可能会留在内存这个缓冲区中。这时候如果你调用了 close()方法关闭了读写流，那么这部分数据就会丢失，所以应该在关闭读写流之前先flush()，先清空数据。

FileOutPutStream继承outputStream,并不提供flush方法的重写，所以无论内容多少，write都会将二进制流直接传递给底层操作系统的I/O,flush无效果而Buffered系列的输入输出流函数单。从Buffered这个单词就可以看出他们是使用缓冲区的,应用程序每次IO都要和设备进行通信，效率很低，因此缓冲区为了提高效率，当写入设备时，先写入缓冲区，等到缓冲区有足够多的数据时，就整体写入设备使用BufferedXXXStream。默认缓冲区大小是8K。读的时候会一直填满缓冲区（或者文件读取完毕），写的时候也是等缓冲区满了之后（或者执行flush操作）才将内容送入内核缓冲区。效率高的原因就是避免了每读一个字节都要陷入操作系统内核（这是个耗时的操作）。flush（）方法是输出储存在内存中全部的内容（批量输出）。 常用比如FileWriter类中就是一个典型，除了可以使用flush输出，最后调用close方法也会批量输出。