java笔记

怎样建立数据库连接：

在项目中导入包含数据库连接驱动程序的jar包即可。

连接测试程序：

 String url = "jdbc:mysql://localhost/book?useUnicode=true&characterEncoding=gb2312";  String username = "root";  String password = "1196824358";  String Jresult="";  try {  Class.forName("com.mysql.jdbc.Driver");  Connection connection = DriverManager.getConnection(  url, username, password );  Statement st=connection.createStatement();  ResultSet rs=null;  Jresult+="连接成功……";  System.out.print(Jresult);  }  catch ( SQLException sqlex ) {  System.err.println( "连接失败" );  sqlex.printStackTrace();  System.exit( 1 ); // terminate program  } 

为什么要关闭数据库连接：

如果不关闭Statement对象，它们会一直占用服务器资源，直到JAVA垃圾收集程序来回收它。作为一种好的编程风格，应在不需要Statement对象时显示式地关闭它们，这将立即释放服务器资源，有助于避免潜在的内存问题。同样，使用完整数据库连接后，就应关闭它，释放连接所占用的数据库资源。

什么时候关闭连接：

直接关connection：
  if(conn != null) {
   try {
    conn.close();
   } catch(Exception e) {
    e.printStackTrace();
   }
   conn = null;
  }
写个工具类来关也可以：
 public static void close(Connection conn) {
  if(conn != null) {
   try {
    conn.close();
   } catch(Exception e) {
    e.printStackTrace();
   }
   conn = null;
  }
 }
注意，在有返回sql相关对象的函数里不要关connection，例如resultset、statement、preparedstatement，呵呵返回connection的就更不用说了；如果connection是几个函数公

用的，那就在这几个函数都调用完了再关闭；其他情况最好在函数里把connection关了！！

----------------------------------------------------------------------------------------------------------------------------------------------------------
在Eclipse中查看JVM的内存使用情况 
方法如下： 
Eclipse 3.2以上应该都可以直接通过 
菜单 Window => Preferences => General => 右边，把 Show Heap Status 打上勾就会在右下角任务栏显示内存监视器,并且可以点击内存回收。 
或
1.在eclipse根目录下建立一个文件，文件名options，不要加后缀直接保存，文件内容org.eclipse.ui/perf/showHeapStatus=true 
2.修改eclipse目录下的eclipse.ini文件，在开始添加如下内容： 
-debug 
options 
-vm 
javaw.exe 
重新启动eclipse，就可以看到下方状态条多了JVM的信息
或
    让你的Eclipse也能显示JVM当前内存使用量：
   1、在Eclipse根目录下建立一个文件，文件名options，文件内容     org.eclipse.ui/perf/showHeapStatus=true
2、用这条命令启动Eclipse： E:\eclipse3.1\eclipse.exe -debug options -vm javaw.exe 或者直接右键Eclipse的快捷方式，在"目标"中填入这行。
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

   
   
   
   

     void java.awt. Container.validate() 
   


  
  
  
  

   
   
   
   
validate
public void validate()
 
    

      Validates this container and all of its subcomponents. 
     
Validating a container means laying out its subcomponents. Layout-related changes, such as setting the bounds of a component, or adding a component to the container, invalidate the container automatically. Note that the ancestors of the container may be invalidated also (see Component.invalidate() for details.) Therefore, to restore the validity of the hierarchy, the validate() method should be invoked on the top-most invalid container of the hierarchy. 
 
     
Validating the container may be a quite time-consuming operation. For performance reasons a developer may postpone the validation of the hierarchy till a set of layout-related operations completes, e.g. after adding all the children to the container. 
 
     
If this Container is not valid, this method invokes the validateTree method and marks this Container as valid. Otherwise, no action is performed.
 
    
 
    
 
     
 
      Overrides: 
     
 
     
 
      validate in class 
      Component 
     
 
     
 
      See Also: 
     
 
     
 
      add(java.awt.Component), 
      invalidate(), 
      isValidateRoot(), 
      JComponent.revalidate(), 
      validateTree() 
     
 
    
  
  
  
  
validate()验证，使生效
public void validate（）
验证这个容器和它的所有子组件。
验证意味着一个容器对它的子组件完成了布局。与布局相关的变化，如设置组件的边界，或添加一个组件到容器中，会使容器自动失效。注意容器的祖先也可能失效（详见Component.invalidate（））。因此，为了恢复容器层次的有效性，应该在容器层级树中最顶端，无效的容器调用validate()方法。

验证容器，可能是一个相当耗时的操作。出于性能原因，开发人员可能会推迟，直到完成一套布局相关业务层次的验证，例如：后加入到容器中所有的孩子。

如果这个容器是无效的，这个方法调用validateTree()方法，并把标志这个容器为有效。否则，不执行任何操作。

----------------------------------------------------------------------------------------------------------------------------------------------------------
Java中final用法总结
一、final
 根据上下文环境，final有“无法改变的”或者“终态的”含义，它可以修饰非抽象类，非抽象类成员方法和变量。你可能出于两种理解而需要阻止改变：设计或效率。
final类不能被继承，没有子类，final类中的方法默认是final的。 
final方法不能被子类的方法覆盖，但可以被继承。 
final成员变量表示常量，只能被赋值一次，赋值后值不再改变。 
final不能用于修饰构造方法。 
注意：父类的private成员方法是不能被子类方法覆盖的，因此private类型的方法默认是final类型的。
1、final类 
　final类不能被继承，因此final类的成员方法没有机会被覆盖，默认都是final的。在设计类时候，如果这个类不需要有子类，类的实现细节不允许改变，并且确信这个类不会再被扩展，那么就设计为final类。
2、final方法 
如果一个类不允许其子类覆盖某个方法，则可以把这个方法声明为final方法。
使用final方法的原因有二： 
第一、把方法锁定，防止任何继承类修改它的意义和实现。 
第二、高效。编译器在遇到调用final方法时候会转入内嵌机制，大大提高执行效率。
 class testF {  public static void main(String args[]){  //TODO自动生成方法存根  }  public void f1(){  System.out.println("父类：f1");  }    //不可被子类覆盖，但可以被继承  public final void f2(){  System.out.println("父类fianl:f2");  }    private void f3(){  System.out.println("父类私有：f3");  }  //看看子类是否可以继承这个方法  public void f4(){  System.out.println("父类公有，调用其私有方法");  f3();  } } public class test extends testF{  public void f1(){  System.out.println("父类的方法被子类覆盖");  }  /*父类的final成员函数是无法被覆盖的  public static void f2(){   }  **/  public void f4(){  super.f4();  System.out.println("扩展父类的方法");  }    public static void main(String[] args){  test t=new test();  t.f1();  t.f2();  t.f4();  //t.f3();无法调用  }   } 
运行结果如下：
父类的方法被子类覆盖 父类fianl:f2 父类公有，调用其私有方法 父类私有：f3 扩展父类的方法 
3、final变量（常量） 
　用final修饰的成员变量表示常量，值一旦给定就无法改变！ 
　final修饰的变量有三种：静态变量、实例变量和局部变量，分别表示三种类型的常量。 
　从下面的例子中可以看出，一旦给final变量初值后，值就不能再改变了。 
　另外，final变量定义的时候，可以先声明，而不给初值，这中变量也称为final空白，无论什么情况，编译器都确保空白final在使用之前必须被初始化。但是，final空白在final关键字final的使用上提供了更大的灵活性，为此，一个类中的final数据成员就可以实现依对象而有所不同，却有保持其恒定不变的特征。 
4、final参数 
当函数参数为final类型时，你可以读取使用该参数，但是无法改变该参数的值。 
------------------------------------------------------------------------------------------------------------------------------------
Java中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只为静态分配一次内存，在加载类的过程中完成静态变量的内存分配，可用类名直接访问（方便），当然也可以通过对象来访问（但是这是不推荐的）。 
　对于实例变量，没创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响（灵活）。 

2、静态方法 
　静态方法可以直接通过类名调用，任何的实例也都可以调用，因此静态方法中不能用this和super关键字，不能直接访问所属类的实例变量和实例方法(就是不带static的成员变量和成员成员方法)，只能访问所属类的静态成员变量和成员方法。因为实例成员与特定的对象关联！这个需要去理解，想明白其中的道理，不是记忆！！！ 
　因为static方法独立于任何实例，因此static方法必须被实现，而不能是抽象的abstract。 

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用来修饰成员变量和成员方法，可简单理解为“全局常量”！ 
对于变量，表示一旦给值就不可修改，并且通过类名可以访问。 
对于方法，表示不可覆盖，并且可以通过类名直接访问。