2010年7月22日 星期四

String/StringBuffer, Vector/ArrayList, HashMap/Hashtable, Interface/Abstract class, Preparedstatement/Statement

String 和 StringBuffer 的區別～
JAVA平台提供了兩個類：String和StringBuffer，它們可以儲存和操作字符串，即包含多個字符的字符數據。這個String類 提供了數值不可改變的字符串。而這個StringBuffer類提供的字符串進行修改。當你知道字符數據要改變的時候你就可以使用 StringBuffer。典型地，你可以使用StringBuffers來動態構造字符數據。

ArrayList,Vector, LinkedList的存儲性能和特性～
ArrayList和Vector都是使用數組方式存儲數據，此數組元素數大於實際存儲的數據以便增加和插入元素，它們都允許直接按序號索引元素，但是插入元素要涉及數組元素移動等內存操作，所以索引數據快而插入數據慢，Vector由於使用了synchronized方法（線程安全），通常性能上較ArrayList差，而LinkedList使用雙向鏈表實現存儲，按序號索引數據需要進行前向或後向遍歷，但是插入數據時只需要記錄本項的前後 項即可，所以插入速度較快。

HashMap和Hashtable的區別～
HashMap是Hashtable的輕量級實現（非線程安全的實現），他們都完成了Map接口，主要區別在於HashMap允許空（null）鍵值（key），由於非線程安全（Synchronized），效率上可能高於Hashtable。
HashMap允許將null作為一個entry的key或者value，而Hashtable不允許。
HashMap把Hashtable的contains方法去掉了，改成containsvalue和containsKey。因為contains方法容易讓人引起誤解。
Hashtable繼承自Dictionary類，而HashMap是Java1.2引進的Map interface的一個實現。
最大的不同是，Hashtable的方法是Synchronize的，而HashMap不是，在多個線程訪問Hashtable時，不需要自己為它的方法實現同步，而HashMap 就必須為之提供外同步。
Hashtable和HashMap採用的hash/rehash算法都大概一樣，所以性能不會有很大的差異。


abstract class和interface有什麼區別～
聲明方法的存在而不去實現的類（class）被叫做抽像類（abstract class），它用於要創建一個體現某些基本行為的類，並為該類聲明方法，但不能在該類中實現該類的情況。不能創建abstract 類的實例。然而可以創建一個變量，其類型是一個抽像類，並讓它指向具體子類的一個實例。不能有抽像構造函數或抽像靜態方法。Abstract 類的子類為它們父類中的所有抽像方法提供實現，否則它們也是抽像類為。取而代之，在子類中實現該方法。知道其行為的其它類可以在類中實現這些方法。
接口（interface）是抽像類的變體。在接口中，所有方法都是抽像的。多繼承性可通過實現這樣的接口而獲得。接口中的所有方法都是抽像的， 沒有一個有程序體。接口只可以定義static final成員變量。接口的實現與子類相似，除了該實現類不能從接口定義中繼承行為。當類實現特殊接口時，它定義（即將程序體給予）所有這種接口的方法。 然後，它可以在實現了該接口的類的任何對像上調用接口的方法。由於有抽像類，它允許使用接口名作為引用變量的類型。通常的動態聯編將生效。引用可以轉換到 接口類型或從接口類型轉換，instanceof 運算符可以用來決定某對象的類是否實現了接口。

Interface:
完全的class藍圖，只能定義名稱，無法定義內容
1. multiple inheritance: A class may implement multiple interfaces.
2. default implementation: An interface cannot provide any code at all, much less default code.

Abstract class:
abstract method可只定義名稱，但不給定內容
把class的藍圖建立起來，由subclass實做
至少擁有一abstract method的class稱為abstract class
1. multiple inheritance: A class may extend only one abstract class.
2. default implementation: An abstract class can provide complete code, default code, and/or just stubs that have to be overridden.


JDBC Preparedstatement 和 Statement 的區別～
Statement 是在執行時才會去編譯SQL語法，
而PreparedStatement 是預先編譯(precompiled)SQL語法，待不定個數的參數代入時才去執行SQL。
所以如果當SQL語法固定且重複性高時，使用PreparedStatement的效率會比較好。

另外，使用PreparedStatement也可以相對的避免一些SQL Injection。

PreparedStatement 也不是沒有缺點，就是因為代入參數，所以無法知道真正執行程式時的SQL語法，造成debug的難度增加。



張貼者： 於 沒有留言:
標籤：

Java Immutable Objects

A strategy for defining Immutable Objects

First let's see an example, SynchronizedRGB
public class SynchronizedRGB {

   //Values must be between 0 and 255.
   private int red;
   private int green;
   private int blue;
   private String name;

   private void check(int red, int green, int blue) {
       if (red <> 255
               || green <> 255
               || blue <> 255) {
           throw new IllegalArgumentException();
       }
   }

   public SynchronizedRGB(int red, int green, int blue, String name) {
       check(red, green, blue);
       this.red = red;
       this.green = green;
       this.blue = blue;
       this.name = name;
   }

   public void set(int red, int green, int blue, String name) {
       check(red, green, blue);
       synchronized (this) {
           this.red = red;
           this.green = green;
           this.blue = blue;
           this.name = name;
       }
   }

   public synchronized int getRGB() {
       return ((red << 16) | (green << 8) | blue);
   }

   public synchronized String getName() {
       return name;
   }

   public synchronized void invert() {
       red = 255 - red;
       green = 255 - green;
       blue = 255 - blue;
       name = "Inverse of " + name;
   }
}


Immutable Objects:

The following rules define a simple strategy for creating immutable objects. Not all classes documented as "immutable" follow these rules. This does not necessarily mean the creators of these classes were sloppy — they may have good reason for believing that instances of their classes never change after construction. However, such strategies require sophisticated analysis and are not for beginners.

  1. Don't provide "setter" methods — methods that modify fields or objects referred to by fields.
  2. Make all fields final and private.
  3. Don't allow subclasses to override methods. The simplest way to do this is to declare the class as final. A more sophisticated approach is to make the constructor private and construct instances in factory methods.
  4. If the instance fields include references to mutable objects, don't allow those objects to be changed:
    • Don't provide methods that modify the mutable objects.
    • Don't share references to the mutable objects. Never store references to external, mutable objects passed to the constructor; if necessary, create copies, and store references to the copies. Similarly, create copies of your internal mutable objects when necessary to avoid returning the originals in your methods.

Applying this strategy to SynchronizedRGB results in the following steps:

  1. There are two setter methods in this class. The first one, set, arbitrarily transforms the object, and has no place in an immutable version of the class. The second one, invert, can be adapted by having it create a new object instead of modifying the existing one.
  2. All fields are already private; they are further qualified as final.
  3. The class itself is declared final.
  4. Only one field refers to an object, and that object is itself immutable. Therefore, no safeguards against changing the state of "contained" mutable objects are necessary.
After these changes, we have ImmutableRGB

final public class ImmutableRGB {

   //Values must be between 0 and 255.
   final private int red;
   final private int green;
   final private int blue;
   final private String name;

   private void check(int red, int green, int blue) {
       if (red <> 255
               || green <> 255
               || blue <> 255) {
           throw new IllegalArgumentException();
       }
   }

   public ImmutableRGB(int red, int green, int blue, String name) {
       check(red, green, blue);
       this.red = red;
       this.green = green;
       this.blue = blue;
       this.name = name;
   }


   public int getRGB() {
       return ((red << 16) | (green << 8) | blue);
   }

   public String getName() {
       return name;
   }

   public ImmutableRGB invert() {
       return new ImmutableRGB(255 - red, 255 - green, 255 - blue,
               "Inverse of " + name);
   }
}

張貼者： 於 沒有留言:
標籤：

Java synchronized example

//Consider a simple class called Counter

class Counter {
private int c = 0;

public void increment() {
c++;
}

public void decrement() {
c--;
}

public int value() {
return c;
}

}


Counter is designed so that each invocation of increment will add 1 to c, and each invocation of decrement will subtract 1 from c. However, if a Counter object is referenced from multiple threads, interference between threads may prevent this from happening as expected.

Interference happens when two operations, running in different threads, but acting on the same data, interleave. This means that the two operations consist of multiple steps, and the sequences of steps overlap.

It might not seem possible for operations on instances of Counter to interleave, since both operations on c are single, simple statements. However, even simple statements can translate to multiple steps by the virtual machine. We won't examine the specific steps the virtual machine takes — it is enough to know that the single expression c++ can be decomposed into three steps:

  1. Retrieve the current value of c.
  2. Increment the retrieved value by 1.
  3. Store the incremented value back in c.
The expression c-- can be decomposed the same way, except that the second step decrements instead of increments.

Suppose Thread A invokes increment at about the same time Thread B invokes decrement. If the initial value of c is 0, their interleaved actions might follow this sequence:

  1. Thread A: Retrieve c.
  2. Thread B: Retrieve c.
  3. Thread A: Increment retrieved value; result is 1.
  4. Thread B: Decrement retrieved value; result is -1.
  5. Thread A: Store result in c; c is now 1.
  6. Thread B: Store result in c; c is now -1.
Thread A's result is lost, overwritten by Thread B. This particular interleaving is only one possibility. Under different circumstances it might be Thread B's result that gets lost, or there could be no error at all. Because they are unpredictable, thread interference bugs can be difficult to detect and fix.

//synchronized
public class SynchronizedCounter {
private int c = 0;

public synchronized void increment() {
c++;
}

public synchronized void decrement() {
c--;
}

public synchronized int value() {
return c;
}
}

If count is an instance of SynchronizedCounter, then making these methods synchronized has two effects:
  • First, it is not possible for two invocations of synchronized methods on the same object to interleave. When one thread is executing a synchronized method for an object, all other threads that invoke synchronized methods for the same object block (suspend execution) until the first thread is done with the object.
  • Second, when a synchronized method exits, it automatically establishes a happens-before relationship with any subsequent invocation of a synchronized method for the same object. This guarantees that changes to the state of the object are visible to all threads.

Note that constructors cannot be synchronized — using the synchronized keyword with a constructor is a syntax error. Synchronizing constructors doesn't make sense, because only the thread that creates an object should have access to it while it is being constructed.


張貼者： 於 沒有留言:
標籤：

Java Basic 之一

Class(類別) 種類～
public: can be used by anyone (even outside of the package)
(none): can be used within this package
abstract: 代表類別內有尚未實做的method
final: 代表此類別不能被別人 inherit

method 範圍種類～
public: can be accessed by anyone (even outside of the package)
protected: can be accessed within this package, **[also... subclass can accessed it even not in the same package]**
(none): can be accessed within this package.
private: can be accessed only by this class.
method 特性種類～
static: 靜態method, 不用被new就可使用
final: 不能被subclass override.
abstract: 只有宣告沒有實體程式的method, child class可以自己寫程式碼.
native: 代表method是用別的程式語言寫成的 (非JAVA)
synchronized: 此method有multi-threads的共用資料, 需被“Monitor” 機制控管.

variable 種類～
static: 靜態變數 (can be used as Class.XXX)
final: 不能改變的值
transient: 暫存變數 (在Object Serialization時, 此變數不存入Hard Drive)
volatile: 迅變變數 (宣告此變數為多工處理的共用變數。Java VM 會保證 volatile 變數安全地被各 client program 存取)

Overloading～
一個Class(類別)擁有一個以上的同名method(函式)，稱為 overloading.
ex:
// Demonstrate method overloading.
class OverloadDemo {
void test() {
System.out.println("No parameters");
}
// Overload test for one integer parameter.
void test(int a) {
System.out.println("a: " + a);
}
// Overload test for two integer parameters.
void test(int a, int b) {
System.out.println("a and b: " + a + " " + b);
}
// overload test for a double parameter
double test(double a) {
System.out.println("double a: " + a);
return a*a;
}
}

class Overload {
public static void main(String args[]) {
OverloadDemo ob = new OverloadDemo();
double result;
// call all versions of test()
ob.test();
ob.test(10);
ob.test(10, 20);
result = ob.test(123.2);
System.out.println("Result of ob.test(123.2): " + result);
}
}

Overriding～
ex:
// Method overriding
class A {
int i, j;
A(int a, int b) {
i = a;
j = b;
}
// display i and j
void show() {
System.out.println("i and j: " + i + " " + j);
}
}

class B extends A {
int k;
B(int a, int b, int c) {
super(a, b);
k = c;
}
// display k – this overrides show() in A
void show() {
System.out.println("k: " + k);
}
}

class Override {
public static void main(String args[]) {
B subOb = new B(1, 2, 3);
subOb.show(); // this calls show() in B
}
}
張貼者： 於 沒有留言:
標籤：

Java Basic 之一

Class(類別) 種類～
public: can be used by anyone (even outside of the package)
(none): can be used within this package
abstract: 代表類別內有尚未實做的method
final: 代表此類別不能被別人 inherit

method 範圍種類～
public: can be accessed by anyone (even outside of the package)
protected: can be accessed within this package, **[also... subclass can accessed it even not in the same package]**
(none): can be accessed within this package.
private: can be accessed only by this class.
method 特性種類～
static: 靜態method, 不用被new就可使用
final: 不能被subclass override.
abstract: 只有宣告沒有實體程式的method, child class可以自己寫程式碼.
native: 代表method是用別的程式語言寫成的 (非JAVA)
synchronized: 此method有multi-threads的共用資料, 需被“Monitor” 機制控管.

variable 種類～
static: 靜態變數 (can be used as Class.XXX)
final: 不能改變的值
transient: 暫存變數 (在Object Serialization時, 此變數不存入Hard Drive)
volatile: 迅變變數 (宣告此變數為多工處理的共用變數。Java VM 會保證 volatile 變數安全地被各 client program 存取)

Overloading～
一個Class(類別)擁有一個以上的同名method(函式)，稱為 overloading.
ex:
class Rectangle{
int l, b;
float p, q;
public Rectangle(int x, int y){
l = x;
b = y;
}
public int first(){
return(l * b);
}
public Rectangle(int x){
l = x;
b = x;
}
public int second(){
return(l * b);
}
public Rectangle(float x){
p = x;
q = x;
}
public float third(){
return(p * q);
}


}

Overriding～
張貼者： 於 沒有留言:
標籤：

2010年7月21日 星期三

Java synchronized

簡單介紹

Synchronized使用時，需指定一個物件，系統會 Lock此物件，當程式進入Synchrnoized區塊或Method時，該物件會被Lock，直到離開Synchronized時才會被釋放。在 Lock期間，鎖定同一物件的其他Synchronized區塊，會因為無法取得物件的Lock而等待。待物件Release Lock後，其他的Synchronized區塊會有一個取得該物件的Lock而可以執行。

各種用法

1. Synchronized Method
synchrnoized public void syncMethod() {
…
}

此種synchronized用法鎖定的物件為Method所屬的物件，只要物件被new出超過一個以上的Instance，就有可能保護不到Method內程式。但如果此物件只會被new出一個Instance，譬如 new出來後就放到ServletContext，要用的時候從ServletContext中拿出來執行，就可以避免此情況。

2. Synchronized Static Method
synchrnoized static public void syncMethod() {
…
}

此種synchronized用法鎖定的物件為Method所屬的物件的 Class，不管被new出幾個的Instance，都能夠保證同一個時間只會有一個Thread在執行此Method。

3. Synchronized(this)
public void syncMethod() {
synchronized(this) {
…
}
}

此種synchronized用法與 synchronized method用法一樣，都是鎖定Method所屬的物件本身。

4. Synchronized(SomeObject)
public void syncMethod() {
synchronized(SomeObject) {
…
}
}

此種 synchronized用法鎖定的是SomeObject，如果SomeObject是同一個Class的兩個不同Instance，那 synchronized區塊內就有可能被同時執行。如果每一個Synchronized的SomeObject都是同一個Instance（或者 SomeObject本身就是Static），就可以保證區塊內同時間只會有一個Thread執行。

當使用 Synchornized(SomeObject)時，SomeObject本身處於被Lock狀態，但此時其他的Thread是可以去更改 SomeObject裡面的值，Lock只是同步化的狀態，不表示不能更改資料。

使用時機

Synchronized的使用時機很難定義，比較常見的情況是，當程式中會取出某一個共用的物件且會判斷物件內容值，再更新物件內容，此情況大部分都需要synchronized保護。

=====================

Java synchronized概念

假設有一排餐廳，他們的編號從1...到無限大 ，每間餐廳都通過Restaurant標準，因此都能提供某些固定的服務。
每間餐廳都擁有一些一般區域與一個預約包廂，一般區域可以讓任意數量的人通行；而包廂只能同時讓一個人使用，若是有多於一個人要用，第一個進入包廂的人會將門鎖上，因此其他要進去的人就無法進入了，另外。
而這些餐廳共用一間豪華廁所，也是一次只能容納一個顧客，若廁所中已經有人，則後到者要等待。

在此例子，每個物件與 Java術語的對應關係是：

* 餐廳標準Restaurant：Class Restaurant
* 餐廳1號：Instance 1 of Restaurant
* 每間餐廳的一般區域：Normal Methods of Instance Restaurant
* 每間餐廳的包廂：Synchronized Methods of Instance Restaurant
* 顧客：Thread
* 所有餐廳共用的豪華廁所：Synchronized Static Methods of Class Restaurant

另外，所謂的包廂，指的是一組房間，因此所有被設定為synchronized的method都算在同一組包廂內。

1.現在若有兩人想要使用同一個餐廳的包廂，後到者B會被檔在門外，而先到者A可以進入包廂並任意使用其中的任何房間，B必須呆呆等到A離開這個包廂，或者A自願進入一間等待室，讓B進入。

在此例中，Thread A呼叫了餐廳instance r1的synchronized method m1();且Thread B隨後呼叫r1的另一個synchronized method m2();則B被阻擋，直到A離開m1()或者A執行了r1的wait()為止。

2.另一例子，若A進入包廂，但B在一般區域活動是沒有問題的，B並不會受到阻擋。
張貼者： 於 沒有留言:
標籤：

Java multi thread 的 sample

Horse.java

import java.lang.Thread;

class Horse extends Thread {
final int MAX_DISTANCE = 600;
int RaceDistance = 400;
int CurrentDistance = 0;
long RaceTime = 0L;

// Constructors
public Horse( ) {
super( );
}

public Horse(String name) {
super(name);
}

public Horse(String name, int distance) {
super(name);
RaceDistance = (distance < MAX_DISTANCE)? distance: MAX_DISTANCE;
}

public void run( ) {
long begin = 0L, end = 0L;
begin = System.currentTimeMillis( );
while (CurrentDistance <= RaceDistance) {
CurrentDistance += Math.floor(Math.random( ) * 10);
System.out.println(getName( ) + ": " + CurrentDistance);
try {
sleep((long)(Math.random( ) * 1000));
} catch (InterruptedException e) {}
}
end = System.currentTimeMillis( );
RaceTime = end - begin;
}//end of run

public int getCurrentDistance( ) {
return CurrentDistance;
}
public long getRaceTime( ) {
return RaceTime;
}
}//end of class


----------------- 我是分隔線 --------------------
RaceHorse.java

public class RaceHorse {

public static void main(String[ ] args) {
Horse Rubby = new Horse("Rubby", 40);
Horse Lisa = new Horse("Lisa", 40);
Rubby.start( );
Lisa.start( );
while (Rubby.isAlive( ) || Lisa.isAlive( )) {
// Do nothing, just wait for the end.
}
if (Rubby.getRaceTime( ) < Lisa.getRaceTime( ))
System.out.println("Rubby win!! Record: " + Rubby.getRaceTime( ) + " ms");
else if (Rubby.getRaceTime( ) > Lisa.getRaceTime( ))
System.out.println("Lisa win!! Record: "+ Lisa.getRaceTime( ) + " ms");
else
System.out.println("Deuce! Record: "+ Rubby.getRaceTime( ));
}//end of main

}//end of class



張貼者： 於 沒有留言:
標籤：

Java Thread 的應用

==== from http://catyku.pixnet.net/blog/post/28903471 ====

Thread的應用，最好的例子就是SocketServer，

Thread簡介可以參考Java Thread簡介

Apache Tomcat用最簡單的方式看，它也是個SocketServer，服務http要求及回覆，

底下有一個簡單的例子，可以建立一個SocketServer，等待Connection的連入

概念是建立一個port Waiting，有人連入後，則再回到Waiting

順便說明implement java.lang.Runnable的用法

public class SocketServer implements java.lang.Runnable {
private int port;
private java.net.ServerSocket ss;

public SocketServer(int port) throws java.io.IOException {
this.port = port;
// 建立一個ServerSocket
this.ss = new java.net.ServerSocket(port);
}

public void run() {
java.net.Socket sk = null;
while (true)// 永遠執行
{
// 等待連入
System.out.println("waiting...");
try {
// 取得連線Socket
sk = this.ss.accept();
// 取得Client連線Address
System.out.println(sk.getLocalAddress());
sk.close();
} catch (java.io.IOException e) {
e.printStackTrace();
}

}
}

public static void main(String args[]) throws java.io.IOException {
// runable要new一個Thread,再把runnable置入
java.lang.Thread thread = new java.lang.Thread(new SocketServer(81));
thread.start();
}
}

可利利用Browser來測試結果，

在網址列打入http://localhost:81 http://ServerIP:port

可以看到Server程式回應如下：

waiting…
0.0.0.0/0.0.0.0
waiting…

取得連線Socket後馬上又accept等待了。

張貼者： 於 沒有留言:
標籤：

Java Thread 之一

===== Java Thread 簡介 =====

Thread 中文翻成 線程

但記得在我看過的JAVA書裡有書翻成 執行緒

Thread 用途:

Thread 用於在同一時間執行多事件,

相當類似於Process

但兩者的區別在於

Process: 要把Process想成 CPU, 多個Process 代表多個CPU 而是每個Process去執行各個不同的程式

Thread: 代表分成很多工作 但是在同一個Process 裡執行, 只是一直切換工作執行, 所以看起來Thread是同時執行的

所以在同一時間內

Process 可以同時有許多個,

但Thread 在同一時間內只有一個,只是他切 換的速度很快所以乍看之下,所有事情都是同時執行

public class TestThread extends java.lang.Thread {

public long waittime;
public String data;

public TestThread(long waittime, String value) {
this.waittime = waittime;
this.data = value;
}

public void run()// 啟動Thread時會執行run
{
try {
while (true) {// 永遠讓Thread執行下去,只有在強制中斷時才會失效
// 停幾秒後執行System內容
Thread.sleep(waittime);
System.out.println(this.data);
}
} catch (Exception e) {
e.printStackTrace();
}

}

public static void main(String args[]) {
// 1000毫秒 = 1秒
// 用start 來啟動thread
(new TestThread(3 * 1000, "Thread-1")).start();
(new TestThread(1 * 1000, "Thread-2")).start();

}
}

備註: 當從主程式(main)呼叫 TestThread時 會先把參數帶給建構子,然後自 動跑 Class TestThread 中的 Run (方法)

結果如下：(可能會有所不同)

Thread-2
Thread-2
Thread-1
Thread-2
Thread-2
Thread-2
Thread-1
Thread-2
Thread-2
Thread-2

......

張貼者： 於 沒有留言:
標籤：

Java static 之一

===== Javaworld TW, adoo 大大 ======

static 翻做 靜態 就是說 一開始 就保留給 宣告成 static 的 成員 或函式
如果以c++來說 就是固定一個記憶體位置給 宣告成 static 的 成員 或函式
不管你 new 幾個物件 , static 的成員或函式 始終指向同樣的記憶體位置
所以當你 更改 static 的 成員的值時
所有 new 出來的物件 中的static 的 成員的值就都會變了

===== Java Gossip: 關 於 static 成員=====
(http://caterpillar.onlyfun.net/Gossip/JavaGossip-V1/AboutStaticMember.htm)

對於每一個基於相同類別所產生的物件而言，其擁有各自的資料成員，然而在某些時候，您會想要這些物件擁有相同的資料成員，其資料是共享的。

舉個例子來說，在Ball類別中，您會使用到圓周率的這個資料，對於任一個球而言，圓周率都是一樣的，您並不需要讓不同的球物件擁有各自的資料成員來記錄 圓周率，而這個記錄的值卻是相同，這只會增加記憶體的消耗而已。

您可以將資料成員宣告為"static"，被宣告為"static" 的資料成員，它是屬於類別所擁有，而不是個別的物件，您可以將"static"視為個別物件所擁有、共享的資料成員。

要宣告static變數，您只要在宣告資料成員時加上"static"關鍵字就可以了，例如：
public class Ball {
// ....
public static double PI = 3.14159; // 宣告static資料

public Ball() {
// ..
}

public Ball(double radius, String name) {
//...
}

public double getVolumn() {
// ......
}
}

由於static成員屬於類別所擁有，所以在不使用物件名稱的情況下，您也可以使用類別名稱加上 . 運算子來存取static資料成員，例如：
System.out.println("PI = " + Ball.PI);

static變數同樣遵守public、protected與 private的存取限制，所以若您要在類別之外直接存取static變數，必須注意它的權限（例如必須設定為public成員）。

雖然您也可以在宣告物件之後，使用 . 運算子來存取static資料成員，但是這並不被鼓勵，通常建議使用類別名稱加上 . 運算子來存取，一方面也可以避免與非static成員混淆。

與靜態資料成員類似的，您也可以宣告方法成員為static方法，又稱靜態方法， 被宣告為靜態的方法通常是為了提供工具，例如在Ball類別上增加一個角度轉徑度的方法toRadius()：
public class Ball {
...
public static double toRadius(double angle) {
return 3.14159 / 180 * angle;
}
}

與靜態資料成員一樣的，您可以透過類別名稱使用'.'運算子來存取static方法（當然要注意權限設定，例如設定為public），例如：
System.out.println("角 度90等於徑度" + Ball.toRadius(90));


靜態資料與靜態方法的作用通常是為了提供共享的資料或工具方法，例如將數學常用常數或計算公式，以static宣告並撰寫，之後您可以把這個類別當作工 具，透過類別名稱來管理與取用這些靜態資料或方法，例如像J2SE 所提供的Math 類別上，就有Math.PI這個靜態常數，以及Math.Exp()、Math.Log()、Math.Sin()等 靜態方法可以直接使用，另外還有像Integer.parseInt()、Integer. MAX_VALUE等也都是靜態方法與靜態資料成員的實際例 子。

由於static成員是屬於類別而不是物件，所以當您呼叫static方法時，並不會傳入物件的位置參考，所以static方法中不會有 this參考，由於沒有this參考，所以在Java的static方法成員中不允許使用非static成員，因為程式沒有this來參考至物件位址，也 就無法辨別要存取哪一個物件的成員，事實上，如果您在static方法中使用非static資料成員，在編譯時就會出現以下的錯誤訊息：
non-static variable test cannot be referenced from a static context

或者是在static函式中呼叫非static函式，在編譯時就會出現以下的錯誤訊息：
non-static method showMe() cannot be referenced from a static context

Java在使用到類別時才會加以載入程式中，如果您要使用一個static資料或方法，而在載入一個類別時，您希望先進行一些初始化動作，您可以使用 static定義一個區塊，並在當中撰寫初始化資源的動作，例如：
public class Ball {
public static int[] arr = new int[10];
 static {
// 一些初始化程式碼
 }

....
}


像上面這樣一個類別，在第一次呼叫而被載入時，static區塊中的程式碼就會被執行，且只會執行一次，要注意的是，static屬性成員必須撰寫在 static區塊之前，而如果在static區塊中發生了例外，則最後會被包裝為 java.lang.ExceptionInInitializerError。




===== from 海芋小站, http://www.inote.tw/2007/12/java-static.html =====

其實這是海芋最近碰到的一個小問題，為什麼在同一個類別中，Static Method不能存取Non-Static Method呢？於是海芋就想啊想的，加上翻了一下資料，終於恍然大悟，就把他寫下來，避免將來忘記。

其實，若以Static和Non- Static分為兩種不同的型態，則Java大概可以分為四種資料成員，分別為「class field」、「class method」、「instance filed」、「instance method」[1]、而這麼 多的型態，我們該如何去分辨呢？

而在Java中，你可以把Static看成是類別所擁有的，而且是一開始就放置於記憶體中的，而 Instance則是伴隨著物件產生而產生的。

所以，如果我們有下列片段程式碼：
public class CD
{
public static double PI = Math.PI;
public double area = 0;
public CD()
{
.........
}
}
而這段程式碼之中，因為PI這個變數是宣告為static的，所以他是屬於 CD類別，因此若您要在別的類別存取他，只要使用「CD.PI」即可，其中「CD為類別名稱」、「PI則為變數名稱」。

再來，因為 area不為static，因此您只能建立物件，再存取他，所以您如果要在別的類別存取他，只能這樣使用。
CD cd1 = new CD();
cd1.area = 20;
而又倒底是 什麼原因，讓static method只能存取static method呢？原因很簡單，因為在同一個類別之中，沒有建立自己的物件，既然沒有建立物件，那如何存取instance method呢？

而 在instance method中，則是可以存取到static method，但是仍然要以「類別名稱.變數/method名稱」來存取，這點是相當重要的喔！

所以總結如下：
  1. 在 同一個類別中，若有method宣告為static，則此method只能呼叫其它宣告為static的method。
  2. 在不同的類別 中，若要呼叫其它class的static method/field，則使用下列程式碼：
    className.fieldName
    className.methodName
  3. 若 要呼叫instance method或是instance filed，則需先建立物件，再使用下列程式碼：objectVariableName.fieldName
    objectVariableName.methodName
  4. 但 是，在同一類別中，instance method和instance method間，可以互相呼叫。
文章打完也說完了， 如果是您不是程式設計師，或許會看得霧殺殺！那就略過吧！


張貼者： 於 沒有留言:
標籤：

java 1.4 和 1.5 的差別

Java 1.5 has many new features, compare to Java 1.4. See the link for a complete explanation. Some of the features are:

  • Generics (e.g. typed collections, like Set)
  • Enhanced for loop (for (String s : set) {...})
  • Autoboxing/unboxing (automatically convert between types like Integer to int and vice versa)
    Before Java 5

    int intPrimitive = intObject.intValue();
    intPrimitive++;
    intObject = new Integer(intPrimitive);

    Using Java 5

    Integer intObject = new Integer(10);
    intObject++;

  • Typesafe enums (enum is now a keyword, types can be created out of enums)
  • Varargs (for printf() function, allows variable number of arguments)
  • Static import (can now import static methods of a class, such as java.lang.Math)
  • Annotations
張貼者： 於 沒有留言:
標籤：
訂閱： 文章 (Atom)