对于一个中等以上项目来说，庞大的表信息无法实现在一个jsp页面中预览，分页显示势在必行。本程序主要实现jsp页中查询数据分页显示功能：

     <%
 String sql=null;
 ResultSet rs=null;
 int PageSize=5;
 int Page=1;
 int totalPage=1;
 int totalRecord=0;
 Connection con=splBean.getConnet();
 Statement stmt=con.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,ResultSet.CONCUR_READ_ONLY);
 //算出总行数tatalRecord
 sql="select count(*) as recordcount from student";
 rs=stmt.executeQuery(sql);
 if(rs.next()) totalRecord=rs.getInt("recordcount");
 System.out.println(totalRecord);

 //算出总页数totalPage
 if(totalRecord%PageSize==0) totalPage=totalRecord/PageSize;
 else totalPage=(int)Math.floor(totalRecord/PageSize)+1;//最后还空余一页情况,Math.floor(x):比x小的最大值。
 if(totalPage==0) totalPage=1;//数据库中一条数据也没有的处理情况;
 //捕捉form表单提交的Page元素
 if(request.getParameter("Page")==null||request.getParameter("Page")=="") Page=1;
 else try{
 Page=Integer.parseInt(request.getParameter("Page"));
 }catch(java.lang.NumberFormatException e){
 Page=1;
 }
 //如果Page非常规数值处理
 if(Page>totalPage) Page=totalPage;
 if(Page<1) Page=1;
 sql="select * from student";
 rs=stmt.executeQuery(sql);
 rs.absolute((Page-1)*PageSize+1);
 ResultSetMetaData meta=rs.getMetaData();
 int col=meta.getColumnCount();//得到表头有多少列
 out.println("<table border='1'>");
 //输出表头信息
 out.println("<tr>");
 for(int i=1;i<col+1;i++)
 {
  out.println("<td>");
  out.print("列名：");
  out.print(meta.getColumnName(i)+"<br>");
  out.print("类型：");
  out.print(typetoString(meta.getColumnType(i)));//检索并返回指定列的sql类型
  out.println("</td>");
 }
 out.println("<td>更改</td>");
 out.println("<td>删除</td>");
 out.println("</tr>");
 for(int iPage=1;iPage<PageSize+1;iPage++)
 { 
 out.print("<tr><td>"+rs.getString(1)+"</td>");
 out.print("<td>"+rs.getString(2)+"</td>");
 out.print("<td>"+rs.getString(3)+"</td>");
 out.print("<td>"+rs.getString(4)+"</td>");
 out.print("<td>"+rs.getString(5)+"</td>");
 out.print("<td>"+rs.getString(6)+"</td>");
 out.print("<td><a href=\"change.jsp?Xuehao="+rs.getString(1)+"\">修改</a></td>");
 out.print("<td><a href=\"del.jsp?Xuehao="+rs.getString(1)+"\">删除</a></td>");
 if(!rs.next()) break;
 }
 out.println("</table>");
 stmt.close();
 con.close();
%>

其中的typetoString（）函数的作用是转换得到sql相应的结果类型.如typetoString（1）的得到的结果伟integer

截图：

     扎堆实验室已经好几天了，一直在学习jsp,javascript来构建动态网站，还好自己有些java基础，也希望自己能一点一点慢慢的进步，以前一直不明白，页面的布局是怎么实现的，今天才明白原来是依靠一个一个<table>中的<td>镶嵌来实现的。今天终于弄明白了一件事就是：在一个jsp页面中显示另一个页面，原来是依靠<iframe>来实现的。

     自己现在知道的在一个jsp页面中嵌套另外一个jsp页面，有三种方法：

     1、通过<%@ include file="header.jsp"%>这种方法只能实现静态页面的加载，最常用是在一个项目中实现通用页头header.jsp和footer.jsp的加载。

     2、通过<%@ include="tt.jsp"%>这种做法可以实现动态页面的加载，但其需要向页面传递参数；

     3、通过<iframe src="jsp的路径">来向页面加载另一个jsp页面，是一个内联框架。

    

页面处理较仓促，未来的及美工，实例演示在一个jsp页面中嵌套另一个页面。

ps:最近越来越明白一个问题就是，编程学习，犹如逆水行舟，不进则退。上半年还写过自定义标签，现在却有点儿忘了，明天争取一天复习一下自定义标签。

 

 

abstract Java 关键字

abstract 关键字可以修改类或方法。

abstract 类可以扩展（增加子类），但不能直接实例化。

abstract 方法不在声明它的类中实现，但必须在某个子类中重写。

示例

 public abstract class MyClass
  {
  }
    public abstract String myMethod();

注释
采用 abstract 方法的类本来就是抽象类，并且必须声明为 abstract。

abstract 类不能实例化。

仅当 abstract 类的子类实现其超类的所有 abstract 方法时，才能实例化 abstract 类的子类。这种类称为具体类，以区别于 abstract 类。

如果 abstract 类的子类没有实现其超类的所有 abstract 方法，该子类也是 abstract 类。

abstract 关键字不能应用于 static、private 或 final 方法，因为这些方法不能被重写，因此，不能在子类中实现。

final 类的方法都不能是 abstract，因为 final 类不能有子类。



extends Java 关键字

extends 关键字用在 class 或 interface 声明中，用于指示所声明的类或接口是其名称后跟有 extends 关键字的类或接口的子类。

示例

  public class Rectangle extends Polygon
  {
  }

注释
在上例中，Rectangle 类继承 Polygon 类的所有 public 和 protected 变量和方法。

Rectangle 类可以重写 Polygon 类的任何非 final 方法。

一个类只能扩展一个其他类。


final Java 关键字

final 关键字可以应用于类，以指示不能扩展该类（不能有子类）。

final 关键字可以应用于方法，以指示不能重写任何子类中的方法。

示例

  public final class MyFinalClass
  {
  }
    public class MyClass
  {
     public final String myFinalMethod()
     {
        <statements>
     }
  }

注释
一个类不能同时是 abstract 又是 final。abstract 意味着必须扩展类，final 意味着不能扩展类。

一个方法不能同时是 abstract 又是 final。abstract 意味着必须重写方法，final 意味着不能重写方法。





finally Java 关键字

finally 关键字用来定义始终在 try-catch-finally 语句中执行的块。

finally 块通常包含清理代码，用在部分执行 try 块后恢复正常运行。

示例

try
  {
     <可能引发异常的块>
  }
  catch (<java.lang.Exception 或子类> e)
  {
     <处理异常 e 的代码>
  }
  finally
  {
     <有异常或无异常情况下都执行的语句>
  }

注释
开始和结束标记 { 和 } 是 finally 子句语法的一部分，即使该子句只包含一个语句，也不能省略这两个标记。

每个 try 块都必须至少有一个 catch 或 finally 子句。

如果执行 try 块的任何部分，不论是否出现异常，也不论 try 或 catch 块是否包含 return、continue 或 break 语句，都一定会执行 finally 块中的代码。

如果不出现异常，控件将跳过 try 块，进入 finally 块。

如果在执行 try 块期间出现异常，并且相应的 catch 块包含 break、continue 或 return 语句，控件将首先穿过 finally 块，之后再执行 break、continue 或 return。


implements Java 关键字

implements 关键字在 class 声明中使用，以指示所声明的类提供了在 implements 关键字后面的名称所指定的接口中所声明的所有方法的实现。

示例

 public class Truck implements IVehicle
  {
  }

注释
在上例中，Truck 类必须提供在 IVehicle 接口中所声明的所有方法的实现。

否则，Truck 类将是独立的；它可以声明其他方法和变量，并扩展另一个类。

一个类可以实现多个接口。




instanceof Java 关键字

instanceof 关键字用来确定对象所属的类。

示例

  if (node instanceof TreeNode)
  {
     <statements>
  }

注释
在上例中，如果 node 是 TreeNode 类的实例，或者是 TreeNode 的子类的实例，则 instanceof 表达式的值将为 true。



interface Java 关键字

interface 关键字用来声明新的 Java 接口，接口是方法的集合。

接口是 Java 语言的一项强大功能。任何类都可声明它实现一个或多个接口，这意味着它实现了在这些接口中所定义的所有方法。

示例

public interface IPolygon
  {
     public float getArea();
     public int getNumberOfSides();
     public int getCircumference();
  }

注释
实现了接口的任何类都必须提供在该接口中的所有方法的实现。

一个类可以实现多个接口。





static Java 关键字

static 关键字可以应用于内部类（在另一个类中定义的类）、方法或字段（类的成员变量）。

示例

public class MyPublicClass
  {
     public final static int MAX_OBJECTS = 100;
     static int _numObjects = 0;
     
     static class MyStaticClass
     {
     }
     
     static int getNumObjects()
     {
     }
  }

注释
通常，static 关键字意味着应用它的实体在声明该实体的类的任何特定实例外部可用。

static（内部）类可以被其他类实例化和引用（即使它是顶级类）。在上面的示例中，另一个类中的代码可以实例化 MyStaticClass 类，方法是用包含它的类名来限定其名称，如 MyClass.MyStaticClass。

static 字段（类的成员变量）在类的所有实例中只存在一次。

可以从类的外部调用 static 方法，而不用首先实例化该类。这样的引用始终包括类名作为方法调用的限定符。在上面的示例中，MyClass 类外部的代码以 MyClass.getNumObjects() 的形式调用 getNumObjects() static 方法。

模式：

public final static <type> varName = <value>;

通常用于声明可以在类的外部使用的类常量。在引用这样的类常量时需要用类名加以限定。在上面的示例中，另一个类可以用 MyClass.MAX_OBJECTS 形式来引用 MAX_OBJECTS 常量。





switch Java 关键字


switch 语句用于基于某个表达式选择执行多个代码块中的某一个。

示例

int arg = <some value>;
  switch (arg)
  {
     case 1:
        <statements>
        break;
     case 2:
        <statements>
        break;
     default:
        <statements>
        break;
  }
    char arg = <some value>;
  switch (arg)
  {
     case 'y':
     case 'Y':
        <statements>
        break;
     case 'n':
     case 'N':
        <statements>
        break;
     default:
        <statements>
        break;
  }

注释
switch 条件的计算结果必须等于 byte、char、short 或 int。

case 块没有隐式结束点。break 语句通常在每个 case 块末尾使用，用于退出 switch 语句。

如果没有 break 语句，执行流将进入所有后面的 case 和/或 default 块。



synchronized Java 关键字

synchronized 关键字可以应用于方法或语句块，并为一次只应由一个线程执行的关键代码段提供保护。

示例

public class MyClass
  {
     public synchronized static String mySyncStaticMethod()
     {
     }
     
     public synchronized String mySyncMethod()
     {
     }
  {
    public class MyOtherClass
  {
     Object someObj;
     
     public String myMethod()
     {
        <statements>
        synchronized (someObj)
        {
           <statements affecting someObj>
        }
     }
  }

注释
synchronized 关键字可防止代码的关键代码段一次被多个线程执行。

如果应用于静态方法（如上例中的 MySyncStaticMethod），那么，当该方法一次由一个线程执行时，整个类将被锁定。

如果应用于实例方法（如上例中的 MySyncMethod），那么，当该方法一次由一个线程访问时，该实例将被锁定。

如果应用于对象或数组，当关联的代码块一次由一个线程执行时，对象或数组将被锁定。





throw Java 关键字


throw 关键字用于引发异常。

示例

import java.io.IOException;
  
  public class MyClass
  {
     public method readFile(String filename) throws IOException
     {
        <statements>
        if (error)
        {
           throw new IOException("error reading file");
        }
     }
  }

注释
throw 语句将 java.lang.Throwable 作为参数。Throwable 在调用栈中向上传播，直到被适当的 catch 块捕获。

引发非 RuntimeException 异常的任何方法还必须在方法声明中使用 throws 修饰符来声明它引发的异常。



throws Java 关键字

throws 关键字可以应用于方法，以便指出方法引发了特定类型的异常。

示例

import java.io.IOException;
  
  public class MyClass
  {
     public method readFile(String filename) throws IOException
     {
        <statements>
        if (error)
        {
           throw new IOException("error reading file");
        }
     }
  }

注释
throws 关键字将逗号分隔的 java.lang.Throwables 列表作为参数。

引发非 RuntimeException 异常的任何方法还必须在方法声明中使用 throws 修饰符来声明它引发的异常。

要在 try-catch 块中包含带 throws 子句的方法的调用，必须提供该方法的调用者。





transient Java 关键字

transient 关键字可以应用于类的成员变量，以便指出该成员变量不应在包含它的类实例已序列化时被序列化。

示例

  public class MyClass
  {
     private transient String password;
  }

不知不觉在实验室已经待了两个星期多了，为了项目做准备，关于jsp用到的Bean类中怎样生成文件的绝对路径问题埋头苦读了两天，总算有点眉目，现在写出来与大家一起共享：）

思想是：通过jsp页面中获得绝对路径，然后传递给Bean类；关键代码如下：

 jsp中：

     <jsp:useBean id="splBean" class="xingzuo.XingZuoBean"/>

     。。。。。。。。。。。。。

     <body>
    <%
    String path=request.getRealPath("/");
    String text_path=path+"text";
    splBean.setText_path(text_path);

   %>

这样在javaBean中就可以通过text_path变量得到所要访问的文件：

javaBean中的代码如下：

    。。。。。。。   

    if((m==3&&d>=21)||(m==4&&d<=20))  {x="\\1.txt";y="img/1.gif";}

    。。。。。。。

    String p=text_path+x;
    InputStream is = new FileInputStream(p);

    。。。。。。。

这样就会把项目中的相对路径转化成绝对路径了：）不知道这个方法麻烦不，希望大家一起分享：）
   

今天把java，jsp.tomcat的相对路径和绝对路径研究了一下，脑袋都大了，付了。。。，还是不慎明了

1.tomcat中根目录是webpps/root/

 

在平静的生活中，我一步一脚印的走向我的目标。每天会过的很充实，但每天都有新的收获。