1.豆芽它长房高，它也是根菜！
2.要么就轰轰烈烈的活着。，要么就安安静静的死去！
3.程序员这一行有三个点在支撑，技术、管理（管理自己的时间和精力）、与人沟通。
4.自动类型转换：
java日期类型转换：
try {
DateFormat format = new SimpleDateFormat("yyyy-MM-dd");
String sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
Timestamp ts = new Timestamp(format.parse(sdf).getTime());
System.out.println(sdf);
} catch (ParseException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
1.在Java开发中，控制台输出仍是一个重要的工具。Java对应的“标准输入”、“标准输出”、“标准错误输出”的概念提供了相应的System.in、System.out、System.err。在Java命令行编程时，经常要用到标准输入输出，在PC上标准的输入就是指从键盘输入，标准的输出就是显示器输出。System.out已经封装成一个PrintStream对象，未进行任何处理。这意味着尽管能直接使用System.out和System.err,但是需要对System.in进行一定的封装，使用起来才会比较方便。
System.out.print, System.err.print 输出一个字符串，不换行
System.out.println, System.err.println 输出一个字符串，换行
System.in.read 从输入中读一个字节
System.in.skip(long n) 在输入中跳过n个字节
2.foreach的用法：
import java.util.*;
public class TestArrays
{
public static void main(String[] args)
{
int[] a = {3, 4, 5, 6};
int[] a2 = {3, 4, 5, 6};
System.out.println("a数组和b数组是否相等：" + Arrays.equals(a, a2));
int[] b = Arrays.copyOf(a, 6);
for (int i : b)
{
System.out.print(i + " "); //注意这里输出数组b的元素用参数i,而不是b[i];
}
System.out.println();
System.out.println("b数组的元素为：" + Arrays.toString(b)); //疯 p_102
}
}
3.初始化块虽然也是java类的一种成员，但他没有名字，也就没有标识，因此无法通过类、对象来调用初始化块，初始化块只在创建java对象时隐式执行，而且在执行构造器之前执行。
4.系统中静态初始化块总是比普通初始化块先执行，静态初始化块是类相关的，用于对整个类进行处理，通常用于对类属性执行初始化处理，静态初始化块不能对实例属性进行初始化处理。
类中静态初始化块、非静态初始化块、和类的构造器的执行顺序是：静态初始化快、非静态初始化块、构造器。
对于局部变量（方法内部定义的变量）而言，其作用域就是它所在的方法，不可能被其他类来访问，因此不能使用方法控制符来修饰（private、public protect等）；并且局部变量除了形参之外，都必须显示初始化。也就是说，必须先给方法局部变量和代码块局部变量指定初始值，否则不可以访问他们。
在同一个类里，成员变量的作用范围是整个类内有效，一个类里不能定义两个同名的成员变量，即使一个是类属性，一个是实例属性也不行；一个方法里不能定义两个同名的局部变量，即使一个是方法局部变量，一个是代码块局部变量或者形参也不行。
5.通过super在子类中调用父类被覆盖的方法的格式为：super.方法名（参数类表）；在子类中调用父类的构造器的格式为：super（父类构造器的参数列表）；
6. 访问控制符的级别表
|
private |
Default（默认） |
protected |
public |
|
|
同一个类中 |
可以 |
可以 |
可以 |
可以 |
|
同一个包中 |
可以 |
可以 |
可以 |
|
|
子类中 |
在同一个包中可以访问 在不同包中不能访问（已验证） |
可以 |
可以 |
|
|
全局范围内 |
可以 |
7.如果一个java源文件里定义的所有类都没有使用public修饰，则这个java源文件的文件名可以是一切合法的文件名，但如果一个java源文件里定义了一个public修饰的类，则这个原文进的文件名必须与public类的类名相同。
8.Java默认为所有源文件导入java.lang包下的所有类，因此前面在java程序中使用String/、System类时都无须使用import语句来导入这些类，但对于前面介绍数组时提到的Array类，其位于java.util包下，则必须使用import语句来导入该类。
9.通常建议为java类保留无参数的构造器，因此，如果为一个类编写了有参数的构造器，通常建议为该类额外编写一个无参数的构造器。
10.在一个类中，如果一个构造器完全包含于（代码完全相同）该类的另一个构造器中，就可以通过this来调用 该构造器，格式为：this（被调构造器的形参列表）。
11.多态：
class BaseClass
{
public int a = 6;
public void base()
{
System.out.println("父类的普通方法！");
}
public void test()
{
System.out.println("父类被覆盖的方法！");
}
}
public class SubClass extends BaseClass
{
public String a = "子类覆盖父类的属性！";
public void sub()
{
System.out.println("子类的普通方法！");
}
public void test()
{
System.out.println("子类重写父类的方法！");
}
public static void main(String[] args)
{
BaseClass A = new BaseClass(); //声明一个BaseClass类的对象
A.base();
A.test();
SubClass B = new SubClass();
System.out.println("子类的属性：" + B.a);
B.sub();
B.test();
BaseClass C = new SubClass();
System.out.println("C对象的属性：" + C.a); //父类的属性
C.base(); //调用父类的普通方法 //父类的普通方法
C.test(); //不知道是该调用父类的test方法还是子类的test方法 //子类重写父类的方法
//C.Sum();//调用子类的普通方法
System.out.println("向下转型：");
if(new BaseClass() instanceof SubClass) //将父类对象赋给子类（向下转型）用instanceof运算符
//判断是否可以转型成功，从而避免ClassCastException异常，这样可以保证程序更加健壮。
{
System.out.println("转型成功！");
SubClass D = (SubClass)new BaseClass(); //向下转型
System.out.println("将父类对象赋给子类对象（向下转型：）" + D.a);
D.base();
D.test();
//D.Sub();
}
else
{
System.out.println("转型失败！");
}
}
}
解析：BaseClass C = new SubClass(); 这一条语句比较特殊，他的编译类型是BaseClass,而运行时类型是SubClass,当调用该引用变量的test方法时（BaseClass类中定义了该方法，子类SubClass覆盖了父类的该方法），实际执行的是SubClass类中覆盖后的test方法，这就是多态。
当运行该引用变量（此处为C）时，其方法行为总是像子类方法的行为，而不是像父类方法的行为，与方法不同的是，对象的属性则不具备多态性，即通过引用变量来访问其包含的实例属性时，系统总是试图访问它编译时（此处为BaseClass）类所定义的属性，而不是它运行时类所定义的属性。
因为子类其实是一种特殊的父类，因此java允许把一个子类对象直接赋给一个父类引用变量，无需任何类型转换，或者被称为向上转型。向上转型是由系统自动完成的。但把一个父类对象赋给子类引用变量时，就需要进行强制类型转换，而且还可能在运行时产生ClassCastException异常，使用instanceof运算符可以让强制类型转换更安全。
12.利用组合实现复用：对于继承而言，子类可以直接获得父类的public方法，程序使用子类时，将可以直接访问该子类从父类那里继承道德方法，而组合则是把旧类（不能说成是父类，因为组合的两个类之间没有继承关系）对象作为新类的属性嵌入，用以实现新类的功能，用户看到的是新类的方法，而不能看到嵌入对象的方法，因此，通常需要在新类里使用private修饰嵌入旧类对象。例如（《疯狂java讲义》 P157）.
13.String类型与基本数据类型之间的转换：
public class Primitive2String
{
public static void main(String[] args)
{
String str = "123";
int it = Integer.parseInt(str); //把一个特定字符串转换成int变量
System.out.println(it);
String flot = "12.2";
//把一个字符串转换成float变量
float ft = Float.parseFloat(flot);
System.out.println(ft);
//把一个float变量转换成String变量
String ftstr = String.valueOf(2.123f); //这里要加f，否则会被默认为double型。
System.out.println(ftstr);
//把一个double变量转换成String变量
String strdb = String.valueOf(2.344);
System.out.println(strdb);
}
}
注意：如果希望把基本类型转换成字符串，还有一种更加简单的方法，将基本类型变量和“ ”进行连接运算，系统会自动把基本类型转换成字符串，例如：
//intStr的值为“5”
String intStr = 5 + "";
基本类型变量和String之间的转换：
例如：public class Primitive2Wrapper
{
public static void main(String[] args)
{
boolean b1 = true;
//通过构造器把b1基本类型变量包装成包装类对象
Boolean b1Obj = new Boolean(b1);
System.out.println(b1Obj); //输出true
int it = 5;
//通过构造器把it基本类型变量包装成类对象
Integer itObj = new Integer(it);
System.out.println(itObj); //输出5
//把一个字符串转换成Float对象
Float f1 = new Float("4.56");
System.out.println(f1); //输出4.56
//把一个字符串转换成Boolean对象
Boolean bObj = new Boolean("false");
System.out.println(bObj); //输出false
//下面程序运行时将出现java.lang.NumberFormatException异常
Long lObj = new Long("ddd"); //这是由字符串不能成功转换成基本类型变量引起的
}
}
1.抽象类不能用来创建实例，只能被当做父类被其他子类继承。
当abstract修饰类时，表明这个类只能被继承，当abstract修饰方法时，表明这个方法必须由子类提供实现（即重写）。而final修饰的类不能被继承，final修饰的方法不能被重写。因此final和abstract永远不能同时使用。除此之外，当使用static来修饰一个方法时，表明这个方法属于当前类，即该方法可以通过类来调用，如果该方法被定义成抽象方法，则将通过该类来调用该方法时出现错误（调用了一个没有方法体的方法肯定会引起错误），因此static和abstract不能同时修饰某个方法，既没有所谓的类抽象方法。
Abstract关键字修饰方法必须被其子类重写才有意义，否则这个方法将永远不会有方法体，因此，abstract方法不能定义为private访问权限（否则子类不能重写该方法的方法体），即private和abstract不能同时使用。
2.接口只能继承接口不能继承类，接口里可以包含属性（只能是常量）、方法（只能是抽象实例方法）、内部类（包括内部接口）和枚举类。接口里的所有成员，包括常量、方法、内部类和枚举类都是public访问权限（系统默认）。在接口中定义属性时，不管是否使用public static final修饰符，接口里的属性总将使用这三个修饰符来修饰。而且，接口里没有构造器和初始化块，因此接口里定义的属性只能在定义时指定默认值。
3.一个类实现一个或多个接口之后，这个类必须完全实现这些接口里所定义的全部抽象方法，（也就是重写这些抽象方法）；否则，该类将保留从父类接口那里继承到的抽象方法，该类也必须定义成抽象类。
4.实现接口方法时，必须使用public访问控制修饰符，因为接口里的方法都是public的，而子类（相当于实现类）重写父类方法时访问权限只能更大或者相等，所以实现类实现接口里的方法时只能使用public访问控制权限。
5.接口和抽象类在用法上也存在差别：
① 接口里只能包含抽象方法，不包含已经提供实现的方法，抽象类则完全可以包含普通方法。
② 接口里不能定义静态方法：抽象类里可以定义静态方法。
③ 接口里只能定义静态常量属性，不能定义普通属性，抽象类里则既可以定义普通属性，也可以定义静态常量属性。
④ 接口不包含构造器；抽象类里可以包含构造器，抽象类里的构造器并不是用于创建对象，而让其子类调用这些构造器来完成属于抽象类的初始化操作。
⑤ 接口里不能包含初始化块，但抽象类则完全可以包含初始化块。
⑥ 一个类最多只能有一个直接父类，包括抽象类；但一个类可以直接实现多个接口，通过实现多个接口可以弥补Java单继承的不足。
18.switch语句的用法：
public class test
{
public static void main(String[] argsk)
{
test t = new test();
t.tee(4);
}
void tee(int i)
{
switch(i)
{
default:
System.out.println("不设置");
case 1:
System.out.println("输出1");
case 2:
System.out.println("输出2"); break;
}
}
}
注意：default放在前面会出现问题。
输出结果为：
不设置
输出1 //这里执行case2是因为case1后面没有break；
输出2
如果上面程序case1后面加上break，则输出结果为：
不设置
输出1
总结：switch中的case与default可以互换位置，但不论如何，只有最后一个case或default才可以省略break,前面的语句必须加break，否则程序会执行下面的语句，也就是break与case并没有什么特殊之处。
20.import可以想某个java文件中导入指定包层次下某个类或全部类，import语句应该出现在package语句（如果有的话）之后、类定义之前。一个java源文件只能包含一个package语句，可以包含多个import语句，多个import语句用于导入多个包层次下的类。Java默认为所有源文件导入java.lang包下的所有类。
21.静态导入语句使用import static语句，用于导入指定类的单个静态属性和全部静态属性。
22.介绍数组时提到Arrays类，其位于java.util包下，则必须使用import语句来导入该类。
23.普通方法可以调用静态变量或静态方法，但静态方法调用普通方法或普通变量时必须创建对象来调用，否则，静态成员是不能引用非静态成员的。
24.在构造其中既可以调用该类的静态成员也可以调用该类的非静态成员，但调用时都必须使用this来调用（其中this在该类的其他地方可以省略，但在构造器中不可省）。
25.注意：构造器不能用static来修饰；
26.类的组合：
class person
{
protected void breath()
{
System.out.println("我贪婪的呼吸这清新的空气！感觉真爽");
}
void heart()
{
System.out.println("我心跳的快从胸膛里蹦出来了！");
}
}
class brid
{
private person a ; //通常需要在新类里使用private修饰嵌入旧类的对象
public brid(person a)
{
this.a = a;
}
public void brea()
{
a.breath();
}
public void heart()
{
a.heart();
}
}
class aaa
{
public static void main(String[] args)
{
person d = new person();
brid A = new brid(d);
A.brea();
A.heart();
}
}
27.经典的仅用两个数据本身进行互换操作：int x = 3; int y = 4; x = x + y; y = x - y; x = x -y;仅 用这三条语句就可以实现两个数的互换而不用第三个变量参与。
28.在java中，类的成员变量既可以赋初值，也可以不赋初值，当不赋初值时，系统会自动给该变量赋相应系统默认的初值（因为系统默认的构造函数会自动初始化该类中的成员变量），但java中的局部变量必须先赋初值然后在使用。
29.在重载方法时，如果两个方法的参数列表完全相同，只有方法的返回值不同，这样不会构成重载（而是方法的重名），因为调用方法时不会检测方法的返回值类型，此时调用方法会产生二义性，因而编译时系统会报错说重复定义了该方法。
30.当一个变量名有多处声明，在使用时不知道当前变量属于哪一个声明时，找跟它最近的一个声明，这就是最近声明原则。
31.局部变量在栈（stack）内存中分配，成员变量在堆（heap）内存中分配，静态变量在数据区（data seg）中分配，代码在代码区存放。当创建一个类的多个对象时，该类的实例变量成员会创建多份并存放在堆内存中，但是该类的静态类变量和该类的方法（不论类方法或实例方法都只有一份存放在代码区（code seg））。
32.如果想将一个类放入包中，在这个类源文件第一句话写package，必须保证该类的class文件位于正确的目录下（注意：该类的源码可能会产生影响，所以当该类的源文件经编译产生.class文件后，将源文件（即.java文件）删除或转移到另外的目录下）。
33.将自己的java程序打成一个jar包的方法：在当前工作路径下，输入jar -cvf 跟上生成jar包的名字子 *.* ,(*.*的意思是将当前目录下的所有目录及子目录全部打包到jar包当中。)
34.如下是将自己的文件打成jar包并导入其他java文件中的例子：
将自己的Dog.java自动生成文件夹层次的命令：javac -d . Dog.java(注意：这里要设置环境变量classpath：)
G:\java>javac -d . Dog.java
G:\java>java Dog
Exception in thread "main" java.lang.NoSuchMethodError: main
G:\java>set classpath = %classpath%;g:\java\;
G:\java>java qq807882379.myjava.Dog
xiaogougou!
将刚才生成的文件夹打成jar包的命令（lijunjun为jar包的包名）：
G:\java>jar -cvf lijunjun.jar qq807882379.*
标明清单(manifest)
增加：qq807882379/(读入= 0) (写出= 0)(存储了 0%)
增加：qq807882379/myjava/(读入= 0) (写出= 0)(存储了 0%)
增加：qq807882379/myjava/Dog.class(读入= 430) (写出= 303)(压缩了 29%)
G:\java>javac -d . Dog.java
G:\java>java qq807882379.myjava.Dog （这里调用的是jar包中的Dog.class）
xiaogougou!
当在其他文件中要导入指定的jar包是要将该jar包设置在环境变量classpath中，才能在其他java程序中引用。
G:\java>set classpath=%classpath%;g:\java\lijunjun.jar;
然后就可以将lijunjun.jar这个jar包导入Cat程序中使用；
G:\java>javac Cat.java
G:\java>java Cat
xiaogougoulaichuanmenle!
xiaomaozaijiadengniwan!
Dog.java程序和Cat.jar程序如下：
package qq807882379.myjava;
public class Dog {
public void print() {
System.out.println("xiaogougoulaichuanmenle!");
}
public static void main(String[] args) {
System.out.println("xiaogougouwolaile!");
}
}
import qq807882379.myjava.Dog;
class Cat
{
public static void main(String[] args) {
Dog d = new Dog();
d.print();
System.out.println("xiaomaozaijiadengniwan!");
}
}
35.当子类继承了父类之后想要重写父类的方法，那么就直接把父类的该方法的函数签名直接从父类复制到子类中，因为重写的条件是方法的返回值、方法名、参数列表要相同。复制粘贴可以防止将父类要重写的方法名在子类中写错，这种情况并不是子类重写了父类的方法，而是子类自己有定义了属于子类自己的方法（这样的错误编译和运行时永远不会报错，很难检查出来！）。并且子类中重写后的方法的访问权限只能同父类的访问权限一样或比父类的访问权限大，绝对不能比父类中该方法的访问权限小。
36.当子类new一个对象出来时，该对象在内存中同时产生了子类的除了该对象名之外的另一个引用this和一个父类的引用super。
37.当在子类构造方法中用super调用父类的构造方法时，必须将super写在子类构造方法的第一行（因为现有父亲才有儿子！）。
38.当编译一个java文件时，java虚拟机会按照classpath设置的路径去寻找你到运行的.class文件，这时如果其他路径下有一个同名的.class文件，而恰好在设置classpath时将.；也就是在当前路径下查找的设置放在了该同名的.class文件的路径后面，则程序在运行时就会运行同名的.class文件，这样程序就会出现意料之外的结果：所以在设置classpath时一定将.;在当前路经下查找设置在第一个，以防出现上面的这种情况，万一出现上面这种情况（即在编译时没有任何问题，可在运行时结果不正确），你可以修改类名来测验。否则这种错误能折腾死人！
39.多态（或动态绑定）：动态绑定是指“在执行期间（而非编译期）判断所引用对象的实际类型，根据其实际的类型调用其相应的方法。”多态（或动态绑定）是面向对象编程的核心中的核心。New的是谁就找谁的方法。
40.Final的变量的值不能被改变，final的方法不能被重写，final的类不能被继承。
41.接口中的方法前面不用写abstract，但接口里的所有方法都是abstract的；
42.接口的特性：接口可以多重实现；接口中声明的属性默认为public static final 的，也只能是public static final的； 接口中只能定义抽象方法，而且这些方法默认为public的，也只能是public的；接口可以继承其他的接口，并添加新的属性和抽象方法。
43.接口里的一个问题：接口A里有一个抽象方法getMoney();接口B里有一个抽象方法getMoney();接口C同时继承了接口A和接口B，如果A和B中的getMoney方法的返回值都是同一类型的，则在C中只定义一个getMoney（）{}方法即可，该方法在A和B里都可见，当A和B中的两个方法的返回值类型不同，则会出问题，例如：A中getMoney的返回值类型为double型，B中的getMoney的返回值为void类型，这时，在C中又该如何实现A和B中的两个getMoney方法，又该如何区分呢？
解答：使用内部类，C类中再写一个内部类D，C类中可以实现A接口及A接口中的抽象方法，在C的内部类D中在实现B接口及B接口中的抽象方法。
44.在java中，函数的返回值可以是数组类型：例如：public static Date[] bubbleSort（Date [] a）{……}；
45.Myeclips工具的一点使用技巧：用鼠标选中一块内容，然后按ctrl+shift+/就可以把这整段给自动注释起来，然后按ctrl+shift+\就可以去掉整段被注释的内容。
46.输入输出流：
47.在创建一个窗口时，如果没有设置关闭事件，则只能在dos窗口的命令行敲Ctrl + C来退出刚创建的窗口。
48.在一个类的内部声明的类叫内部类，在一个在类的方法里或该类内部的初始化块或if语句块里声明的类叫局部类.
49.Panel类的默认布局管理器为FlowLayout;Frame窗口默认的布局管理器是BorderLayout；
50.在创建多线程时，如果能使用接口就不要从Thread继承，因为接口比较灵活，他可以实现多个接口和继承其他一个父类：
51.在DOS窗口查在当前路径下的全部文件名用 dir ；要查某一类型的文件如.class文件可以用dir *.class来查询。。
52.《TCP\IP详解》；
53.端口号是用来区分同一台机器上的不同应用程序。
54.TCP和UDP各有65536个端口号；
55.当方法里的逻辑比较简单，语句比较少，不经常变动时可以考虑使用匿名类，一般使用内部类就可以了。
56.在那个线程里调用的sleep（）方法，就让那个线程睡眠。
57.容器类对象在调用remove、contains等方法时需要比较对象是否相等，这会涉及到对象类型的equals方法和hashCode方法；对于自定义的类型，需要重写equals和hashCode方法以实现自定义的对象相等规则。 注意：相等的对象应该具有相等的hashCode。记住一个原则：你要重写这一对象的equals方法必须重写该对象的hashCode方法。
import java.util.*;
public class Test {
public static void main(String[] args) {
Collection c = new LinkedList();
c.add("hello");
c.add(new Name("f1", "l1"));
c.add(new Integer(100));
System.out.println(c);
c.remove("hello");
System.out.println(c.remove(new Name("f1", "l1"))); //remove的返回类型是boolean型
System.out.println(c);
}
}
class Name {
private String firstName, lastName;
public Name(String firstName, String lastName) {
this.firstName = firstName;
this.lastName = lastName;
}
public String getFirstName() {
return firstName;
}
public String getLastName() {
return lastName;
}
public String toString() {
return firstName + " " + lastName;
}
public boolean equals (Object obj) { //这里重写了equals方法
if(obj instanceof Name) {
Name name = (Name) obj;
return (firstName.equals(name.firstName))
&& (lastName.equals(name.lastName));
}
return super.equals(obj);
}
public int hashCode() { //同样在这里重写了hashCode方法
return firstName.hashCode();
}
}
58.如何选择数据结构：Array读快改慢；Linked改快读慢；hash两者之间。
59.在命令行窗口上输入一个cls则会将当前命令行窗口清除，以第一行开始。
60.Comparable接口只有用作自己本类的对象之间作比较时才有意义。
61.在API文档中，查找一个只知道函数名称不知道是在那个包的那个类里的函数，可以在API文档的index页面下摁Ctrl+f来搜素，也可以在左上角的索引框中输入你要查找的内容。
62.在MyEclipse中当一个对象后面加一个点时MyEclipse会自动提示，有时提示会自动消失，这时可以按Alt+/提示就会自动显示。
63.Winmerge工具比较前一个版本和后一个版本之间的代码的变动
64.我怎么从键盘输入一个int/double/字符串?
答: java的I/O操作比C++要复杂一点。如果要从键盘输入，样例代码如下:BufferedReader cin = new BufferedReader( new InputStreamReader( System.in ) );String s = cin.readLine();
这样你就获得了一个字符串，如果你需要数字的话再加上:int n = Integer.parseInt( s ); 或者 double d = Double.parseDouble( s );
65.关闭资源最严谨的方式为：（首先关闭资源的代码要放在finally块中）例如：
finally {
try {
if(rs != null) {
rs.close();
}finally {
try {
if(st != null) {
st.close();
}
}finally {
if(conn != null) {
conn.close();
}
}
}
}
}
66.单例类就是将该类的构造方法定义成private，不允许类外部new该类的实例对象。而在类的内部new一个该类的对象，然后定义一个public方法返回该类new出来的对象作为该类对外部的接口，所以该方法的返回类型为该类的类类型。
67.JavaBean是使用Java语言编写的组件。组件的特点是：能够完成特定的功能，这些功能主要用于共享；是一个大系统的组成部分，不能独立运行，主要目的是供其他文件进行调用。
注意：在编写JavaBean时一定要注意编程的规范。这里用到的编程的规范有：为类创建一个包，包名通常使用小写，类名首字母大写，类名中每个单词的首字母大写，属性名通常首字母小写；方法名首字母小写；代码的缩进。
68.java的util类和数据库的sql类中都有getDate()方法，util类中的getDate()方法可以取出日期和时间，而sql类中的getDate()方法，只能取出当前的日期，不能取出当前的具体时间，这就是util类和sql类中getDate()方法的区别。关系是sql中的getDate()方法是从util类中继承下来的。
69.ctrl + 1 可以对java程序中的一个变量全部重命名。
70.J2EE的三层架构图：
71.一个类的内部类在该类的静态方法中不能直接new一个该内部类的实例出来，
例： class A {
Public static void main(String[] args) {
B b = new B(); (错误：不能在静态方法中直接new一个内部类的对象)
}
Class B {}
}
可以通过在一个方法中new 一个B的对象出来，然后再在静态方法中调用这个方法，就可以解决上面的问题：
class A {
Public static void main(String[] args) {
test(); (通过方法调用解决)
}
Class B {}
Public void test() {
B b = new B();
}
}
//在面板上画出图片
Image im = Toolkit.getDefaultToolkit().getImage(Panel.class.getResource("/a3531368.jpg"));
//上面这句可以用（image1 = ImageIO.read(new File("images/1.gif"));）这一句代替，并且效果更好
//显示图片
g.drawImage(im, 10, 10, 200, 150, this);
//如何画出字
g.setColor(Color.red);
g.setFont(new Font("华文彩云", Font.BOLD ,30));
g.drawString("祖国万岁", 100, 120);
一个事件源可以有多个事件监听者。
在JPanel或者Panel控件中有一个paint(Graphics g)方法，在该方法中必须要写一句：super.paint(g);;如果不写，则画出的图形（在移动的时候会留下痕迹）：
如果加上super.paint(g); 则画出的图形在移动的过程中不会留下痕迹：
注意：鼠标的移动和拖拽事件在MouseMotionListener接口中实现监听。
窗口的最小化、最大化、还原等事件的监听接口为：WindowLinstener ;
在处理键盘的事件响应时应该用e.getKeyCode()==KeyEvent.VK_W来判断哪个键是被按下，而不应该用e.getKeyChar()==KeyEvent.VK_W来判断那个键被按下。
唐骏：人无我有，人有我精，人精我转。
注意线程的两种启动方式：
1.extends Thread方式；
public class Test {
public static void main(String[] args) {
Cat cat = new Cat();
cat.start();
}
}
class Cat extends Thread {
int times = 0;
public void run() {
while(true) {
try {
Thread.sleep(1000);
} catch(InterruptedException e) {
e.printStackTrace();
}
times++;
System.out.println("Hello World!" + times);
if(times == 10) {
//退出
break;
}
}
}
}
2.implements Runnable方式：
public class Test2 {
public static void main(String[] args) {
Dog dog = new Dog();
Thread t = new Thread(dog);
t.start();
}
}
class Dog implements Runnable {
int times = 0;
public void run() {
while(true) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("hello world " + times);
times++;
if(times == 10) {
//退出
break;
}
}
}
}
例如：
public class Test4 {
public static void main(String[] args) {
Cat cat1 = new Cat();
//Cat cat1 = new Cat(); //错误：java.lang.IllegalThreadStateException
cat1.start();
Dog dog1 = new Dog();
Thread t = new Thread(dog1);
Thread t2 = new Thread(dog1);
t.start();
//t.start(); //java.lang.IllegalThreadStateException
t2.start(); //可以
}
}
//猫类
class Cat extends Thread {
public void run() {
System.out.println("11");
}
}
//狗类
class Dog implements Runnable {
public void run() {
System.out.println("22");
}
}
Thread.currentThread().getName();该条语句可以得到当前线程的名字。
三个窗口买2000张票的程序：
public class Test {
public static void main(String[] args) {
//定义三个售票窗口
TicketWindow tw1 = new TicketWindow();
TicketWindow tw2 = new TicketWindow();
TicketWindow tw3 = new TicketWindow();
Thread t1 = new Thread(tw1);
Thread t2 = new Thread(tw1);
Thread t3 = new Thread(tw1);
t1.start();
t2.start();
t3.start();
}
}
//售票窗口
class TicketWindow implements Runnable{
private static int nums = 2000; //一共2000张票
public void run() {
while(true) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//认为if else 要保证其原子性
synchronized(this) {
//判断是否还有票
if(nums > 0) {
//显示售票信息
System.out.println(Thread.currentThread().getName() + "在售出第" + nums + "张票");
nums--;
} else {
//售票结束
System.out.println("售票结束");
break;
}
}
}
}
}
一个文件的后缀名没有意义，因为可以把一个文本文件修改后缀名为.mp3,但是用记事本打开后依然可以编写文字，但是该文件用mp3播放器却不能播放。
还有一种给文件加密的方法：以视频文件为例，首先用记事本将该视屏文件以二进制文件的形式打开，在某一地方加入几个字母（123），然后保存，之后用视频播放器播放或者任何播放器都不可能打开该文件，因为该文件的文件头已经被破坏，如果想看该文件，依然用记事本打开该文件，删除你加的那几个字母，然后用指定播放器打开该文件，该文件就又可以正常播放了。
经典问题：
如上图所示：为什么该txt文件大小只占22个字节，去占用4KB的空间。
答：因为该操作系统分配的硬盘最小块就是4KB，如果该文件的大小大于4KB，则这里所占用的空间就会变为8KB..
较难破译的密码格式：[email protected]~cqw
字节流对象可以操作任何类型的文件。
用程序对文件及文件夹的各种操作：
/*
* 功能：File类的基本用法
*/
package com.test3;；
import java.io.*;
public class Test {
public static void main(String[] args) {
/*File f = new File("e:/1.txt");
//得到文件的路径
System.out.println("文件路径" + f.getAbsolutePath());
//得到文件的大小(返回的是字节大小)
System.out.println("文件大小" + f.length());
//文件是否可读
System.out.println("可读" + f.canRead());*/
//创建文件和创建文件夹
/*File f = new File("e:/2.txt");
if(!f.exists()) { //判断2.txt文件是否存在
try {
f.createNewFile();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
} else {
System.out.println("文件已经存在，暂时不能创建！");
}
*/
//如何创建文件夹
/*File f = new File("e:/ljj");
if(f.isDirectory()) {//判断该文件夹是否已经存在
System.out.println("文件夹已经存在");
} else {
//创建文件夹
f.mkdir();
}*/
//列出一个文件夹下面的所有文件
File f = new File("g:/java");
if(f.isDirectory()) {//判断如果f是一个文件夹
File[] lists = f.listFiles();
for(int i=0; i<lists.length; i++) {
System.out.println("文件名 ：" + i + "--" + lists[i].getName());
}
}
}
}
从文件中读取内容到控制台打印出来：
/*
* 使用FileInputStream从文件中读入内容
*/
package com.test4;
import java.io.*;
public class Test {
public static void main(String[] args) {
//得到一个文件对象f->e:/1.txt
File f = new File("e:/1.txt");
FileInputStream fis = null;
//因为File类没有读写的能力，所以需要使用InputStream
try {
fis = new FileInputStream(f);
//定义一个字节数组 ,相当于一个缓存
byte[] bytes = new byte[1024];
int n = 0; //记录实际读取到的字节数
//循环读取
while((n = fis.read(bytes)) != -1) { //read函数因为已经到达文件末尾而没有更多的数据，则返回-1.
//把字节转成String
String s = new String(bytes, 0, n);
System.out.println(s);
}
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
//关闭文件流 必须放在这里
try {
fis.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
把内容保存到文件中：
//演示FileOutputStream流的使用
package com.test5;
import java.io.*;
public class Test {
public static void main(String[] args) {
/*BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String str = null;
try {
while((str = br.readLine()) != null) {
System.out.println(str);
}
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}*/
File f = new File("e:/3.txt");
//字节输出流
FileOutputStream fos = null;
try {
fos = new FileOutputStream(f);
String s = "小米
ok helloworld\r\n"; //加上\r\n(回车换行)，“中国您好”就会在文件中换行输出
String s1 = "中国您好";
fos.write(s.getBytes()); //将String类型转成byte数组作为参数
fos.write(s1.getBytes());
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
fos.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
/*用io流复制图片
* 思路：先把图片读入到内存，然后在写入到某个文件
* 因为图片是二进制文件，因此只能用字节流完成
*/
package com.test6;
import java.io.*;
public class Test {
public static void main(String[] args) {
File f1 = new File("E:\\壁纸\\新建文件夹\\tankD.gif");//源文件
FileInputStream fis = null;
FileOutputStream fos = null;
try {
fis = new FileInputStream(f1);
fos = new FileOutputStream("e:/meinv.jpg"); //复制到目的地
byte[] buf = new byte[512];
int n = 0;//实际读取到的字节数
//循环读取
while((n=fis.read(buf)) != -1) {
//输出到指定文件
fos.write(buf);
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
fis.close();
fos.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
/*
* 演示文件字符流的案例（文件的复制）
* 即文件的读入和写出
*/
package com.test7;
import java.io.*;
public class Test {
public static void main(String[] args) {
//文件取出字符流对象（输入流）
FileReader fr = null;
//写入到文件（输出流）
FileWriter fw = null;
try {
fr = new FileReader("e:/1.txt");
fw = new FileWriter("e:/4.txt");
//读入到内存
int n = 0; //实际读取到的字符数
char c[] = new char[1024];
while((n=fr.read(c))!= -1)//read()方法如果已到达流的末尾，则返回-1
{
fw.write(c, 0, n); //防止输出的文件用记事本打开没有乱码用EditPlus则会出现乱码
}
} catch (IOException e) {
e.printStackTrace();
} finally {
try {
fr.close();
fw.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
* 我的记事本：界面加功能
*/
package com.test8;
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import javax.swing.*;
public class NotePad extends JFrame implements ActionListener{
//定义需要的组件
JTextArea jta = null;
//菜单条
JMenuBar jmb = null;
//第一个JMenu
JMenu jm1 = null;
//定义JMenuItem
JMenuItem jmi1 = null;
JMenuItem jmi2 = null;
public static void main(String[] args) {
NotePad np = new NotePad();
}
public NotePad() {
//创建jta
jta = new JTextArea();
jmb = new JMenuBar();
jm1 = new JMenu("文件");
//设置助记符
jm1.setMnemonic(‘F‘);
jmi1 = new JMenuItem("打开", new ImageIcon("open.gif"));
//注册监听
jmi1.addActionListener(this);
jmi1.setActionCommand("open");
jmi2 = new JMenuItem("保存");
//对保存菜单处理
jmi2.addActionListener(this);
jmi2.setActionCommand("save");
//加入
this.setJMenuBar(jmb);
//把jm1放入jmb
jmb.add(jm1);
//把item放入Menu
jm1.add(jmi1);
jm1.add(jmi2);
//放入JFrame
this.add(jta);
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
this.setSize(400, 300);
this.setVisible(true);
}
@Override
public void actionPerformed(ActionEvent arg0) {
// TODO Auto-generated method stub
//判断那个菜单被选中
if(arg0.getActionCommand().equals("open")){
//System.out.println("open");
//推荐JFileChooser
JFileChooser jfc1 = new JFileChooser();
//设置名字
jfc1.setDialogTitle("请选择文件……");
jfc1.showOpenDialog(null); //表示打开时使用默认方式打开
jfc1.setVisible(true); //显示
//得到用户选择的绝对路径
String filename = jfc1.getSelectedFile().getAbsolutePath();
//System.out.println(filename);
//BufferedReader 处理字符效率比较高
FileReader fr = null;
BufferedReader br = null;
try {
fr = new FileReader(filename);
br = new BufferedReader(fr);
//从文件中读取信息并显示到jta
String s = "";
String allCon = "";
while((s = br.readLine()) != null) {
//显示到记事本中
allCon += s + "\r\n";
}
//放置到jta即可
jta.setText(allCon);
} catch(Exception e) {
e.printStackTrace();
} finally {
try {
br.close();
fr.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
} else if (arg0.getActionCommand().equals("save")) {
//出现保存对话框
JFileChooser jfc = new JFileChooser();
jfc.setDialogTitle("另存为……");
//按默认方式显示
jfc.showSaveDialog(null);
jfc.setVisible(true);
//得到用户希望把文件保存到何处，文件的绝对路径
String file = jfc.getSelectedFile().getAbsolutePath();
//准备写入到指定文件即可
FileWriter fw = null;
BufferedWriter bw = null;
try {
fw = new FileWriter(file);
bw = new BufferedWriter(fw);
bw.write(this.jta.getText());
} catch (IOException e) {
e.printStackTrace();
} finally {
try { //注意这里关闭时关闭顺序不能互换，否则内容不能被写出去
bw.close();
fw.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
界面如下：
关闭
注意：关闭io流或数据库连接都应遵循一个原则: 后打开的先关闭；
集合：ArrayList集合可以实现栈和队列两种功能。当给集合中添加元素时，如果用addlLast()则是队列的形式存放（先进先出），如果用addFirst()则是以栈的形式存放（先进后出）。
Java的Swing编程中，使用JFrame jf = new JFrame(); jf..setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 则在关闭窗口时也保证jvm（java虚拟机同时也退出）。
选择字段类型时如何判断何时使用char或varchar：
1.varchar是可变长的，可以节省空间，但是查询时效率比较低
2.Char不可变长，当可以确定字段的长度是应该使用char,因为可以提高查询速度。
数据库中表的主键不能重复，主键不能为空，主键可以修改（但不能修改为已经从在的主键。）
Sql中null不能用=来匹配，而要用is 例如：
快速自增长插入语句：
/*演示使用jdbc-odbc桥连的方式操作数据库 （student）
* 1.配置数据源
连接sqls2005的插入语句：
import java.sql.*;
/*演示使用jdbc-odbc桥连的方式操作数据库 （student）
* 1.配置数据源
* 2.在程序中去连接数据源
*/
public class Test {
public static void main(String[] args) {
Connection conn = null;
Statement stmt = null;
ResultSet rs = null;
try {
//1.加载驱动，（作用是把需要的驱动加入内存）
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
//2.得到连接(指定连接到那个数据源，用户名和密码)
conn = DriverManager.getConnection("jdbc:odbc:mytest","sa","");
//3.创建statement和PreparedStatement
//Statement:主要用于发送sql语句到数据库
stmt = conn.createStatement();
//4.执行（crud,创建数据库，备份数据库，删除数据……）
//1.演示添加一条数据到xmk表
/*int i = stmt.executeUpdate("insert into test(sname,sex) values (‘ljj‘,‘男‘)");
if(i == 1) {
System.out.println("插入ok");
} else {
System.out.println("失败");
}*/
rs = stmt.executeQuery("select * from test");
while(rs.next()) {
int i = rs.getInt(1);
String name = rs.getString(2);
String sex = rs.getString(3);
System.out.println(i + " " + name + " " + sex);
}
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
try {
rs.close();
stmt.close();
conn.close();
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
学习网络最经典的教程：
追踪数据包发送经过的路由：
本地回绕地址：127.*.*.* 不一定非要是：127.0.0.1
Java中得到整个屏幕的宽度和高度：
用Swing组件创建的窗口的关闭方法：
取出登录时的用户名和密码：
`Model2开发满含楼餐饮系统的模式图：
学习tcp/ip的必看书籍：（网络黑客的圣经）
单例模式的形成过程：
在程序中通过程序代码动态的编译类：
UDPSocket编程： （服务器端）
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.net.UnknownHostException;
public class UDPServer {
public static void main(String[] args) {
try {
DatagramSocket ds = new DatagramSocket(6000);
byte[] buf = new byte[100];
DatagramPacket dp = new DatagramPacket(buf,100 );
ds.receive(dp);
System.out.println(new String(buf, 0, dp.getLength()));
String str = "Welcome you!";
DatagramPacket spSend = new DatagramPacket(str.getBytes(), str.length(), dp.getAddress(), dp.getPort());
ds.send(spSend);
ds.close();
} catch (SocketException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
（客户端：）
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.net.UnknownHostException;
public class UDPClient {
public static void main(String[] args) {
try {
DatagramSocket ds = new DatagramSocket();
String str = "Hello, this is zhangsan";
DatagramPacket dp = new DatagramPacket(str.getBytes(), str.length(), InetAddress.getByName("localhost"), 6000);
ds.send(dp);
byte[] buf = new byte[100];
DatagramPacket dpRecv = new DatagramPacket(buf, 100);
ds.receive(dpRecv);
System.out.println(new String(buf, 0, dpRecv.getLength()));
ds.close();
} catch (SocketException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (UnknownHostException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
简单的以二进制格式下载的简易下载程序：（孙鑫Java无难事12.rar\孙鑫Java无难事12）
package com.bjsxt.url;
import java.awt.event.*;
import java.io.*;
import java.net.*;
import javax.swing.*;
public class Download {
public static void main(String[] args) {
JFrame jf = new JFrame("下载程序");
jf.setSize(600, 400);
jf.setLocation(100, 100);
JPanel jp = new JPanel();
JLabel jl = new JLabel("Please input URL:");
final JTextField tf = new JTextField(30);
jp.add(jl);
jp.add(tf);
jf.getContentPane().add(jp, "North");
final JTextArea ta = new JTextArea();
jf.getContentPane().add(ta);
JButton btn = new JButton("Download");
btn.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent arg0) {
String str = tf.getText();
try {
URL url = new URL(str);
URLConnection urlConn = url.openConnection();
String line = System.getProperty("line.separator");
ta.append("Host:" + url.getHost());
ta.append(line);
ta.append("Port:" + url.getDefaultPort());
ta.append(line);
ta.append(urlConn.getContentType());
ta.append(line);
ta.append("ContentLength:" + urlConn.getContentLength());
InputStream is = urlConn.getInputStream();
//InputStreamReader isr = new InputStreamReader(is);
//BufferedReader br = new BufferedReader(isr);
FileOutputStream fos = new FileOutputStream("1.html");
//String strLine;
//while((strLine = br.readLine()) != null) {
int data;
while((data = is.read()) != -1) {
//fos.write(strLine.getBytes());
//fos.write(line.getBytes());
fos.write(data);
}
//br.close();
is.close();
fos.close();
} catch (MalformedURLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
});
jf.getContentPane().add(btn, "South");
jf.setDefaultCloseOperation(jf.EXIT_ON_CLOSE);
jf.setVisible(true);
}
}
多态的三个特性：
1.有继承
2.有重写
3.有父类引用指向子类对象。
注意：因为继承的父类发生改变时子类一定会发生改变，所以继承的耦合度比较高，为降低耦合度，应谨慎使用继承。
Java的反射机制的应用举例：
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class TestReflection {
public static void main(String[] args) {
String str = "T";
try {
Class c = Class.forName(str);
Object o = c.newInstance(); //创建一个类的对象
//拿到该类的所有方法名并放入数组中
Method[] methods = c.getMethods();
for(Method m : methods) {
//通过反射机制调用mm方法
if(m.getName().equals("mm")) {
m.invoke(o);
}
//可变参数的应用
if(m.getName().equals("m1")) {
m.invoke(o, 1, 2);
//拿到m1方法的参数类型
for(Class paramType : m.getParameterTypes()) {
System.out.println(paramType.getName());
}
}
//System.out.println(m.getName());
//拿到方法的返回值的类型
if(m.getName().equals("getS")) {
Class returnType = m.getReturnType();
System.out.println(returnType.getName());
}
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
}
class T {
static {
System.out.println("T loaded!");
}
public T() {
System.out.println("T constructed!");
}
int i;
String s;
public void m1(int i, int j) {
this.i = i + j;
System.out.println(this.i);
}
public void mm() {
System.out.println("mm invoked");
}
public String getS() {
return s;
}
}
Struts2中最常用的几个标签：
注意如下sql语句中的where、group by、 having、 order by的顺序；
设计单例的方法：
当以这样的方式向数据库中插入时间时，可以保存年、月、日、时、分、秒：
数据库连接池的配置：
可以通过tomcat的管理页面配置各种数据库的连接池（可以参考王勇的drp中oracle的连接池的配置）：通过tomcat管理页面配置的连接池是放在tomcat--》conf下的——》server.xml
文件中：
<Resource
name="jdbc/ljj"
type="javax.sql.DataSource"
password="drp"
driverClassName="oracle.jdbc.driver.OracleDriver"
maxIdle="2"
maxWait="5000"
username="drp"
url="jdbc:oracle:thin:@localhost:1521:orcl"
maxActive="4"
/>
可以将上面的这些内容剪贴到tomcat--》conf--》context中如下；
<!-- The contents of this file will be loaded for each web application -->
<Context>
<!-- Default set of monitored resources -->
<WatchedResource>WEB-INF/web.xml</WatchedResource>
<!-- Uncomment this to disable session persistence across Tomcat restarts -->
<!--
<Manager pathname="" />
-->
<Resource
name="jdbc/ljj"
type="javax.sql.DataSource"
password="drp"
driverClassName="oracle.jdbc.driver.OracleDriver"
maxIdle="2"
maxWait="5000"
username="drp"
url="jdbc:oracle:thin:@localhost:1521:orcl"
maxActive="4"
/>
</Context>
然后如果context.xml文件是放在tomcat原来的目录下不改变的话该连接池对所有配置到tomcat上的项目都起作用，也可以将context.xml文件剪贴到MyEclipse中的某一个项目WeebRoot--》Web-INF下，这样就可以对该项目起作用，而对其他项目不起作用。
然后在jsp页面中具体使用连接池的具体方法是（如果取得连接Connection后，与使用jdbc没有什么区别）：
<%@ page language="java" import="java.util.*" pageEncoding="GB18030"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>
<%@ page import="java.sql.*" %>
<%@ page import="javax.sql.*" %>
<%@ page import="javax.naming.*" %>
<%
Connection conn = null;
PreparedStatement pstmt = null;
ResultSet rs = null;
try {
Context ctx = new InitialContext();
//通过JNDI查找DataSource
DataSource ds = (DataSource)ctx.lookup("java:comp/env/jdbc/ljj");
conn = ds.getConnection();
pstmt = conn.prepareStatement("select * from m_user");
rs = pstmt.executeQuery();
out.println("输出数据如下");
while(rs.next()) {
out.println("id==" + rs.getInt("userid") + ", " + rs.getString("username" ));
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if(rs != null) rs.close();
if(pstmt != null) pstmt.close();
//注意：该链接一定要归还给连接池，否则会出问题：
if(conn != null) conn.close();
} catch (Exception e) {
e.printStackTrace();
}
}
%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<base href="<%=basePath%>">
<title>My JSP ‘user_test.jsp‘ starting page</title>
<meta http-equiv="pragma" content="no-cache">
<meta http-equiv="cache-control" content="no-cache">
<meta http-equiv="expires" content="0">
<meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
<meta http-equiv="description" content="This is my page">
<!--
<link rel="stylesheet" type="text/css" href="styles.css">
-->
</head>
<body>
user_Test.jsp <br>
</body>
</html>
}
链式编程的编程技巧：
public class FilterChain {
List<Filter> FilterList = new ArrayList<Filter>();
//链式编程的技巧
public FilterChain addFilter(Filter f){
this.FilterList.add(f);
return this;
}
}
在主方法中：
public class Main {
public static void main(String[] args) {
FilterChain fc = new FilterChain();
//开始链式编程
fc.addFilter(new HTMLFilter())
.addFilter(new SesitiveFilter())
.addFilter(new FaceFilter());
}
}
注意：判断内存中两份字节码是否相等应该用“==”来比较。（因为同一个类的字节码在内存中尽有一个类）
对于数据库连接对象、输入输出流对象等物理资源，不会被垃圾回收器自动回收的，必须要手动释放，方法是在try-catch-finally的finally块中编写释放资源的代码。
默认构造方法都是public的？
需要开发人员注意的是，默认的构造方法（是指在java编译器中自动生成的构造方法）未必都是public的，并且默认的构造方法是一定有super()方法的。在现实中，默认构造方法的修饰符是与所在类的修饰符一致的，也就是说如果类是public的，默认构造方法的修饰符就是public的；如果类无修饰符，默认构造方法也将没有修饰符。例如下面的代码：
public class Test{
//默认的构造方法
public Test(){
super();
}
}
如果类无修饰符：
class Test{
//默认的构造方法
Test(){
super();
}
}
配置用EditPlus作为java编译器：
在定义接口时， 只有在接口中抛异常，实现接口的子类中才能抛比父类小的异常，如果父类不抛异常，则子类不能抛异常，RuntimeException异常除外。