【Java學習系列】第3課--Java 高級教程

時間 2020-05-09

標籤 Java學習系列 java 高級教程欄目 Java 简体版

原文原文鏈接

本文地址html

能夠拜讀：從零開始學 Javajava

分享提綱：mysql

　　1. Java數據結構程序員

　　2. Java 集合框架web

　　3. Java泛型算法

　　4. Java序列化sql

　　5. Java網絡編程數據庫

　　6. Java發送Email編程

　　7. Java多線程編程api

　　8. Java Applet基礎

　　9. Java MySQL鏈接

1. java數據結構

　　1）【概述】

　　Java工具包提供了強大的數據結構。在Java中的數據結構主要包括如下幾種接口和類：

枚舉（Enumeration）
位集合（BitSet）
向量（Vector）
棧（Stack）
字典（Dictionary）
哈希表（Hashtable）
屬性（Properties）

　　以上這些類是傳統遺留的，在Java2中引入了一種新的框架-集合框架(Collection)，咱們後面再討論。

　　2）枚舉（Enumeration）

　　　　a)【定義】枚舉（Enumeration）接口雖然它自己不屬於數據結構,但它在其餘數據結構的範疇裏應用很廣。枚舉（The Enumeration）接口定義了一種從數據結構中取回連續元素的方式

　　　　b)【代碼舉例】

import java.util.Vector;
import java.util.Enumeration;

public class EnumerationTester {

   public static void main(String args[]) {
      Enumeration days;
      Vector dayNames = new Vector();
      dayNames.add("Sunday");
      dayNames.add("Monday");
      dayNames.add("Tuesday");
      dayNames.add("Wednesday");
      dayNames.add("Thursday");
      dayNames.add("Friday");
      dayNames.add("Saturday");
      days = dayNames.elements();
      while (days.hasMoreElements()){
         System.out.println(days.nextElement()); 
      }
   }
}

EnumerationTester.java

　　運行結果：

Sunday
Monday
Tuesday
Wednesday
Thursday
Friday
Saturday

運行結果

　　3）位集合（BitSet）

　　　　a)【定義】

　　　　　　位集合類實現了一組能夠單獨設置和清除的位或標誌。該類在處理一組布爾值的時候很是有用，你只須要給每一個值賦值一"位"，而後對位進行適當的設置或清除，就能夠對布爾值進行操做了。

　　　　b)【代碼舉例】

import java.util.BitSet;

public class BitSetDemo {

  public static void main(String args[]) {
     BitSet bits1 = new BitSet(16);
     BitSet bits2 = new BitSet(16);
      
     // set some bits
     for(int i=0; i<16; i++) {
        if((i%2) == 0) bits1.set(i);
        if((i%5) != 0) bits2.set(i);
     }
     System.out.println("Initial pattern in bits1: ");
     System.out.println(bits1);
     System.out.println("\nInitial pattern in bits2: ");
     System.out.println(bits2);

     // AND bits
     bits2.and(bits1);
     System.out.println("\nbits2 AND bits1: ");
     System.out.println(bits2);

     // OR bits
     bits2.or(bits1);
     System.out.println("\nbits2 OR bits1: ");
     System.out.println(bits2);

     // XOR bits
     bits2.xor(bits1);
     System.out.println("\nbits2 XOR bits1: ");
     System.out.println(bits2);
  }
}

BitSetDemo.java

　　運行結果：

Initial pattern in bits1:
{0, 2, 4, 6, 8, 10, 12, 14}

Initial pattern in bits2:
{1, 2, 3, 4, 6, 7, 8, 9, 11, 12, 13, 14}

bits2 AND bits1:
{2, 4, 6, 8, 12, 14}

bits2 OR bits1:
{0, 2, 4, 6, 8, 10, 12, 14}

bits2 XOR bits1:
{}

運行結果

　4）向量(Vector )

　　a)【定義】

　　　　向量（Vector）類和傳統數組很是類似，可是Vector的大小能根據須要動態的變化。

　　　　和數組同樣，Vector對象的元素也能經過索引訪問。

　　　　使用Vector類最主要的好處就是在建立對象的時候沒必要給對象指定大小，它的大小會根據須要動態的變化。

　　b)【代碼實例】

import java.util.*;

public class VectorDemo {

   public static void main(String args[]) {
      // initial size is 3, increment is 2
      Vector v = new Vector(3, 2);
      System.out.println("Initial size: " + v.size());
      System.out.println("Initial capacity: " +
      v.capacity());
      v.addElement(new Integer(1));
      v.addElement(new Integer(2));
      v.addElement(new Integer(3));
      v.addElement(new Integer(4));
      System.out.println("Capacity after four additions: " +
          v.capacity());

      v.addElement(new Double(5.45));
      System.out.println("Current capacity: " +
      v.capacity());
      v.addElement(new Double(6.08));
      v.addElement(new Integer(7));
      System.out.println("Current capacity: " +
      v.capacity());
      v.addElement(new Float(9.4));
      v.addElement(new Integer(10));
      System.out.println("Current capacity: " +
      v.capacity());
      v.addElement(new Integer(11));
      v.addElement(new Integer(12));
      System.out.println("First element: " +
         (Integer)v.firstElement());
      System.out.println("Last element: " +
         (Integer)v.lastElement());
      if(v.contains(new Integer(3)))
         System.out.println("Vector contains 3.");
      // enumerate the elements in the vector.
      Enumeration vEnum = v.elements();
      System.out.println("\nElements in vector:");
      while(vEnum.hasMoreElements())
         System.out.print(vEnum.nextElement() + " ");
      System.out.println();
   }
}

VectorDemo.java

　　　　運行結果：

Initial size: 0
Initial capacity: 3
Capacity after four additions: 5
Current capacity: 5
Current capacity: 7
Current capacity: 9
First element: 1
Last element: 12
Vector contains 3.

Elements in vector:
1 2 3 4 5.45 6.08 7 9.4 10 11 12

運行結果

5）棧（Stack）

　　a)【定義】

　　　　棧（Stack）實現了一個後進先出（LIFO）的數據結構。

　　　　你能夠把棧理解爲對象的垂直分佈的棧，當你添加一個新元素時，就將新元素放在其餘元素的頂部。

　　　　當你從棧中取元素的時候，就從棧頂取一個元素。換句話說，最後進棧的元素最早被取出。

　　b)【代碼實例】

import java.util.*;

public class StackDemo {

   static void showpush(Stack st, int a) {
      st.push(new Integer(a));
      System.out.println("push(" + a + ")");
      System.out.println("stack: " + st);
   }

   static void showpop(Stack st) {
      System.out.print("pop -> ");
      Integer a = (Integer) st.pop();
      System.out.println(a);
      System.out.println("stack: " + st);
   }

   public static void main(String args[]) {
      Stack st = new Stack();
      System.out.println("stack: " + st);
      showpush(st, 42);
      showpush(st, 66);
      showpush(st, 99);
      showpop(st);
      showpop(st);
      showpop(st);
      try {
         showpop(st);
      } catch (EmptyStackException e) {
         System.out.println("empty stack");
      }
   }
}

StackDemo.java

　　　　運行結果：

stack: [ ]
push(42)
stack: [42]
push(66)
stack: [42, 66]
push(99)
stack: [42, 66, 99]
pop -> 99
stack: [42, 66]
pop -> 66
stack: [42]
pop -> 42
stack: [ ]
pop -> empty stack

運行結果

6）字典（Dictionary）

　　a)【定義】

　　　　字典（Dictionary）類是一個抽象類，它定義了鍵映射到值的數據結構。

　　　　當你想要經過特定的鍵而不是整數索引來訪問數據的時候，這時候應該使用Dictionary。

　　　　因爲Dictionary類是抽象類，因此它只提供了鍵映射到值的數據結構，而沒有提供特定的實現。

7）哈希表（Hashtable）

　　a)【定義】　　

　　　　Hashtable類提供了一種在用戶定義鍵結構的基礎上來組織數據的手段。

　　　　例如，在地址列表的哈希表中，你能夠根據郵政編碼做爲鍵來存儲和排序數據，而不是經過人名。

　　b)【代碼實現】

import java.util.*;

public class HashTableDemo {

   public static void main(String args[]) {
      // Create a hash map
      Hashtable balance = new Hashtable();
      Enumeration names;
      String str;
      double bal;

      balance.put("Zara", new Double(3434.34));
      balance.put("Mahnaz", new Double(123.22));
      balance.put("Ayan", new Double(1378.00));
      balance.put("Daisy", new Double(99.22));
      balance.put("Qadir", new Double(-19.08));

      // Show all balances in hash table.
      names = balance.keys();
      while(names.hasMoreElements()) {
         str = (String) names.nextElement();
         System.out.println(str + ": " +
         balance.get(str));
      }
      System.out.println();
      // Deposit 1,000 into Zara's account
      bal = ((Double)balance.get("Zara")).doubleValue();
      balance.put("Zara", new Double(bal+1000));
      System.out.println("Zara's new balance: " +
      balance.get("Zara"));
   }
}

HashTableDemo.java

　　運行結果以下：

Qadir: -19.08
Zara: 3434.34
Mahnaz: 123.22
Daisy: 99.22
Ayan: 1378.0

Zara's new balance: 4434.34

運行結果

8）哈希表（Hashtable）

　　a)【定義】

　　　　Properties 繼承於 Hashtable.Properties 類表示了一個持久的屬性集.屬性列表中每一個鍵及其對應值都是一個字符串。

　　　　Properties 類被許多Java類使用。例如，在獲取環境變量時它就做爲System.getProperties()方法的返回值。

　　b)【代碼實現】

import java.util.*;

public class PropDemo {

   public static void main(String args[]) {
      Properties capitals = new Properties();
      Set states;
      String str;
      
      capitals.put("Illinois", "Springfield");
      capitals.put("Missouri", "Jefferson City");
      capitals.put("Washington", "Olympia");
      capitals.put("California", "Sacramento");
      capitals.put("Indiana", "Indianapolis");

      // Show all states and capitals in hashtable.
      states = capitals.keySet(); // get set-view of keys
      Iterator itr = states.iterator();
      while(itr.hasNext()) {
         str = (String) itr.next();
         System.out.println("The capital of " +
            str + " is " + capitals.getProperty(str) + ".");
      }
      System.out.println();

      // look for state not in list -- specify default
      str = capitals.getProperty("Florida", "Not Found");
      System.out.println("The capital of Florida is "
          + str + ".");
   }
}

PropDemo.java

　　運行結果以下：

The capital of Missouri is Jefferson City.
The capital of Illinois is Springfield.
The capital of Indiana is Indianapolis.
The capital of California is Sacramento.
The capital of Washington is Olympia.

The capital of Florida is Not Found.

運行結果

2. Java集合框架

　　1）概述

　　集合框架是一個用來表明和操縱集合的統一架構。全部的集合框架都包含以下內容：

接口：是表明集合的抽象數據類型。接口容許集合獨立操縱其表明的細節。在面向對象的語言，接口一般造成一個層次。
實現（類）：是集合接口的具體實現。從本質上講，它們是可重複使用的數據結構。
算法：是實現集合接口的對象裏的方法執行的一些有用的計算，例如：搜索和排序。這些算法被稱爲多態，那是由於相同的方法能夠在類似的接口上有着不一樣的實現。

　　除了集合，該框架也定義了幾個Map接口和類。Map裏存儲的是鍵/值對。儘管Map不是collections，可是它們徹底整合在集合中。

　　2）Java集合框架體系圖

　　　3）集合接口及實現類

　　　　　　a)【接口】

　　　　　　　　集合接口有 Collection 接口， List 接口， Set， SortedSet， Map， Map.Entry， SortedMap， Enumeration 8種

　　　　　　b)【實現類(集合類)】

　　　　　　　　實現類有 AbstractCollection， ArrayList， HashSet， HashMap 等15中集合類

　　　4）迭代器遍歷集合

　　　　a)【概述】

　　　　　　一般狀況下，你會但願遍歷一個集合中的元素。例如，顯示集合中的每一個元素。

　　　　　　通常遍歷數組都是採用for循環或者加強for，這兩個方法也能夠用在集合框架，可是還有一種方法是採用迭代器遍歷集合框架，它是一個對象，實現了Iterator 接口或ListIterator接口。

　　　　　　迭代器，使你可以經過循環來獲得或刪除集合的元素。ListIterator 繼承了Iterator，以容許雙向遍歷列表和修改元素。

　　　　b)【代碼示例】

public class Test{
 public static void main(String[] args) {
     List<String> list=new ArrayList<String>();
     list.add("Hello");
     list.add("World");
     list.add("HAHAHAHA");
     //第一種遍歷方法使用foreach遍歷List
     for (String str : list) {            //也能夠改寫for(int i=0;i<list.size();i++)這種形式
        System.out.println(str);
     }
 
     //第二種遍歷，把鏈表變爲數組相關的內容進行遍歷
     String[] strArray=new String[list.size()];
     list.toArray(strArray);
     for(int i=0;i<strArray.length;i++) //這裏也能夠改寫爲  foreach(String str:strArray)這種形式
     {
        System.out.println(strArray[i]);
     }
     
    //第三種遍歷 使用迭代器進行相關遍歷
     
     Iterator<String> ite=list.iterator();
     while(ite.hasNext())//判斷下一個元素以後有值
     {
         System.out.println(ite.next());
     }
 }
}

遍歷 ArrayList

public class Test{
     public static void main(String[] args) {
      Map<String, String> map = new HashMap<String, String>();
      map.put("1", "value1");
      map.put("2", "value2");
      map.put("3", "value3");
      
      //第一種：廣泛使用，二次取值
      System.out.println("經過Map.keySet遍歷key和value：");
      for (String key : map.keySet()) {
       System.out.println("key= "+ key + " and value= " + map.get(key));
      }
      
      //第二種
      System.out.println("經過Map.entrySet使用iterator遍歷key和value：");
      Iterator<Map.Entry<String, String>> it = map.entrySet().iterator();
      while (it.hasNext()) {
       Map.Entry<String, String> entry = it.next();
       System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
      }
      
      //第三種：推薦，尤爲是容量大時
      System.out.println("經過Map.entrySet遍歷key和value");
      for (Map.Entry<String, String> entry : map.entrySet()) {
       System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
      }
    
      //第四種
      System.out.println("經過Map.values()遍歷全部的value，但不能遍歷key");
      for (String v : map.values()) {
       System.out.println("value= " + v);
      }
     }
}

遍歷 Map

　3. Java泛型

　　1）【概述】

　　　　Java 泛型（generics）是 JDK 5 中引入的一個新特性, 泛型提供了編譯時類型安全檢測機制，該機制容許程序員在編譯時檢測到非法的類型。泛型的本質是參數化類型，也就是說所操做的數據類型被指定爲一個參數

　　　　能夠參考：Java總結篇系列：Java泛型

　　2）【泛型方法】

　　　　你能夠寫一個泛型方法，該方法在調用時能夠接收不一樣類型的參數。根據傳遞給泛型方法的參數類型，編譯器適當地處理每個方法調用。

　　　　下面是定義泛型方法的規則：

- 全部泛型方法聲明都有一個類型參數聲明部分（由尖括號分隔），該類型參數聲明部分在方法返回類型以前（在下面例子中的<E>）。
- 每個類型參數聲明部分包含一個或多個類型參數，參數間用逗號隔開。一個泛型參數，也被稱爲一個類型變量，是用於指定一個泛型類型名稱的標識符。
- 類型參數能被用來聲明返回值類型，而且能做爲泛型方法獲得的實際參數類型的佔位符。
- 泛型方法體的聲明和其餘方法同樣。注意類型參數只能表明引用型類型，不能是原始類型（像int,double,char的等）。

　　　　-- 代碼示例

public class GenericMethodTest
{
   // 泛型方法 printArray                         
   public static < E > void printArray( E[] inputArray )
   {
      // 輸出數組元素            
         for ( E element : inputArray ){        
            System.out.printf( "%s ", element );
         }
         System.out.println();
    }
 
    public static void main( String args[] )
    {
        // 建立不一樣類型數組： Integer, Double 和 Character
        Integer[] intArray = { 1, 2, 3, 4, 5 };
        Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 };
        Character[] charArray = { 'H', 'E', 'L', 'L', 'O' };
 
        System.out.println( "整型數組元素爲:" );
        printArray( intArray  ); // 傳遞一個整型數組
 
        System.out.println( "\n雙精度型數組元素爲:" );
        printArray( doubleArray ); // 傳遞一個雙精度型數組
 
        System.out.println( "\n字符型數組元素爲:" );
        printArray( charArray ); // 傳遞一個字符型數組
    } 
}

GenericMethodTest.java

　　　　編譯運行結果以下：

整型數組元素爲:
1 2 3 4 5 

雙精度型數組元素爲:
1.1 2.2 3.3 4.4 

字符型數組元素爲:
H E L L O

編譯運行結果

　　3）【泛型類】

　　　　-- 代碼示例：

public class Box<T> {
   
  private T t;
 
  public void add(T t) {
    this.t = t;
  }
 
  public T get() {
    return t;
  }
 
  public static void main(String[] args) {
    Box<Integer> integerBox = new Box<Integer>();
    Box<String> stringBox = new Box<String>();
 
    integerBox.add(new Integer(10));
    stringBox.add(new String("菜鳥教程"));
 
    System.out.printf("整型值爲 :%d\n\n", integerBox.get());
    System.out.printf("字符串爲 :%s\n", stringBox.get());
  }
}

Box.java

編譯運行結果以下：

整型值爲 :10

字符串爲 :菜鳥教程

編譯運行結果

4. Java 序列化

　　1）【概述】

　　　　-- 【序列化和反序列化】Java 提供了一種對象序列化的機制，該機制中，一個對象能夠被表示爲一個字節序列，該字節序列包括該對象的數據、有關對象的類型的信息和存儲在對象中數據的類型。

　　　　將序列化對象寫入文件以後，能夠從文件中讀取出來，而且對它進行反序列化，也就是說，對象的類型信息、對象的數據，還有對象中的數據類型能夠用來在內存中新建對象。

　　　　-- 【序列化條件】請注意，一個類的對象要想序列化成功，必須知足兩個條件：

　　　　　　該類必須實現 java.io.Serializable 對象。

　　　　　　該類的全部屬性必須是可序列化的。若是有一個屬性不是可序列化的，則該屬性必須註明是短暫的。

　　　　　　若是你想知道一個 Java 標準類是不是可序列化的，請查看該類的文檔。檢驗一個類的實例是否能序列化十分簡單，只須要查看該類有沒有實現 java.io.Serializable接口。

　　2）【代碼示例】

public class Employee implements java.io.Serializable
{
   public String name;
   public String address;
   public transient int SSN;
   public int number;
   public void mailCheck()
   {
      System.out.println("Mailing a check to " + name
                           + " " + address);
   }
}

Employee.java

import java.io.*;
 
public class SerializeDemo
{
   public static void main(String [] args)
   {
      Employee e = new Employee();
      e.name = "Reyan Ali";
      e.address = "Phokka Kuan, Ambehta Peer";
      e.SSN = 11122333;
      e.number = 101;
      try
      {
         FileOutputStream fileOut =
         new FileOutputStream("/tmp/employee.ser");
         ObjectOutputStream out = new ObjectOutputStream(fileOut);
         out.writeObject(e);
         out.close();
         fileOut.close();
         System.out.printf("Serialized data is saved in /tmp/employee.ser");
      }catch(IOException i)
      {
          i.printStackTrace();
      }
   }
}

序列化對象-SerializeDemo.java

import java.io.*;
 
public class DeserializeDemo
{
   public static void main(String [] args)
   {
      Employee e = null;
      try
      {
         FileInputStream fileIn = new FileInputStream("/tmp/employee.ser");
         ObjectInputStream in = new ObjectInputStream(fileIn);
         e = (Employee) in.readObject();
         in.close();
         fileIn.close();
      }catch(IOException i)
      {
         i.printStackTrace();
         return;
      }catch(ClassNotFoundException c)
      {
         System.out.println("Employee class not found");
         c.printStackTrace();
         return;
      }
      System.out.println("Deserialized Employee...");
      System.out.println("Name: " + e.name);
      System.out.println("Address: " + e.address);
      System.out.println("SSN: " + e.SSN);
      System.out.println("Number: " + e.number);
    }
}

反序列化對象--DeserializeDemo.java

Deserialized Employee...
Name: Reyan Ali
Address:Phokka Kuan, Ambehta Peer
SSN: 0
Number:101

編譯運行結果

5. Java網絡編程

　　1）【概述】

　　　　網絡編程是指編寫運行在多個設備（計算機）的程序，這些設備都經過網絡鏈接起來。

　　　　java.net 包中 J2SE 的 API 包含有類和接口，它們提供低層次的通訊細節。你能夠直接使用這些類和接口，來專一於解決問題，而不用關注通訊細節。

　　　　java.net 包中提供了兩種常見的網絡協議的支持：

- 　　TCP：TCP 是傳輸控制協議的縮寫，它保障了兩個應用程序之間的可靠通訊。一般用於互聯網協議，被稱 TCP / IP。
- 　　UDP：UDP 是用戶數據報協議的縮寫，一個無鏈接的協議。提供了應用程序之間要發送的數據的數據包。

　　2）【Socket 編程】

套接字使用TCP提供了兩臺計算機之間的通訊機制。客戶端程序建立一個套接字，並嘗試鏈接服務器的套接字。

當鏈接創建時，服務器會建立一個 Socket 對象。客戶端和服務器如今能夠經過對 Socket 對象的寫入和讀取來進行進行通訊。

java.net.Socket 類表明一個套接字，而且 java.net.ServerSocket 類爲服務器程序提供了一種來監聽客戶端，並與他們創建鏈接的機制。

如下步驟在兩臺計算機之間使用套接字創建TCP鏈接時會出現：

- - 服務器實例化一個 ServerSocket 對象，表示經過服務器上的端口通訊。
  - 服務器調用 ServerSocket 類的 accept() 方法，該方法將一直等待，直到客戶端鏈接到服務器上給定的端口。
  - 服務器正在等待時，一個客戶端實例化一個 Socket 對象，指定服務器名稱和端口號來請求鏈接。
  - Socket 類的構造函數試圖將客戶端鏈接到指定的服務器和端口號。若是通訊被創建，則在客戶端建立一個 Socket 對象可以與服務器進行通訊。
  - 在服務器端，accept() 方法返回服務器上一個新的 socket 引用，該 socket 鏈接到客戶端的 socket。

鏈接創建後，經過使用 I/O 流在進行通訊，每個socket都有一個輸出流和一個輸入流，客戶端的輸出流鏈接到服務器端的輸入流，而客戶端的輸入流鏈接到服務器端的輸出流。

TCP 是一個雙向的通訊協議，所以數據能夠經過兩個數據流在同一時間發送.如下是一些類提供的一套完整的有用的方法來實現 socket。

--【兩個類】

ServerSocket 類的方法：

　　服務器應用程序經過使用 java.net.ServerSocket 類以獲取一個端口,而且偵聽客戶端請求。它有4個構造方法

Socket 類的方法：

　　java.net.Socket 類表明客戶端和服務器都用來互相溝通的套接字。客戶端要獲取一個 Socket 對象經過實例化，而服務器得到一個 Socket 對象則經過 accept() 方法的返回值。有5個構造方法

3）【代碼示例】

　　a)【Socket 客戶端實例】

　　　　以下的 GreetingClient 是一個客戶端程序，該程序經過 socket 鏈接到服務器併發送一個請求，而後等待一個響應。

// 文件名 GreetingClient.java
 
import java.net.*;
import java.io.*;
 
public class GreetingClient
{
   public static void main(String [] args)
   {
      String serverName = args[0];
      int port = Integer.parseInt(args[1]);
      try
      {
         System.out.println("Connecting to " + serverName
                             + " on port " + port);
         Socket client = new Socket(serverName, port);
         System.out.println("Just connected to "
                      + client.getRemoteSocketAddress());
         OutputStream outToServer = client.getOutputStream();
         DataOutputStream out =
                       new DataOutputStream(outToServer);
 
         out.writeUTF("Hello from "
                      + client.getLocalSocketAddress());
         InputStream inFromServer = client.getInputStream();
         DataInputStream in =
                        new DataInputStream(inFromServer);
         System.out.println("Server says " + in.readUTF());
         client.close();
      }catch(IOException e)
      {
         e.printStackTrace();
      }
   }
}

GreetingClient.java

// 文件名 GreetingServer.java
 
import java.net.*;
import java.io.*;
 
public class GreetingServer extends Thread
{
   private ServerSocket serverSocket;
   
   public GreetingServer(int port) throws IOException
   {
      serverSocket = new ServerSocket(port);
      serverSocket.setSoTimeout(10000);
   }
 
   public void run()
   {
      while(true)
      {
         try
         {
            System.out.println("Waiting for client on port " +
            serverSocket.getLocalPort() + "...");
            Socket server = serverSocket.accept();
            System.out.println("Just connected to "
                  + server.getRemoteSocketAddress());
            DataInputStream in =
                  new DataInputStream(server.getInputStream());
            System.out.println(in.readUTF());
            DataOutputStream out =
                 new DataOutputStream(server.getOutputStream());
            out.writeUTF("Thank you for connecting to "
              + server.getLocalSocketAddress() + "\nGoodbye!");
            server.close();
         }catch(SocketTimeoutException s)
         {
            System.out.println("Socket timed out!");
            break;
         }catch(IOException e)
         {
            e.printStackTrace();
            break;
         }
      }
   }
   public static void main(String [] args)
   {
      int port = Integer.parseInt(args[0]);
      try
      {
         Thread t = new GreetingServer(port);
         t.start();
      }catch(IOException e)
      {
         e.printStackTrace();
      }
   }
}

GreetingServer.java

　　　　c)【編譯及運行】

　　　　編譯以上兩個 java 文件代碼，並執行如下命令來啓動服務，使用端口號爲 6066：

$ java GreetingServer 6066
Waiting for client on port 6066...

　　　　新開一個命令窗口，執行以上命令來開啓客戶端：

$ java GreetingClient localhost 6066
Connecting to localhost on port 6066
Just connected to localhost/127.0.0.1:6066
Server says Thank you for connecting to /127.0.0.1:6066
Goodbye!

6. Java發送Email

　　1）【概述】

　　　使用Java應用程序發送 E-mail 十分簡單，可是首先你應該在你的機器上安裝 JavaMail API 和Java Activation Framework (JAF)

- 您能夠從 Java 網站下載最新版本的 JavaMail，打開網頁右側有個 Downloads 連接，點擊它下載。
- 您能夠從 Java 網站下載最新版本的 JAF（版本 1.1.1）。

　　你也可使用本站提供的下載連接：

- - JavaMail mail.jar 1.4.5
  - 　　JAF（版本 1.1.1） activation.jar

　　下載並解壓縮這些文件，在新建立的頂層目錄中，您會發現這兩個應用程序的一些 jar 文件。您須要把 mail.jar 和 activation.jar 文件添加到您的 CLASSPATH 中。

　　(java 命令行引用jar包的方法的整理)

　　若是你使用第三方郵件服務器如QQ的SMTP服務器，可查看文章底部用戶認證完整的實例。

　　2）【代碼示例】

　　　　發送帶有附件的郵件

// 文件名 SendFileEmail.java
 
import java.util.*;
import javax.mail.*;
import javax.mail.internet.*;
import javax.activation.*;
 
public class SendFileEmail
{
   public static void main(String [] args)
   {
     
      // 收件人電子郵箱
      String to = "abcd@gmail.com";
 
      // 發件人電子郵箱
      String from = "web@gmail.com";
 
      // 指定發送郵件的主機爲 localhost
      String host = "localhost";
 
      // 獲取系統屬性
      Properties properties = System.getProperties();
 
      // 設置郵件服務器
      properties.setProperty("mail.smtp.host", host);
 
      // 獲取默認的 Session 對象。
      Session session = Session.getDefaultInstance(properties);
 
      try{
         // 建立默認的 MimeMessage 對象。
         MimeMessage message = new MimeMessage(session);
 
         // Set From: 頭部頭字段
         message.setFrom(new InternetAddress(from));
 
         // Set To: 頭部頭字段
         message.addRecipient(Message.RecipientType.TO,
                                  new InternetAddress(to));
 
         // Set Subject: 頭字段
         message.setSubject("This is the Subject Line!");
 
         // 建立消息部分
         BodyPart messageBodyPart = new MimeBodyPart();
 
         // 消息
         messageBodyPart.setText("This is message body");
        
         // 建立多重消息
         Multipart multipart = new MimeMultipart();
 
         // 設置文本消息部分
         multipart.addBodyPart(messageBodyPart);
 
         // 附件部分
         messageBodyPart = new MimeBodyPart();
         String filename = "file.txt";
         DataSource source = new FileDataSource(filename);
         messageBodyPart.setDataHandler(new DataHandler(source));
         messageBodyPart.setFileName(filename);
         multipart.addBodyPart(messageBodyPart);
 
         // 發送完整消息
         message.setContent(multipart );
 
         //   發送消息
         Transport.send(message);
         System.out.println("Sent message successfully....");
      }catch (MessagingException mex) {
         mex.printStackTrace();
      }
   }
}

SendFileEmail.java

7. Java多線程編程

　　　　1）【概述】

　　　　　　Java 給多線程編程提供了內置的支持。一個多線程程序包含兩個或多個能併發運行的部分。程序的每一部分都稱做一個線程，而且每一個線程定義了一個獨立的執行路徑。

　　　　　　多線程是多任務的一種特別的形式，但多線程使用了更小的資源開銷。

　　　　　　這裏定義和線程相關的另外一個術語 - 進程：一個進程包括由操做系統分配的內存空間，包含一個或多個線程。一個線程不能獨立的存在，它必須是進程的一部分。一個進程一直運行，　　　　　

　　　　　　直到全部的非守候線程都結束運行後才能結束。

　　　　　　多線程能知足程序員編寫高效率的程序來達到充分利用 CPU 的目的。

　　　　2）【代碼示例】　　　　　

　　　　Java 提供了三種建立線程的方法：

- 經過實現 Runable 接口；
- 經過繼承 Thread類自己；
- 經過 Callable 和 Future 建立線程。

　　　　方法1：經過實現 Runnable 接口來建立線程

class RunnableDemo implements Runnable {
   private Thread t;
   private String threadName;
   
   RunnableDemo( String name) {
      threadName = name;
      System.out.println("Creating " +  threadName );
   }
   
   public void run() {
      System.out.println("Running " +  threadName );
      try {
         for(int i = 4; i > 0; i--) {
            System.out.println("Thread: " + threadName + ", " + i);
            // 讓線程睡眠一會
            Thread.sleep(50);
         }
      }catch (InterruptedException e) {
         System.out.println("Thread " +  threadName + " interrupted.");
      }
      System.out.println("Thread " +  threadName + " exiting.");
   }
   
   public void start () {
      System.out.println("Starting " +  threadName );
      if (t == null) {
         t = new Thread (this, threadName);
         t.start ();
      }
   }
}
 
public class TestThread {
 
   public static void main(String args[]) {
      RunnableDemo R1 = new RunnableDemo( "Thread-1");
      R1.start();
      
      RunnableDemo R2 = new RunnableDemo( "Thread-2");
      R2.start();
   }   
}

RunnableDemo.java

　　　　運行結果以下：

Creating Thread-1
Starting Thread-1
Creating Thread-2
Starting Thread-2
Running Thread-1
Thread: Thread-1, 4
Running Thread-2
Thread: Thread-2, 4
Thread: Thread-1, 3
Thread: Thread-2, 3
Thread: Thread-1, 2
Thread: Thread-2, 2
Thread: Thread-1, 1
Thread: Thread-2, 1
Thread Thread-1 exiting.
Thread Thread-2 exiting.

方法1運行結果

　　　　方法2：經過實現 Runnable 接口來建立線程

class RunnableDemo implements Runnable {
   private Thread t;
   private String threadName;
   
   RunnableDemo( String name) {
      threadName = name;
      System.out.println("Creating " +  threadName );
   }
   
   public void run() {
      System.out.println("Running " +  threadName );
      try {
         for(int i = 4; i > 0; i--) {
            System.out.println("Thread: " + threadName + ", " + i);
            // 讓線程睡眠一會
            Thread.sleep(50);
         }
      }catch (InterruptedException e) {
         System.out.println("Thread " +  threadName + " interrupted.");
      }
      System.out.println("Thread " +  threadName + " exiting.");
   }
   
   public void start () {
      System.out.println("Starting " +  threadName );
      if (t == null) {
         t = new Thread (this, threadName);
         t.start ();
      }
   }
}
 
public class TestThread {
 
   public static void main(String args[]) {
      RunnableDemo R1 = new RunnableDemo( "Thread-1");
      R1.start();
      
      RunnableDemo R2 = new RunnableDemo( "Thread-2");
      R2.start();
   }   
}

RunnableDemo.java

　　　　運行結果以下：

Creating Thread-1
Starting Thread-1
Creating Thread-2
Starting Thread-2
Running Thread-1
Thread: Thread-1, 4
Running Thread-2
Thread: Thread-2, 4
Thread: Thread-1, 3
Thread: Thread-2, 3
Thread: Thread-1, 2
Thread: Thread-2, 2
Thread: Thread-1, 1
Thread: Thread-2, 1
Thread Thread-1 exiting.
Thread Thread-2 exiting.

方法運行結果

　　　　方法3：經過 Callable 和 Future 建立線程

public class CallableThreadTest implements Callable<Integer> {
    public static void main(String[] args)  
    {  
        CallableThreadTest ctt = new CallableThreadTest();  
        FutureTask<Integer> ft = new FutureTask<>(ctt);  
        for(int i = 0;i < 100;i++)  
        {  
            System.out.println(Thread.currentThread().getName()+" 的循環變量i的值"+i);  
            if(i==20)  
            {  
                new Thread(ft,"有返回值的線程").start();  
            }  
        }  
        try  
        {  
            System.out.println("子線程的返回值："+ft.get());  
        } catch (InterruptedException e)  
        {  
            e.printStackTrace();  
        } catch (ExecutionException e)  
        {  
            e.printStackTrace();  
        }  
  
    }
    @Override  
    public Integer call() throws Exception  
    {  
        int i = 0;  
        for(;i<100;i++)  
        {  
            System.out.println(Thread.currentThread().getName()+" "+i);  
        }  
        return i;  
    }  
}

CallableThreadTest.java

8. Java Applet基礎

　　1）【概述】

　　　　1.1）基礎　　　　

　　　　Applet 是一種 Java 程序。它通常運行在支持 Java 的 Web 瀏覽器內。由於它有完整的 Java API支持,因此Applet 是一個全功能的 Java 應用程序。

以下所示是獨立的 Java 應用程序和 applet 程序之間重要的不一樣：

Java 中 Applet 類繼承了 java.applet.Applet 類。
Applet 類沒有定義 main()，因此一個 Applet 程序不會調用 main() 方法。
Applet 被設計爲嵌入在一個 HTML 頁面。
當用戶瀏覽包含 Applet 的 HTML 頁面，Applet 的代碼就被下載到用戶的機器上。
要查看一個 Applet 須要 JVM。 JVM 能夠是 Web 瀏覽器的一個插件，或一個獨立的運行時環境。
用戶機器上的 JVM 建立一個 Applet 類的實例，並調用 Applet 生命週期過程當中的各類方法。
Applet 有 Web 瀏覽器強制執行的嚴格的安全規則，Applet 的安全機制被稱爲沙箱安全。
Applet 須要的其餘類能夠用 Java 歸檔（JAR）文件的形式下載下來。

　　2）【代碼示例】

　　　　　　 2.1)【java源文件】HelloWorldApplet.java

import java.applet.*;
import java.awt.*;
 
public class HelloWorldApplet extends Applet
{
   public void paint (Graphics g)
   {
      g.drawString ("Hello World", 25, 50);
   }
}

HelloWorldApplet.java

　　　　　　2.2)【html調用applet】

<html>
<title>The Hello, World Applet</title>
<hr>
<applet code="HelloWorldApplet.class" width="320" height="120">
If your browser was Java-enabled, a "Hello, World"
message would appear here.
</applet>
<hr>
</html>

testApplet.html

　　　　　　2.3)【運行方式】　　　

　　　　　　　　2.3.1)命令行運行applet: https://zhidao.baidu.com/question/136902514.html

　　　　　　 appletviewer testApplet.html

　　　　　　　　2.3.2)下載瀏覽器支持的java : https://www.java.com/zh_CN/download/manual.jsp#mac

　　　　　　　　2.3.3) java被阻止時： https://java.com/zh_CN/download/help/jcp_security.xml

　　　　　　 — mac上java的控制面板的位置： https://java.com/zh_CN/download/help/mac_controlpanel.xml

　9. Java MySQ鏈接

　　1）【概述】

　　　　Java 鏈接 MySQL 須要驅動包，最新版下載地址爲：http://dev.mysql.com/downloads/connector/j/，解壓後獲得jar庫文件，而後在對應的項目中導入該庫文件。

　　　　你能夠下載本站提供的 jar 包：mysql-connector-java-5.1.39-bin.jar

　　2）【代碼示例】

package com.runoob.test;
 
import java.sql.*;
 
public class MySQLDemo {
 
    // JDBC 驅動名及數據庫 URL
    static final String JDBC_DRIVER = "com.mysql.jdbc.Driver";  
    static final String DB_URL = "jdbc:mysql://localhost:3306/RUNOOB";
 
    // 數據庫的用戶名與密碼，須要根據本身的設置
    static final String USER = "root";
    static final String PASS = "123456";
 
    public static void main(String[] args) {
        Connection conn = null;
        Statement stmt = null;
        try{
            // 註冊 JDBC 驅動
            Class.forName("com.mysql.jdbc.Driver");
        
            // 打開連接
            System.out.println("鏈接數據庫...");
            conn = DriverManager.getConnection(DB_URL,USER,PASS);
        
            // 執行查詢
            System.out.println(" 實例化Statement對...");
            stmt = conn.createStatement();
            String sql;
            sql = "SELECT id, name, url FROM websites";
            ResultSet rs = stmt.executeQuery(sql);
        
            // 展開結果集數據庫
            while(rs.next()){
                // 經過字段檢索
                int id  = rs.getInt("id");
                String name = rs.getString("name");
                String url = rs.getString("url");
    
                // 輸出數據
                System.out.print("ID: " + id);
                System.out.print(", 站點名稱: " + name);
                System.out.print(", 站點 URL: " + url);
                System.out.print("\n");
            }
            // 完成後關閉
            rs.close();
            stmt.close();
            conn.close();
        }catch(SQLException se){
            // 處理 JDBC 錯誤
            se.printStackTrace();
        }catch(Exception e){
            // 處理 Class.forName 錯誤
            e.printStackTrace();
        }finally{
            // 關閉資源
            try{
                if(stmt!=null) stmt.close();
            }catch(SQLException se2){
            }// 什麼都不作
            try{
                if(conn!=null) conn.close();
            }catch(SQLException se){
                se.printStackTrace();
            }
        }
        System.out.println("Goodbye!");
    }
}