abin — Sun, 02 Sep 2012 08:43:00 GMT

package com.abin.lee.collection.inner;

public class LiangCheng {

public static String LocalProcess(String wu, String id) {

String well = null;

if (wu.equalsIgnoreCase("abin")) {

LiangCheng liangCheng=new LiangCheng();

LiangCheng.Process process=liangCheng.new Process();

well=process.getNameById(id);

}

return well;

}

public class Process {

private String result = null;

public String getNameById(String id) {

if (id.equalsIgnoreCase("15")) {

result = "lee";

}

return result;

}

public static void main(String[] args) {

LiangCheng liangCheng=new LiangCheng();

String wu="abin";

String id="15";

String result=liangCheng.LocalProcess(wu, id);

System.out.println("result="+result);

}

abin 2012-09-02 16:43 发表评论

Java 静态内部类和枚�?银联支付)

abin — Sat, 01 Sep 2012 16:03:00 GMT

//�q�里面主要是�׃��银联的手机支付用��C��一个付�Ƅ��转换方式问题�Q�当调用支付宝付�Ƅ��时候，比如一分钱格式��是我们普通用的格式：0.01�Q�而银联确要把格式转化�?00000000001�Q�银联要求是12位）�q�种格式的，最后一位是分，然后向前依次是角�Q�元�Q�十元，癑օ��Q�相信不用我��_��你已�l�懂了吧。所以这里就需要一个�{换，��Z��应对�?000�Q?000.00�Q?000.0�q�种传过来的格式的数据，特做一下�{换，然后传给银联�q�行支付�?br />

package com.abin.lee.collection.inner;

public class ConsumeFinance {

public static enum Currency{

CHINARMB("chinarmb"),DOLLAR("dollar"),HK("hk");

private Currency(String textVal){

this.textVal=textVal;

}

private String textVal;

public String toString(){

return textVal;

}

public static String ConsumeProcess(String money,Currency currency){

System.out.println("currentcy="+currency);

String flag=null;

if(currency.equals(Currency.CHINARMB)){

ConsumeFinance.ChinaProcess chinaProcess=new ConsumeFinance.ChinaProcess();

flag=chinaProcess.chinaChange(money, currency);

}

return flag;

}

public static String ConsumeProcessReturn(String money,Currency currency){

System.out.println("currentcy="+currency);

String flag=null;

if(currency.equals(Currency.CHINARMB)){

ConsumeFinance.ChinaReturn chinaReturn=new ConsumeFinance.ChinaReturn();

flag=chinaReturn.chinaReChange(money, currency);

}

return flag;

}

public static class ChinaProcess{

private static String status=null;

public static String chinaChange(String money,Currency currency){

int point=money.lastIndexOf(".");

if(point==-1){

StringBuffer stb=new StringBuffer();

int len=money.length();

int lon=10-len;

for(int i=0;i

stb.append("0");

}

stb.append(money);

stb.append("00");

status=stb.toString().intern();

}

if(point>0){

int len=money.indexOf(".");

int chn=money.length()-len-1;

switch(chn){

//先判断money格式�?00.0�q�种格式的，��数点后面有一位小数点的情�?/div>

case 1:

StringBuffer stb=new StringBuffer(money);

stb.deleteCharAt(len);

int lend=stb.length();

StringBuffer sb=new StringBuffer();

for(int i=0;i<12-lend;i++){

sb.append("0");

}

sb.append(stb.toString());

status=sb.toString().intern();

//先判断money格式�?00.01�q�种格式的，��数点后面有两位��数点的情况

case 2:

money=money.replace(".", "");

int lende=money.length();

String connect="";

for(int i=0;i<12-lende;i++){

connect+="0";

}

status=connect+money;

}

return status;

}

//�?00000001001转化�?0.01�q�种格式

public static class ChinaReturn{

private static String status=null;

public static String chinaReChange(String money,Currency currency){

int change=money.length();

int num=0;

for(int i=0;i

int value=Integer.valueOf(String.valueOf(money.charAt(i)));

if(value>0){

num=i;

break;

}

money=money.substring(num);

if(num==10){

status="0."+money;

}

if(num==11){

status="0.0"+money;

}

if(num<10){

System.out.println(money.length());

StringBuffer stb=new StringBuffer(money);

stb.insert(money.length()-2, ".");

status=stb.toString().intern();

}

return status;

}

public static void main(String[] args) {

Currency currency=Currency.CHINARMB;

String money="000000001001";

String result=ConsumeProcessReturn(money, currency);

// String result=ConsumeProcess(money, currency);

System.out.println("result="+result);

}

abin 2012-09-02 00:03 发表评论

Java内部�c�L�ȝ��

abin — Fri, 13 Apr 2012 18:11:00 GMT

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

　　��Z��么需要内部类�Q?br />
　　典型的情冉|��Q�内部类�l�承自某个类或实现某个接口，内部�cȝ��代码操作创徏其的外围�cȝ��对象。所以你可以认�ؓ内部�c�L��供了某种�q�入其外围类的窗口。��用内部类最吸引人的原因是：

　　每个内部�c�都能独立地�l�承自一个（接口的）实现�Q�所以无论外围类是否已经�l�承了某个（接口的）实现�Q�对于内部类都没有媄响。如果没有内部类提供的可以��承多个具体的或抽象的�cȝ��能力�Q�一些设计与�~�程问题��很难解冟뀂从�q�个角度看，内部�c�M��得多重��承的解决�Ҏ��变得完整。接口解决了部分问题�Q�而内部类有效地实��C��“多重�l�承”�?br />
　　A�Q�成员内部类

　　作�ؓ外部�cȝ��一个成员存在，与外部类的属性、方法�ƈ列�?br />
publicclass Outer {
privatestaticinti = 1;
privateintj = 10;
privateintk = 20;

publicstaticvoidouter_f1() {
}

publicvoidouter_f2() {
}

// 成员内部�c�M��Q�不能定义静态成�?br />// 成员内部�c�M��Q�可以访问外部类的所有成�?br />class Inner {
// static int inner_i = 100; //内部�c�M��不允许定义静态变�?br />intj = 100; // 内部�c�d��外部�cȝ��实例变量可以共存
intinner_i = 1;

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

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

// 外部�cȝ��静态方法访问成员内部类�Q�与在外部类外部讉K��成员内部�c�M��?br />publicstaticvoidouter_f4() {
//step1 建立外部�c�d��?br />Outer out = new Outer();
//step2 �Ҏ��外部�c�d��象徏立内部类对象
Inner inner = out.new Inner();
//step3 讉K��内部�cȝ��Ҏ��
inner.inner_f1();
}

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

　　注意�Q�内部类是一个编译时的概念，一旦编译成功，��׃��成�ؓ完全不同的两�c�R��对于一个名为outer的外部类和其内部定义的名为inner的内部类。编译完成后出现outer.class和outer$inner.class两类�?br />
　　B:局部内部类

　　在方法中定义的内部类�U�Cؓ局部内部类。与局部变量类��|��局部内部类不能有访问说明符�Q�因为它不是外围�cȝ��一部分�Q�但是它可以讉K��当前代码块内的常量，和此外围�c�L��有的成员�?br />
publicclass Outer {
privateints = 100;
privateintout_i = 1;

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

//定义在方法内�?br />class Inner {
ints = 300; // 可以定义与外部类同名的变�?br />
// static int m = 20; //不可以定义静态变�?br />Inner(int k) {
inner_f(k);
}

intinner_i = 100;

voidinner_f(int k) {
//如果内部�c�L��有与外部�c�d��名的变量�Q�在内部�c�M��可以直接讉K��外部�cȝ��实例变量
System.out.println(out_i);
//可以讉K��外部�cȝ��局部变�?��x��法内的变�?�Q�但是变量必��L��final�?br />System.out.println(j);
//System.out.println(i);
//如果内部�c�M��有与外部�c�d��名的变量�Q�直接用变量名访问的是内部类的变�?br />System.out.println(s);
//用this.变量名访问的也是内部�c�d��?br />System.out.println(this.s);
//用外部类�?this.内部�c�d��量名讉K��的是外部�c�d��?br />System.out.println(Outer.this.s);
}
}
new Inner(k);
}

publicstaticvoid main(String[] args) {
// 讉K��局部内部类必须先有外部�c�d��?br />Outer out = new Outer();
out.f(3);
}
}

　　C�Q�静态内部类(嵌套�c?�Q�（注意�Q�前两种内部�c�M��变量�c�M��Q�所以可以对照参考变量）

　　如果你不需要内部类对象与其外围�c�d��象之间有联系�Q�那你可以将内部�c�d��明�ؓstatic。这通常�U�Cؓ嵌套�c�（nested class�Q�。想要理解static应用于内部类时的含义�Q�你��必��记住，普通的内部�c�d��象隐含地保存了一个引用，指向创徏它的外围�c�d��象。然而，当内部类是static的时�Q�就不是�q�样了。嵌套类意味着�Q?br />
　　1. 要创建嵌套类的对象，�q�不需要其外围�cȝ��对象�?br />　　2. 不能从嵌套类的对象中讉K��非静态的外围�c�d��象�?br />
publicclass Outer {
privatestaticinti = 1;
privateintj = 10;
publicstaticvoidouter_f1() {
}

publicvoidouter_f2() {
}

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

voidinner_f2() {
// 静态内部类不能讉K��外部�cȝ��非静态成�?包括非静态变量和非静态方�?
// System.out.println("Outer.i"+j);
// outer_f2();
}
}

publicvoidouter_f3() {
// 外部�c�访问内部类的静态成员：内部�c?静态成�?br />System.out.println(Inner.inner_i);
Inner.inner_f1();
// 外部�c�访问内部类的非静态成�?实例化内部类卛_��
Inner inner = new Inner();
inner.inner_f2();
}

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

　　生成一个静态内部类不需要外部类成员�Q�这是静态内部类和成员内部类的区别。静态内部类的对象可以直接生成：Outer.Inner in = new Outer.Inner(); 而不需要通过生成外部�c�d��象来生成。这样实际上佉K��态内部类成�ؓ了一个顶�U�类(正常情况下，你不能在接口内部攄��M��代码�Q�但嵌套�c�d��以作为接口的一部分�Q�因为它是static 的。只是将嵌套�cȝ��于接口的命名�I�间内，�q��ƈ不违反接口的规则�Q?br />
　　D�Q�匿名内部类(from thinking in java 3th)

　　��单地��_��匿名内部�c�d��是没有名字的内部�c�R��什么情况下需要��用匿名内部类�Q�如果满��下面的一些条�Ӟ��使用匿名内部�c�L��比较合适的�Q?br />
　　·只用到类的一个实例�?br />　　·�c�d��定义后马上用到�?br />　　·�c�非常小�Q�SUN推荐是在4行代码以下）
　　·�l�类命名�q�不会导致你的代码更�Ҏ��被理解�?br />　　在��用匿名内部类�Ӟ��要记住以下几个原则：
　　·匿名内部�c�M��能有构造方法�?br />　　·匿名内部�c�M��能定义�Q何静态成员、方法和�c�R�?br />　　·匿名内部�c�M��能是public,protected,private,static�?br />　　·只能创徏匿名内部�cȝ��一个实例�?br />·一个匿名内部类一定是在new的后面，用其隐含实现一个接口或实现一个类�?br />　　·因匿名内部类为局部内部类�Q�所以局部内部类的所有限刉��对其生效�?br />
　　下面的例子看��h��有点奇怪：

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

public int value() {
return i;
}
}; // 在这里需要一个分�?br />}

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

　　cont()�Ҏ��下面两个动作合�q�在一��P��q�回值的生成�Q�与表示�q�个�q�回值的�cȝ��定义�Q�进一步说�Q�这个类是匿名的�Q�它没有名字。更�p�的是，看�v来是你正要创��Z��个Contents对象�Q?br />
return new Contents()

　　但是�Q�在到达语句�l�束的分号之前，你却��_��“�{�一�{�，我想在这里插入一个类的定�?#8221;:

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

　　�q�种奇怪的语法指的是：“创徏一个��承自Contents的匿名类的对象�?#8221;通过new 表达式返回的引用被自动向上�{型�ؓ对Contents的引用。匿名内部类的语法是下面例子的简略�Ş式：

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

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

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);
}
}

　　只需��单地传递合适的参数�l�基�cȝ��构造器卛_��Q�这里是��x 传进new Wrapping(x)。在匿名内部�c�L��分号�Q��ƈ不是用来标记此内部类�l�束�Q�C++中是那样�Q�。实际上�Q�它标记的是表达式的�l�束�Q�只不过�q�个表达式正巧包含了内部�cȝŞ了。因此，�q�与别的地方使用的分��h��一致的�?br />
　　如果在匿名类中定义成员变量，你同栯��够对其执行初始化操作�Q?br />
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");
}
}

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

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();
}
}

　　在此例中�Q�不要求变量i 一定是final 的。因为i 被传递给匿名�cȝ��基类的构造器�Q�它�q�不会在匿名�c�d��部被直接使用。下例是带实例初始化�?#8220;parcel”形式。注意dest()的参数必��L��final�Q�因为它们是在匿名类内被使用的�?br />
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);
}
}

　　在实例初始化的部分，你可以看到有一�D�代码，那原本是不能作�ؓ成员变量初始化的一部分而执行的�Q�就是if 语句�Q�。所以对于匿名类而言�Q�实例初始化的实际效果就是构造器。当然它受到了限�Ӟ��你不能重载实例初始化�Q�所以你只能有一个构造器�?br />
　　从多层嵌套类中访问外�?br />
　　一个内部类被嵌套多��层�q�不重要�Q�它能透明地访问所有它所嵌入的外围类的所有成员，如下所�C�：

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()不需要�Q何条�Ӟ��即��它们被定义�ؓprivate�Q�。这个例子同时展�C�Z��如何从不同的�c�里面创建多层嵌套的内部�c�d��象的基本语法�?#8220;.new”语法能��生正��的作用域，所以你不必在调用构造器旉��定类名�?br />
　　内部�cȝ��重蝲问题

　　如果你创��Z��一个内部类�Q�然后��承其外围�c�dƈ重新定义此内部类�Ӟ��会发生什么呢�Q�也��是��_��内部�c�d��以被重蝲吗？�q�看��h��g��是个很有用的点子�Q�但�?#8220;重蝲”内部�c�d��好像它是外围�cȝ��一个方法，其实�q�不起什么作用：

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();
}
}

　　输出�l�果为：

New Egg()
Egg.Yolk()

　　�~�省的构造器是编译器自动生成的，�q�里是调用基�cȝ��~�省构造器。你可能认�ؓ既然创徏了BigEgg 的对象，那么所使用的应该是�?#8220;重蝲”�q�的Yolk�Q�但你可以从输出中看到实际情况�ƈ不是�q�样的�?br />
　　�q�个例子说明�Q�当你��承了某个外围�cȝ��时候，内部�c�dƈ没有发生什么特别神奇的变化。这两个内部�c�L��完全独立的两个实体，各自在自��q��命名�I�间内。当�Ӟ��明确地��承某个内部类也是可以的：

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();
}
}

　　输出�l�果为：

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

　　现在BigEgg2.Yolk 通过extends Egg2.Yolk 明确地��承了此内部类�Q��ƈ且重载了其中的方法。Egg2 的insertYolk()�Ҏ��使得BigEgg2 ��它自己的Yolk 对象向上转型�Q�然后传递给引用y。所以当g()调用y.f()�Ӟ��重蝲后的新版的f()被执行。第二次调用Egg2.Yolk()是BigEgg2.Yolk 的构造器调用了其基类的构造器。可以看到在调用g()的时候，新版的f()被调用了�?br />
　　内部�cȝ��l�承问题�Q�thinking in java 3th p294�Q?br />
　　因�ؓ内部�cȝ��构造器要用到其外围�c�d��象的引用�Q�所以在你��承一个内部类的时候，事情变得有点复杂。问题在于，那个“�U�密�?#8221;外围�c�d��象的引用必须被初始化�Q�而在被��承的�c�M��q�不存在要联接的�~�省对象。要解决�q�个问题�Q�需使用专门的语法来明确说清它们之间的关联：

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);
}
}

　　输出�l�果为：

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

　　可以看到�Q�InheritInner 只��承自内部�c�，而不是外围类。但是当要生成一个构造器�Ӟ��~�省的构造器�q�不��好�Q�而且你不能只是传递一个指向外围类对象的引用。此外，你必��d��构造器内��用如下语法：

enclosingClassReference.super();

　　�q�样才提供了必要的引用，然后�E�序才能�~�译通过�?br />

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

abin 2012-04-14 02:11 发表评论

欧美日韩视频在线第一区,在线播放日韩专区,久久一本综合

Java 静态内部类和枚�?银联支付)

Java内部�c�L�ȝ��