亚洲高清在线观看,亚洲欧美日本韩国,亚洲制服丝袜精品久久

2012年6月23日

設計模式之代理模式01
問題：如何知道一個方法的運行時間：
引出代理----------------------
1.直接在原來類上修改
利用System.currentTimeMillis()
•public void Move() {
long start=System.currentTimeMillis();
System.out.println("Tank Moving

");
        try {
            Thread.sleep(new Random().nextInt(10000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        long end=System.currentTimeMillis();
        System.out.println("time:"+(end-start));

    }

2.利用繼承
如果不能在原來類上添加函數。則可以利用新建類繼承extends原來類，重寫方法，在super.方法前后加入此函數System.currentTimeMillis()
public class Tank2 extends Tank{
    @Override
    public void Move() {
        long start=System.currentTimeMillis();
        super.Move();
        long end=System.currentTimeMillis();
        System.out.println("time2:"+(end-start));
    }

}

3.利用聚合。新建一個類B實現接口函數，B類里面有需要測試的類A的對象。相當于B是A的一個代理。實際上，第二種方法也算是一個代理
public class Tank3 implements Moveable{
    public Tank3(Tank myt) {
        super();
        this.myt=myt;
    }
    Tank myt;

    @Override
    public void Move() {
        long start=System.currentTimeMillis();
        myt.Move();
        long end=System.currentTimeMillis();
        System.out.println("time3:"+(end-start));
    }
}

4、利用聚合實現多個代理。下面寫時間代理（運行的時間）和日志代理（打?。?可以通過改變client類上代理調用順序來改變出現的順序
------------- Moveable .java-------------
package mypro.cn;
public interface Moveable {
    public void Move();
}

---------------tank.java-----------
package mypro.cn;
import java.util.Random;
public class Tank implements Moveable{

    public void Move() {
        System.out.println("Tank Moving

");
        try {
            Thread.sleep(new Random().nextInt(10000));
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
}
----------- TankTimeProxy.java-------------------------
package mypro.cn;
import java.text.DateFormat;

public class TankTimeProxy implements Moveable{
    public TankTimeProxy(Moveable myt) {
        super();
        this.myt=myt;
    }
    Moveable myt;

    @Override
    public void Move() {
        long start=System.currentTimeMillis();
        java.util.Date date = new java.util.Date();
        String currTime = DateFormat.getDateTimeInstance().format(date);
        System.out.println("starttime:"+currTime);
        myt.Move();
        long end=System.currentTimeMillis();
        System.out.println("time:"+(end-start));
    }
}

------------------------- TankLogProxy .java-------------------------------
package mypro.cn;

public class TankLogProxy implements Moveable{
    public TankLogProxy(Moveable myt) {
        super();
        this.myt=myt;
    }
    Moveable myt;

    @Override
    public void Move() {//日志代理
        System.out.println("tank start");
        myt.Move();
        System.out.println("tank stop");    }
}

--------------------- Client .java----------------------------
package mypro.cn;
public class Client {
    public static void main(String[] args) {
        Tank t=new Tank();
        TankTimeProxy ttp=new TankTimeProxy(t);//先時間代理，即先包裝一層時間
        TankLogProxy tlp=new TankLogProxy(ttp);//再日志代理，最外層包裝日志
        Moveable m=tlp;
        m.Move();
    }
}

改變包裝順序，先包裝日志，再包裝時間：

posted @ 2012-06-28 22:16 兔小翊閱讀(128) | 評論 (0) | 編輯收藏

設計模式之工廠模式：

設計模式之工廠模式：
1、    掌握什么叫反射
2、    掌握class類的作用
3、    通過反射實例化對象
4、    通過反射調用類中方法的操作原理
5、    工廠設計的改進，重點掌握其思想，程序和配置相分離
package fac.cn;
interface Fruit{
    public void eat();
}
class Apple implements Fruit{
    public void eat(){
        System.out.println("吃蘋果");
    }
}
class Orange implements Fruit{
    public void eat(){
        System.out.println("吃橘子");
    }
}

class Factory{
    public static Fruit getInstance(String className){
        Fruit f=null;
        if(className.equals("Apple"))
            f=new Apple();
        else if(className.equals("Orange"))
            f=new Orange();
        return f;
    }
}
public class FactoryDemo {
    public static void main(String args[]){
        Fruit fruit=Factory.getInstance("Apple");
        fruit.eat();
    }

}
注：本程序的確實現了工廠操作。所有的問題集中在工廠操作中，因為每次只要一增加子類，則必須修改工廠。此時可以根據反射機制來完成，通過Class類來修改工廠
如下表即為修改的工廠類和主類
class Factory{
    public static Fruit getInstance(String className){
        Fruit f=null;
            try {
                f=(Fruit)Class.forName(className).newInstance();
            }
            catch (Exception e) {
                e.printStackTrace();
            }
        return f;
    }
}
public class FactoryDemo2 {
    public static void main(String args[]){
        Fruit fruit=Factory.getInstance("fac2.cn.Apple");
        fruit.eat();
    }

}
注：在以上操作中，工廠類完全不用修改，但是每次操作應用時，都必須輸入很長的包.類.名稱，使用時很不方便。最好的方法是通過一個別名來表示這個完成的包.類名稱，而且在類增加的時候，別名也可以自動增加。所以如果想要完成這樣的操作，可以使用屬性類配置

class MyPropertiesOperate{//屬性操作類
    private Properties pro=null;
    private File file=new File("D:\\Workplace"+File.separator+"Fruit.properties");
    public MyPropertiesOperate(){
        this.pro=new Properties();
        if(file.exists()){//文件存在
            try {
                pro.loadFromXML(new FileInputStream(file)); //讀取
            }
            catch (Exception e) {
            }
        }
        else this.save();
    }

    private void save(){
        this.pro.setProperty("Apple", "cn3.Apple");
        this.pro.setProperty("Orange", "cn3.Orange");
        try {
            this.pro.storeToXML(new FileOutputStream(this.file),"Fruit"); //讀取
        }
        catch (Exception e) {
        }
    }
    public Properties getProperties(){
        return this.pro;
    }

}
public class FactoryDemo3 {
    public static void main(String args[]){
        Properties myPro=new MyPropertiesOperate().getProperties();
        Fruit fruit=Factory.getInstance(myPro.getProperty("Orange"));
        fruit.eat();
    }

}
注：從以上的操作代碼中發現，程序通過一個配置文件，可以控制程序的執行，也就是達到了配置文件和程序相分離的目的。這個設計思想現在還在使用中，包括三大框架等。最新的設計理論，是將注釋寫入代碼之中，讓注釋起到程序控制的作用。要實現此操作，則使用Annotation完成

posted @ 2012-06-28 16:47 兔小翊閱讀(108) | 評論 (0) | 編輯收藏

Class方法摘要

方法摘要





<U> Class<? extends 
U>

asSubclass(Class<U> clazz)
強制轉換該
Class
對象，以表示指定的 class
對象所表示的類的一個子類。

T cast(Object obj)

將一個對象強制轉換成此 Class 對象所表示的類或接口。

boolean desiredAssertionStatus()

如果要在調用此方法時將要初始化該類，則返回將分配給該類的斷言狀態。

static Class<?> forName(String className)

返回與帶有給定字符串名的類或接口相關聯的 Class 對象。

static Class<?> forName(String name, boolean initialize, ClassLoader loader)

使用給定的類加載器，返回與帶有給定字符串名的類或接口相關聯的 Class
對象。





<A extends Annotation> 

A

getAnnotation(Class<A> annotationClass)

如果存在該元素的指定類型的注釋，則返回這些注釋，否則返回 null。

Annotation[] getAnnotations()

返回此元素上存在的所有注釋。

String getCanonicalName()

返回 Java Language Specification 中所定義的底層類的規范化名稱。

Class<?>[] getClasses()

返回一個包含某些 Class 對象的數組，這些對象表示屬于此 Class
對象所表示的類的成員的所有公共類和接口。

ClassLoader getClassLoader()

返回該類的類加載器。

Class<?> getComponentType()

返回表示數組組件類型的 Class。

Constructor<T> getConstructor(Class<?>... parameterTypes)

返回一個 Constructor 對象，它反映此 Class
對象所表示的類的指定公共構造方法。

Constructor<?>[] getConstructors()

返回一個包含某些 Constructor 對象的數組，這些對象反映此 Class
對象所表示的類的所有公共構造方法。

Annotation[] getDeclaredAnnotations()

返回直接存在于此元素上的所有注釋。

Class<?>[] getDeclaredClasses()

返回 Class 對象的一個數組，這些對象反映聲明為此 Class
對象所表示的類的成員的所有類和接口。

Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)

返回一個 Constructor 對象，該對象反映此 Class
對象所表示的類或接口的指定構造方法。

Constructor<?>[] getDeclaredConstructors()

返回 Constructor 對象的一個數組，這些對象反映此 Class
對象表示的類聲明的所有構造方法。

Field getDeclaredField(String name)

返回一個 Field 對象，該對象反映此 Class
對象所表示的類或接口的指定已聲明字段。

Field[] getDeclaredFields()

返回 Field 對象的一個數組，這些對象反映此 Class
對象所表示的類或接口所聲明的所有字段。

Method getDeclaredMethod(String name, Class<?>... parameterTypes)

返回一個 Method 對象，該對象反映此 Class
對象所表示的類或接口的指定已聲明方法。

Method[] getDeclaredMethods()

返回 Method 對象的一個數組，這些對象反映此 Class
對象表示的類或接口聲明的所有方法，包括公共、保護、默認（包）訪問和私有方法，但不包括繼承的方法。

Class<?> getDeclaringClass()

如果此 Class 對象所表示的類或接口是另一個類的成員，則返回的 Class
對象表示該對象的聲明類。

Class<?> getEnclosingClass()

返回底層類的立即封閉類。

Constructor<?> getEnclosingConstructor()

如果該 Class 對象表示構造方法中的一個本地或匿名類，則返回 Constructor
對象，它表示底層類的立即封閉構造方法。

Method getEnclosingMethod()

如果此 Class 對象表示某一方法中的一個本地或匿名類，則返回 Method
對象，它表示底層類的立即封閉方法。

T[] getEnumConstants()

如果此 Class 對象不表示枚舉類型，則返回枚舉類的元素或 null。

Field getField(String name)

返回一個 Field 對象，它反映此 Class
對象所表示的類或接口的指定公共成員字段。

Field[] getFields()

返回一個包含某些 Field 對象的數組，這些對象反映此 Class
對象所表示的類或接口的所有可訪問公共字段。

Type[] getGenericInterfaces()

返回表示某些接口的 Type，這些接口由此對象所表示的類或接口直接實現。

Type getGenericSuperclass()

返回表示此 Class 所表示的實體（類、接口、基本類型或 void）的直接超類的
Type。

Class<?>[] getInterfaces()

確定此對象所表示的類或接口實現的接口。

Method getMethod(String name, Class<?>... parameterTypes)

返回一個 Method 對象，它反映此 Class
對象所表示的類或接口的指定公共成員方法。

Method[] getMethods()

返回一個包含某些 Method 對象的數組，這些對象反映此 Class
對象所表示的類或接口（包括那些由該類或接口聲明的以及從超類和超接口繼承的那些的類或接口）的公共 member 方法。

int getModifiers()

返回此類或接口以整數編碼的 Java 語言修飾符。

String getName()

以 String 的形式返回此 Class
對象所表示的實體（類、接口、數組類、基本類型或 void）名稱。

Package getPackage()

獲取此類的包。

ProtectionDomain getProtectionDomain()

返回該類的 ProtectionDomain。

URL getResource(String name)

查找帶有給定名稱的資源。

InputStream getResourceAsStream(String name)

查找具有給定名稱的資源。

Object[] getSigners()

獲取此類的標記。

String getSimpleName()

返回源代碼中給出的底層類的簡稱。

Class<? super T> getSuperclass()

返回表示此 Class 所表示的實體（類、接口、基本類型或 void）的超類的 Class。

TypeVariable<Class<T>>[] getTypeParameters()

按聲明順序返回 TypeVariable 對象的一個數組，這些對象表示用此
GenericDeclaration 對象所表示的常規聲明來聲明的類型變量。

boolean isAnnotation()

如果此 Class 對象表示一個注釋類型則返回 true。

boolean isAnnotationPresent(Class<? extends Annotation> annotationClass)

如果指定類型的注釋存在于此元素上，則返回 true，否則返回 false。

boolean isAnonymousClass()

當且僅當底層類是匿名類時返回 true。

boolean isArray()

判定此 Class 對象是否表示一個數組類。

boolean isAssignableFrom(Class<?> cls)
判定此
Class
對象所表示的類或接口與指定的 Class 參數所表示的類或接口是否相同，或是否是其超類或超接口。

boolean isEnum()

當且僅當該類聲明為源代碼中的枚舉時返回 true。

boolean isInstance(Object obj)

判定指定的 Object 是否與此 Class
所表示的對象賦值兼容。

boolean isInterface()

判定指定的 Class 對象是否表示一個接口類型。

boolean isLocalClass()

當且僅當底層類是本地類時返回 true。

boolean isMemberClass()

當且僅當底層類是成員類時返回 true。

boolean isPrimitive()

判定指定的 Class 對象是否表示一個基本類型。

boolean isSynthetic()

如果此類是復合類，則返回 true，否則 false。

T newInstance()

創建此 Class 對象所表示的類的一個新實例。

String toString()

將對象轉換為字符串。

posted @ 2012-06-23 17:07 兔小翊閱讀(164) | 評論 (0) | 編輯收藏

常用鏈接

留言簿

隨筆檔案

搜索

最新評論

閱讀排行榜

評論排行榜