mingyilai的部落格

package pkg13.pkg50;

import java.util.Properties;

public class Main {

    public static void main(String[] args) {
        Properties pro = new Properties();      //建立Properties物件
        pro.setProperty("BJ", "BeiJing");       //設定內容 
        pro.setProperty("times", "60");
        
        System.out.println("BJ 的屬性值為" + pro.getProperty("BJ"));
        System.out.println("time的屬性值為" + pro.getProperty("times"));
    }
    
}
 

run:
BJ 的屬性值為BeiJing
time的屬性值為60
BUILD SUCCESSFUL (total time: 0 seconds)
 

package pkg13.pkg26;

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

public class Main {
    public static void main(String[] args) {
        Map<String, String> map = null;         //宣告Map物件
        map = new HashMap<String, String>();        //key和value是string類別
        //增加內容 
        map.put("Gjun", "巨匠電腦");
        map.put("Google", "http://www.google.com");
        map.put("Yahoo", "http://www.yahoo.com.tw");
        map.put("Pcschool", "http://www.pcschool.com.tw");
        
        String val = map.get("Gjun");       //根據key求出value
        System.out.println("val = " + val);
        
        //將map的key值全部列出
        //先宣告一個Set來接收key
        Set<String> keys = map.keySet();
        //利用Iterator介面，將集合內容輸出
        //產生key的Iterator介面實體
        Iterator <String> iter = keys.iterator();
        //hasNext判斷有值時，列出值
        while(iter.hasNext()){
            String str = iter.next();
            System.out.print(str + "  ");
            System.out.println(map.get(str));
        }
    }
}
 

run:
val = 巨匠電腦
Google  http://www.google.com
Yahoo  http://www.yahoo.com.tw
Gjun  巨匠電腦
Pcschool  http://www.pcschool.com.tw
BUILD SUCCESSFUL (total time: 0 seconds)
 

 allSet.add("aa");
        allSet.add("aa");
        allSet.add("bb");

run:
[aa, bb, cc, dd]
[aa, bb, cc, dd]
BUILD SUCCESSFUL (total time: 0 seconds)
 

package pkg13.pkg1;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

public class Main {

    public static void main(String[] args) {
        //定義一個List物件
        List<String> allList = null;            //父類別
        Collection<String> allCollection = null;
        
        allList = new ArrayList<String>();          //子類別
        allCollection = new ArrayList<String>();  //向上轉型
         
        //新增資料
        allList.add("Hello");
        allList.add("Tom");
        allList.add("May");
        //指定位置插入
        allList.add(1,"John");
        
        //刪除資料
        allList.remove(0);
        allList.remove("Tom");
        System.out.println(allList);
        
        allCollection.add("AA");
        allCollection.add("BB");
        allCollection.add("CC");
        //指定位置插入
        allList.addAll(1,allCollection);        //此處為向上轉型，所以無法執行子類別的方法
        System.out.println(allCollection);
        System.out.println(allList);
        allList.removeAll(allCollection);
        System.out.println(allList);
    }
}
 

run:
[John, May]
[AA, BB, CC]
[John, AA, BB, CC, May]
[John, May]
BUILD SUCCESSFUL (total time: 0 seconds)
 

一個多執行緒的程式如果是透過Runnable介面實現的，則表示類別中的屬性將被多個執行緒共用。

package pkg9.pkg19;

class MyThread implements Runnable{
    private int ticket = 5;
    public void run(){
        for(int i = 0 ; i < 100 ; i++){
            if(ticket > 0){
                try{
                Thread.sleep(1000);
                }catch(InterruptedException ex){}
                System.out.println("賣票 目前有" + ticket-- + "票");
                
            }
        }
    }
}
public class Main {

    public static void main(String[] args) {
        MyThread mt = new MyThread();
        Thread t1 = new Thread(mt);
        Thread t2 = new Thread(mt);
        Thread t3 = new Thread(mt);
        t1.start();
        t2.start();
        t3.start();
    }
}
 

run:
賣票 目前有4票
賣票 目前有3票
賣票 目前有5票
賣票 目前有2票
賣票 目前有1票
賣票 目前有1票
賣票 目前有0票
BUILD SUCCESSFUL (total time: 3 seconds)

同步就是指多個操作在同一個時間段內只能有一個執行緒執行，其他執行緒要等待此執行緒完成之後才可以繼續執行。

package pkg9.pkg19;

class MyThread implements Runnable {

    private int ticket = 5;

    public void run() {
        for (int i = 0; i < 100; i++) {
            //同步程式碼區塊
            synchronized (this) {
                if (ticket > 0) {
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException ex) {
                    }
                    System.out.println("賣票 目前有" + ticket-- + "票");
                }
            }
        }
    }
}

public class Main {

    public static void main(String[] args) {
        MyThread mt = new MyThread();
        Thread t1 = new Thread(mt);
        Thread t2 = new Thread(mt);
        Thread t3 = new Thread(mt);
        t1.start();
        t2.start();
        t3.start();
    }
}
 

run:
賣票 目前有5票
賣票 目前有4票
賣票 目前有3票
賣票 目前有2票
賣票 目前有1票
BUILD SUCCESSFUL (total time: 5 seconds)
 

package pkg9.pkg8;

import com.sun.istack.internal.logging.Logger;
import java.util.logging.Level;

class MyThread implements Runnable{
    public void run(){
        for(int i = 0 ; i < 5 ; i++){
            System.out.println(Thread.currentThread().getName() + "i = " + i);
            //執行禮讓
            if( i == 3){
                System.out.println("讓");
                Thread.currentThread().yield();  //執行緒禮讓
            }
        }
    }
}
public class Main {

    public static void main(String[] args) {
        MyThread my = new MyThread();       //產生實體物件
        Thread t1 = new Thread(new MyThread(),"執行緒-A");       //產生實體Thread物件
        Thread t2 = new Thread(new MyThread(),"執行緒-B"); 
        Thread t3 = new Thread(new MyThread(),"執行緒-C"); 
        //設定執行的優先順序
        t1.setPriority(Thread.MIN_PRIORITY);
        t2.setPriority(Thread.NORM_PRIORITY);
        t3.setPriority(Thread.MAX_PRIORITY);
        t1.start();
        t2.start();
        t3.start();
    }
}
 

run:
執行緒-Ai = 0
執行緒-Ai = 1
執行緒-Ai = 2
執行緒-Ai = 3
讓
執行緒-Bi = 0
執行緒-Ci = 0
執行緒-Ci = 1
執行緒-Ci = 2
執行緒-Ci = 3
讓
執行緒-Bi = 1
執行緒-Bi = 2
執行緒-Bi = 3
讓
執行緒-Ai = 4
執行緒-Ci = 4
執行緒-Bi = 4
BUILD SUCCESSFUL (total time: 0 seconds)
 

package pkg9.pkg8;

import com.sun.istack.internal.logging.Logger;
import java.util.logging.Level;

class MyThread implements Runnable{
    public void run(){
        for(int i = 0 ; i < 3 ; i++){
            try{
                Thread.sleep(1000);
            }catch(Exception e){}
            System.out.println(Thread.currentThread().getName() + "i = " + i);
        }
    }
}
public class Main {

    public static void main(String[] args) {
        MyThread my = new MyThread();       //產生實體物件
        Thread t1 = new Thread(new MyThread(),"執行緒-A");       //產生實體Thread物件
        Thread t2 = new Thread(new MyThread(),"執行緒-B"); 
        Thread t3 = new Thread(new MyThread(),"執行緒-C"); 
        //設定執行的優先順序
        t1.setPriority(Thread.MIN_PRIORITY);
        t2.setPriority(Thread.NORM_PRIORITY);
        t3.setPriority(Thread.MAX_PRIORITY);
        t1.start();
        t2.start();
        t3.start();
    }
}
 

run:
執行緒-Ai = 0
執行緒-Bi = 0
執行緒-Ci = 0
執行緒-Ai = 1
執行緒-Ci = 1
執行緒-Bi = 1
執行緒-Ai = 2
執行緒-Bi = 2
執行緒-Ci = 2
BUILD SUCCESSFUL (total time: 3 seconds)
 

並非執行緒的優先順序越高就一定會先執行，哪個執行緒先執行將由CPU的排程決定。主方法的優先順序是NORM_PRIORITY

package pkg9.pkg14;

class MyThread implements Runnable{
    public void run(){
        int t = 0;
        int i = 1;
        while(true){
            System.out.println("i =" + i);
            i++;
        }
    }
}
public class Main {

    public static void main(String[] args) {
        MyThread mt = new MyThread();
        Thread t = new Thread(mt,"Thread - A");
        t.setDaemon(true);   //設定在背景執行
        t.start();
        
    }
}
 

package pkg9.pkg13;

class MyThread implements Runnable{
    public void run(){
        System.out.println("1.進入run方法");
        try{
            Thread.sleep(10000);            //休眠10秒
            System.out.println("2.完成休眠");
        }catch(Exception e){
            System.out.println("3.休眠被終止");
            return;
        }
    }
}
public class Main {

    public static void main(String[] args) {
        MyThread mt  = new MyThread();
        Thread t = new Thread(mt,"Thread - A");
        t.start();
        
        try{
            Thread.sleep(2000);  //休息2秒再繼續中斷
        }catch(Exception e){
        }
        t.interrupt();          //中斷執行緒執行
    }
}
 

run:
1.進入run方法
3.休眠被終止
BUILD SUCCESSFUL (total time: 2 seconds)
 

package pkg9.pkg8;

import com.sun.istack.internal.logging.Logger;
import java.util.logging.Level;

class MyThread implements Runnable{
    public void run(){
        for(int i = 0 ; i < 3 ; i++){
            System.out.println(Thread.currentThread().getName() + "i = " + i);
        }
    }
}
public class Main {

   
    public static void main(String[] args) {
        MyThread my = new MyThread();       //產生實體物件
        Thread t = new Thread(my,"執行緒-C");       //產生實體Thread物件
        
        t.start();          //執行執行緒
        
        for(int i = 0 ; i <50 ; i++){               //迴圈50次 
            if(i > 10){                                     //判斷變數內容
                try{
                    t.join();                                   //執行緒t進行強制執行
                }catch(Exception e){}               //需要進行例外處理
            }
            System.out.println("i = " + i);
        }
    }
}
 

run:
執行緒-Ci = 0
執行緒-Ci = 1
執行緒-Ci = 2
i = 0
i = 1
i = 2
i = 3
i = 4
i = 5
i = 6
i = 7
i = 8
i = 9
i = 10
i = 11
i = 12
i = 13
i = 14
i = 15
i = 16
i = 17
i = 18
i = 19
i = 20
i = 21
i = 22
i = 23
i = 24
i = 25
i = 26
i = 27
i = 28
i = 29
i = 30
i = 31
i = 32
i = 33
i = 34
i = 35
i = 36
i = 37
i = 38
i = 39
i = 40
i = 41
i = 42
i = 43
i = 44
i = 45
i = 46
i = 47
i = 48
i = 49
BUILD SUCCESSFUL (total time: 0 seconds)
 

package pkg9.pkg8;

class MyThread implements Runnable{
    public void run(){
        for(int i = 0 ; i < 3 ; i++){
            System.out.println(Thread.currentThread().getName() + "i = " + i);
        }
    }
}

public class Main {

   
    public static void main(String[] args) {
        MyThread my = new MyThread();
        new Thread(my).start();
        new Thread(my,"執行緒-A").start();
        new Thread(my,"執行緒-B").start();
        new Thread(my).start();       //系統自動設定執行緒名稱
        new Thread(my).start();      //系統自動設定執行緒名稱
        
        Thread t = new Thread(my,"執行緒-C");
        t.start();
        
        System.out.println("判斷執行緒-C是否有啟動中 -- >" + t.isAlive());     //判斷是否啟動執行緒
    }
}

執行緒-Ai = 0
執行緒-Ai = 1
執行緒-Ai = 2
Thread-1i = 0
Thread-1i = 1
Thread-1i = 2
執行緒-Bi = 0
執行緒-Bi = 1
執行緒-Bi = 2
Thread-0i = 0
Thread-0i = 1
Thread-0i = 2
執行緒-Ci = 0
執行緒-Ci = 1
執行緒-Ci = 2
判斷執行緒-C是否有啟動中 -- >true
Thread-2i = 0
Thread-2i = 1
Thread-2i = 2

Java是多執行緒的程式設計語言，每當使用Java指令執行一個類別時，實際上都會啟動一個JVM，每一個JVM實際上就是在作業系統中啟動了一個處理程序，Java本身具備了垃圾的收集機制。所以在Java執行時至少會啟動兩個執行緒，一個是main執行緒，另外一個是垃圾收集執行緒。

package pkg9.pkg8;

class MyThread implements Runnable{
    public void run(){
        for(int i = 0 ; i < 3 ; i++){
            System.out.println(Thread.currentThread().getName() + "i = " + i);
        }
    }
}

public class Main {

   
    public static void main(String[] args) {
        MyThread my = new MyThread();
        new Thread(my).start();
        new Thread(my,"執行緒-A").start();
        new Thread(my,"執行緒-B").start();
        new Thread(my).start();       //系統自動設定執行緒名稱
        new Thread(my).start();      //系統自動設定執行緒名稱
        
        Thread t = new Thread(my,"執行緒-C");
        t.start();
        
        System.out.println("判斷執行緒-C是否有啟動中 -- >" + t.isAlive());     //判斷是否啟動執行緒
    }
}

執行緒-Ai = 0
執行緒-Ai = 1
執行緒-Ai = 2
Thread-1i = 0
Thread-1i = 1
Thread-1i = 2
執行緒-Bi = 0
執行緒-Bi = 1
執行緒-Bi = 2
Thread-0i = 0
Thread-0i = 1
Thread-0i = 2
執行緒-Ci = 0
執行緒-Ci = 1
執行緒-Ci = 2
判斷執行緒-C是否有啟動中 -- >true
Thread-2i = 0
Thread-2i = 1
Thread-2i = 2

package pkg7.pkg15;

//自訂例外的類別
class MyException extends Exception{
    public MyException(String msg){
        super(msg);
    }
}

public class Main {
   
    public static void main(String[] args) {
        int a = 10;
        try{
            if(a == 10){
                throw new MyException("自訂的例外。");
            }
        }catch(Exception e){
            System.out.println(e);
        }
    }
}

pkg7.pkg15.MyException: 自訂的例外。

package pkg7.pkg1;

public class Main {

    public static void main(String[] args) {
        System.out.println("計算開始");
        try {
            int i = Integer.parseInt(args[0]);
            int j = Integer.parseInt(args[1]);
            int temp = 0;
            temp = i / j;
            System.out.println("兩個數字相除結果：" + temp);
            //補捉錯誤  
        } catch (ArithmeticException e) {
            System.out.println("錯誤訊息為：" + e);
            System.out.println("除數不可為0 ");
        } catch (NumberFormatException e) {
            System.out.println("數字轉換例外了**********");
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("陣列超出的例外了************");
        } finally {
            System.out.println("無論是否出現例外，一定會執行這一段！");
        }
        System.out.println("計算結束");
    }
}

package pkg7.pkg1;

public class Main {
    public static void main(String[] args) {
        System.out.println("計算開始");
        int i = 10;
        int j = 0 ;
        int temp = 0;
        //補捉錯誤
        try{
            //本來要執行的區段放這裡
            temp = i / j;
        }catch(ArithmeticException e){
            System.out.println("錯誤訊息為：" + e);
            System.out.println("除數不可為0 ");
        }
        
        System.out.println("兩個數字相除結果：" + temp);
        System.out.println("計算結束");
    }
}

計算開始
錯誤訊息為：java.lang.ArithmeticException: / by zero
除數不可為0 
兩個數字相除結果：0
計算結束

/*
內部類別的擴充
 */
package pkg6.pkg42;

//在一個抽象類別中
//宣告一個介面
abstract class A{
    public abstract void printA();
    //宣告一個內部介面
    interface B{
        public void printB();
    }
    interface C{
        public void printC();
    }
}
//實現的類別
class X extends A {
    public void printA(){
        System.out.println("Hello --> A");
    }
    class Y implements B{
        public void printB(){
                System.out.println("Hello --> B");
        }
    }
    class Z implements C{
        public void printC(){
                System.out.println("Hello --> C");
        }
    }
}

public class Main {
    public static void main(String[] args) {
        //建立物件
        A.B b = new X().new Y();
        b.printB();
        
        A.C c = new X().new Z();
        c.printC();
    }
}

執行結果：

Hello --> B
Hello --> C

package pkg6.pkg40;

//定義Network的介面
interface Network{
    public void browse();  //瀏覽的方法
}

class Real implements Network{
    public void browse(){
        System.out.println("上網瀏覽資訊");
    }
}
//代理的設計
class Proxy implements Network{
    private Network network;
    
    public Proxy(Network network){
        this.network = network;
    }
    public void check(){
        System.out.println("檢查使用者是否合法");
    }
    public void browse(){
        this.check();
        this.network.browse();
    }
}
public class Main {

   
    public static void main(String[] args) {
        
        Network net = null;
        //透過 Proxy代理的方式上網
        //net = new Proxy(new Real());   //向上轉型 
        //net.browse();
        
        //直接連上網
        net = new Real();
        net.browse();
    }
    
}

執行結果：

檢查使用者是否合法
上網瀏覽資訊

/*
轉接器設計
 */
package pkg6.pkg41;

//轉接設計

interface Window{
    public void fun1();
    public void fun2();
    public void fun3();
    public void fun4();
    public void fun5();
}

//定義一個抽象類別實現介面的所有方法
//但是，本體為空的

abstract class WindowAdapter implements Window{
    public void fun1(){};
    public void fun2(){};
    public void fun3(){};
    public void fun4(){};
    public void fun5(){};
}

class WindowImp1 extends WindowAdapter{
    public void fun1(){
        System.out.println("執行fun1");
    }
}

class WindowImp2 extends WindowAdapter{
    public void fun2(){
        System.out.println("執行fun2");
    }
}

public class Main {

    
    public static void main(String[] args) {
        Window win = new WindowImp1();  //向上轉型
        win.fun1();
        win.fun2();
        System.out.println("");
        Window win2 = new WindowImp2();  //向上轉型
        win2.fun1();
        win2.fun2();
    }
    
}

執行結果：

執行fun1

執行fun2

package pkg6.pkg31;

class A {

    public void fun1() {
        System.out.println("A -- > fun1");
    }

    public void fun2() {
        System.out.println("A -- > fun2");
    }
}

class B extends A {

    public void fun1() {
        System.out.println("B -- > fun1");
    }

    public void fun3() {
        System.out.println("B -- > fun3");
    }
}

class C extends A {

    public void fun1() {
        System.out.println("C -- > fun1");
    }

    public void fun5() {
        System.out.println("C -- > fun5");
    }
}

public class Main {

    public static void main(String[] args) {
        A a1 = new C();//向下轉型前，一定要先向上轉型，確認關係
                                //向下轉型 
                                 //為什麼要向下轉型呢？
                                //為了使用 子 類別的個別特殊功能
        fun(a1);

        System.out.println("");

        A a2 = new B();//向下轉型前，一定要先向上車型，確認關係
                                //向下轉型 
                                //為什麼要向下轉型呢？
                                //為了使用 子 類別的個別特殊功能
        fun(a2);
    }
    //此處為向上轉型
    public static void fun(A a) {  //對於乘客來說，他只在意要搭交通工具
        //
        a.fun1();  //不管搭那一個交通工具一定都可以執行的功能

         //根據搭到不同的交通工具，應該可以執行不同的功能
        if (a instanceof B) {
            ((B) a).fun3();      //利用向下轉型，去執行特殊功能 
        }
        if (a instanceof C) {
            ((C) a).fun5();      //利用向下轉型，去執行特殊功能
        }

    }
}

執行結果：

C -- > fun1
C -- > fun5

B -- > fun1
B -- > fun3

package pkg6.pkg38;

interface Fruit{
    public void eat();
}

class Apple implements Fruit{
    public void eat(){
        System.out.println("**吃Apple");
    }
}
class Orange implements Fruit{
    public void eat(){
        System.out.println("**吃Orange");
    }
}

//工廠設計模式 Factory
class Factory {
    public static Fruit getInstance(String className){
        Fruit f = null;
        if("apple".equals(className)){
            f = new Apple();
        }
        if("orange".equals(className)){
            f = new Orange();
        }
        return f;
    }
}

public class Main {

   
    public static void main(String[] args) {
//        Fruit f = new Apple();
//        f.eat();
//        Fruit f2 = new Orange();
//        f2.eat();
            
            Fruit f =null;
            //透過工廠取得我要的水果
            //我要apple
            f= Factory.getInstance("apple");
            f.eat();
            f= Factory.getInstance("orange");
            f.eat();
           
    }
}

執行結果：

**吃Apple
**吃Orange