argc argv

argc argc用法

int main(int argc, char **argv)

假設執行為:  test.exe  a b c

則輸出為:   argv[0] = test.exe, argv[1] = a, argv[2] = b, argv[3] = c

argc = 4

savedInstanceState Bundle 存值取值

savedInstanceState.putParcelable("名稱 A", 物件_A);
savedInstanceState.putInt("名稱 B", 物件_B);
物件_C.writeToBundle(savedInstanceState, "名稱 C");
物件_D.writeToBundle(savedInstanceState, "名稱 D");


super.onRestoreInstanceState(savedInstanceState);
物件_A = savedInstanceState.getParcelable("M名稱 A");
物件_B = savedInstanceState.getInt("名稱 B");
物件_C.readFromBundle(savedInstanceState, "名稱 C");
物件_D.readFromBundle(savedInstanceState, "名稱 D");

Broadcast 設計

Broadcast 廣播機制

//傳送廣播
public class SentBroadcas extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);

Button b1 = (Button) findViewById(R.id.Button01);
//點擊Button後發送廣播
b1.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
Intent intent = new Intent().setAction("android.intent.test")
sendBroadcast(intent);
}
});
}
}

//接收廣播
public class BroadcastReciever extends BroadcastReceiver {
@Override
public void onReceive(Context context, Intent intent) {
if(intent.getAction().equals("android.intent.test")){
}
}
}


//在AndroidManifest.xml註冊
<receiver android:name="BroadcastReciever">
    <intent -filter="">
        <action android:name="android.intent.test">
        </action></intent>
</receiver>

----------------------------------------------------------------------------------------------

Android Handler

Handler

使用Handler的post方法，將要執行的執行緒物件加到佇列中

handler.post(updateThread); 馬上加入到消息佇列內

創造一個Handler物件

Handler handler = new Handler();

將要執行的功能寫到執行緒物件的run方法中

Runnable updateThread = new Runnable(){

        @override

        public void run(){

        System.out.println(“UpdareThread”);

        handler.postDelayed(updateThread, 3000); 每3000毫秒加一次

}

}

將Thread移除

handler.removeCallbacks(updateThread);

將ProgressBar加入到Handler

根據控制鍵ID取的代表控制鍵的物件，並為按鈕設置監聽器

Runnable updateThread = new Runnable(){

int i = 0 ;

        @Override

        public void run() {

            System.out.println("Begin Thread");

            i = i + 10 ;

                //取的一個消息物件，Message類別由Android操作系統提供

            Message msg = updateBarHandler.obtainMessage();

                //將msg物件的arg1參數設置為I，用arg1和arg2這兩個成員資料傳遞消息，優點為系統  性能消耗較少

            msg.arg1 = i ;

            try {

                        //設置當前執行緒睡眠1秒

                        Thread.sleep(1000);

            } catch (InterruptedException e) {

                        e.printStackTrace();

            }

                //將msg物件加入到消息佇列中

                updateBarHandler.sendMessage(msg);

            if( i == 100){ //當i值為100時，將執行緒物件從Handler中移除

                        updateBarHandler.removeCallbacks(updateThread);

            }

        }

};

//使用匿名內部類別來覆寫Handler中的handleMessage方法

Handler updateBarHandler = new Handler(){

@Override

public void handleMessage(Message msg) { //取得Message msg

bar.setProgress(msg.arg1);

updateBarHandler.post(updateThread);

}

sendMessage(msg); 送msg到佇列

handleMessage(Message msg) 從佇列取msg

Handler不是產生一個thread來執行而是直接使用runnable方法

Bundle 類似鍵值對

HandlerThread 實作了looper來處理消息佇列功能

這個類別由Android應用程序框架提供

HandlerThread  handlerThread = new HandlerThread(“handler_thread”);

handlerThread.start();

MyHandler myHandler = new MyHandler(handlerThread.getLooper());

Message msg = myHandler.obtainMessage(); //得到消息

Msg.sendToTarget(); //將msg發送到目標物件，所謂的目標物件就是生成msg物件的handler物件

class MyHandler exteands Handler{

        public MyHandler(){

}

Public MyHandler(Looper looper){ //將handler綁定到looper上

        super(looper);

}

}

傳送資料與取得資料

msg.obj=”abc”;

String s = (String)msg.obj;

傳送大量資料利用Bundle

Bundle b = new Bundle();

b.putInt(“age”, 20);

b.putString(“name”, “Jhon”);

msg.setData(b);

msg.sendToTarget();

取資料

Bundle b = msg.getData();

Int ag = b.getInt(“age”);

String name = b.getString(“name”);

JAVA設計模式

複合(composition)或聚合(aggregation) ---   has-a

即以既有的classes合成新的class

將某個class物件置於另一個class內

新的classes可由任意數目 任意型別的他種物件組成

繼承

父類別 --- base class, super class, parent class

子類別 --- derived class, inherited class, sub class, child class

子類別完全覆寫父類別 is-a

子類別加入新介面元素 is-like-a

陣列宣告

1. Integer[] a = new Integer[3];

2. Integer[] a = new Integer[] {new Integer(1), new Integer(2), 3,};

3. Integer[] a = {new Integer(1), new Integer(2), 3,};

//初值列最後的逗號可有可無

委任(delegation)

介於繼承與合成之間，將成員物件置於新建立的class中(類似合成)，但同時又將該成員的所有methods都放到新的class中，成為新的class介面的一部分(類似繼承)。

向上轉型(upcasting)

在derived class中可以使用base class的所有函式，所以任何可發送給base class的訊息，也都可以發送給derived class

多型(Polymorphism)

介面與實作分離，

工廠模式

用已產生其他其他類別的類別

抽象類別(abstract class)

用來表示介面，沒有專屬的實作內容，含有0個或1個以上的abstract method的類別稱為abstract class，且不可產生物件，繼承abstract class的derived class需要實作abstract method。

介面(interface)

可以內含資料成員，但這些資料成員都會自然成為static和final，介面只提供形式，不含實作內容，介面可允許設計出可向上轉型至多個基礎型別的class，以達到多重繼承的變形，且不可產生物件

Strategy設計模式

依據所傳入的引數物件不同，而有不同行為展現的method

Adapter

撰寫程式碼來接收既有的介面，並且產生你所需的介面



class Member{
private int mid;
private String name;
private Car car;
public Member(int mid, String name){
this.mid = mid;
this.name = name;
}
public String getMemberInfo() {
return "編號" + this.mid + ", 姓名" + this.name;
}
public void setCar(Car car){
this.car = car;
}
public Car getCar(){
return this.car;
}
}
class Car{
private Member member;
private String name;
public Car(String name){
this.name = name;
}
public String getCarInfo(){
return "車的名稱 " + this.name;
}
public void setMember(Member member){
this.member = member;
}
public Member getMember(){
return this.member;
}
}

public class Hello {
public static void main(String args[]) {
Member mem = new Member(1, "kent");
Car car = new Car("BMW");
mem.setCar(car);
car.setMember(mem);
System.out.println(mem.getMemberInfo());
System.out.println(mem.getCar().getCarInfo());
}
}

class Node{

                private String data;

                private Node next;

                public Node(String data){

                                this.data = data;

                }

                public void setNext(Node next){

                                this.next = next;

                }

                public Node getNext(){

                                return this.next;

                }

                public String getData(){

                                return this.data;

                }

                public void addNode(Node newNode){

                                if(this.next == null){

                                                this.next = newNode;

                                }else{

                                                this.next.addNode(newNode);

                                }

                }

                public void printNode(){

                                System.out.println(this.data);

                                if(this.next != null){

                                                this.next.printNode();

                                }

                }

                public boolean containsNode(String data){

                                if(this.data.equals(data)){

                                                return true;

                                }else{

                                                if(this.next != null){

                                                                return this.next.containsNode(data);

                                                }else{

                                                                return false;

                                                }

                                }

                }

                public void removeNode(Node previous, String data){

                                if(this.data.equals(data)){

                                                previous.next = this.next;

                                }else{

                                                this.next.removeNode(this, data);

                                }

                }

}

class Link{

                private Node root;

                public void add(String data){

                                if(data == null){

                                                return;

                                }

                                Node newNode = new Node(data);

                                if(this.root == null){

                                                this.root = newNode;

                                }else{

                                                this.root.addNode(newNode);

                                }

                }

                public void print(){

                                if(this.root != null){

                                                this.root.printNode();

                                }

                }

                public boolean contains(String data){

                                if(data == null || this.root == null){

                                                return false;

                                }

                                return this.root.containsNode(data);

                }

                public void remove(String data){

                                if(this.contains(data)){

                                                if(this.root.getData().equals(data)){

                                                                this.root = this.root.getNext();

                                                }else{

                                                                this.root.getNext().removeNode(this.root, data);

                                                }

                                }

                }

}

public class Hello{

                public static void main(String args[]){

                                Link all = new Link();

                                all.add("A");

                                all.add("B");

                                all.add("C");

                                all.remove("B");

                                all.remove("A");

                                all.print();

                                System.out.println(all.contains("A"));

                                System.out.println(all.contains("X"));

                               

                }

}