测试脚本

测试脚本

Java内部类的分析和整理

package test.jdk;

/**
* 内部类的收集与整理
*
* @author 赵学庆 www.java2000.net
*/
public class InnerTest {
private String instAtt = "实例变量";

private static String staticAtt = "静态变量";

public void test() {
int methodAtt = 1;
final int methodFinalAtt = 2;
// 非静态方法里的内部类
class staticMethodInnerClass {
@Override
public String toString() {
// 非静态方法里无法访问实例的外部变量
System.out.println("非静态方法的内部类可以访问外部类的实例变量：" + instAtt);
System.out.println("非静态方法的内部类可以访问外部类的静态变量：" + staticAtt);
// 非静态方法里无法访问方法的非final的变量
// System.out.println(methodAtt);
System.out.println("非静态方法的内部类可以访问方法的final变量：" + methodFinalAtt);
return "my nickname is white";
}
}
new staticMethodInnerClass().toString();
new Object() {
@Override
public String toString() {
System.out.println("非静态方法的匿名内部类可以访问外部类的实例变量：" + instAtt);
System.out.println("非静态方法的匿名内部类可以访问外部类的静态变量：" + staticAtt);
// 静态方法里匿名内部类无法访问方法的非final的变量
// System.out.println(methodAtt);
System.out.println("非静态方法的匿名内部类可以访问方法的final变量：" + methodFinalAtt);
return "我是匿名内部类";
}
}.toString();
}

public static void main(String blackbat[]) {
int methodAtt = 1;
final int methodFinalAtt = 2;
// 静态方法里的内部类
class staticMethodInnerClass {
@Override
public String toString() {
// 静态方法里无法访问实例的外部变量
// System.out.println(instAtt);
System.out.println("静态方法的内部类可以访问外部类的静态变量：" + staticAtt);
// 静态方法里无法访问方法的非final的变量
// System.out.println(methodAtt);
System.out.println("静态方法的内部类可以访问方法的final变量：" + methodFinalAtt);
return "my nickname is white";
}
}
new staticMethodInnerClass().toString();
new Object() {
@Override
public String toString() {
// 静态方法的匿名内部类不能访问外部类的非静态变量
// System.out.println("非静态方法的匿名内部类可以访问外部类的非静态变量：" + instAtt);
System.out.println("非静态方法的匿名内部类可以访问外部类的静态变量：" + staticAtt);
// 静态方法里匿名内部类无法访问方法的非final的变量
// System.out.println(methodAtt);
System.out.println("非静态方法的匿名内部类可以访问方法的final变量：" + methodFinalAtt);
return "我是匿名内部类";
}
}.toString();
new InnerTest().test();
// 建立静态内部类(static Inner Class)的对象
ImOutClass.StaticInnerClass staticIC = new ImOutClass.StaticInnerClass();
staticIC.access();
/*
* 建立非静态内部类(non-static Inner Class)的对象.
注意这种建立对象的格式 首先创建外部类的对象 然后使用对象.new 来创建。
*/
ImOutClass outC = new ImOutClass();
ImOutClass.InstInnerClass inC = outC.new InstInnerClass();
inC.access();
}
}

class ImOutClass {
private static String staticAtt = " 外部类的类变量 ";

private String instAtt = " 外部类的实例变量 ";

private static String xx = "外部静态变量";

// private String xx = "外部类的实例变量";
// 外部类的非静态方法
public void instanMethod() {
System.out.println(" 和外部类实例方法 ");
}

// 外部类的静态方法
public static void staticMethod() {
System.out.println(" 和外部类静态方法 ");
}

// 静态内部类(static Inner Class)
public static class StaticInnerClass {
public StaticInnerClass() {
System.out.println(" 我是静态内部类 ");
}

public void access() {
System.out.println(" 我可以访问 " + staticAtt);
staticMethod();
System.out.println(" 我可以访问外部的静态变量 " + xx);
// 非静态的方法 instanMethod() 无法从静态的地方使用
// instanMethod();
}
}

// 非静态内部类(non-static Inner Class)
public class InstInnerClass {
public InstInnerClass() {
System.out.println(" 我是成员级内部类，非静态内部类 ");
}

public void access() {
System.out.println(" 我可以访问 " + instAtt);
instanMethod();
staticMethod();
System.out.println(" 我可以访问外部的静态变量 " + xx);
}
}
}

运行结果为

静态方法的内部类可以访问外部类的静态变量：静态变量
静态方法的内部类可以访问方法的final变量：2
非静态方法的匿名内部类可以访问外部类的静态变量：静态变量
非静态方法的匿名内部类可以访问方法的final变量：2
非静态方法的内部类可以访问外部类的实例变量：实例变量
非静态方法的内部类可以访问外部类的静态变量：静态变量
非静态方法的内部类可以访问方法的final变量：2
非静态方法的匿名内部类可以访问外部类的实例变量：实例变量
非静态方法的匿名内部类可以访问外部类的静态变量：静态变量
非静态方法的匿名内部类可以访问方法的final变量：2
我是静态内部类
我可以访问 外部类的类变量
和外部类静态方法
我可以访问外部的静态变量 外部静态变量
我是成员级内部类，非静态内部类
我可以访问 外部类的实例变量
和外部类实例方法
和外部类静态方法
我可以访问外部的静态变量 外部静态变量

关于Hibernate3.2的count返回值的问题

@Override
public int countAllSubject() {
Session session = HibernateUtil.getSessionFactory().getCurrentSession();
session.beginTransaction();
return ((Long) session.createQuery(
"select count(*) from Post where idParent=0").iterate().next())
.intValue();
}

问题关键在那个
(Long)
在我的机器上运行正常,可在一些网友的机器上运行报错
java.lang.ClassCastException: java.lang.Integer

他们修改成(Integer)则运行正常

我的机器上如果改成Integer,则会报错。

java.lang.ClassCastException: java.lang.Long cannot be cast to java.lang.Integer


经排查，最终确定：

由于我使用的是Hibernate 3.2版本，经确认，这个版本已经把以前返回 Integer的改成了 Long,
因为JPA里面的返回值规定是Long, Hibernate为了兼容这个，所以修改了返回值。

如果你从Hibernate 3.0.x/3.1.x升级到最新的3.2版，一定要注意，3.2版的很多sql函数如count(), sum()的唯一返回值已经从Integer变为Long，如果不升级代码，会得到一个ClassCastException。

这个变化主要是为了兼容JPA，可以在hibernate.org的最新文档中找到说明。

Hibernate Team也提供了一个与原来兼容的解决方案：

Configuration classicCfg = new Configuration();
classicCfg.addSqlFunction( "count", new ClassicCountFunction());
classicCfg.addSqlFunction( "avg", new ClassicAvgFunction());
classicCfg.addSqlFunction( "sum", new ClassicSumFunction());
SessionFactory classicSf = classicCfg.buildSessionFactory();

jsp:include 装载动态页面的问题

提问:
<%
String id="01";//从数据库中获取，非固定值
%>


为什么include中取不到id的值？
如何在根据id的变化，include不同的页面？

解答：
在外面把整个字符串生成了，在放到page里面，不要再page里面再次合成了。

<%
String id = "01";
String pageURL = "hello" + id;
%>


结论：
在许多标签里面，再次嵌套jsp表达式是不行的，不要再里面再次运算了。

JAVA通过Session和Cookie实现网站自动登录的技术

本方案为我这个站点当前使用的，能用，但不保证是最先进的。
原文：http://www.java2000.net/p1010

第一步，登陆的时候一旦选择了[自动登录]的选项，则需要在登陆成功后，附加下面的代码
应为一般网站都提供保存用户名的功能，所以我把这个写到了外面。只有密码是单独处理的。
其中的host就是你的域名
login.jsp
String host = request.getServerName();
Cookie cookie = new Cookie("SESSION_LOGIN_USERNAME", username); // 保存用户名到Cookie
cookie.setPath("/");
cookie.setDomain(host);
cookie.setMaxAge(99999999);
response.addCookie(cookie);
if (ParamUtils.getBooleanParameter(request, "savePassword")) {
// 保存密码到Cookie，注意需要加密一下
cookie = new Cookie("SESSION_LOGIN_PASSWORD", MD5.encode(u.getPassword()));
cookie.setPath("/");
cookie.setDomain(host);
cookie.setMaxAge(99999999);
response.addCookie(cookie);
}

这样，Cookie就生成了
第二步，在用户访问网站的时候，如果检测到没有登陆，则进行下面的判断。
index.jsp
String usernameCookie = null;
String passwordCookie = null;
Cookie[] cookies = request.getCookies();
if (cookies != null) {
for (Cookie cookie : cookies) {
if ("SESSION_LOGIN_USERNAME".equals(cookie.getName())) {
usernameCookie = cookie.getValue(); // 得到cookie的用户名
}
if ("SESSION_LOGIN_PASSWORD".equals(cookie.getName())) {
passwordCookie = cookie.getValue(); // 得到cookie的密码
}
}
if (usernameCookie != null && passwordCookie != null) { // 如果存在
if(Login.checkLogin(usernameCookie ,passwordCookie)){
// 登陆成功的处理
}else{
// 登陆不成功的处理
}
}
}

一段注册码生成程序，有剪贴板操作

import java.io.*;
import java.text.*;
import java.util.Calendar;
import java.awt.datatransfer.*;

public class T {
private void go() throws Exception {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
System.out.println("XXXclipse Cracker");
System.out.print("Please Input User ID:");
String userId = br.readLine();
if (userId.length() == 0)
return;
String serialString = getSerial(userId, "200");
System.out.println("Serial Code:" + serialString);
java.awt.Toolkit.getDefaultToolkit().getSystemClipboard().setContents(
new StringSelection(serialString), null);
System.out
.println("Note:The serial code has succefully copied into clipboard!\nPress 'Enter' to exit...");
br.readLine();
}

public static void main(String args[]) throws Exception {
new T().go();
}

public String getSerial(String userId, String licenseNum) {
Calendar cal = Calendar.getInstance();
cal.add(1, 3);
cal.add(6, -1);
NumberFormat nf = new DecimalFormat("000");
licenseNum = nf.format(Integer.valueOf(licenseNum));
String verTime = (new StringBuilder("-")).append(
(new SimpleDateFormat("yyMMdd")).format(cal.getTime())).append("0").toString();
String type = "YE3MP-";
String need = (new StringBuilder(userId.substring(0, 1))).append(type).append("300").append(
licenseNum).append(verTime).toString();
String dx = (new StringBuilder(need))
.append(
"Decompiling this copyrighted software is a violation of both your license agreement and the Digital Millenium Copyright Act of 1998 (http://www.loc.gov/copyright/legislation/dmca.pdf). Under section 1204 of the DMCA, penalties range up to a $500,000 fine or up to five years imprisonment for a first offense. Think about it; pay for a license, avoid prosecution, and feel better about yourself.")
.append(userId).toString();
int suf = decode(dx);
String code = (new StringBuilder(need)).append(String.valueOf(suf)).toString();
return change(code);
}

private int decode(String s) {
int i = 0;
char ac[] = s.toCharArray();
int j = 0;
for (int k = ac.length; j < k; j++)
i = 31 * i + ac[j];
return Math.abs(i);
}

private String change(String s) {
byte abyte0[] = s.getBytes();
char ac[] = new char[s.length()];
int i = 0;
for (int k = abyte0.length; i < k; i++) {
int j = abyte0[i];
if (j >= 48 && j <= 57)
j = ((j - 48) + 5) % 10 + 48;
else if (j >= 65 && j <= 90)
j = ((j - 65) + 13) % 26 + 65;
else if (j >= 97 && j <= 122)
j = ((j - 97) + 13) % 26 + 97;
ac[i] = (char) j;
}
return String.valueOf(ac);
}
}

公交换乘算法(本人并未验证)

/**
* 公交换乘一站的算法思想：
* （注意：车次信息、站点信息、公交信息是等价的都是以HashMap的形式存储信息）
* 1.从数据库中获得所有公交信息存储到ArrayList，每个具体信息的元数据有三个：
* 公交车次、公交站点、该公交站点距离该公交车次的始发站点的站数，具体信息用HashMap保存
* 2.然后把公交信息数据进行结构化，把所有公交站点抽出，再把每一个站点对应的所有车次抽出
* 与其一一对应，单一的车次信息用HashMap存储，站点对应的所有车次信息用ArrayList存储，
* 所有的站点有经过站点的车次信息用HashMap存储
* 3.根据查询要求，分别从结构化以后的公交信息数据中找到，经过出发地的所有车次，经过目的地
* 的所有车次，然后在分别遍历每个车次，筛选出符合要求的中转站点，筛选规则是：每查询出一个
* 站点时，得到该站点距离该站点对应车次的始发站的站数，如果这个站数小于查询站点距离该车次的始
* 发站的站数，那么就符合规则，便把该站点信息保存到符合站点的ArrayList中，反之亦然
* 4.分别得到查询条件中出发地和目的地的中转站点信息（中转站点信息存储在ArrayList中），然
* 后遍历两个中转站点信息的集合，得到最终的具体中转信息（最终中转信息也是用ArrayList存储）
*/
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.HashMap;
import java.util.Map;

public class T {
private String start = null;// 出发地

private String whither = null;// 目标地

private List schedule = null;// 用于缓存列车时刻表。

private HashMap stationsOfLine = null; // 所有公交线路，每个list存储该线路经过的所有车站。

private HashMap linesOfStation = null;// 所有车站，每个list中存储通过该车站的所有车次。

// private ArrayList startLine = new ArrayList ();//
// 途经出发地的所有车次。
// private ArrayList whitherLine = new ArrayList ();//
// 途经目的地的所有车次。
private ArrayList