<%@ taglib uri="http://www.opensymphony.com/oscache" prefix="oscache" %>
<%
try{
session.invalidate();
}catch(Exception e){}
String scope = "application";
if (request.getParameter("scope") != null)
{
scope = request.getParameter("scope");
}
boolean refresh = false;
if (request.getParameter("refresh") != null)
{
refresh = true;
}
boolean forceCacheUse = false;
if (request.getParameter("forceCacheUse") != null)
{
forceCacheUse = true ;
}
%>
<oscache:cache duration="40s" refresh="<%= request.getParameter("refresh") == null ? false : true %>" scope="<%= scope %>">
// *****************************页面部分*********************************//
</oscache:cache>
posted @
2006-03-21 12:02 xnabx 阅读(159) |
评论 (0) |
编辑 收藏
如interface A{..}
这是你提供个某个部分的一个接口,然后
public class B implements A{...}
B是实现接口的一个类
A a=new B();
对象a的形式类型为A,实际指向一个B,可是你只能使用接口中已经规定的方法,以后你无论怎么修改B,都不会影响到其他部分对对象a的使用
这样可以实现多态,如果B和C都实现了接口A,那么我可以声明一个A的对象变量,而实际的实例可能是B也可能是C
多态----对同一个方法的调用，不同的实现类，有不同的响应结果
posted @
2006-03-21 09:26 xnabx 阅读(119) |
评论 (0) |
编辑 收藏
new String(str.getBytes("gbk"),"utf-8")
java中的字符串都是用unicode编码来表示的,GBK编码的汉字应该是从程序外面获得的(如数据库中,或文本文件中), 例如从本地文本文件1.txt以字节流方式读取,得到的字节数组buf就是以GBK编码的字节数组,然后用GBK解码成Unicode字符串str = new String(buf,"GBK"); 然后再编码成
UTF-8的字节数组str.getBytes("UTF-8"),这样才算真正的转换
posted @
2006-03-20 22:13 xnabx 阅读(1293) |
评论 (1) |
编辑 收藏问题：
<iframe name="I1" src="cs7.jsp" height="300" width="200"></iframe><br>
<iframe name="I2" id="I2" src="cs8.jsp" height="300" width="200">iframe>
如何把I1的值传到I2里的一个input里？
处理：
document.getElementById("I2").src="cs8.jsp?param=p"
然后再cs8.jsp中接受param值放到input中
posted @
2006-03-20 13:50 xnabx 阅读(331) |
评论 (0) |
编辑 收藏问题:
A.JSP如下:
……
<iframe src="B.jsp" id="B" frameborder="0" border="0"></iframe>
……
B.JSP如下，里面有一个C的JS方法
……
<script type="text/javascript">
function C()
{
}
</script>
……
请问如何在A.jsp里调用该C方法？
处理：
用b.document.script.c()
跨域脚本访问可能造成严重的安全问题。一些用户禁用了跨域脚本访问。
posted @
2006-03-20 13:43 xnabx 阅读(993) |
评论 (0) |
编辑 收藏问题：<html>
<iframe frameborder=0 width=600 height=50 marginheight=0 marginwidth=0 scrolling=no src="applytest.jsp" id="applytest"></iframe>
<FORM name="form1" METHOD="POST" ACTION="customer.do?command=addapplystudent" onsubmit="return check_data()">
<table>
<tr>
<TD align="left">姓名 </TD>
<td><input type="text" name="cname">
<font color="#FF0000">*</font>
</td>
</tr>
</table>
</html>
///////////////////////////////////////////////////////////
现在在Action里取到的学生所在地区的id总是空，我现在请教各位------怎么取到iframe中的某个参数的值？
处理：
可以通过iframe的id="applytest"来访问其页面的标签,如document.all.applytest.all.xxx来访问其中的名为xxx的标签.通过再在主页面设置hidden将其值拷贝一下就行.
posted @
2006-03-20 13:09 xnabx 阅读(1246) |
评论 (0) |
编辑 收藏问题一、
<table width="99%" border="0" align="center" cellpadding="0" cellspacing="0">
<tr>
<td colspan="2"><iframe frameborder=no
marginheight=0 marginwidth=0 name=schistory scrolling=no
src="frame2.htm" width=100%> </iframe></td>
</tr>
</table>
现在的问题是当frame2.htm显示的内容很长时,有些内容看不到;如何做到该网页随iframe中嵌入的网页内容长度自动出现滚动条,并且这滚动条不是出现在iframe中
处理：
你这个属于让iframe的子页面决定父页面的高度。
写javascript吧。
<script language="Javascript">
function window.onload()
{
parent.document.all("mainFrame").style.height=document.body.scrollHeight+670;
}
</script>
写在iframe调用的子页面里面
后面的670是父页面比子页面高的高度
问题二、如何动态控制IFrame的长和宽
主页面要放置一个IFrame用于嵌套显示子页面的信息，但是子页面的数据多少不一，导致子页面可能会很长或很短，要动态控制IFrame的高低随子页面的长短而变化。
主页面如下：
<HTML>
<HEAD>
<TITLE> New Document </TITLE>
</HEAD>
<BODY >
<TABLE>
<TR>
<TD>
<iframe id="frmTest" height="100px" name="frmTest" src="in.html"></iframe>
</TD>
</TR>
</TABLE>
</BODY>
</HTML>
子页面只需要做如下处理即可：
在页面的最下端添加如下JS脚本：
<script language=javascript>
window.parent.document.all("frmTest").style.height = document.body.scrollHeight + 10;
</script>
其中frmTest即为Main页面的IFrame的ID。
posted @
2006-03-20 13:03 xnabx 阅读(2384) |
评论 (3) |
编辑 收藏2.下面代码的输出是什么？一共在内存中生成了几个String对象？为什么？
String s1 = “aaa”;
String s2 = “aaa”;
String s3 = new String(“aaa”);
String s4 = new String(“AAA”);
System.out.println(s1 == s2);
System.out.println(s1 == s3);
System.out.println(s1.equals(s3));
3.下列程序在1处是否会有异常，如果没有，输出是什么？是否会运行到2处，如果会，输出是什么？为什么会有这样的结果？
public class TestClass {
public void test1() {
List list = new ArrayList();
test2(list);
System.out.println(list.size()); // 1处
test3(list);
System.out.println(list.size()); // 2处
}
public void test2(List list) {
list = null;
}
public void test3(List list) {
list.add(“aaaa”);
}
}
4.请选出下面哪些描述是正确的。
public class ClassA {
public synchronized void a(){
}
public synchronized void b(){
}
}
2 instances of ClassA had been instantiated obj1 and obj2.
Which statements about thread are true?
1)One thread is calling obj1.a(), another thread can call obj1.b(). .
2)One thread is calling obj1.a(), another thread cannot call obj1.b().
3)One thread is calling obj1.a(), another thread can call obj2.b(). .
4)One thread is calling obj1.a(), another thread cannot call obj2.b().
5.下面的程序输出是什么？为什么？
public class Parent {
public void test(ArrayList list) {
System.out.println("invoke parent's test method");
}
public static void main(String[] args) {
Child a = new Child();
ArrayList list = new ArrayList();
a.test(list);
}
}
class Child extends Parent {
public void test(List list) {
System.out.println("invoke child's test method");
}
}
6.下面的程序输出是什么？为什么？
public class Parent {
public void test(List list) {
System.out.println("invoke parent's test method");
}
public static void main(String[] args) {
Child a = new Child();
ArrayList list = new ArrayList();
a.test(list);
}
}
class Child extends Parent {
public void test(List list) {
System.out.println("invoke child's test method");
}
}
7.仔细分析下面的程序，写出程序的输出结果。
public class Parent {
{
System.out.println("parent instance block");
}
public void test() {
System.out.println("parent test method");
}
static {
System.out.println("parent static block");
}
public Parent() {
System.out.println("parent constructor");
test();
}
public static void main(String[] args) {
new Child();
}
}
class Child extends Parent {
private static int staticValue = 20;
private int instanceValue = 20;
{
System.out.println("child instance block");
}
public void test() {
System.out.println("child test method");
System.out.println("static value is: " + staticValue);
System.out.println("instance value is: " + instanceValue);
}
static {
System.out.println("child static block");
}
public Child() {
System.out.println("child constructor");
}
}
8.下面程序的输出是什么？
public class TestException {
public void test1() {
int result = test2();
System.out.println(result);
}
public int test2() {
try{
String s = null;
s.substring(0, 1);
return 1;
} catch(Exception e) {
return 2;
} finally {
return 3;
}
}
public static void main(String[] args) {
(new TestException()).test1();
}
}
9.请写出数据库查询操作的伪代码，程序不需要通过编译，只要思路正确，关键步骤不丢失就可以了。注意异常的捕获，IO流的关闭。可能用到的类或接口有（Connection，DriverManager, Statement, PreparedStatement, ResultSet, SQLException）。
posted @
2006-03-19 23:12 xnabx 阅读(144) |
评论 (0) |
编辑 收藏
5.1.1·介绍
什么是异常？在Java编程语言中，异常类定义程序中可能遇到的轻微
的错误条件。可以写代码来处理异常并继续程序执行，而不是让程序
中断。在程序执行中，任何中断正常程序流程的异常条件就是错误或
]异常。例如，发生下列情况时，会出现异常：
- 想打开的文件不存在
- 网络连接中断
- 受控操作数超出预定范围
- 非常感兴趣地正在装载的类文件丢失
在Java编程语言中，错误类定义被认为是不能恢复的严重错误条件。在
大多数情况下，当遇到这样的错误时，建议让程序中断。Java编程语言
实现C++异常来帮助建立弹性代码。在程序中发生错误时，发现错误的
方法能抛出一个异常到其调用程序，发出已经发生问题的信号。然后，
调用方法捕获抛出的异常，在可能时，再恢复回来。这个方案给程序员
一个写处理程序的选择，来处理异常。通过浏览API，可以决定方法抛出
的是什么样的异常。
5.1.2·实例
考虑一下HelloWorld.java程序版本的简单扩展，它通过信息来循环：
1. public class HelloWorld {
2. public static void main (String args[]) {
3. int i = 0;
4.
5. String greetings [] = {
6. "Hello world!",
7. "No, I mean it!",
8. "HELLO WORLD!!"
9. };
10.
11. while (i < 4) {
12. System.out.println (greetings[i]);
13. i++;
14. }
15. }
16. }
正常情况下，当异常被抛出时，在其循环被执行四次之后，程序终止，并带有
错误信息，就象前面所示的程序那样。
1. c:\student\> java HelloWorld
2. Hello world!
3. No, I mean it!
4. HELLO WORLD!!
5. java.lang.ArrayIndexOutOfBoundsException: 3
6. at HelloWorld.main(HelloWorld.java:12)
异常处理允许程序捕获异常，处理它们，然后继续程序执行。它是分层把关，
因此，错误情况不会介入到程序的正常流程中。特殊情况发生时，在与正常
执行的代码分离的代码块中被处理。这就产生了更易识别和管理的代码。
5.2·异常处理
Java编程语言提供了一个来考虑哪个异常被抛出以及如何来恢复它的机制。
·try和catch语句
要处理特殊的异常，将能够抛出异常的代码放入try块中，然后创建相应的
catch块的列表，每个可以被抛出异常都有一个。如果生成的异常与catch
中提到的相匹配，那么catch条件的块语句就被执行。在try块之后，可能
有许多catch块，每一个都处理不同的异常。
1. try {
2. // code that might throw a particular exception
3. } catch (MyExceptionType e) {
4. // code to execute if a MyExceptionType exception is thrown
5. } catch (Exception e) {
6. // code to execute if a general Exception exception is thrown
7. }
5.2.1·调用栈机制
如果方法中的一个语句抛出一个没有在相应的try/catch块中处理的异常，
那么这个异常就被抛出到调用方法中。如果异常也没有在调用方法中被处理，
它就被抛出到该方法的调用程序。这个过程要一直延续到异常被处理。
如果异常到这时还没被处理，它便回到main()，而且，即使main()不处理它，
那么，该异常就异常地中断程序。考虑这样一种情况，在该情况中main()
方法调用另一个方法（比如，first()），然后它调用另一个
（比如，second()）。如果在second()中发生异常，那么必须做一个检查
来看看该异常是否有一个catch；如果没有，那么对调用栈（first()）中的
下一个方法进行检查，然后检查下一个（main()）。如果这个异常在该
调用栈上没有被最后一个方法处理，那么就会发生一个运行时错误，
程序终止执行。
5.2.2·finally语句
finally语句定义一个总是执行的代码块，而不考虑异常是否被捕获。
下述样板代码来自Frank Yellin弗兰克叶林的白皮书《Java中的低级安全》：
1. try {
2. startFaucet();
3. waterLawn();
4. }
5. finally {
6. stopFaucet();
7. }
在前面的例子中，即使异常在打开开关或给草地浇水时发生，开关也能被关掉。
try 后面的括号中的代码被称做保护码。如果终止程序的System.exit()
方法在保护码内被执行，那么，这是finally语句不被执行的唯一情况。
这就暗示，控制流程能偏离正常执行顺序，比如，如果一个return语句
被嵌入try块内的代码中，那么，finally块中的代码应在return前执行。
5.2.3·重访前例
下面的例子是第169页main()方法的重写。本程序以前的版本中产生的
异常被捕获，数组索引重新设定，使下述程序继续运行。
1. public static void main (String args[]) {
2. int i = 0;
3. String greetings [] = {
4. "Hello world!",
5. "No, I mean it!",
6. "HELLO WORLD!!"
7. };
8. while (i < 4) {
9. try {
10. System.out.println (greetings[i]);
11. } catch (ArrayIndexOutOfBoundsException e){
12. System.out.println( "Re-setting Index Value");
13. i = -1;
14. } finally {
15. System.out.println("This is always printed");
16. }
17. i++;
18. } // end while()
19. } // end main()
当循环被执行时，下述在屏幕上出现的信息将改变。
1. Hello world!
2. This is always printed
3. No, I mean it!
4. This is always printed
5. HELLO WORLD!!
6. This is always printed
7. Re-setting Index Value
8. This is always printed
5.3·异常分类
在Java编程语言中，异常有三种分类。Java.lang.Throwable类充当所有
对象的父类，可以使用异常处理机制将这些对象抛出并捕获。在Throwable
类中定义方法来检索与异常相关的错误信息，并打印显示异常发生的栈
跟踪信息。它有Error和Exception两个基本子类.
Throwable类不能使用，而使用子类异常中的一个来描述任何特殊异常。
每个异常的目的描述如下：
- Error表示恢复不是不可能但很困难的情况下的一种严重问题。比如说
内存溢出。不可能指望程序能处理这样的情况。
- RuntimeException表示一种设计或实现问题。也就是说，它表示如果
程序运行正常，从不会发生的情况。比如，如果数组索引扩展不超出
数组界限，那么，ArrayIndexOutOfBoundsException异常从不会抛出。
比如，这也适用于取消引用一个空值对象变量。因为一个正确设计和
实现的程序从不出现这种异常，通常对它不做处理。这会导致一个
运行时信息，应确保能采取措施更正问题，而不是将它藏到谁也不
注意的地方。
- 其它异常表示一种运行时的困难，它通常由环境效果引起，可以进行
处理。例子包括文件未找到或无效URL异常（用户打了一个错误的URL），
如果用户误打了什么东西，两者都容易出现。这两者都可能因为用户
错误而出现，这就鼓励程序员去处理它们。
5.4·共同异常
Java编程语言提供几种预定义的异常。下面是可能遇到的更具共同性的
异常中的几种：
- ArithmeticException—整数被0除，运算得出的结果。
- int I =12 / 0；
- NullPointerException—当对象没被实例化时，访问对象的属性或
方法的尝试：
- Date d= null;
- System.out.println(d.toString());
- NegativeArraySizeException—创建带负维数大小的数组的尝试。
- ArrayIndexoutofBoundsException—访问超过数组大小范围的一个元
素的尝试。
- SecurityException—典型地被抛出到浏览器中，SecurityManager类将
抛出applets的一个异常，该异常企图做下述工作（除非明显地得到允许）：
- 访问一个本地文件
- 打开主机的一个socket，这个主机与服务于applet的主机不是同一个。
- 在运行时环境中执行另一个程序
5.5·处理或声明规则
为了写出健壮的代码，Java编程语言要求，当一个方法在栈（即，它已经被
调用）上发生Exception（它与Error或RuntimeException不同）时，那么，
该方法必须决定如果出现问题该采取什么措施。程序员可以做满足该要求
的两件事：
第一，通过将Try｛｝catch（）｛｝块纳入其代码中，在这里捕获给被
命名为属于某个超类的异常，并调用方法处理它。即使catch块是空的，
这也算是处理情况。
第二，让被调用的方法表示它将不处理异常，而且该异常将被抛回到它所
遇到的调用方法中。它是按如下所示通过用throws子句标记的该调用方法
的声明来实现的： public void troublesome() throws IOException
关键字throws之后是所有异常的列表，方法可以抛回到它的调用程序中。
尽管这里只显示了一个异常，如果有成倍的可能的异常可以通过该方法
被抛出，那么，可以使用逗号分开的列表。
是选择处理还是选择声明一个异常取决于是否给你自己或你的调用程序一个
更合适的候选的办法来处理异常。注—由于异常类象其它类一样被组编到
层次中，而且由于无论何时想要使用超类都必须使用子类， 因此，可以
捕获异常“组”并以相同的捕获代码来处理它们。例如，尽管
IOExceptions（EOFException,FileNotFoundException等等）
有几种不同的类型，通过俘获IOException，也可以捕获
IOException任何子类的实例。
5.6·创建自己的异常
5.6.1·介绍
用户定义异常是通过扩展Exception类来创建的。这种异常类可以包含
一个“普通”类所包含的任何东西。下面就是一个用户定义异常类例子，
它包含一个构造函数、几个变量以及方法：
1. public class ServerTimedOutException extends Exception {
2. private String reason;
3. private int port;
4. public ServerTimedOutException (String reason,int port){
5. this.reason = reason;
6. this.port = port;
7. }
8. public String getReason() {
9. return reason;
10. }
11. public int getPort() {
12. return port;
13. }
14. }
使用语句来抛出已经创建的异常：
throw new ServerTimedOutException
("Could not connect", 80);
5.6.2·实例
考虑一个客户服务器程序。在客户代码中，要与服务器连接，并希望
服务器在5秒钟内响应。如果服务器没有响应，那么，代码就如下所述
抛出一个异常（如一个用户定义的ServerTimedOutException）。
1. public void connectMe(String serverName) throws
ServerTimedOutException {
2. int success;
3. int portToConnect = 80;
4. success = open(serverName, portToConnect);
5. if (success == -1) {
6. throw new ServerTimedOutException(
7. "Could not connect", 80);
8. }
9. }
要捕获异常，使用try语句：
1. public void findServer() {
2. . . .
3. try {
4. connectMe(defaultServer);
5. } catch(ServerTimedOutException e) {
6. System.out.println("Server timed out, trying alternate");
7. try {
8. connectMe(alternateServer);
9. } catch (ServerTimedOutException e1) {
10. System.out.println("No server currently available");
11. }
12. }
13. .. .
注—try和catch块可以如前例所述那样被嵌套。
也可能部分地处理一个异常然后也将它抛出。如：
try {
.....
.....
} catch (ServerTimedOutException e) {
System.out.println("Error caught ");
throw e;
}
|
posted @
2006-03-19 22:56 xnabx 阅读(235) |
评论 (0) |
编辑 收藏
private static void getMaxdays(int year,int mon){
Calendar ca = Calendar.getInstance();
ca.clear();
ca.set(Calendar.YEAR,year);
ca.set(Calendar.MONTH,mon+1);
int max = ca.getActualMaximum(Calendar.DAY_OF_MONTH);
System.out.println(max);
}
posted @
2006-03-19 22:48 xnabx 阅读(313) |
评论 (0) |
编辑 收藏