java

1）static方法　　static方法一般称作静态方法，由于静态方法不依赖于任何对象就可以进行访问，因此对于静态方法来说，是没有this的，因为它不依附于任何对象，既然都没有对象，就谈不上this了。并且由于这个特性，在静态方法中不能访问类的非静态成员变量和非静态成员方法，因为非静态成员方法/变量都是必须依赖具体的对象才能够被调用。2）static变量　　static变量也称作静态变量，静态变量和非静态变量的区别是：静态变量被所有的对象所共享，在内存中只有一个副本，它当且仅当在类初次加载时会被初始化。而非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。3）static代码块　　static关键字还有一个比较关键的作用就是用来形成静态代码块以优化程序性能。static块可以置于类中的任何地方，类中可以有多个static块。在类初次被加载的时候，会按照static块的顺序来执行每个static块，并且只会执行一次。

有要详解,那我找资料给你吧static表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，也可以形成静态static代码块，但是Java语言中没有全局变量的概念。 被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的实例，被类的所有实例共享。只要这个类被加载，Java虚拟机就能根据类名在运行时数据区的方法区内定找到他们。因此，static对象可以在它的任何对象创建之前访问，无需引用任何对象。 用public修饰的static成员变量和成员方法本质是全局变量和全局方法，当声明它类的对象市，不生成static变量的副本，而是类的所有实例共享同一个static变量。 static变量前可以有private修饰，表示这个变量可以在类的静态代码块中，或者类的其他静态成员方法中使用（当然也可以在非静态成员方法中使用--废话），但是不能在其他类中通过类名来直接引用，这一点很重要。实际上你需要搞明白，private是访问权限限定，static表示不要实例化就可以使用，这样就容易理解多了。static前面加上其它访问权限关键字的效果也以此类推。 static修饰的成员变量和成员方法习惯上称为静态变量和静态方法，可以直接通过类名来访问，访问语法为： 类名.静态方法名(参数列表...) 类名.静态变量名 用static修饰的代码块表示静态代码块，当Java虚拟机（JVM）加载类时，就会执行该代码块（用处非常大，呵呵）。 1、static变量 　按照是否静态的对类成员变量进行分类可分两种：一种是被static修饰的变量，叫静态变量或类变量；另一种是没有被static修饰的变量，叫实例变量。两者的区别是： 　对于静态变量在内存中只有一个拷贝（节省内存），JVM只为静态分配一次内存，在加载类的过程中完成静态变量的内存分配，可用类名直接访问（方便），当然也可以通过对象来访问（但是这是不推荐的）。 　对于实例变量，没创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响（灵活）。 所以一般在需要实现以下两个功能时使用静态变量：uf06c 在对象之间共享值时uf06c 方便访问变量时2、静态方法 静态方法可以直接通过类名调用，任何的实例也都可以调用，因此静态方法中不能用this和super关键字，不能直接访问所属类的实例变量和实例方法(就是不带static的成员变量和成员成员方法)，只能访问所属类的静态成员变量和成员方法。因为实例成员与特定的对象关联！这个需要去理解，想明白其中的道理，不是记忆！！！ 因为static方法独立于任何实例，因此static方法必须被实现，而不能是抽象的abstract。例如为了方便方法的调用，Java API中的Math类中所有的方法都是静态的，而一般类内部的static方法也是方便其它类对该方法的调用。静态方法是类内部的一类特殊方法，只有在需要时才将对应的方法声明成静态的，一个类内部的方法一般都是非静态的 3、static代码块 　static代码块也叫静态代码块，是在类中独立于类成员的static语句块，可以有多个，位置可以随便放，它不在任何的方法体内，JVM加载类时会执行这些静态的代码块，如果static代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次。例如： public class Test5 { private static int a; private int b; static{ Test5.a=3; System.out.println(a); Test5 t=new Test5(); t.f(); t.b=1000; System.out.println(t.b); } static{ Test5.a=4; System.out.println(a); } public static void main(String[] args) { // TODO 自动生成方法存根 } static{ Test5.a=5; System.out.println(a); } public void f(){ System.out.println("hhahhahah"); } } 运行结果： 3 hhahhahah 1000 4 5 　利用静态代码块可以对一些static变量进行赋值，最后再看一眼这些例子，都一个static的main方法，这样JVM在运行main方法的时候可以直接调用而不用创建实例。 4、static和final一块用表示什么 static final用来修饰成员变量和成员方法，可简单理解为“全局常量”！ 对于变量，表示一旦给值就不可修改，并且通过类名可以访问。 对于方法，表示不可覆盖，并且可以通过类名直接访问。有时你希望定义一个类成员，使它的使用完全独立于该类的任何对象。通常情况下，类成员必须通过它的类的对象访问，但是可以创建这样一个成员，它能够被它自己使用，而不必引用特定的实例。在成员的声明前面加上关键字static(静态的)就能创建这样的成员。如果一个成员被声明为static，它就能够在它的类的任何对象创建之前被访问，而不必引用任何对象。你可以将方法和变量都声明为static。static 成员的最常见的例子是main( ) 。因为在程序开始执行时必须调用main() ，所以它被声明为static。 声明为static的变量实质上就是全局变量。当声明一个对象时，并不产生static变量的拷贝，而是该类所有的实例变量共用同一个static变量。声明为static的方法有以下几条限制： u2022 它们仅能调用其他的static 方法。 u2022 它们只能访问static数据。 u2022 它们不能以任何方式引用this 或super（关键字super 与继承有关，在下一章中描述）。 如果你需要通过计算来初始化你的static变量，你可以声明一个static块，Static 块仅在该类被加载时执行一次。下面的例子显示的类有一个static方法，一些static变量，以及一个static 初始化块： // Demonstrate static variables，methods，and blocks. class UseStatic { static int a = 3; static int b; static void meth(int x) { System.out.println("x = " + x); System.out.println("a = " + a); System.out.println("b = " + b); } static { System.out.println("Static block initialized."); b = a * 4; } public static void main(String args[]) { meth(42); } } 一旦UseStatic 类被装载，所有的static语句被运行。首先，a被设置为3，接着static 块执行(打印一条消息)，最后，b被初始化为a*4 或12。然后调用main()，main() 调用meth() ，把值42传递给x。3个println ( ) 语句引用两个static变量a和b，以及局部变量x 。 注意：在一个static 方法中引用任何实例变量都是非法的。 下面是该程序的输出： Static block initialized. x = 42 a = 3 b = 12 在定义它们的类的外面，static 方法和变量能独立于任何对象而被使用。这样，你只要在类的名字后面加点号运算符即可。例如，如果你希望从类外面调用一个static方法，你可以使用下面通用的格式： classname.method( ) 这里，classname 是类的名字，在该类中定义static方法。可以看到，这种格式与通过对象引用变量调用非static方法的格式类似。一个static变量可以以同样的格式来访问——类名加点号运算符。这就是Java 如何实现全局功能和全局变量的一个控制版本。 下面是一个例子。在main() 中，static方法callme() 和static 变量b在它们的类之外被访问。 class StaticDemo { static int a = 42; static int b = 99; static void callme() { System.out.println("a = " + a); } } class StaticByName { public static void main(String args[]) { StaticDemo.callme(); System.out.println("b = " + StaticDemo.b); } } 下面是该程序的输出： a = 42 b = 99 static成员是不能被其所在class创建的实例访问的。 如果不加static修饰的成员是对象成员，也就是归每个对象所有的。 加static修饰的成员是类成员，就是可以由一个类直接调用，为所有对象共有的这样可以么？

申明为静态 变量和非静态的区别就是 饮水机和杯子饮水机全班用一个，公用的杯子一人一个，自己用自己的

他是静态变量

static可以修饰变量（属性）、方法、代码块和内部类static属性：属于这个类所有，即由该类创建的所有对象共享同一个static属性。可以对象创建后通过对象名.属性名和类名.属性名两种方式来访问。也可以在没有创建任何对象之前通过类名.属性名的方式来访问。static方法：也可以通过对象名.方法名和类名.方法名两种方式来访问static代码块：当类被第一次使用时（可能是调用static属性和方法，或者创建其对象）执行静态代码块，且只被执行一次，主要作用是实现static属性的初始化。static内部类：属于整个外部类，而不是属于外部类的每个对象。不能访问外部类的非静态成员（变量或者方法），.可以访问外部类的静态成员

实例方法可以操作类变量(static变量），也叫类的静态变量。static方法不能操作实例变量。原因很简单，实例变量（或实例方法）是要有类的实例才能访问的，即先要new一个对象，才能访问。而static方法或变量，不需要创建对象，直接通过类名访问，所以它不能访问实例变量。

static变量是在类第一次加载的时候已经准备的，static方法是可以直接通过类名访问的

mave verify

你的问题解决了吗？

本文我将为大家介绍Bootstrap中的弹出窗口组件Modal,此组件简单易用，效果大气漂亮且很实用！由于浏览器提供的alert和confirm框体验不好，而且浏览器没有提供一个标准的以对话框的形式显示自定义HTML的弹框函数，所以很多项目都会自定义对话框组件。本篇文章介绍自己在项目中基于bootstrap的modal组件，自定义alert，confirm和modal对话框的经验，相对比较简单实用，希望能对你有所参考价值。1. 实例展示详细的代码可通过前面给出的下载链接下载源码去了解，代码量不大，这三个组件加起来只有200多行如果你有javascript的组件开发经验，我这个层级的代码相信你一下子就能看明白。源码中我还给出了一个demo，这个demo模拟了一个比较贴近现实需求的一个场景：1）用户点击界面上的某个按钮，打开之前定义的一个modal框：2）用户在打开的modal框内填写一些表单，点击确定的时候，会触发一些校验：没填email时：填写了email之后：这两个提示其实是为了演示Alert和Confirm的效果硬塞进去的，实际上可能没有这么别扭的功能。3）在提示Password为空的时候，细心的人会发现那个确定按钮处于一个禁用的状态，这个考虑是因为确定按钮最终要完成的是一些异步任务，在异步任务成功完成之前，我希望modal组件都不要关闭，并且能够控制已点击的按钮不能重复点击；4）我用setTimeout模拟了一个异步任务，这个异步任务在点击确定按钮之后，3s才会回调，并且：当email输入admin@admin 的时候，会给出提交成功的提示，确定之后就会关闭所有的弹框：当email输入其它值得时候，会给出提交失败的提示，并且modal框会依然显示在那里：在组件定义里面，尤其是注册按钮这一块，我加了一些AOP编程的处理，同时利用了jquery的延迟对象，来实现我需要的异步编程，详情请阅读源码，有问题可以在评论区交流赐教。2. 组件需求有时候为了写一个好用的组件，只需要把它的大概原型和要对外部提供的接口确定下来，就已经完成这个组件编写最重要的工作了，虽然还没有开始编码。以本文要编写的这几个组件来说，我想要的这几个组件的原型和调用形式分别是这样的：1）自定义alert框原型是：调用时最多需要两个参数，一个msg用来传递要显示的提示内容，一个onOk用来处理确定按钮点击时候的回调，调用形式有以下2种：第一种是没有回调的情况，那么直接传递msg即可，第二种是有回调的情况，用options对象的方式来传递msg和onOks回调这两个参数。不管onOk回调有没有，点击按钮的时候都要关闭弹框。2）自定义confirm框这个框的原型跟alert框只差一个按钮：调用形式只有一种：onCancel是在点击取消按钮时候的回调。不管onOk和onCancel回调有没有，点击按钮的时候都要关闭弹框。onCancel回调可以没有。3）自定义modal框原型：调用形式：跟Alert和Confirm不同的是，一个页面里面只需要一个Alert和Confirm的实例，但是可能需要多个Modal的实例，所以每个Modal对象都需要单独new一下。由于每个Modal要完成的事情都不相同，所以：需要一个title参数来设置名称，表达这个Modal正在处理的事情；content参数表示Modal的html内容；width参数设置Modal的宽度，Modal的高度保持auto；buttons参数用来配置这个Modal上面的按钮，一般情况下Modal组件只需要两个按钮（确定和取消）就够了，但也有少数情况需要多个按钮，所以把按钮做成配置的方式相对灵活一点，每个按钮用三个参数来配置，html表示按钮的html结构，selector方便注册回调的时候通过事件委托的方式来处理，callback配置按钮点击时的回调；onContentReady这个事件回调，可以在Modal初始化完毕的时候，主动去初始化Modal内部html的一些组件；由于组件初始化一般只进行一次，所以放在这个回调里面最合适；onContentChange回调，在一个Modal需要被用作不同的场景，显示不同的HTML的内容时会派上用场，但是不是非常的好用，处理起来逻辑会稍微偏复杂，如果一个Modal实例只做一件事情的时候，onContentChange这个回调就用不到了；onModalShow这个回调在每次显示Modal的时候都会显示，使用的场景有很多，比如某个Modal用来填写一些表单内容，下次填写的时候需要reset一下表单才能给用户使用，这种处理在这个回调里面处理就比较合适；onModalHide这个回调有用，不过能够用到的场景不多，算是预留的一个接口。4）其它需求所有类型的弹框都做成虚拟模态的形式，显示框的同时加一个遮罩；所有框都不需要支持拖动和大小调整；alert和dialog框的标题，按钮数量、按钮位置、按钮文字都固定。实际上：遮罩这个效果，bootstrap的modal组件本身就已经支持了；拖动和大小调整，这个功能属于锦上添花，但是对软件本身来说，并一定有多少额外的好处，所以我选择不做这种多余的处理；alert和dialog不需要做太过个性化，能够统一风格，改变浏览器原生的弹框体验即可。5）DEMO中调用实例接下来演示下我在完成这三个组件开发之后，实际使用过程中调用这些组件的方式：3. 实现要点1）最基础的一点，要对bootstrap的modal组件源码有所了解：初始化方式：$modal.modal()打开：$modal.modal("show")关闭：$modal.modal(hide)事件：bootstrap大部分带过渡效果的组件的事件都是成对的，并且一个是现在时，一个是完成时，modal组件定义了2对：show.bs.modal和shown.bs.modal，hide.bs.modal和hidden.bs.modal。这两对事件分别在打开和关闭的过渡效果执行前后触发。从我要定义的组件需求来说，定义组件的时候需要show.bs.modal和hidden.bs.modal这两个事件，在侦听到bootstrap的modal组件派发这两个事件的时候，派发自己定义的组件的事件：modalShow和modalHide。选项：backdrop： 是否显示遮罩；keyboard： 是否支持键盘回调；show：是否在初始化完毕就立即显示。这三个选项默认都是true，但是在我定义组件的时候，我都配置成了false，键盘回调这种特性暂时不考虑，所以配置为true；当调用bootstrap的modal初始化的时候当然不能立即显示弹框，所以也不能配置为true；backdrop配置为false的原因在下一点介绍。2）遮罩处理如果启用bootstrap的遮罩，会发现在点击遮罩部分的时候，弹框就会自动关掉了，这不是我期望的虚拟模态效果，所以必须把backdrop配置为false。但是把这个选项配置为false之后，又会引发一个新问题，就是组件没有了遮罩效果，所以为了兼顾这两个问题，只能自己写一个简单的遮罩处理：这段代码中引入count变量的原因是因为BackDrop是一个全局的单例对象，当调用多个modal实例的open方法的时候，都会调用BackDrop的show方法，为了保证在调用BackDrop的hide方法时，能够确保在所有的modal实例都关闭之后再隐藏Backdrop，所以就加了一个count变量来记录BackDrop的show方法被调用了多少次，只有当count为0的时候，调用BackDrop的hide方法才会真正隐藏BackDrop。3）组件的选项的默认值定义通过buttons配置两个默认的按钮，确定和取消，然后为了简化这两个默认按钮的回调配置，把这两个按钮的接口进一步扩展到了上一级别，onOk和onCancel分别会在点击确定和取消的时候被调用，这两个选项完全是函数回调，不像onContentReady这种属于事件回调。getDefaultBtnCallbackProxy用来辅助注册onOk和onCancel：里面的this会被绑定到modal实例上。4）构造函数：这个主要是声明了用到的一些实例变量。5）关键的原型方法和函数这是个原型方法，组件的初始化也是在这个方法调用的时候执行的（延迟初始化）。这是个函数，用来初始化组件。其中：setTitle是个原型方法，用来设置modal的标题；setContent是个原型方法，用来设置modal的html内容；addButtons是个原型方法，用来注册按钮；setWidth是个原型方法，用来设置modal的宽度；bindHandler是个函数，用来注册modal的那些事件；倒数第二步调用$modal.modal()初始化bootstrap的modal组件；最后一步触发contentReady事件。bindHandler源码：为了方便使用，我把onContentChange这几个回调的上下文绑定到了当前的modal实例。最后两个事件侦听就是把bootstrap的事件封装成了我定义的modal事件。addButtons源码：从这个代码可以看出：当按钮点击之后，按钮就会被禁用；当按钮返回false的时候，按钮恢复，但是modal不会被关闭，说明当前的一些操作被代码给拦下来了；当按钮返回的是一个延迟对象的时候，会等到延迟对象完成的时候才会恢复按钮，并且只有在延迟对象resolve的时候才会关闭modal；否则就恢复按钮，并主动关闭modal。在这段代码里面考虑了：按钮的防重复点击，modal的自动关闭以及异步任务的处理。6）封装Alert和ConfirmAlert和Confirm其实就是一个特殊的modal，另外这两个组件还可以共用一个modal，了解到这些基础之后，组件就可以这样定义：这段代码里：首先考虑到了延迟初始化这个全局的modal组件；由于onModalHide和onModalShow这两个回调属于事件回调，在初始化组件的时候通过options传进去的参数，不能通过修改options的方式来更改回调，只能通过重新注册的方式来处理；而onOk和onCancel属于函数回调，只要更改了options里面的引用，回调就能更改；考虑到Alert和Confirm内容的长短，新加了一个参数width，以便调节框的宽度。4. 小结本文介绍的是自己在定义js组件过程中的一些方法和实践，代码偏多，不容易引起人的阅读兴趣，但是文中介绍的方法比较简单，而且这三个组件我已经用到好几个项目里面，从目前来看，能够解决我所有需要的弹框需求，所以我把它推荐出来，希望能给有需要的人带来帮助。

wwwwwwwwwwwwwwwwwwwww

alert("警告");yesOrNo = confirm("确认？");inputValue = prompt("输入内容提示", "默认值");

JavaScript中的confirm()方法可以实现弹出的对话框的确认和取消的按钮，如果用户点击确定按钮，则 confirm() 返回 true。如果点击取消按钮，则 confirm() 返回 false。有时当我们在网站上注册的用户信息，会弹出，显示诸如下面的页面。这就是弹出的确认对话框，经常会与警告和提示结合在一起。下面我们就来使用confirm()方法来实现这样的对话框我们先来看一下confirm()方法的用法<script> var 变量 = confirm("想要显示的字符串或者值");document.write(变量);</script>具体的代码示例如下<!DOCTYPE html><html lang = "ja"> <head> <meta charset = "utf-8"> <title>JavaScript</title> </head> <body> <script> var answer = confirm("输入正确吗？"); document.write(answer); </script> </body></html>运行效果如下：会显示出一个对话框当你点击确定按钮时，对话框消失，会在页面上显示一个true。效果如下当你点击取消按钮时，对话框也消失，会在页面上显示false。效果如下

字母表中的顺序

DateFormat df=new DateFormat("yymmdd");System.out.println(df.valueOf(你的日期));就是有一个日期格式类，可以直接用

采用日历类Calendarx0dx0ax0dx0aCalendar calendar = Calendar.getInstance();x0dx0a//第二个参数的意思表示与当前时间的比较，数字表示天数，1表示下一天 -1表示前一天。x0dx0acalendar.add(Calendar.DAY_OF_MONTH,1);x0dx0a//这样就可以获取到下一天，然后你自己去格式化吧x0dx0acalendar.getTime();

//对Date类型数据的天数进行加减运算，num可以是负值 publicstaticDatechangeDate(Datedate,intnum)throwsParseException{ Calendarc=Calendar.getInstance(); c.setTime(date); c.add(Calendar.DATE,num); returnformatChange(c.getTime()); } //将Date类型数据转为yyyyMMdd格式 publicstaticDateformatChange(Datedate)throwsParseException{ returnnewSimpleDateFormat("yyyyMMdd").parse(newSimpleDateFormat("yyyyMMdd").format(date)); } //执行入口 publicstaticvoidmain(String[]args)throwsParseException{ System.out.println(changeDate(newDate(),-15)); }

SimpleDateFormat s = new SimpleDateFormat("MMDD"); Date yd = new Date(); Date d; try { d = s.parse("0123"); d.setYear(yd.getYear()); System.out.println(d); } catch (ParseException e) { e.printStackTrace(); }

这个应用可以使用JavaConfig完成配置。我把它切分为下面几个部分：ServicesConfig（服务配置）无需扫描组件，配置真的非常简单：@ConfigurationpublicclassServicesConfig{@AutowiredprivateAccountRepositoryaccountRepository;@BeanpublicUserServiceuserService(){returnnewUserService(accountRepository);}

换UC或者opera mini

自己做个模态窗口就可以了

string,字符类型变量

在介绍Java 8的流（Stream）时，我们学会了一些集合操作的实用技巧。现在我们要看看怎样把这些循环转换为更简洁，可读性更高的代码。开始编码！好吧，讲的够多了，是时候展示一些例子了！这次我们要以文章为例子。一篇文章拥有一个标题，一个作者和几个标签。private class Article { private final String title; private final String author; private final List<String> tags; private Article(String title, String author, List<String> tags) { this.title = title; this.author = author; this.tags = tags; } public String getTitle() { return title; } public String getAuthor() { return author; } public List<String> getTags() { return tags; } }每个例子都会包含一个使用传统循环的方案和一个使用Java 8新特性的方案。在第一个例子里，我们要在集合中查找包含“Java”标签的第一篇文章。看一下使用for循环的解决方案。public Article getFirstJavaArticle() { for (Article article : articles) { if (article.getTags().contains("Java")) { return article; } } return null;}现在我们使用Stream API的相关操作来解决这个问题。public Optional<Article> getFirstJavaArticle() { return articles.stream() .filter(article -> article.getTags().contains("Java")) .findFirst(); }是不是很酷？我们首先使用 filter 操作去找到所有包含Java标签的文章，然后使用 findFirst() 操作去获取第一次出现的文章。因为Stream是“延迟计算”（lazy）的并且filter返回一个流对象，所以这个方法仅在找到第一个匹配元素时才会处理元素。现在，让我们获取所有匹配的元素而不是仅获取第一个。首先使用for循环方案。public List<Article> getAllJavaArticles() { List<Article> result = new ArrayList<>(); for (Article article : articles) { if (article.getTags().contains("Java")) { result.add(article); } } return result;}使用Stream操作的方案。public List<Article> getAllJavaArticles() { return articles.stream() .filter(article -> article.getTags().contains("Java")) .collect(Collectors.toList()); }在这个例子里我们使用 collection 操作在返回流上执行少量代码而不是手动声明一个集合并显式地添加匹配的文章到集合里。到目前为止还不错。是时候举一些突出Stream API强大的例子了。根据作者来把所有的文章分组。照旧，我们使用循环方案。public Map<String, List<Article>> groupByAuthor() { Map<String, List<Article>> result = new HashMap<>(); for (Article article : articles) { if (result.containsKey(article.getAuthor())) { result.get(article.getAuthor()).add(article); } else { ArrayList<Article> articles = new ArrayList<>(); articles.add(article); result.put(article.getAuthor(), articles); } } return result;}我们能否找到一个使用流操作的简洁方案来解决这个问题？public Map<String, List<Article>> groupByAuthor() { return articles.stream() .collect(Collectors.groupingBy(Article::getAuthor));}很好！使用 groupingBy 操作和 getAuthor 方法，我们得到了更简洁、可读性更高的代码。现在，我们查找集合中所有不同的标签。我们从使用循环的例子开始。public Set<String> getDistinctTags() { Set<String> result = new HashSet<>(); for (Article article : articles) { result.addAll(article.getTags()); } return result;}好，我们来看看如何使用Stream操作来解决这个问题。public Set<String> getDistinctTags() { return articles.stream() .flatMap(article -> article.getTags().stream()) .collect(Collectors.toSet());}棒极了！flatmap 帮我把标签列表转为一个返回流，然后我们使用 collect 去创建一个集合作为返回值。一切皆有可能以上的就是如何使用可读性更高的代码代替循环的例子。务必仔细看看Stream API，因为这篇文章仅仅提到它的一些皮毛而已。

软件工程师怎么认证?软件工程师认证难不难?软件工程师证书有用吗?一些想从事IT行业的人士都会问这个问题。?随着方针政策对互联网行业的支持，各大企业也纷纷转战互联网。软件工程师的地位和作用也更加凸显。一些企业也明确把软件工程师认证作为考核新员工的一个标准。？那么软件开发工程师认证有几类呢?北大青鸟老师在此解答。？1.国际企业认证，比如微软的MCSD、Oracle的OCJP等？以上几种认证是国际认证，费用几千元，试题难度可想而知。而且以英文形式命题，需要考生有较强的英文基础和深厚的软件开发知识储备。？这就激励考生在平时多下功夫，督促考生以考带学，一箭双雕。？2.国内企业认证，比如软考证书、工信部软件工程师认证等？与国际软件工程师认证相比，国内的认证难度较低，费用也不贵。一些企业在入职时候会要求员工出示相关的证书。？3.劳动部门颁发的软件工程师认证？北大青鸟软件工程师认证由劳动部门和印度阿博泰克联合认证颁发。具有权威性和认可性。学员学习结束后，通过考试方能获得软件工程师认证证书。？综上所述，软件工程师认证主要包括国际认证，国内认证和联合认证三个方面。北大青鸟北京嘉荟校区的专业老师在此提醒各位IT人士。？如果想学习软件开发，技术是位的，证书只是一个敲门砖而已。在面试时候，很多面试官深入问几个技术问题，便知能力如何。所以证书是有用，但是不可一味的迷恋证书，掌握过硬的技术才是关键。

字符串类型

你这么写怎么数组初始化？当然是写在这个大括号里。要不岂不是转换一个空字符串数组。

1、Mcp　　-----MCP微软认证专家证书证明您有能力：获得业界承认的对至少一种微软产品的技术的精通和所需的专业技能,为获得其他的微软认证建立基础通过任何一个微软认证的考试（Networking Essentials 例外），您都可获得此认证。（目前已更新为MCTS认证）2、MCSE　　----MCSE微软认证系统工程师证书是行业中承认范围最广的一项高级技术证书。获得MCSE证书，证明自己具备使用高级的Microsoft Windows平台和Microsoft服务器产品，为企业提供成功的设计、实施和管理商业解决方案的能力。（目前已更新为MCITP认证）3、 MCSD　　----MCSD微软认证解决方案开发专家证书是行业中认可范围最广的一项高级技术证书。获得MCSD证书，证明自己具备使用微软产品为企业提供成功的设计、实施和管理商业解决方案的能力。4、 MCDBA　　----MCDBA微软认证数据库管理员证书，个人可以证明自己拥有领导企业成功地设计、实现和管理Microsoft SQL Server数据库所需的技能。5、 MCT　　---- MCT微软认证讲师在微软的培训和认证过程中有很重要的作用。MCT由微软确认具有指导的资格和技术的认证，他们可以为计算机专业人员提供以微软正式教程（MOC）为指导的课程。微软产品组开发了MOC课程，用于培训计算机专业人员，这些专业人员将使用微软技术开发、支持和实现解决方案。MCT认证获得不是采用培训+考试的方式，而是需要向MCT管理中心申请，并通过面试（或电话面试）获得。6、MCAD　　——MCAD微软认证应用程序开发专家证书是针对那些开发并维护部门级应用程序、组件、Web或桌面系统客户端及后端数据服务的专业人员而提供的。其工作角色涵盖了从需求实现到解决方案建立、部署与维护在内的各种任务。培训期限　　1、MCP ： 建议理论80学时，实习40学时　　2、MCSE： 建议理论280学时，实习140学时　　3、MCDBA：建议理论200学时，实习100学时　　4、MCSA： 建议理论200学时，实习100学时　　5、MCAD： 建议理论200学时，实习100学时

请参看http://blog.csdn.net/ghostresur/archive/2009/06/08/4250390.aspx

org.apache.commons.lang.StringUtils类是用于操作Java.lang.String类的，而且此类是null安全的，即如果输入参数String为null，则不会抛出NullPointerException异常。 StringUtils类中有130多个静态方法，都可以通过如下方式调用：StringUtils.xxx()。 常用方法简介： 1. public static boolean isEmpty(String str) 判断某字符串是否为空，为空的标准是 str==null 或 str.length()==0 下面是 StringUtils 判断是否为空的示例： StringUtils.isEmpty(null) = true StringUtils.isEmpty("") = true StringUtils.isEmpty(" ") = false //注意在 StringUtils 中空格作非空处理 StringUtils.isEmpty(" ") = false StringUtils.isEmpty("bob") = false StringUtils.isEmpty(" bob ") = false 2. public static boolean isNotEmpty(String str) 判断某字符串是否非空，等于 !isEmpty(String str) 下面是示例： StringUtils.isNotEmpty(null) = false StringUtils.isNotEmpty("") = false StringUtils.isNotEmpty(" ") = true StringUtils.isNotEmpty(" ") = true StringUtils.isNotEmpty("bob") = true StringUtils.isNotEmpty(" bob ") = true 3. public static boolean isBlank(String str) 判断某字符串是否为空或长度为0或由空白符(whitespace) 构成 下面是示例： StringUtils.isBlank(null) = true StringUtils.isBlank("") = true StringUtils.isBlank(" ") = true StringUtils.isBlank(" ") = true StringUtils.isBlank(" f ") = true //对于制表符、换行符、换页符和回车符 StringUtils.isBlank() //均识为空白符 StringUtils.isBlank("") = false //""为单词边界符 StringUtils.isBlank("bob") = false StringUtils.isBlank(" bob ") = false 4. public static boolean isNotBlank(String str) 判断某字符串是否不为空且长度不为0且不由空白符(whitespace) 构成，等于 !isBlank(String str) 下面是示例： StringUtils.isNotBlank(null) = false StringUtils.isNotBlank("") = false StringUtils.isNotBlank(" ") = false StringUtils.isNotBlank(" ") = false StringUtils.isNotBlank(" f ") = false StringUtils.isNotBlank("") = true StringUtils.isNotBlank("bob") = true StringUtils.isNotBlank(" bob ") = true 5. public static String trim(String str) 去掉字符串两端的控制符(control characters, char <= 32) , 如果输入为 null 则返回null 下面是示例： StringUtils.trim(null) = null StringUtils.trim("") = "" StringUtils.trim(" ") = "" StringUtils.trim("  f ") = "" StringUtils.trim(" ss ") = "ss" StringUtils.trim(" d d dd ") = "d d dd" StringUtils.trim("dd ") = "dd" StringUtils.trim(" dd ") = "dd" 6. public static String trimToNull(String str) 去掉字符串两端的控制符(control characters, char <= 32) ,如果变为 null 或""，则返回 null下面是示例： StringUtils.trimToNull(null) = null StringUtils.trimToNull("") = null StringUtils.trimToNull(" ") = null StringUtils.trimToNull("  f ") = null StringUtils.trimToNull(" ss ") = "ss" StringUtils.trimToNull(" d d dd ") = "d d dd" StringUtils.trimToNull("dd ") = "dd" StringUtils.trimToNull(" dd ") = "dd" 7. public static String trimToEmpty(String str)

详细的这儿有哇：解析Java中的String对象的数据类型 1. 首先String不属于8种基本数据类型，String是一个对象。 因为对象的默认值是null，所以String的默认值也是null；但它又是一种特殊的对象，有其它对象没有的一些特性。 2. new String()和new String(“”)都是申明一个新的空字符串，是空串不是null； 3. String str=”kvill”； String str=new String (“kvill”);的区别： 在这里，我们不谈堆，也不谈栈，只先简单引入常量池这个简单的概念。 常量池(constant pool)指的是在编译期被确定，并被保存在已编译的.class文件中的一些数据。它包括了关于类、方法、接口等中的常量，也包括字符串常量。 看例1： String s0=”kvill”; String s1=”kvill”; String s2=”kv” + “ill”; System.out.println( s0==s1 ); System.out.println( s0==s2 ); 结果为： true true 首先，我们要知结果为道Java会确保一个字符串常量只有一个拷贝。 因为例子中的s0和s1中的”kvill”都是字符串常量，它们在编译期就被确定了，所以s0==s1为true；而”kv”和”ill”也都是字符串常量，当一个字符串由多个字符串常量连接而成时，它自己肯定也是字符串常量，所以s2也同样在编译期就被解析为一个字符串常量，所以s2也是常量池中”kvill”的一个引用。 所以我们得出s0==s1==s2; 用new String() 创建的字符串不是常量，不能在编译期就确定，所以new String() 创建的字符串不放入常量池中，它们有自己的地址空间。 看例2： String s0=”kvill”; String s1=new String(”kvill”); String s2=”kv” + new String(“ill”); System.out.println( s0==s1 ); System.out.println( s0==s2 ); System.out.println( s1==s2 ); 结果为： false false false 例2中s0还是常量池中”kvill”的应用，s1因为无法在编译期确定，所以是运行时创建的新对象”kvill”的引用，s2因为有后半部分new String(“ill”)所以也无法在编译期确定，所以也是一个新创建对象”kvill”的应用;明白了这些也就知道为何得出此结果了。 4. String.intern()： 再补充介绍一点：存在于.class文件中的常量池，在运行期被JVM装载，并且可以扩充。String的intern()方法就是扩充常量池的一个方法；当一个String实例str调用intern()方法时，Java查找常量池中是否有相同Unicode的字符串常量，如果有，则返回其的引用，如果没有，则在常量池中增加一个Unicode等于str的字符串并返回它的引用；看例3就清楚了 例3： String s0= “kvill”; String s1=new String(”kvill”); String s2=new String(“kvill”); System.out.println( s0==s1 ); System.out.println( “**********” ); s1.intern(); s2=s2.intern(); //把常量池中“kvill”的引用赋给s2 System.out.println( s0==s1); System.out.println( s0==s1.intern() ); System.out.println( s0==s2 ); 结果为： false ********** false //虽然执行了s1.intern(),但它的返回值没有赋给s1 true //说明s1.intern()返回的是常量池中”kvill”的引用 true 最后我再破除一个错误的理解： 有人说，“使用String.intern()方法则可以将一个String类的保存到一个全局String表中，如果具有相同值的 Unicode字符串已经在这个表中，那么该方法返回表中已有字符串的地址，如果在表中没有相同值的字符串，则将自己的地址注册到表中“如果我把他说的这个全局的String表理解为常量池的话，他的最后一句话，“如果在表中没有相同值的字符串，则将自己的地址注册到表中”是错的： 看例4： String s1=new String("kvill"); String s2=s1.intern(); System.out.println( s1==s1.intern() ); System.out.println( s1+" "+s2 ); System.out.println( s2==s1.intern() ); 结果： false kvill kvill true 在这个类中我们没有声名一个”kvill”常量，所以常量池中一开始是没有”kvill”的，当我们调用s1.intern()后就在常量池中新添加了一个”kvill”常量，原来的不在常量池中的”kvill”仍然存在，也就不是“将自己的地址注册到常量池中”了。 s1==s1.intern()为false说明原来的“kvill”仍然存在； s2现在为常量池中“kvill”的地址，所以有s2==s1.intern()为true。 5. 关于equals()和==: 这个对于String简单来说就是比较两字符串的Unicode序列是否相当，如果相等返回true;而==是比较两字符串的地址是否相同，也就是是否是同一个字符串的引用。 6. 关于String是不可变的 这一说又要说很多，大家只要知道String的实例一旦生成就不会再改变了，比如说：String str=”kv”+”ill”+” “+”ans”; 就是有4个字符串常量，首先”kv”和”ill”生成了”kvill”存在内存中，然后”kvill”又和” “ 生成 ”kvill “存在内存中，最后又和生成了”kvill ans”;并把这个字符串的地址赋给了str,就是因为String的“不可变”产生了很多临时变量，这也就是为什么建议用StringBuffer的原因了，因为StringBuffer是可改变的。

String是一种数据类型，是一个类，字符串就是String类的对象。

stroke解释为“敲击”所以感觉上是一个键盘的击键事件，通过这个事件来触发某些操作是不是特别的设计模式不太清楚

这个是因为您访问的网站存在恶意代码的缘故，诺顿出现提示说明它已经帮您拦截了这个恶意代码，所以请您放心

1、首先要检测是网站本身的问题还是你电脑的问题：在别的电脑上（有条件的话可以使用多台）打开同一个网址，如果也发生这样的错误，那就说明是网站自身的问题，你是无能为力的，最多可以向网站管理或运营方提交意见甚至投诉。如果别的电脑上运行都没问题，那么可以测试第2项。2、其次是要检测是否浏览器兼容问题：在你的电脑上分别用IE（建议至少IE7以上）、Chrome（谷歌浏览器）、FireFox（火狐浏览器）打开会出问题的网址（也可以用360浏览器等所谓的双核浏览器分别用“兼容模式”和“极速模式”打开网址），如果三种浏览器（或者两种模式）中至少有一种不会出现你说的错误提示，那么我的建议是换浏览器（或者切换模式），如果用惯原来的不想换，请继续参考第3项。如果所有浏览器（或者所有模式）都出错，也请继续看第3项。3、现在已经可以肯定是你的电脑有问题了，你可以用360之类的工具对浏览器及相关的网络系统进行修复，如果不奏效，那么你可以先试着重装浏览器，实在不行就只能重装系统了。

一个FORM表单中有两个SUBMIT按钮（例如“修改”“删除”），只有一个ACTION处理页面 在此ACTION页面中如何区分是处理“修改”呢还是处理“删除”？ 方法1： 假如FORM表单是这样的： 你可以在ASP中读取Request("Action")的值，如果用户选择“修改”，则这个变量是"修改"。 方法2： 可以做一个脚本函数，比如： function modify() { document.form1.action="modify.jsp"; document.form1.submit(); } function delete() { document.form1.action="delete.jsp"; document.form1.submit(); } 这样可以实现将多个按钮发送到不同网页中。

　　substring 方法用于提取字符串中介于两个指定下标之间的字符　　substring(start,end)　　开始和结束的位置，从零开始的索引　　参数 描述　　start 必需。一个非负的整数，规定要提取的子串的第一个字符在 stringObject 中的位置。　　stop 可选。一个非负的整数，比要提取的子串的最后一个字符在 stringObject 中的位置多 1。如果省略该参数，那么返回的子串会一直到字符串的结尾。　　返回值　　一个新的字符串，该字符串值包含 stringObject 的一个子字符串，其内容是从 start 处到 stop-1 处的所有字符，其长度为 stop 减 start。　　说明　　substring 方法返回的子串包括 start 处的字符，但不包括 end 处的字符。　　如果 start 与 end 相等，那么该方法返回的就是一个空串（即长度为 0 的字符串）。　　如果 start 比 end 大，那么该方法在提取子串之前会先交换这两个参数。　　如果 start 或 end 为负数，那么它将被替换为 0。　　2.substr 方法　　定义和用法　　substr 方法用于返回一个从指定位置开始的指定长度的子字符串。　　语法　　stringObject.substr(start [, length ])　　参数 描述　　start 必需。所需的子字符串的起始位置。字符串中的第一个字符的索引为 0。　　length 可选。在返回的子字符串中应包括的字符个数。　　说明　　如果start为负数，则start=str.length+start。　　如果 length 为 0 或负数，将返回一个空字符串。　　如果没有指定该参数，则子字符串将延续到stringObject的最后。　　举例：　　var str = "0123456789";　　alert(str.substring(0));------------"0123456789"　　alert(str.substring(5));------------"56789"　　alert(str.substring(10));-----------""　　alert(str.substring(12));-----------""　　alert(str.substring(-5));-----------"0123456789"　　alert(str.substring(-10));----------"0123456789"　　alert(str.substring(-12));----------"0123456789"　　alert(str.substring(0,5));----------"01234"　　alert(str.substring(0,10));---------"0123456789"　　alert(str.substring(0,12));---------"0123456789"　　alert(str.substring(2,0));----------"01"　　alert(str.substring(2,2));----------""　　alert(str.substring(2,5));----------"234"　　alert(str.substring(2,12));---------"23456789"　　alert(str.substring(2,-2));---------"01"　　alert(str.substring(-1,5));---------"01234"　　alert(str.substring(-1,-5));--------""　　alert(str.substr(0));---------------"0123456789"　　alert(str.substr(5));---------------"56789"　　alert(str.substr(10));--------------""　　alert(str.substr(12));--------------""　　alert(str.substr(-5));--------------"56789"　　alert(str.substr(-10));-------------"0123456789"　　alert(str.substr(-12));-------------"0123456789"　　alert(str.substr(0,5));-------------"01234"　　alert(str.substr(0,10));------------"0123456789"　　alert(str.substr(0,12));------------"0123456789"　　alert(str.substr(2,0));-------------""　　alert(str.substr(2,2));-------------"23"　　alert(str.substr(2,5));-------------"23456"　　alert(str.substr(2,12));------------"23456789"　　alert(str.substr(2,-2));------------""　　alert(str.substr(-1,5));------------"9"　　alert(str.substr(-1,-5));-----------""

http://javootoo.l2fprod.com/这里很多.比较推荐左边的JGoodies和Liquid.

javascript中截取字符串的实现方法如下：1、使用substr()函数：substr()方法可在字符串中抽取从start下标开始的指定数目的字符。varstr="Helloworld!";//定义字符串document.write(str.substr(3));//打印截取后的结果从第三位开始到最后输出结果如下：loworld!如果是写成指定起始位和长度就会按照指定的长度输出：document.write(str.substr(3,5));输出结果：lowo2、利用substring()函数：substring()方法用于提取字符串中介于两个指定下标之间的字符。varstr="Helloworld!";document.write(str.substr(3));输出结果如下：loworld!如果是写成指定起始位和长度就会按照指定的长度输出：document.write(str.substr(3,7));输出结果：low

: byte short int long float double char boolean 区别很大,基本类型很特殊,内部用指针操作,包装类就是一般的类

java有个操作符叫instanceof可以判 boolean a=student instanceof Person 这里 student应该是对象实例

String str = "123";try{ boolean isNumber = Number.class.isAssignableFrom(str.getClass());}catch(Exception e){}

判断对象o实现的所有接口中是否有szInterface * 2008-08-07 修正多继承中判断接口的功能， * 以及修正接口继承后的判断功能 * package test; * * public interface ITest extends Serializable * public class Test1 implements ITest * public class Test2 extends Test1 * public class Test3 extends Test2 * * isInterface(Test3.class, "java.io.Serializable") = true * isInterface(Test3.class, "test.ITest") = true * @param c * @param szInterface * @return */ public boolean isInterface(Class c, String szInterface) { Class[] face = c.getInterfaces(); for (int i = 0, j = face.length; i < j; i++) { if(face[i].getName().equals(szInterface)) { return true; } else { Class[] face1 = face[i].getInterfaces(); for(int x = 0; x < face1.length; x++) { if(face1[x].getName().equals(szInterface)) { return true; } else if(isInterface(face1[x], szInterface)) { return true; } } } } if (null != c.getSuperclass()) { return isInterface(c.getSuperclass(), szInterface); } return false; }

直接使用 instanceof进行校验就好了……

public class Demo12 {public static void main(String[] args) {Class<A> a = A.class;Class<B> b = B.class;if (a.isAssignableFrom(b)) {System.out.println("A是B的父类");}else {System.out.println("A不是B的父类");}}}class A{}class B extends A{}

什么叫连接

下面是能判断是否指定类的子类。但是要想全部查询。这个不太可能吧。Class c = ArrayList.class;c.isPrimitive(); //判断c是否为基本数据类型c.isAssignableFrom(List.class); //判断c是否是List类的子类或父类c.getGenericType(); //得到泛型类型不过呢。你可以看看 eclipse 中的实现。就是你点击一个类。然后按 F4 就能从 "Type Hierarchy"。就能看到所有子类了。你可以搜搜看。

看该类类名后面有没有implements接口

if(suffix.equals("class")){ file.delete(); }这里的file还是当初的("e:/files")路径，里面应该这么写File file1 = new File("e:/files/"+s); file1.delete();这样就能删掉class文件

package my.utils.algorithm.files;import java.io.IOException;import java.nio.file.FileVisitResult;import java.nio.file.Files;import java.nio.file.Path;import java.nio.file.Paths;import java.nio.file.SimpleFileVisitor;import java.nio.file.attribute.BasicFileAttributes;import java.util.ArrayList;import java.util.List;public class FileVisitorUtil { public static void main(String[] args) throws IOException { Path startingDir = Paths.get("D:\workspace\AlgorithmUtils\src"); FindFileVisitor findJavaVisitor = new FindFileVisitor(".java"); Files.walkFileTree(startingDir, findJavaVisitor); for (String name : findJavaVisitor.getFilenameList()) { System.out.println(name); } }}class FindFileVisitor extends SimpleFileVisitor<Path> { private List<String> filenameList = new ArrayList<String>(); private String fileSuffix = null; public FindFileVisitor(String fileSuffix) { this.fileSuffix = fileSuffix; } @Override public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) { if (file.toString().endsWith(fileSuffix)) { filenameList.add(file.toString()); } return FileVisitResult.CONTINUE; } public List<String> getFilenameList() { return filenameList; } public void setFilenameList(List<String> filenameList) { this.filenameList = filenameList; }}

比较字符串s1和s2的内容是否相同,比较时忽略大小写的区别

有吧

你有j2se的api么？？？？？里面有 所有方法

初始化父类,并可以调用父类中的方法和属性

super出现在继承了父类的子类中。有三种存在方式：第一种super.xxx;(xxx为变量名或对象名)这种方法意义为，获取父类中的名字为xxx的变量或方法引用。使用这种方法可以直接访问父类中的变量或对象，进行修改赋值等操作。第二种super.xxx();(xxx为方法名)这种方法意义为，直接访问并调用父类中的方法。第三种super();这种方法意义为，调用父类的初始化方法，其实就是调用父类中的public xxx()方法。

进程是程序在处理机中的一次运行。一个进程既包括其所要执行的指令，也包括了执行指令所需的系统资源，不同进程所占用的系统资源相对独立。所以进程是重量级的任务，它们之间的通信和转换都需要操作系统付出较大的开销。 线程是进程中的一个实体，是被系统独立调度和分派的基本单位。线程自己基本上不拥有系统资源，但它可以与同属一个进程的其他线程共享进程所拥有的全部资源。所以线程是轻量级的任务，它们之间的通信和转换只需要较小的系统开销。 Java支持多线程编程，因此用Java编写的应用程序可以同时执行多个任务。Java的多线程机制使用起来非常方便，用户只需关注程序细节的实现，而不用担心后台的多任务系统。 Java语言里，线程表现为线程类。Thread线程类封装了所有需要的线程操作控制。在设计程序时，必须很清晰地区分开线程对象和运行线程，可以将线程对象看作是运行线程的控制面板。在线程对象里有很多方法来控制一个线程是否运行，睡眠，挂起或停止。线程类是控制线程行为的唯一的手段。一旦一个Java程序启动后，就已经有一个线程在运行。可通过调用Thread.currentThread方法来查看当前运行的是哪一个线程。 class ThreadTest{ public static void main(String args[]){ Thread t = Thread.currentThread(); t.setName("单线程"); //对线程取名为"单线程" t.setPriority(8); //设置线程优先级为8，最高为10，最低为1，默认为5 System.out.println("The running thread: " + t); // 显示线程信息 try{ for(int i=0;i<3;i++){ System.out.println("Sleep time " + i); Thread.sleep(100); // 睡眠100毫秒 } }catch(InterruptedException e){// 捕获异常 System.out.println("thread has wrong"); } }}多线程的实现方法继承Thread类可通过继承Thread类并重写其中的run()方法来定义线程体以实现线程的具体行为，然后创建该子类的对象以创建线程。在继承Thread类的子类ThreadSubclassName中重写run()方法来定义线程体的一般格式为: public class ThreadSubclassName extends Thread{ public ThreadSubclassName(){ ..... // 编写子类的构造方法，可缺省 }public void run(){ ..... // 编写自己的线程代码 }}用定义的线程子类ThreadSubclassName创建线程对象的一般格式为: ThreadSubclassName ThreadObject = new ThreadSubclassName();然后，就可启动该线程对象表示的线程： ThreadObject.start(); //启动线程 应用继承类Thread的方法实现多线程的程序。本程序创建了三个单独的线程，它们分别打印自己的“Hello World!”。 class ThreadDemo extends Thread{ private String whoami; private int delay; public ThreadDemo(String s,int d){ whoami=s; delay=d; } public void run(){try{ sleep(delay); }catch(InterruptedException e){ } System.out.println("Hello World!" + whoami + " " + delay); } } public class MultiThread{ public static void main(String args[]){ ThreadDemo t1,t2,t3; t1 = new ThreadDemo("Thread1", (int)(Math.random()*2000));t2 = new ThreadDemo("Thread2", (int)(Math.random()*2000)); t3 = new ThreadDemo("Thread3", (int)(Math.random()*2000)); t1.start(); t2.start(); t3.start(); }}实现Runnable接口编写多线程程序的另一种的方法是实现Runnable接口。在一个类中实现Runnable接口(以后称实现Runnable接口的类为Runnable类),并在该类中定义run()方法，然后用带有Runnable参数的Thread类构造方法创建线程。创建线程对象可用下面的两个步骤来完成:(1)生成Runnable类ClassName的对象 ClassName RunnableObject = new ClassName();(2)用带有Runnable参数的Thread类构造方法创建线程对象。新创建的线程的指针将指向Runnable类的实例。用该Runnable类的实例为线程提供 run()方法---线程体。 Thread ThreadObject = new Thread(RunnableObject);然后，就可启动线程对象ThreadObject表示的线程：ThreadObject.start();在Thread类中带有Runnable接口的构造方法有: public Thread(Runnable target); public Thread(Runnable target, String name); public Thread(String name);public Thread(ThreadGroup group，Runnable target); public Thread(ThreadGroup group，Runnable target， String name); 其中，参数Runnable target表示该线程执行时运行target的run()方法，String name以指定名字构造线程，ThreadGroup group表示创建线程组。用Runnable接口实现的多线程。class TwoThread implements Runnable{ TwoThread(){ Thread t1 = Thread.currentThread(); t1.setName("第一主线程"); System.out.println("正在运行的线程: " + t1); Thread t2 = new Thread(this,"第二线程"); System.out.println("创建第二线程"); t2.start(); try{ System.out.println("第一线程休眠"); Thread.sleep(3000); }catch(InterruptedException e){System.out.println("第一线程有错"); } System.out.println("第一线程退出"); } public void run(){ try{ for(int i = 0;i < 5;i++){ System.out.println(“第二线程的休眠时间：” + i); Thread.sleep(1000); } }catch(InterruptedException e){ System.out.println("线程有错"); }System.out.println("第二线程退出"); } public static void main(String args[]){ new TwoThread(); }}程序运行结果如下：正在运行的线程: Thread[第一主线程,5,main创建第二线程第一线程休眠第二线程的休眠时间：0第二线程的休眠时间：1第二线程的休眠时间：2第一线程退出第二线程的休眠时间：3第二线程的休眠时间：4第二线程退出至于一个处理器同时处理多个程序，其实不是同时运行多个程序的，简单的说，如果是单核的CPU，在运行多个程序的时候其实是每个程序轮流占用CPU的，只是每个程序占用的时间很短，所以我们人为的感觉是“同时”运行多个程序。

..挺好

1. 应该是您的递归算法调用的层级太多导致的。优化下算法，让调用层级减低才行。2. 这种情况自己维护个栈序列，用循环的方式来处理应该就可以了。例如可以是：1. （start,end）入栈2. 栈是否为空，若为空则退出3. 弹出栈定元素，如果start-end<breakpoint使用插入排序，完成后回到2。 否则对[start，end]序列进行划分，将小于和大于choosePivot(a,start,end);的区间入栈 （minstart,minend), (maxstart, maxend)4. 重复2，3，直到栈为空

请问您是不是安装着360安全卫士呢，不妨把它关闭了，再试试i。

没有区别，大小写的区别JavaScript一种直译式脚本语言，是一种动态类型、弱类型、基于原型的语言，内置支持类型。它的解释器被称为JavaScript引擎，为浏览器的一部分，广泛用于客户端的脚本语言，最早是在HTML（标准通用标记语言下的一个应用）网页上使用，用来给HTML网页增加动态功能。

<html><body><script type="text/javascript">var n=100;document.write("无论是html的语法还是javascript的语法，|都可以直接输入（按Shift+\），不需要转义。<br />");document.write("下面是用document.write方法输出的100个|：<br />");for(var i=0;i<n;i++){document.write("|");}</script></body></html>

这个没啥区别哈，都是同一个也是js就是javascript英文缩写，是前台脚本语言

js是javascript的简称

netscape开发了在Navigator中使用的LiveScript语言，后改名为JavaScript Microsoft发行jscript用于internet explorer. 最初的jscript和javascript差异过大，web程序员不得不痛苦的为两种浏览器编写两种脚本。于是诞生了ECMAScript,是一种国际标准化的javascript版本。现在的主流浏览器都支持这种版本。 我们写程序的时候最好写<script language=javascript>而不是<script language=jscript>因为javascript是一个通用的名称，所有浏览器都认识，而jscript只有IE认识。 其他语言细节上的区别，不是一两下能说完的。编程时最好遵循ECMAscript标准。这样可以保证兼容性。 顺便说一下,javascript原来叫Livescript，后来Sun的java风头正盛的时候netscape就把名字改成javascript。

JScript是由微软公司开发的活动脚本语言，是微软对ECMAScript规范的实现。JScript最初是随Internet Explorer 3.0于1996年8月发布。在网络程序员谈论Internet Explorer中的JavaScript的时候，他们实际上是指JScript。所以说，一样的

javascript,JScript,js都是同一概念，为客户端脚本，即由浏览器端解释，执行的。只要有一个浏览器，就可以运行javascript了。程序代码一般包含在<script></script>内。JSP即java server page.是在服务器端使用的，类似于asp,asp.net,只不过asp和asp.net使用的编程语言分别为：vbscript,c#,而JSP采用的编程语言为java,程序块包含在<%%>内。要运行jsp则需搭建web服务器，由服务器执行。

netscape开发了在Navigator中使用的LiveScript语言，后改名为JavaScript Microsoft发行jscript用于internet explorer. 最初的jscript和javascript差异过大，web程序员不得不痛苦的为两种浏览器编写两种脚本。于是诞生了ECMAScript,是一种国际标准化的javascript版本。现在的主流浏览器都支持这种版本。 我们写程序的时候最好写<script language=javascript>而不是<script language=jscript>因为javascript是一个通用的名称，所有浏览器都认识，而jscript只有IE认识。 其他语言细节上的区别，不是一两下能说完的。编程时最好遵循ECMAscript标准。这样可以保证兼容性。 顺便说一下,javascript原来叫Livescript，后来Sun的java风头正盛的时候netscape就把名字改成javascript。

95%以上一样说白了jscript就是山寨javaScript

javascript的简写就是js 有的也说成是 jscript ;

jscript 相当于微软版的javascript，主要作为ASP的默认脚本语言，运行于后台或者说服务器端（而我们通常意义上的javascript则运行于前端或者说浏览器端、客户端）。es（即ECMAScript）则是javascript的行业标准。它只是一种标准，并不是实际的程序设计语言，具体的实现是由各种客户代理程序（通常就是浏览器内核）去完成的。所以这三者在类别和使用场景上并没有什么交集，无法进行比较，更谈不上谁好谁坏。

这是java?

public class Test { public static void main(String[] args) { Integer i1 = 127; Integer i2 = 127; Integer i3 = Integer.valueOf(127); if (i1 == i2) System.out.println("i1 == i2 is true!"); else System.out.println("i1 == i2 is false!"); if (i1 >= i2) System.out.println("i1 >= i2 is true!"); else System.out.println("i1 >= i2 is false!"); if (i1 == i3) System.out.println("i1 == i3 is true!"); else System.out.println("i1 == i3 is false!"); }}当值是127时，输出是：i1 == i2 is true!i1 >= i2 is true!i1 == i3 is true!当值是128时，输出是：i1 == i2 is false!i1 >= i2 is true!i1 == i3 is false!说明： 我使用的是Sun JDK 1.5.0_03-b07 和 Eclipse 3.2M4。 “Integer i1 = 127;”在JDK1.4下不能编译通过的，会提示：“ Type mismatch: cannot convert from int to Integer”的错误，一般改写为：“Integer i1 = new Integer(127);”。 “Integer i1 = 127;”在JDK1.5下可以编译通过的，这就是自动装箱（Autoboxing）和自动拆箱（Auto-Unboxing）。自动装箱（Autoboxing）特性让Java自动包装一个简单数据类型（例如int）到对应的包装类型中（例如Integer）中。 在《JSR 201: Extending the Java Programming Language with Enumerations, Autoboxing, Enhanced for loops and Static Import》中，对这个问题，是作了这样的规定： If the value p being boxed is true, false, a byte, an ASCII character, or an integer or short number between -127 and 128, then let r1 and r2 be the results of any two boxing conversions of p. It is always the case that r1 == r2. 在Java中，The following is the list of primitives stored as immutable objects（不可变对象）: * boolean values true and false* All byte values* short values between -128 and 127* int values between -128 and 127* char in the range u0000 to u007F 为了更容易理解问题，用Jad将上面代码反编译，如下：import java.io.PrintStream;public class Test{ public Test() { } public static void main(String args[]) { Integer i1 = Integer.valueOf(128); Integer i2 = Integer.valueOf(128); Integer i3 = Integer.valueOf(128); if(i1 == i2) System.out.println("i1 == i2 is true!"); else System.out.println("i1 == i2 is false!"); if(i1.intValue() >= i2.intValue()) System.out.println("i1 >= i2 is true!"); else System.out.println("i1 >= i2 is false!"); if(i1 == i3) System.out.println("i1 == i3 is true!"); else System.out.println("i1 == i3 is false!"); }}从这可以看出，“Integer i1 = 128;”在JDK1.5下应该编译成了“Integer i1 = Integer.valueOf(128);”。再看看java.lang.Integer中关于valueOf的源代码是怎样的： public static Integer valueOf(int i) { final int offset = 128; if (i >= -128 && i <= 127) { // must cache return IntegerCache.cache[i + offset]; } return new Integer(i); } 可以看出，这个值在-128到127之间，会将其cached（缓存）起来，如果多次使用的话，会节省内存和改善性能；如果不在这个范围之内，则生成一个新的Integer Object instance，这样如果进行“==”时，由于是比较两个不同的Object references，故结果是false。事实上，这个特性从JDK 1.3就存在了（以前的我不清楚） 。

String re = "\[QUOTE\](.*)\[\/QUOTE\]"; String strContent = "[QUOTE]引自楼主的发帖:3[/QUOTE]"; Pattern pattern = Pattern.compile(re); Matcher matcher = pattern.matcher(strContent); strContent = matcher.replaceAll("<blockquote>$1</blockquote>"); System.out.println(strContent);

swing就是全称 - 3-

ResultSet rs = stmt.executeQuery("SELECT * FROM EMPLOYEES"); CachedRowSet crs = new CachedRowSetImpl(); //也可以是WebRowSetImpl，FilteredRowSetImpl，JoinRowSetImpl，因为他们均继承自CachedRowSetImpl crs.populate(rs); 运行populate()方法后，ResultSet对象rs中的数据就被填充到crs对象中了。 (3)用XML填充 如果您打算将XML作为数据交换格式在客户端和你的服务器之间传输数据并且向实现数据离线编辑、或者向使用XML格式的数据的话，可以使用WebRowSet接口来用XML填充数据。 WebRowSet wrs = new WebRowSetImpl(); wrs.readXml(new FileReader(new File("D:\employees.xml"))); 运行readXml()方法后，employees.xml文件的数据就被填充到wrs对象中了。employees.xml 文件的格式参见附录

1、检查下载的jdk是不是64位，而ubuntu是32位导致错误2、检查java是否有被赋予执行权限，用ll查看3、检查当前用户对jdk目录是否拥有可读权限

Java高手是怎么炼成的，你猜。他们说当你精通这25个学习点，一切都水到渠成了。01你需要精通面向对象分析与设计(OOA/OOD)、涉及模式(GOF，J2EEDP)以及综合模式。你应该了解UML，尤其是class、object、interaction以及statediagrams。02你需要学习Java语言的基础知识以及它的核心类库(collections、serialization、streams、networking、multithreading、reflection、event、handling、NIO、localization以及其他)。03你应该了解JVM、classloaders、classreflect以及垃圾回收的基本工作机制等。你应该有能力反编译一个类文件并且明白一些基本的汇编指令。04如果你将要写客户端程序，你需要学习Web的小应用程序(applet)，必需掌握GUI设计的思想和方法，以及桌面程序的SWING、AWT、SWT。你还应该对UI部件的JavaBEAN组件模式有所了解。JavaBEANS也被应用在JSP中以把业务逻辑从表现层中分离出来。05你需要学习Java数据库技术，并且会使用至少一种persistence/ORM构架，例如hibernate、JDO、CocoBase、TopLink、InsideLiberator(国产JDO红工厂软件)或者iBatis。06你还应该了解对象关系的阻抗失配的含义以及它是如何影响业务对象与关系型数据库的交互，和它的运行结果。还需要掌握不同的数据库产品运用，比如Oracle、MySQL、SQLserver。07你需要学习Servlets、JSP，以及JSTL(StandardTagLibraries)和可以选择的第三方TagLibraries。08你需要熟悉主流的网页框架，例如JSF、Struts、Tapestry、Cocoon、WebWork，以及他们下面的涉及模式，如MVC/MODEL2。09你需要学习如何使用及管理Web服务器，例如tomcat、resin、Jrun，并且知道如何在其基础上扩展和维护Web程序。10你需要学习分布式对象以及远程API，例如RMI和RMI/IIOP。11你需要掌握各种流行中间件技术标准和与Java结合实现，比如Tuxedo、CROBA，当然也包括JavaEE本身。12你需要学习最少一种的XMLAPI，JAXP(JavaAPIforXMLProcessing)、JDOM(JavaforXMLDocumentObjectModel)、DOM4J或JAXR(JavaAPIforXMLRegistries)。13你应该学习如何利用Java的API和工具来构建WebService。例如JAX-RPC(JavaAPIforXML/RPC)、SAAJ(SOAPwithAttachmentsAPIforJava)、JAXB(JavaArchitectureforXMLBinding)、JAXM(JavaAPIforXMLMessaging)、JAXR(JavaAPIforXMLRegistries)或者JWSDP(JavaWebServicesDeveloperPack)。14你需要学习一门轻量级应用程序框架，例如spring、PicoContainer、Avalon，以及它们的IoC/DI风格(setter，constructor，interfaceinjection)。15你需要熟悉不同的J2EE技术，例如JNDI(JavaNamingandDirectoryInterface)、JMS(JavaMessageService)、JTA/JTS(JavaTransactionAPI/JavaTransactionService)、JMX(JavaManagementeXtensions)，以及JavaMail。16你需要学习企业级JavaBeans(EJB)以及它们的不同组件模式：Stateless/StatefulSessionBeans、EntityBeans(包含Bean-ManagedPersistence[BMP]或者Container-ManagedPersistence[CMP]和它的EJB-QL)，或者Message-DrivenBeans(MDB)。17你需要学习如何管理与配置一个J2EE应用程序服务器，如WebLogic、JBoss等，并且利用它的附加服务，例如簇类，连接池以及分布式处理支援。你还需要了解如何在它上面封装和配置应用程序并且能够监控、调整它的性能。18你需要熟悉面向方面的程序设计以及面向属性的程序设计(这两个都被很容易混淆的缩写为AOP)，以及他们的主流Java规格和执行。例如AspectJ和AspectWerkz。19你需要熟悉对不同有用的API和framework等来为你服务。例如Log4J(logging/tracing),Quartz(scheduling),JGroups(networkgroupcommunication),JCache(distributedcaching),Lucene(full-textsearch),JakartaCommons等等。20你应该熟练掌握一种JavaIDE例如sunOne、netBeans、IntelliJIDEA或者Eclipse。(有些人更喜欢VI或EMACS来编写文件。随便你用什么了)21Java(精确的说是有些配置)是冗长的，它需要很多的人工代码(例如EJB)，所以你需要熟悉代码生成工具，例如XDoclet。22你需要熟悉一种单元测试体系(JNunit)，并且学习不同的生成、部署工具(Ant，Maven)。23你需要熟悉一些在Java开发中经常用到的软件工程过程。例如RUP(RationalUnifiedProcess)andAgilemethodologies。24你还需要紧跟Java发展的步伐，比如现在可以深入的学习Webwork2.0。25你必需要对实际项目的开发流程有所了解，至少要有两个有实际应用价值的项目，而不是练习项目!因为现在企业看重的是你有没有实际的开发经验，真正开发经验的体现就是你做的项目，也就是有实际应用的项目!

//连接SQL 代码如下: var conn = new ActiveXObject("ADODB.Connection"); conn.Open("Provider=SQLOLEDB.1; Data Source=tgf; User ID=sa; " +"Password=sasa; Initial Catalog=MyBulletin"); var rs = new ActiveXObject("ADODB.Recordset"); var sql="select id,name from Category"; rs.open(sql, conn); alert(rs(0));//取出第一个来 rs.close(); rs = null; conn.close(); conn = null; //连接ACCESS 代码如下: function conn(){ var db_bbs db_bbs="dd.mdb"//定义数据库 var conn = new ActiveXObject("ADODB.Connection"); conn.Open("Provider=Microsoft.Jet.OLEDB.4.0;Data Source="+db_bbs+""); var rs = new ActiveXObject("ADODB.Recordset"); var sql="select name from authors"; //数据库中有authors表，name字段 rs.open(sql,conn); alert(rs(0))//取出第一个来 conn.close(); conn = null; }

另外打开一个页面；与self是相对的，就是在本页面打开。

你所描述的RecordSet应该是ADO中的类型。在Java中是用ResultSet来记录数据保存数据库中提取的数据信息，你直接搜ResultSet即可

JavaScript的array对象也是JavaScript的内置函数之一，Array对象是用于处理数组的，使用Array对象时，我们需要先用new来创建一个array对象。我们在如何使用JavaScript中的string对象这篇文章中已经介绍了如何创建一个内置函数，所以接下来我们就直接用new来创建一个Array对象var family= new Array（）;然后我们来看具体的示例代码如下添加"Tom", "Jerry", "Soucy"并使用console.log调用调试。<!DOCTYPE html><html> <head> <meta charset="utf-8"> <title>JavaScript</title> </head> <body> <script> var family= new Array("Tom", "Jerry", "Soucy"); console.log(family); </script> </body></html>运行效果如下接下来我们来看一下Array对象的属性和方法属性1. length（获取数组长度）代码如下<script> var family= new Array("Tom", "Jerry", "Soucy"); console.log(family.length); </script>运行效果如下在family数组中有Tom, Jerry, Soucy三个元素，因此显示为3。关于length和属性在排列的length属性中代替要素数，如果代入后的要素数比代入前的要素数小的话，要素也被删除。这次，“Taro”，“Jiro”，“Saburo”的排列的length属性将2代入““Taro”，“Jiro”。那么请说明各代码。初始值如下。通过将元素数分配给数组的length属性，如果赋值后的元素数小于替换前的元素数，则该元素将被删除。此时，["Tom", "Jerry", "Soucy"]通过在所述数组的长度属性设为2，则数组就变为["Tom", "Jerry"]。我们来说明一下初始值如下。var family = ["Tom", "Jerry", "Soucy"];下面将元素为3的family数组的长度设置为2family.length = 2;这时，数组family的元素会删除一个，显示数组的代码如下。 console.log(family)此时数组的值是["Tom", "Jerry"]。这是此时显示数组元素下标的代码。console.log(Object.keys(family));显示结果是0 , 1。显示当前数组长度的代码如下console.log（family.length）;显示结果为2我们来尝试获取第一个元素我们编写代码如下console.log(family.1);但是，因为语法不同，所以会发生错误。会显示如下的结果这是显示当前第二个元素（下标为1）的正确语法代码。console.log(family[1]);运行结果如下这是显示下标值为1的元素的代码，它是通过从数组family的length属性递减1获得的数字。console.log(family[family.length - 1]);运行结果和上述一样Array对象的方法方法1. slice()（获取数组元素）在slice（）方法中，可以通过指定下标来搜索指定的元素。（下标是对数组元素进行编号的，从0开始一直到n......）检索元素时，必须在（）中指定起始位置的下标和结束位置的下标。如果未指定特定的范围，则会从第一个元素开始检索的最后一个元素。我们来看具体的示例 <script> var family= new Array("Tom", "Jerry", "Soucy"); console.log(family.slice(0,2)); </script>运行结果如下slice(0,2)指的是从下标为0的元素开始到下标为2的元素前，所以运行结果是"Tom", "Jerry"。还有需要知道的是：如果slice（0），则显示"Tom", "Jerry", "Soucy"如果slice（0,1），则显示"Tom"如果slice（1），则显示"Jerry", "Soucy"如果slice（1,2），则显示"Jerry"如果slice（2），则显示"Soucy"方法2. reverse()（翻转元素顺序）代码如下<script> var family= new Array("Tom", "Jerry", "Soucy"); console.log(family.reverse()); </script>运行结果如下：顺序翻转了过来方法3. push()（在末尾添加新元素）在push()中，您可以在数组末尾添加一个新元素，并在添加后获取元素数。代码如下<script> var family= new Array("Tom", "Jerry", "Soucy"); console.log(family.push("Marry", "Cindy"));</script>运行效果如下元素个数从3增加到了5，如果要显示增加的元素，可以再输入以下代码console.log(family)运行结果如下