少年阿宾

那些青春的岁月

:: 管理

500 Posts :: 0 Stories :: 135 Comments :: 0 Trackbacks

内部类是指在一个外部类的内部再定义一个类。内部类作为外部类的一个成员，并且依附于外部类而存在的。内部类可为静态，可用protected和private修饰（而外部类只能使用public和缺省的包访问权限）。内部类主要有以下几类：成员内部类、局部内部类、静态内部类、匿名内部类

　　为什么需要内部类？

　　典型的情况是，内部类继承自某个类或实现某个接口，内部类的代码操作创建其的外围类的对象。所以你可以认为内部类提供了某种进入其外围类的窗口。使用内部类最吸引人的原因是：

　　每个内部类都能独立地继承自一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。如果没有内部类提供的可以继承多个具体的或抽象的类的能力，一些设计与编程问题就很难解决。从这个角度看，内部类使得多重继承的解决方案变得完整。接口解决了部分问题，而内部类有效地实现了“多重继承”。

　　A：成员内部类

　　作为外部类的一个成员存在，与外部类的属性、方法并列。

publicclass Outer {
privatestaticinti = 1;
privateintj = 10;
privateintk = 20;

publicstaticvoidouter_f1() {
}

publicvoidouter_f2() {
}

// 成员内部类中，不能定义静态成员
// 成员内部类中，可以访问外部类的所有成员
class Inner {
// static int inner_i = 100; //内部类中不允许定义静态变量
intj = 100; // 内部类和外部类的实例变量可以共存
intinner_i = 1;

void inner_f1() {
System.out.println(i);
//在内部类中访问内部类自己的变量直接用变量名
System.out.println(j);
//在内部类中访问内部类自己的变量也可以用this.变量名
System.out.println(this.j);
//在内部类中访问外部类中与内部类同名的实例变量用外部类名.this.变量名
System.out.println(Outer.this.j);
//如果内部类中没有与外部类同名的变量，则可以直接用变量名访问外部类变量
System.out.println(k);
outer_f1();
outer_f2();
}
}

//外部类的非静态方法访问成员内部类
publicvoidouter_f3() {
Inner inner = new Inner();
inner.inner_f1();
}

// 外部类的静态方法访问成员内部类，与在外部类外部访问成员内部类一样
publicstaticvoidouter_f4() {
//step1 建立外部类对象
Outer out = new Outer();
//step2 根据外部类对象建立内部类对象
Inner inner = out.new Inner();
//step3 访问内部类的方法
inner.inner_f1();
}

publicstaticvoid main(String[] args) {
//outer_f4(); //该语句的输出结果和下面三条语句的输出结果一样
//如果要直接创建内部类的对象，不能想当然地认为只需加上外围类Outer的名字，
//就可以按照通常的样子生成内部类的对象，而是必须使用此外围类的一个对象来
//创建其内部类的一个对象：
//Outer.Inner outin = out.new Inner()
//因此，除非你已经有了外围类的一个对象，否则不可能生成内部类的对象。因为此
//内部类的对象会悄悄地链接到创建它的外围类的对象。如果你用的是静态的内部类，
//那就不需要对其外围类对象的引用。
Outer out = new Outer();
Outer.Inner outin = out.new Inner();
outin.inner_f1();
}
}

　　注意：内部类是一个编译时的概念，一旦编译成功，就会成为完全不同的两类。对于一个名为outer的外部类和其内部定义的名为inner的内部类。编译完成后出现outer.class和outer$inner.class两类。

　　B:局部内部类

　　在方法中定义的内部类称为局部内部类。与局部变量类似，局部内部类不能有访问说明符，因为它不是外围类的一部分，但是它可以访问当前代码块内的常量，和此外围类所有的成员。

publicclass Outer {
privateints = 100;
privateintout_i = 1;

publicvoid f(finalint k) {
finalint s = 200;
int i = 1;
finalint j = 10;

//定义在方法内部
class Inner {
ints = 300; // 可以定义与外部类同名的变量

// static int m = 20; //不可以定义静态变量
Inner(int k) {
inner_f(k);
}

intinner_i = 100;

voidinner_f(int k) {
//如果内部类没有与外部类同名的变量，在内部类中可以直接访问外部类的实例变量
System.out.println(out_i);
//可以访问外部类的局部变量(即方法内的变量)，但是变量必须是final的
System.out.println(j);
//System.out.println(i);
//如果内部类中有与外部类同名的变量，直接用变量名访问的是内部类的变量
System.out.println(s);
//用this.变量名访问的也是内部类变量
System.out.println(this.s);
//用外部类名.this.内部类变量名访问的是外部类变量
System.out.println(Outer.this.s);
}
}
new Inner(k);
}

publicstaticvoid main(String[] args) {
// 访问局部内部类必须先有外部类对象
Outer out = new Outer();
out.f(3);
}
}

　　C：静态内部类(嵌套类)：（注意：前两种内部类与变量类似，所以可以对照参考变量）

　　如果你不需要内部类对象与其外围类对象之间有联系，那你可以将内部类声明为static。这通常称为嵌套类（nested class）。想要理解static应用于内部类时的含义，你就必须记住，普通的内部类对象隐含地保存了一个引用，指向创建它的外围类对象。然而，当内部类是static的时，就不是这样了。嵌套类意味着：

　　1. 要创建嵌套类的对象，并不需要其外围类的对象。
　　2. 不能从嵌套类的对象中访问非静态的外围类对象。

publicclass Outer {
privatestaticinti = 1;
privateintj = 10;
publicstaticvoidouter_f1() {
}

publicvoidouter_f2() {
}

// 静态内部类可以用public,protected,private修饰
// 静态内部类中可以定义静态或者非静态的成员
staticclass Inner {
staticintinner_i = 100;
intinner_j = 200;
staticvoidinner_f1() {
//静态内部类只能访问外部类的静态成员(包括静态变量和静态方法)
System.out.println("Outer.i" + i);
outer_f1();
}

voidinner_f2() {
// 静态内部类不能访问外部类的非静态成员(包括非静态变量和非静态方法)
// System.out.println("Outer.i"+j);
// outer_f2();
}
}

publicvoidouter_f3() {
// 外部类访问内部类的静态成员：内部类.静态成员
System.out.println(Inner.inner_i);
Inner.inner_f1();
// 外部类访问内部类的非静态成员:实例化内部类即可
Inner inner = new Inner();
inner.inner_f2();
}

publicstaticvoid main(String[] args) {
newOuter().outer_f3();
}
}

　　生成一个静态内部类不需要外部类成员：这是静态内部类和成员内部类的区别。静态内部类的对象可以直接生成：Outer.Inner in = new Outer.Inner(); 而不需要通过生成外部类对象来生成。这样实际上使静态内部类成为了一个顶级类(正常情况下，你不能在接口内部放置任何代码，但嵌套类可以作为接口的一部分，因为它是static 的。只是将嵌套类置于接口的命名空间内，这并不违反接口的规则）

　　D：匿名内部类(from thinking in java 3th)

　　简单地说：匿名内部类就是没有名字的内部类。什么情况下需要使用匿名内部类？如果满足下面的一些条件，使用匿名内部类是比较合适的：

　　·只用到类的一个实例。
　　·类在定义后马上用到。
　　·类非常小（SUN推荐是在4行代码以下）
　　·给类命名并不会导致你的代码更容易被理解。
　　在使用匿名内部类时，要记住以下几个原则：
　　·匿名内部类不能有构造方法。
　　·匿名内部类不能定义任何静态成员、方法和类。
　　·匿名内部类不能是public,protected,private,static。
　　·只能创建匿名内部类的一个实例。
·一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类。
　　·因匿名内部类为局部内部类，所以局部内部类的所有限制都对其生效。

　　下面的例子看起来有点奇怪：

//在方法中返回一个匿名内部类
public class Parcel6 {
public Contents cont() {
return new Contents() {
private int i = 11;

public int value() {
return i;
}
}; // 在这里需要一个分号
}

public static void main(String[] args) {
Parcel6 p = new Parcel6();
Contents c = p.cont();
}
}

　　cont()方法将下面两个动作合并在一起：返回值的生成，与表示这个返回值的类的定义！进一步说，这个类是匿名的，它没有名字。更糟的是，看起来是你正要创建一个Contents对象：

return new Contents()

　　但是，在到达语句结束的分号之前，你却说：“等一等，我想在这里插入一个类的定义”:

return new Contents() {
private int i = 11;
public int value() { return i; }
};

　　这种奇怪的语法指的是：“创建一个继承自Contents的匿名类的对象。”通过new 表达式返回的引用被自动向上转型为对Contents的引用。匿名内部类的语法是下面例子的简略形式：

class MyContents implements Contents {
private int i = 11;
public int value() { return i; }
}
return new MyContents();

　　在这个匿名内部类中，使用了缺省的构造器来生成Contents。下面的代码展示的是，如果你的基类需要一个有参数的构造器，应该怎么办：

public class Parcel7 {
public Wrapping wrap(int x) {
// Base constructor call:
return new Wrapping(x) { // Pass constructor argument.
public int value() {
return super.value() * 47;
}
}; // Semicolon required
}
public static void main(String[] args) {
Parcel7 p = new Parcel7();
Wrapping w = p.wrap(10);
}
}

　　只需简单地传递合适的参数给基类的构造器即可，这里是将x 传进new Wrapping(x)。在匿名内部类末尾的分号，并不是用来标记此内部类结束（C++中是那样）。实际上，它标记的是表达式的结束，只不过这个表达式正巧包含了内部类罢了。因此，这与别的地方使用的分号是一致的。

　　如果在匿名类中定义成员变量，你同样能够对其执行初始化操作：

public class Parcel8 {
// Argument must be final to use inside
// anonymous inner class:
public Destination dest(final String dest) {
return new Destination() {
private String label = dest;
public String readLabel() { return label; }
};
}
public static void main(String[] args) {
Parcel8 p = new Parcel8();
Destination d = p.dest("Tanzania");
}
}

　　如果你有一个匿名内部类，它要使用一个在它的外部定义的对象，编译器会要求其参数引用是final 型的，就像dest()中的参数。如果你忘记了，会得到一个编译期错误信息。如果只是简单地给一个成员变量赋值，那么此例中的方法就可以了。但是，如果你想做一些类似构造器的行为，该怎么办呢？在匿名类中不可能有已命名的构造器（因为它根本没名字！），但通过实例初始化，你就能够达到为匿名内部类“制作”一个构造器的效果。像这样做：

abstract class Base {
public Base(int i) {
System.out.println("Base constructor, i = " + i);
}
public abstract void f();
}

public class AnonymousConstructor {
public static Base getBase(int i) {
return new Base(i) {
{
System.out.println("Inside instance initializer");
}
public void f() {
System.out.println("In anonymous f()");
}
};
}
public static void main(String[] args) {
Base base = getBase(47);
base.f();
}
}

　　在此例中，不要求变量i 一定是final 的。因为i 被传递给匿名类的基类的构造器，它并不会在匿名类内部被直接使用。下例是带实例初始化的“parcel”形式。注意dest()的参数必须是final，因为它们是在匿名类内被使用的。

public class Parcel9 {
public Destinationdest(final String dest, final float price) {
return new Destination() {
private int cost;
// Instance initialization for each object:
{
cost = Math.round(price);
if(cost > 100)
System.out.println("Over budget!");
}

private String label = dest;
public String readLabel() { return label; }
};
}
public static void main(String[] args) {
Parcel9 p = new Parcel9();
Destination d = p.dest("Tanzania", 101.395F);
}
}

　　在实例初始化的部分，你可以看到有一段代码，那原本是不能作为成员变量初始化的一部分而执行的（就是if 语句）。所以对于匿名类而言，实例初始化的实际效果就是构造器。当然它受到了限制：你不能重载实例初始化，所以你只能有一个构造器。

　　从多层嵌套类中访问外部

　　一个内部类被嵌套多少层并不重要，它能透明地访问所有它所嵌入的外围类的所有成员，如下所示：

class MNA {
private void f() {}
class A {
private void g() {}
public class B {
void h() {
g();
f();
}
}
}
}
public class MultiNestingAccess {
public static void main(String[] args) {
MNA mna = new MNA();
MNA.A mnaa = mna.new A();
MNA.A.B mnaab = mnaa.new B();
mnaab.h();
}
}

　　可以看到在MNA.A.B中，调用方法g()和f()不需要任何条件（即使它们被定义为private）。这个例子同时展示了如何从不同的类里面创建多层嵌套的内部类对象的基本语法。“.new”语法能产生正确的作用域，所以你不必在调用构造器时限定类名。

　　内部类的重载问题

　　如果你创建了一个内部类，然后继承其外围类并重新定义此内部类时，会发生什么呢？也就是说，内部类可以被重载吗？这看起来似乎是个很有用的点子，但是“重载”内部类就好像它是外围类的一个方法，其实并不起什么作用：

class Egg {
private Yolk y;

protectedclass Yolk {
public Yolk() {
System.out.println("Egg.Yolk()");
}
}

public Egg() {
System.out.println("New Egg()");
y = new Yolk();
}
}

publicclass BigEgg extends Egg {
publicclass Yolk {
public Yolk() {
System.out.println("BigEgg.Yolk()");
}
}

publicstaticvoid main(String[] args) {
new BigEgg();
}
}

　　输出结果为：

New Egg()
Egg.Yolk()

　　缺省的构造器是编译器自动生成的，这里是调用基类的缺省构造器。你可能认为既然创建了BigEgg 的对象，那么所使用的应该是被“重载”过的Yolk，但你可以从输出中看到实际情况并不是这样的。

　　这个例子说明，当你继承了某个外围类的时候，内部类并没有发生什么特别神奇的变化。这两个内部类是完全独立的两个实体，各自在自己的命名空间内。当然，明确地继承某个内部类也是可以的：

class Egg2 {
protected class Yolk {
public Yolk() {
System.out.println("Egg2.Yolk()");
}

public void f() {
System.out.println("Egg2.Yolk.f()");
}
}

private Yolk y = new Yolk();

public Egg2() {
System.out.println("New Egg2()");
}

public void insertYolk(Yolk yy) {
y = yy;
}

public void g() {
y.f();
}
}

public class BigEgg2 extends Egg2 {
public class Yolk extends Egg2.Yolk {
public Yolk() {
System.out.println("BigEgg2.Yolk()");
}

public void f() {
System.out.println("BigEgg2.Yolk.f()");
}
}

public BigEgg2() {
insertYolk(new Yolk());
}

public static void main(String[] args) {
Egg2 e2 = new BigEgg2();
e2.g();
}
}

　　输出结果为：

Egg2.Yolk()
New Egg2()
Egg2.Yolk()
BigEgg2.Yolk()
BigEgg2.Yolk.f()

　　现在BigEgg2.Yolk 通过extends Egg2.Yolk 明确地继承了此内部类，并且重载了其中的方法。Egg2 的insertYolk()方法使得BigEgg2 将它自己的Yolk 对象向上转型，然后传递给引用y。所以当g()调用y.f()时，重载后的新版的f()被执行。第二次调用Egg2.Yolk()是BigEgg2.Yolk 的构造器调用了其基类的构造器。可以看到在调用g()的时候，新版的f()被调用了。

　　内部类的继承问题（thinking in java 3th p294）

　　因为内部类的构造器要用到其外围类对象的引用，所以在你继承一个内部类的时候，事情变得有点复杂。问题在于，那个“秘密的”外围类对象的引用必须被初始化，而在被继承的类中并不存在要联接的缺省对象。要解决这个问题，需使用专门的语法来明确说清它们之间的关联：

class WithInner {
class Inner {
Inner(){
System.out.println("this is a constructor in WithInner.Inner");
};
}
}

public class InheritInner extends WithInner.Inner {
// ! InheritInner() {} // Won't compile
InheritInner(WithInner wi) {
wi.super();
System.out.println("this is a constructor in InheritInner");
}

public static void main(String[] args) {
WithInner wi = new WithInner();
InheritInner ii = new InheritInner(wi);
}
}

　　输出结果为：

this is a constructor in WithInner.Inner
this is a constructor in InheritInner

　　可以看到，InheritInner 只继承自内部类，而不是外围类。但是当要生成一个构造器时，缺省的构造器并不算好，而且你不能只是传递一个指向外围类对象的引用。此外，你必须在构造器内使用如下语法：

enclosingClassReference.super();

　　这样才提供了必要的引用，然后程序才能编译通过。

http://blog.sina.com.cn/s/blog_56898c310100a3i3.html

posted @ 2012-04-14 02:11 abin 阅读(515) | 评论 (0) | 编辑收藏

Java反射机制(二)

package com.abin.lee.reflect;

import java.lang.reflect.Method;

public class InvokeTester {
public int add(int param1,int param2){
  return param1+param2;
}
public String echo(String message){
  return "hello"+message;
}
public static void main(String[] args) {
  try {
   Class<?> classType=InvokeTester.class;
   Object invokeTester=classType.newInstance();
   System.out.println(invokeTester instanceof InvokeTester);
   Method addMethod=classType.getMethod("add", new Class[]{int.class,int.class});
   Object result=addMethod.invoke(invokeTester, new Object[]{1,2});
   System.out.println((Integer)result);

   System.out.println("----------");
   Method echoMethod=classType.getMethod("echo", new Class[]{String.class});
   Object result2=echoMethod.invoke(invokeTester, new Object[]{"abin"});
   System.out.println(result2);
  } catch (Exception e) {
   e.printStackTrace();
   System.out.println(e.getMessage());
  }
}
}

posted @ 2012-04-14 02:08 abin 阅读(560) | 评论 (0) | 编辑收藏

Java反射机制(一)

package com.abin.lee.reflect;

import java.lang.reflect.Method;

public class DumpMethods {
public static void main(String[] args) {
  try {
   Class clazz=Class.forName("java.util.Stack");
   Method method[]=clazz.getDeclaredMethods();
   for(int i=0;i<method.length;i++)
    System.out.println(method[i].toString());
  } catch (Exception e) {
   e.printStackTrace();
   System.err.println(e.getMessage());
  }
}

}

posted @ 2012-04-14 01:02 abin 阅读(746) | 评论 (0) | 编辑收藏

统计某一目录下每个文件中出现的字母个数、数字个数、空格个数及行数(JAVA)

package com.abin.lee.test;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStreamReader;

public class FileTotal {

public static void ReadSubdirectory(File dir){
  if(dir.isDirectory()){
   File[] subFile=dir.listFiles();
   for(int i=0;i<subFile.length;i++){
    if(subFile[i].isDirectory()){
     ReadSubdirectory(subFile[i]);
    }else{
     ReadSubFile(subFile[i]);
    }
   }
  }
}
public static void ReadSubFile(File file){
  int numCount=0;
  int letterCount=0;
  int spaceCount=0;
  int lineCount=0;
  int temp=0;
  try {
   FileInputStream input=new FileInputStream(file);
   while((temp=input.read())!=-1){
    if(temp>=48&&temp<=57){
     numCount++;
    }else if((temp>=65&&temp<=90)||(temp>97&&temp<122)){
     letterCount++;
    }else if(temp==32){
     spaceCount++;
    }
   }
   BufferedReader buffer=new BufferedReader(new InputStreamReader(new FileInputStream(file)));
   while(buffer.readLine()!=null){
    lineCount++;
   }
   System.out.println("文件路径："+file.getAbsolutePath());
   System.out.println("数字个数:"+numCount);
   System.out.println("字母个数:"+letterCount);
   System.out.println("空格个数:"+spaceCount);
   System.out.println("行数数:"+lineCount);

  } catch (Exception e) {
   e.printStackTrace();
  }
}
public static void main(String[] args) {
  ReadSubdirectory(new File("D://image"));
}
}

posted @ 2012-03-31 22:02 abin 阅读(1296) | 评论 (0) | 编辑收藏

Mybatis resultMap使用

今天在项目中用了mybatis的resultMap。以前用的时候都是一些简单的查询，修改，分页。这次涉及到了POJO对象之间的一对多和多对一的关系映射。

mybatis有几种使用方式, 我喜欢用mapper的方式,然后用spring来管理mybatis.

开发工具是Eclipse jee, mybatis版本是3.0.5, mybatis-sprint-1.0.1

工程文件目录

mybatis-config.xml 是mybatis的配置文件：

<configuration>
    <settings>
        <setting name="cacheEnabled" value="false" />
        <setting name="useGeneratedKeys" value="true" />
        <setting name="defaultExecutorType" value="REUSE" />
    </settings>
	<mappers>
        <mapper resource="com/exam/persistence/mapper/ClientMapper.xml" />
    </mappers>
</configuration>

applicationContext.xml:

<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
	<property name="dataSource" ref="dataSource" />
	<property name="configLocation" value="/WEB-INF/mybatis-config.xml" />
</bean>

<bean id="clientMapper" class="org.mybatis.spring.mapper.MapperFactoryBean">
    <property name="mapperInterface" value="com.exam.persistence.mapper.ClientMapper" />
    <property name="sqlSessionFactory" ref="sqlSessionFactory" />
</bean>

配置文件就是这些了。主要的东西在下面：

业务逻辑涉及到三张表: Client, Subscriber, Account. 其中Client表和Subscriber表是多对一的关系. Client表和Account是一对多的关系。

在com.example.persistence.mapper目录下，需要创建两个文件分别是：ClientMapper.java 和 ClientMapper.xml

对象映射关系主要在ClientMapper.xml中定义：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
    PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
    "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.exam.persistence.mapper.ClientMapper">
    <resultMap id="clients" type="com.exam.entity.Clients">
    	<id property="externalId" column="externalId" />
    	<result property="id" column="id"/>
    	<result property="subscriptionId" column="subscriptionId"/>
    	<association property="subscription" column="subscriptionId" javaType="com.exam.entity.Subscription" select="selectSubscription"/>
    	<collection property="accounts" column="id" ofType="com.exam.entity.Accounts" select="selectAccounts"/>
    </resultMap>
    
    <select id="getClientByID" resultMap="clients" parameterType="java.lang.String">
       select 
           client.internal_id as id,
           client.external_id as externalId,
       from CLIENT client 
            left outer join SUBSCRIPTION subscription on client.subscription_id = subscription.subscription_id
            left outer join ACCOUNT accounts on client.internal_id = accounts.id
        where client.external_id = #{external_id}
    </select>
    
    <select id="selectAccounts" parameterType="int" resultType="com.exam.entity.Accounts">
    	select * from ACCOUNT where client_id=#{client_id}
    </select>
    <select id="selectSubscription" parameterType="java.lang.String" resultType="com.exam.entity.Subscription">
    	select * from SUBSCRIPTION where subscription_id = #{subscription_id}
    </select>
</mapper>

这个xml文件定义了一个resultMap id="clients". clients里面包含了一个assoction(多对一)和一个collection(一对多). 这两个分别对应了两个select id.

ClientMapper.java是一个interface：

import java.util.List;
import com.exam.entity.Clients;
public interface ClientMapper {
  public List<Clients> getClientByID(String external_id);
}

其中函数名"getClientByID"应该和ClientMapper.xml中的select id的值相同。

在com.exam.entity目录下面需要定义Clients, Accounts, Subscription 三个POJO类。就不在这里写POJO类了。

这样我们在service逻辑中就可以使用ClientMapper.

public class ClientServiceImpl implements ClientService {
	private ClientMapper clientMapper;

	public ClientMapper getClientMapper() {
		return deviceMapper;
	}

	public void setClientMapper(ClientMapper clientMapper) {
		this.clientMapper = clientMapper;
	}

         @Override
	public List<Clients> getClientByID(String external_id) {
	    return getClientMapper().getClientByID(external_id);
	}
}我们需要在applicationContext中把clientMapper注入到这个server类中就ok了。

先写到这里。

http://m.oschina.net/blog/29845

posted @ 2012-03-28 22:23 abin 阅读(4844) | 评论 (0) | 编辑收藏

HibernateTransactionManager 和 hibernateTemplate的区别

在applicationContext.xml中有如下配置：

也可以：
<bean id="hibernateTemplate" class="org.springframework.orm.hibernate3.HibernateTransactionManager">
    <property name="sessionFactory">
       <ref bean="sessionFactory"/>
    </property>
</bean>

两种实现方式其实没有区别，尤其是第二种不要自己去关闭session，session在事务结束后都会自动关闭。但是一定要注意延迟加载的问题，当对象在session关闭前没有从数据库中取得，而jsp中需要展示对象时，会提示LazyInitializationException，你可以通过OpenSessionInViewFilter来保证延迟加载不会出现错误，即：
<filter>
     <filter-name>opensession</filter-name>
     <filter-class>org.springframework.orm.hibernate3.support.OpenSessionInViewFilter</filter-class>
</filter>
<filter-mapping>
     <filter-name>opensession</filter-name>
     <url-pattern>*.do</url-pattern>
</filter-mapping>

posted @ 2012-03-27 22:30 abin 阅读(996) | 评论 (0) | 编辑收藏

Java 拆分字符串

package com.abin.inter.test;

public class SplitString1 {
public static void main(String[] args) {
  StringBuffer stb = new StringBuffer();
  String unitId1 = "aaaaa";
  String callerNumber1 = "bbbbb";
  String calleeNumber1 = "ccccc";
  stb.append(unitId1).append("|").append(callerNumber1).append("|")
    .append(calleeNumber1);
  System.out.println("stb=" + stb.toString());
  String unitId = stb.toString()
    .substring(0, stb.toString().indexOf("|"));
  System.out.println("unitId=" + unitId);
  String temp1 = stb.toString().substring(unitId.length() + 1,
    stb.toString().length() - unitId.length());
  System.out.println("temp1=" + temp1);
  String callerNumber = temp1.substring(0, temp1.indexOf("|"));
  System.out.println("callerNumber=" + callerNumber);
  System.out.println("unitId.length()=" + unitId.length());
  System.out.println("callerNumber.length()=" + callerNumber.length());
  System.out.println("stb=" + stb.toString().length());
  String temp2 = stb.toString().substring(
    unitId.length() + callerNumber.length() + 2,
    stb.toString().length());
  System.out.println("temp2=" + temp2);
  String calleeNumber = temp2.substring(0, temp2.length());
  System.out.println("calleeNumber=" + calleeNumber);
}
}

posted @ 2012-03-27 20:04 abin 阅读(494) | 评论 (0) | 编辑收藏

开发邮件遇到的问题？

小弟最近开发OA系统里面的一个邮件模块，基本的收发功能是实现了，但是不是很完善。

特别是在控制邮件中的附件时，点击收件箱，附件和内容都开始接收，问题是出在这里？

1.如果接受1000封或者更多，附件为1M或者更大，那么服务器要控制以G为单位的附件下载，速度肯定会很慢的，

2.问老大，老大没有直接回答，叫我们想想，他给意见是附件在凌晨自动开始下载。（这个只是老大为了，给我们思路）。

3.老大说最好的效果是：点击收件箱，页面开始接收每封邮件的标题（内容，和附件不管），点击某封邮件的标题，开始接收邮件的内容(同时标题也接受，内容中的附件不接收)，但点击附件时开始接受。

4.感觉这个想法比较好,按照老大说的这种页面怎么分开请求，

5.不知道各位前辈有没有更好的设计思路。

谢谢各位看完啊！

小弟第一次发，前辈多多支持哦！

这种方式用ajax来实现就最完美解决
点击收件箱，页面开始接收每封邮件的标题（内容，和附件不管），点击某封邮件的标题，开始接收邮件的内容(同时标题也接受，内容中的附件不接收)，但点击附件时开始接受。

每个都是一个单独的请求，每次都得到想要的那部分数据，用ajax来做

posted @ 2012-03-27 19:43 abin 阅读(660) | 评论 (1) | 编辑收藏

C语言文件读写

#include "stdio.h"
int main(int argc,char *argv[])
{
FILE *fp;
char ch;
if((fp=fopen("bing.doc","wt+"))==NULL){
  printf("CANNOT open this bing.txt");
  getch();
  exit(0);
}
printf("input a string :\n");
ch=getchar();
while(ch!='\n')
{
  fputc(ch,fp);
  ch=getchar();
}
rewind(fp);
ch=fgetc(fp);
while(ch!=EOF)
{
  putchar(ch);
  ch=fgetc(fp);
}
printf("\n");
fclose(fp);

}

posted @ 2012-03-26 21:13 abin 阅读(254) | 评论 (0) | 编辑收藏

Java容器集合类的区别用法

Java容器集合类的区别用法

Set,List,Map,Vector,ArrayList的区别
JAVA的容器---List,Map,Set
Collection
├List
│├LinkedList
│├ArrayList
│└Vector
│　└Stack
└Set
Map
├Hashtable
├HashMap
└WeakHashMap
Collection接口
　　Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素（Elements）。一些 Collection允许相同的元素而另一些不行。一些能排序而另一些不行。Java SDK不提供直接继承自Collection的类，Java SDK提供的类都是继承自Collection的“子接口”如List和Set。
　　所有实现Collection接口的类都必须提供两个标准的构造函数：无参数的构造函数用于创建一个空的Collection，有一个 Collection参数的构造函数用于创建一个新的Collection，这个新的Collection与传入的Collection有相同的元素。后一个构造函数允许用户复制一个Collection。
　　如何遍历Collection中的每一个元素？不论Collection的实际类型如何，它都支持一个iterator()的方法，该方法返回一个迭代子，使用该迭代子即可逐一访问Collection中每一个元素。典型的用法如下：
　　　　Iterator it = collection.iterator(); // 获得一个迭代子
　　　　while(it.hasNext()) {
　　　　　　Object obj = it.next(); // 得到下一个元素
　　　　}
　　由Collection接口派生的两个接口是List和Set。
List接口
　　List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引（元素在List中的位置，类似于数组下标）来访问List中的元素，这类似于Java的数组。
和下面要提到的Set不同，List允许有相同的元素。
　　除了具有Collection接口必备的iterator()方法外，List还提供一个listIterator()方法，返回一个 ListIterator接口，和标准的Iterator接口相比，ListIterator多了一些add()之类的方法，允许添加，删除，设定元素，还能向前或向后遍历。
　　实现List接口的常用类有LinkedList，ArrayList，Vector和Stack。
LinkedList类
　　LinkedList实现了List接口，允许null元素。此外LinkedList提供额外的get，remove，insert方法在 LinkedList的首部或尾部。这些操作使LinkedList可被用作堆栈（stack），队列（queue）或双向队列（deque）。
　　注意LinkedList没有同步方法。如果多个线程同时访问一个List，则必须自己实现访问同步。一种解决方法是在创建List时构造一个同步的List：
　　　　List list = Collections.synchronizedList(new LinkedList(...));
ArrayList类
　　ArrayList实现了可变大小的数组。它允许所有元素，包括null。ArrayList没有同步。
size，isEmpty，get，set方法运行时间为常数。但是add方法开销为分摊的常数，添加n个元素需要O(n)的时间。其他的方法运行时间为线性。
　　每个ArrayList实例都有一个容量（Capacity），即用于存储元素的数组的大小。这个容量可随着不断添加新元素而自动增加，但是增长算法并没有定义。当需要插入大量元素时，在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。
　　和LinkedList一样，ArrayList也是非同步的（unsynchronized）。
Vector类
　　Vector非常类似ArrayList，但是Vector是同步的。由Vector创建的Iterator，虽然和ArrayList创建的 Iterator是同一接口，但是，因为Vector是同步的，当一个Iterator被创建而且正在被使用，另一个线程改变了Vector的状态（例如，添加或删除了一些元素），这时调用Iterator的方法时将抛出ConcurrentModificationException，因此必须捕获该异常。
Stack 类
　　Stack继承自Vector，实现一个后进先出的堆栈。Stack提供5个额外的方法使得Vector得以被当作堆栈使用。基本的push和pop 方法，还有peek方法得到栈顶的元素，empty方法测试堆栈是否为空，search方法检测一个元素在堆栈中的位置。Stack刚创建后是空栈。
Set接口
　　Set是一种不包含重复的元素的Collection，即任意的两个元素e1和e2都有e1.equals(e2)=false，Set最多有一个null元素。
　　很明显，Set的构造函数有一个约束条件，传入的Collection参数不能包含重复的元素。
　　请注意：必须小心操作可变对象（Mutable Object）。如果一个Set中的可变元素改变了自身状态导致Object.equals(Object)=true将导致一些问题。
Map接口
　　请注意，Map没有继承Collection接口，Map提供key到value的映射。一个Map中不能包含相同的key，每个key只能映射一个 value。Map接口提供3种集合的视图，Map的内容可以被当作一组key集合，一组value集合，或者一组key-value映射。
Hashtable类
　　Hashtable继承Map接口，实现一个key-value映射的哈希表。任何非空（non-null）的对象都可作为key或者value。
　　添加数据使用put(key, value)，取出数据使用get(key)，这两个基本操作的时间开销为常数。
Hashtable通过initial capacity和load factor两个参数调整性能。通常缺省的load factor 0.75较好地实现了时间和空间的均衡。增大load factor可以节省空间但相应的查找时间将增大，这会影响像get和put这样的操作。
使用Hashtable的简单示例如下，将1，2，3放到Hashtable中，他们的key分别是”one”，”two”，”three”：
　　　　Hashtable numbers = new Hashtable();
　　　　numbers.put(“one”, new Integer(1));
　　　　numbers.put(“two”, new Integer(2));
　　　　numbers.put(“three”, new Integer(3));
　　要取出一个数，比如2，用相应的key：
　　　　Integer n = (Integer)numbers.get(“two”);
　　　　System.out.println(“two = ” + n);
　　由于作为key的对象将通过计算其散列函数来确定与之对应的value的位置，因此任何作为key的对象都必须实现hashCode和equals方法。hashCode和equals方法继承自根类Object，如果你用自定义的类当作key的话，要相当小心，按照散列函数的定义，如果两个对象相同，即obj1.equals(obj2)=true，则它们的hashCode必须相同，但如果两个对象不同，则它们的hashCode不一定不同，如果两个不同对象的hashCode相同，这种现象称为冲突，冲突会导致操作哈希表的时间开销增大，所以尽量定义好的hashCode()方法，能加快哈希表的操作。
　　如果相同的对象有不同的hashCode，对哈希表的操作会出现意想不到的结果（期待的get方法返回null），要避免这种问题，只需要牢记一条：要同时复写equals方法和hashCode方法，而不要只写其中一个。
　　Hashtable是同步的。
HashMap类
　　HashMap和Hashtable类似，不同之处在于HashMap是非同步的，并且允许null，即null value和null key。，但是将HashMap视为Collection时（values()方法可返回Collection），其迭代子操作时间开销和HashMap 的容量成比例。因此，如果迭代操作的性能相当重要的话，不要将HashMap的初始化容量设得过高，或者load factor过低。
WeakHashMap类
　　WeakHashMap是一种改进的HashMap，它对key实行“弱引用”，如果一个key不再被外部所引用，那么该key可以被GC回收。
总结
　　如果涉及到堆栈，队列等操作，应该考虑用List，对于需要快速插入，删除元素，应该使用LinkedList，如果需要快速随机访问元素，应该使用ArrayList。
　　如果程序在单线程环境中，或者访问仅仅在一个线程中进行，考虑非同步的类，其效率较高，如果多个线程可能同时操作一个类，应该使用同步的类。
　　要特别注意对哈希表的操作，作为key的对象要正确复写equals和hashCode方法。
　　尽量返回接口而非实际的类型，如返回List而非ArrayList，这样如果以后需要将ArrayList换成LinkedList时，客户端代码不用改变。这就是针对抽象编程。
Java 集合类 map set list arraylist hashmap hashtable(转)
Vector的方法都是同步的(Synchronized),是线程安全的(thread-safe)，而ArrayList的方法不是，由于线程的同步必然要影响性能，因此,ArrayList的性能比Vector好。
当Vector或ArrayList中的元素超过它的初始大小时,Vector会将它的容量翻倍,而ArrayList只增加50%的大小，这样,ArrayList就有利于节约内存空间。
Hashtable和HashMap
它们的性能方面的比较类似 Vector和ArrayList，比如Hashtable的方法是同步的,而HashMap的不是。
ArrayList和LinkedList
对于处理一列数据项,Java提供了两个类ArrayList和LinkedList,ArrayList的内部实现是基于内部数组Object[],所以从概念上讲,它更象数组，但LinkedList的内部实现是基于一组连接的记录,所以,它更象一个链表结构，所以,它们在性能上有很大的差别。
（1）从上面的分析可知,在ArrayList的前面或中间插入数据时,你必须将其后的所有数据相应的后移,这样必然要花费较多时间，所以,当你的操作是在一列数据的后面添加数据而不是在前面或中间,并且需要随机地访问其中的元素时,使用ArrayList会提供比较好的性能。
（2）而访问链表中的某个元素时,就必须从链表的一端开始沿着连接方向一个一个元素地去查找,直到找到所需的元素为止，所以,当你的操作是在一列数据的前面或中间添加或删除数据,并且按照顺序访问其中的元素时,就应该使用LinkedList了。
（3）如果在编程中,1，2两种情形交替出现,这时,你可以考虑使用List这样的通用接口,而不用关心具体的实现，在具体的情形下,它的性能由具体的实现来保证。
设置集合类的初始大小
在Java 集合框架中的大部分类的大小是可以随着元素个数的增加而相应的增加的，我们似乎不用关心它的初始大小,但如果我们考虑类的性能问题时,就一定要考虑尽可能地设置好集合对象的初始大小,这将大大提高代码的性能，比如,Hashtable缺省的初始大小为101,载入因子为0.75,即如果其中的元素个数超过 75个,它就必须增加大小并重新组织元素，所以,如果你知道在创建一个新的Hashtable对象时就知道元素的确切数目如为110,那么,就应将其初始大小设为110/0.75=148,这样,就可以避免重新组织内存并增加大小。
特别要理解的：
Hashtable类
　　Hashtable继承Map接口，实现一个key-value映射的哈希表。任何非空（non-null）的对象都可作为key或者value。
　　添加数据使用put(key, value)，取出数据使用get(key)，这两个基本操作的时间开销为常数。
Hashtable 通过initial capacity和load factor两个参数调整性能。通常缺省的load factor 0.75较好地实现了时间和空间的均衡。增大load factor可以节省空间但相应的查找时间将增大，这会影响像get和put这样的操作。
使用Hashtable的简单示例如下，将1，2，3放到Hashtable中，他们的key分别是”one”，”two”，”three”：
　　　　Hashtable numbers = new Hashtable();
　　　　numbers.put(“one”, new Integer(1));
　　　　numbers.put(“two”, new Integer(2));
　　　　numbers.put(“three”, new Integer(3));
　　要取出一个数，比如2，用相应的key：
　　　　Integer n = (Integer)numbers.get(“two”);
　　　　System.out.println(“two = ” + n);
　　由于作为key的对象将通过计算其散列函数来确定与之对应的value的位置，因此任何作为key的对象都必须实现hashCode和equals方法。hashCode和equals方法继承自根类Object，如果你用自定义的类当作key的话，要相当小心，按照散列函数的定义，如果两个对象相同，即obj1.equals(obj2)=true，则它们的hashCode必须相同，但如果两个对象不同，则它们的hashCode不一定不同，如果两个不同对象的hashCode相同，这种现象称为冲突，冲突会导致操作哈希表的时间开销增大，所以尽量定义好的hashCode()方法，能加快哈希表的操作。
　　如果相同的对象有不同的hashCode，对哈希表的操作会出现意想不到的结果（期待的get方法返回null），要避免这种问题，只需要牢记一条：要同时复写equals方法和hashCode方法，而不要只写其中一个。
　　Hashtable是同步的。
HashMap类
　　HashMap和Hashtable类似，不同之处在于HashMap是非同步的，并且允许null，即null value和null key。，但是将HashMap视为Collection时（values()方法可返回Collection），其迭代子操作时间开销和HashMap的容量成比例。因此，如果迭代操作的性能相当重要的话，不要将HashMap的初始化容量设得过高，或者load factor过低。
LinkedList类
　　LinkedList实现了List接口，允许null元素。此外LinkedList提供额外的get，remove，insert方法在 LinkedList的首部或尾部。这些操作使LinkedList可被用作堆栈（stack），队列（queue）或双向队列（deque）。
　　注意LinkedList没有同步方法。如果多个线程同时访问一个List，则必须自己实现访问同步。一种解决方法是在创建List时构造一个同步的List：
　　　　List list = Collections.synchronizedList(new LinkedList(...));
ArrayList类
　　ArrayList实现了可变大小的数组。它允许所有元素，包括null。ArrayList没有同步。
size，isEmpty，get，set方法运行时间为常数。但是add方法开销为分摊的常数，添加n个元素需要O(n)的时间。其他的方法运行时间为线性。
　　每个ArrayList实例都有一个容量（Capacity），即用于存储元素的数组的大小。这个容量可随着不断添加新元素而自动增加，但是增长算法并没有定义。当需要插入大量元素时，在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。
　　和LinkedList一样，ArrayList也是非同步的（unsynchronized）。
Vector类
　　Vector非常类似ArrayList，但是Vector是同步的。由Vector创建的Iterator，虽然和ArrayList创建的 Iterator是同一接口，但是，因为Vector是同步的，当一个Iterator被创建而且正在被使用，另一个线程改变了Vector的状态（例如，添加或删除了一些元素），这时调用Iterator的方法时将抛出ConcurrentModificationException，因此必须捕获该异常。
细说Java之util类:
线性表，链表，哈希表是常用的数据结构，在进行Java开发时，JDK已经为我们提供了一系列相应的类来实现基本的数据结构。这些类均在java.util包中。本文试图通过简单的描述，向读者阐述各个类的作用以及如何正确使用这些类。
Collection
├List
│├LinkedList
│├ArrayList
│└Vector
│　└Stack
└Set
Map
├Hashtable
├HashMap
└WeakHashMap
Collection接口
　　Collection是最基本的集合接口，一个Collection代表一组Object，即Collection的元素（Elements）。一些 Collection允许相同的元素而另一些不行。一些能排序而另一些不行。Java SDK不提供直接继承自Collection的类，Java SDK提供的类都是继承自Collection的“子接口”如List和Set。
　　所有实现Collection接口的类都必须提供两个标准的构造函数：无参数的构造函数用于创建一个空的Collection，有一个Collection参数的构造函数用于创建一个新的Collection，这个新的Collection与传入的Collection有相同的元素。后一个构造函数允许用户复制一个Collection。
　　如何遍历Collection中的每一个元素？不论Collection的实际类型如何，它都支持一个iterator()的方法，该方法返回一个迭代子，使用该迭代子即可逐一访问Collection中每一个元素。典型的用法如下：
　　　　Iterator it = collection.iterator(); // 获得一个迭代子
　　　　while(it.hasNext()) {
　　　　　　Object obj = it.next(); // 得到下一个元素
　　　　}
　　由Collection接口派生的两个接口是List和Set。
List接口
　　List是有序的Collection，使用此接口能够精确的控制每个元素插入的位置。用户能够使用索引（元素在List中的位置，类似于数组下标）来访问List中的元素，这类似于Java的数组。
和下面要提到的Set不同，List允许有相同的元素。
　　除了具有Collection接口必备的iterator()方法外，List还提供一个listIterator()方法，返回一个 ListIterator接口，和标准的Iterator接口相比，ListIterator多了一些add()之类的方法，允许添加，删除，设定元素，还能向前或向后遍历。
　　实现List接口的常用类有LinkedList，ArrayList，Vector和Stack。
LinkedList类
　　LinkedList实现了List接口，允许null元素。此外LinkedList提供额外的get，remove，insert方法在 LinkedList的首部或尾部。这些操作使LinkedList可被用作堆栈（stack），队列（queue）或双向队列（deque）。
　　注意LinkedList没有同步方法。如果多个线程同时访问一个List，则必须自己实现访问同步。一种解决方法是在创建List时构造一个同步的List：
　　　　List list = Collections.synchronizedList(new LinkedList(...));
ArrayList类
　　ArrayList实现了可变大小的数组。它允许所有元素，包括null。ArrayList没有同步。
size，isEmpty，get，set方法运行时间为常数。但是add方法开销为分摊的常数，添加n个元素需要O(n)的时间。其他的方法运行时间为线性。
　　每个ArrayList实例都有一个容量（Capacity），即用于存储元素的数组的大小。这个容量可随着不断添加新元素而自动增加，但是增长算法并没有定义。当需要插入大量元素时，在插入前可以调用ensureCapacity方法来增加ArrayList的容量以提高插入效率。
　　和LinkedList一样，ArrayList也是非同步的（unsynchronized）。
Vector类
　　Vector非常类似ArrayList，但是Vector是同步的。由Vector创建的Iterator，虽然和ArrayList创建的 Iterator是同一接口，但是，因为Vector是同步的，当一个Iterator被创建而且正在被使用，另一个线程改变了Vector的状态（例如，添加或删除了一些元素），这时调用Iterator的方法时将抛出ConcurrentModificationException，因此必须捕获该异常。
Stack 类
　　 Stack继承自Vector，实现一个后进先出的堆栈。Stack提供5个额外的方法使得Vector得以被当作堆栈使用。基本的push和pop方法，还有peek方法得到栈顶的元素，empty方法测试堆栈是否为空，search方法检测一个元素在堆栈中的位置。Stack刚创建后是空栈。
Set接口
　　Set是一种不包含重复的元素的Collection，即任意的两个元素e1和e2都有e1.equals(e2)=false，Set最多有一个null元素。
　　很明显，Set的构造函数有一个约束条件，传入的Collection参数不能包含重复的元素。
　　请注意：必须小心操作可变对象（Mutable Object）。如果一个Set中的可变元素改变了自身状态导致Object.equals(Object)=true将导致一些问题。
Map接口
　　请注意，Map没有继承Collection接口，Map提供key到value的映射。一个Map中不能包含相同的key，每个key只能映射一个 value。Map接口提供3种集合的视图，Map的内容可以被当作一组key集合，一组value集合，或者一组key-value映射。
Hashtable类
　　Hashtable继承Map接口，实现一个key-value映射的哈希表。任何非空（non-null）的对象都可作为key或者value。
　　添加数据使用put(key, value)，取出数据使用get(key)，这两个基本操作的时间开销为常数。
Hashtable 通过initial capacity和load factor两个参数调整性能。通常缺省的load factor 0.75较好地实现了时间和空间的均衡。增大load factor可以节省空间但相应的查找时间将增大，这会影响像get和put这样的操作。
使用Hashtable的简单示例如下，将1，2，3放到Hashtable中，他们的key分别是”one”，”two”，”three”：
　　　　Hashtable numbers = new Hashtable();
　　　　numbers.put(“one”, new Integer(1));
　　　　numbers.put(“two”, new Integer(2));
　　　　numbers.put(“three”, new Integer(3));
　　要取出一个数，比如2，用相应的key：
　　　　Integer n = (Integer)numbers.get(“two”);
　　　　System.out.println(“two = ” + n);
　　由于作为key的对象将通过计算其散列函数来确定与之对应的value的位置，因此任何作为key的对象都必须实现hashCode和equals方法。hashCode和equals方法继承自根类Object，如果你用自定义的类当作key的话，要相当小心，按照散列函数的定义，如果两个对象相同，即obj1.equals(obj2)=true，则它们的hashCode必须相同，但如果两个对象不同，则它们的hashCode不一定不同，如果两个不同对象的hashCode相同，这种现象称为冲突，冲突会导致操作哈希表的时间开销增大，所以尽量定义好的hashCode()方法，能加快哈希表的操作。
　　如果相同的对象有不同的hashCode，对哈希表的操作会出现意想不到的结果（期待的get方法返回null），要避免这种问题，只需要牢记一条：要同时复写equals方法和hashCode方法，而不要只写其中一个。
　　Hashtable是同步的。
HashMap类
　　HashMap和Hashtable类似，不同之处在于HashMap是非同步的，并且允许null，即null value和null key。，但是将HashMap视为Collection时（values()方法可返回Collection），其迭代子操作时间开销和HashMap 的容量成比例。因此，如果迭代操作的性能相当重要的话，不要将HashMap的初始化容量设得过高，或者load factor过低。
WeakHashMap类
　　WeakHashMap是一种改进的HashMap，它对key实行“弱引用”，如果一个key不再被外部所引用，那么该key可以被GC回收。
总结
　　如果涉及到堆栈，队列等操作，应该考虑用List，对于需要快速插入，删除元素，应该使用LinkedList，如果需要快速随机访问元素，应该使用ArrayList。
　　如果程序在单线程环境中，或者访问仅仅在一个线程中进行，考虑非同步的类，其效率较高，如果多个线程可能同时操作一个类，应该使用同步的类。
　　要特别注意对哈希表的操作，作为key的对象要正确复写equals和hashCode方法。
　　尽量返回接口而非实际的类型，如返回List而非ArrayList，这样如果以后需要将ArrayList换成LinkedList时，客户端代码不用改变。这就是针对抽象编程。

posted @ 2012-03-23 12:31 abin 阅读(885) | 评论 (0) | 编辑收藏

仅列出标题

少年阿宾

常用链接

留言簿(22)

我参与的团队

随笔分类

随笔档案

新闻分类

相册

搜索

最新评论

阅读排行榜

评论排行榜