JavaSe基本知識

標籤：構建   訪問   for   inf   pat   方法調用   無法   啟動   錯誤   

JavaSe複習

1. java體系

2. java核心體制

3. 環境配置

4. 基礎文法

5. 物件導向

6. 異常（Exception）

7. 數組（Array）

8. 基礎類（常用類）

9. 輸入輸出 流 （I/O Stream）

10.容器/泛型 （Collection / Generic）

11. 線程 （Thread）

12.網路編程 （TCP/UDP）

13. GUI

14. Meta Data

15 Regex

 

1. java體系

2. java核心體制2.1 java虛擬機器2.2 java回收機制3. 環境配置4. 基礎文法4.1 標識符4.1.1 什麼是表示符4.1.2 命名規則

（1) 組成

（2）開頭

（3）大小寫敏感，無長度限制。

（4）約定俗成：見名起意，不能與關鍵詞重名

4.2 關鍵字4.3 資料類型4.3.1 常量4.3.2 變數

（1）定義

本質上是記憶體中的一小塊地區,用命令名來訪問這個地區。

所以必須先聲明（申請），然後賦值（填充內容）

（2）程式執行過程

 

（3）局部變數

（4）成員變數

4.3.3 枚舉類型

（1）只能取特定值的一個

（2）使用enum關鍵字

（3）是java.lang.Enum類型

 

（4）其他用法

package com.cfl.util;import org.apache.commons.collections.map.HashedMap;import java.util.Map;public enum Resouce {_51JOB("51job", 1), ZHILIAN("zhilian", 2), DAJIE("dajie", 3),HIATOU("haitou", 4), LAGOU("lagou", 5), SHIXIZENG("shixiseng", 6);private String name ;private int index ;private Resouce(String name , int index ){    this.name = name ;    this.index = index ;}public String getName() {    return name;}public void setName(String name) {    this.name = name;}public int getIndex() {    return index;}public void setIndex(int index) {    this.index = index;}

}

4.3.4 資料類型的劃分

 

注意： （1）java基礎資料型別 (Elementary Data Type)長度不受系統影響 （2）float f = 12.3f 必須加f

4.3.5 基礎資料類型的轉換

（1）boolean 不能和其他類型相互轉換

（2）容量大自動轉換成容量小的。容量小的轉換容量大的，必須強轉,可能造成溢出。

Java語言提供了八種基本類型。六種數字類型（四個整數型（預設是int 型），兩個浮點型（預設是double 型）），一種字元類型，還有一種布爾型。

byte：

byte資料類型是8位、有符號的，以二進位補碼錶示的整數；（256個數字），佔1位元組最小值是-128（-2^7）；最大值是127（2^7-1）；預設值是0；byte類型用在大型數組中節約空間，主要代替整數，因為byte變數佔用的空間只有int類型的四分之一；例子：byte a = 100，byte b = -50。

short：

short資料類型是16位、有符號的以二進位補碼錶示的整數，佔2位元組最小值是-32768（-2^15）；最大值是32767（2^15 - 1）；Short資料類型也可以像byte那樣節省空間的。一個short變數是int型變數所佔空間的二分之一；預設值是0；例子：short s = 1000，short r = -20000。

int：

int資料類型是32位、有符號的以二進位補碼錶示的整數；佔3位元組最小值是-2,147,483,648（-2^31）；最大值是2,147,485,647（2^31 - 1）；一般地整型變數預設為int類型；預設值是0；例子：int a = 100000, int b = -200000。

long：

long資料類型是64位、有符號的以二進位補碼錶示的整數；佔4位元組最小值是-9,223,372,036,854,775,808（-2^63）；最大值是9,223,372,036,854,775,807（2^63 -1）；這種類型主要使用在需要比較大整數的系統上；預設值是0L；例子： long a = 100000L，int b = -200000L。long a=111111111111111111111111(錯誤，整數型變數預設是int型)long a=111111111111111111111111L(正確，強制轉換)

float：

float資料類型是單精確度、32位、符合IEEE 754標準的浮點數；佔4位元組    -3.4*E38- 3.4*E38。。。浮點數是有舍入誤差的float在儲存大型浮點數組的時候可節省記憶體空間；預設值是0.0f；浮點數不能用來表示精確的值，如貨幣；例子：float f1 = 234.5f。float f=6.26(錯誤  浮點數預設類型是double類型)float f=6.26F（轉換正確，強制）double d=4.55(正確)

double：

double資料類型是雙精確度、64位、符合IEEE 754標準的浮點數；浮點數的預設類型為double類型；double類型同樣不能表示精確的值，如貨幣；預設值是0.0d；例子：double d1 = 123.4。

boolean：

boolean資料類型表示一位的資訊；只有兩個取值：true和false；這種類型只作為一種標誌來記錄true/false情況；預設值是false；例子：boolean one = true。

char：

char類型是一個單一的16位Unicode字元；用 ‘’表示一個字元。。java 內部使用Unicode字元集。。他有一些逸出字元  ，2位元組最小值是’\u0000’（即為0）；最大值是’\uffff’（即為65,535）；可以當整數來用，它的每一個字元都對應一個數字

（3）實數，預設為double

（4）整數，預設為int

4.4 運算子和運算式

（1）

 

（2）自增，自減

（3）邏輯運算子---短路

（4）優先順序

 

（5）三目運算子

4.5 分支

（1）if--else

（2）switch

 注意： java 6及以下只能探測int（或自動轉為int，如：short）的值,java 7及以上可以探測swString的值

4.6 迴圈4.6.1 for,while 和 do--while

（1）異同

for和while是先判斷再執行do...while是先執行一次再判斷繼不繼續所以for和while語句塊可能一次都不執行，但是do...while至少會執行一次

(2)當迴圈次數不太確定，用while。

(3)continue對while和do-while影響很大

4.6.2 break 和 continue

（1） break跳出整個迴圈，注意不是跳出if

（2） continue 跳出本次迴圈，進入下一次迴圈

4.7 方法4.8 變數的範圍4.9 遞迴調用5. 物件導向5.1 程式設計語言的發展

 

 

5.2 面向過程的設計思想5.3 物件導向的設計思想5.4 對象和類的概念5.5 類之間的關係

(1)關聯

往往是類中的方法的參數和另外的類有關

（2）繼承

（3）聚集和組合

 

 

（4）實現關係

5.6 對象和引用

（1）java中除了基本類型外，都叫參考型別.

5.7 java類的定義

(1) 記憶體解析

 

（2）類和對象的關係

 

5.8 建構函式

(1) 使用new+構造方法建立一個新的對象

（2）與類同名，無傳回值

（3）初始化類

（4）執行順序

Z

package constructor;public class Z {    Z(){        System.out.println("Z");    }}

A

package constructor;public class A extends Z{    A(){        System.out.println("A");    }        static{        System.out.println("static");    } }

main

package constructor;public class Main {    public static void main(String[] args) {        A a = new A();     }}

結果

staticZA

5.9 對象的建立和使用

（1）記憶體解析

 

（2）方法重載

5.10 this關鍵字5.11 package 和import

（1）預設引用java.lang

5.12 存取控制

 

5.13 類的繼承

（1）java是單繼承

（2）構造方法

--子類構造的過程中，必須調用基類的構造方法。

--子類構造方法可以用super顯示調用基類的構造方法，不調，則預設調用無參數構造方法

--子類構造方法可以用super顯示調用基類的構造方法,必須寫在子類構造方法的第一行

--如果子類沒有顯式調用基類的構造方法，而基類又沒有無參數構造方法則報錯

5.14 方法的重寫

（1） 重寫要考慮訪問限制

5.14 final關鍵字5.15 Object類

（1）是所有java類的基類

（2）equals方法 （比較是否指向一個地方）

5.16 對象轉型

（1）基類引用可以指向其子類

（2）基類不可訪問子類新增加的成員

（3）可以使用對象instanceof類名 來判斷該引用型變數所“指向”的對象是否屬於該類，或其子類

（4）子類對象當基類對象來用，叫向上轉型

（5）父類當子類對象來用，叫向下轉型.(強制轉換)

Animal a = new Animal();a = new Dog();//if(a instanceof Dog ){    Dog g = (Dog) a;//強制轉換,資料仍在}

 

 

 

5.17 多態

 

5.18 抽象類別

（1）用abstract關鍵字來修飾一個類,這個類叫抽象類別;用abstract來修飾一個方法叫抽象方法

（2）含有抽象方法的必須聲明為抽象類別,抽象類別必須被繼承。

（3）（繼承了抽象類別）的非抽象類別,抽象方法必須被重寫,（繼承了抽象類別）的抽象類別可以不重寫。

（4）抽象類別不能執行個體化

（5）抽象方法只需聲明,而不需要實現

5.19 final關鍵字

（1）final的值不能改變

（2）final的方法不能被重寫

（3）final的類不能被繼承

寫類庫用的比較多

5.20 介面

（1）是抽象方法和常量值的定義的集合

這是為了避免多繼承的父類變數的重複，設定為靜態變數，讓他不屬於任何類。

（2）一種特殊的抽象類別，只包含常量和方法的定義,沒有變數和方法實現。

6. 異常（Exception）

（1）所有異常類的根源：Throwable

 

 

（2）Error ：系統異常，無法處理

（3）Exception ：可處理可catch的錯誤

（4）RuntimeException ：

--頻繁出現，可以不捕捉,如：被0除，下標溢出。

 

（5）必須捕捉的Excetion 如 IOException

（6）有傳回值的方法，return語句在try{}中，必須先執行完finally再返回。

package exception;public class Main {    public static void main(String[] args) {        int k = f();        System.out.println(k);    }public static int f(){int i = 2 ;int j = 1 ;try{int x = i/j ;return 0 ;}catch(Exception e){e.printStackTrace();}finally{System.out.println("finally");}return 0 ;}

}

結果

finally0

（7）先捕捉小的異常，再捕捉大的

（8）異常和重寫

7. 數組（Array）7.1 一維數組

（1）動態初始化

int a = new int [3];a[0] = 1 ;a[1] = 2 ;1[2] = 3;

（2）靜態初始化

int a = {1,2,3};Date days []{    new Date(1,4,2018),    new Date(1,5,2018)}

(3) 預設值

Date days[] = new Date[3];System.out.println(days[0]);

結果：null

7.2 二維數組

(1) 靜態初始化

int a[][] = new {{1,2,3},{3,4,5,6},{7,8,9}};

(2) 數組的聲明應該按照高維到低維順序(左到右)

 

8. 基礎類（常用類）8.1 String 和 StringBuffer

（1）String 常用方法

 

 

 

（2）StringBuffer 常用方法

 

 

 

 

 

（3）String和StringBuffer比較

--Stirng 是不可變的字元序列，修改時構建新的，是不斷copy

--StringBuffer是可變的，可直接修改

8.2 封裝類8.3 Math和File

（1）Math 常用方法

 

（2）File 常用方法

 

--遞迴列出檔案樹形結構

 

 

9. 輸入輸出 流 （I/O Stream）9.1 Java流式輸入輸出原理

 

9.2 Java流類的分類

 

 

9.3 輸入/輸出流類

--站在程式角度

9.3.1 InputStream

（1）組織關係

（2）基本方法

9.3.2 OutputStream

（1）組織關係

 

 

（2）基本方法

 

 

 

9.3.3 Reader

（1）組織關係

 

（2）基本方法

 

9.3.4 Writer

（1）組織關係

 

（2）基本方法

 

 

9.4 常見的節點流和處理流

--原始的管道，節點流。套在其他管道流上的，叫處理流

（1） 節點流

 

（2） 處理流

 

9.5 檔案流

--例子 FileInputStream

package io;import java.io.File;import java.io.FileInputStream;import java.io.FileNotFoundException;import java.io.FileOutputStream;import java.io.IOException;public class IOMain {    public static void main(String[] args) {FileInputStream fis = null;FileOutputStream fos = null;try { fis = new FileInputStream("C:/Users/L/Desktop/test2.txt");  fos = new FileOutputStream("C:/Users/L/Desktop/x.txt");  int c ;  while((c=fis.read())!=-1){ fos.write(c); fos.flush(); } System.out.println("ok"); } catch (FileNotFoundException e) {e.printStackTrace();} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}

--FileReader

package io;import java.io.FileInputStream;import java.io.FileNotFoundException;import java.io.FileOutputStream;import java.io.FileReader;import java.io.FileWriter;import java.io.IOException;import java.io.Writer;public class IOMain2 {    public static void main(String[] args) {FileReader fis = null;FileWriter fos = null;try { fis = new FileReader("C:/Users/L/Desktop/test2.txt");  fos = new FileWriter("C:/Users/L/Desktop/x.txt");  int c ;  while((c=fis.read())!=-1){ fos.write(c); System.out.println((char)c); fos.flush(); } System.out.println("ok"); } catch (FileNotFoundException e) {e.printStackTrace();} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}

--BufferedReader

package io;import java.io.BufferedReader;import java.io.BufferedWriter;import java.io.FileNotFoundException;import java.io.FileReader;import java.io.FileWriter;import java.io.IOException;import java.io.Reader;import java.io.Writer;public class IOMain3 {    public static void main(String[] args) {BufferedReader fis = null;BufferedWriter fos = null;try { fis = new BufferedReader(new FileReader("C:/Users/L/Desktop/test2.txt"));  fos = new BufferedWriter(new FileWriter("C:/Users/L/Desktop/y.txt"));  String c ;  while((c=fis.readLine())!=null){ fos.write(c); System.out.println(c); fos.flush(); } System.out.println("ok"); } catch (FileNotFoundException e) {e.printStackTrace();} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}

9.6 緩衝流9.7 資料流9.8 轉換流9.9 Print流9.9 Object流10.容器/泛型 （Collection / Generic）

--1 1 3 6 1個圖，1個類，3個知識點，6個介面

10.1 組織關係圖

 

10.2 一個類

 

10.3 6個介面10.3.1 Collection介面

 

10.3.2 Set

--資料對象無順序，不可以重複（equals），可以和集合相呼應

--重寫equals和hashcode,確定判斷重複的條件

 

 

--JDK API中Set的容器類有HashSet，和TreeSet

10.3.3 List

--資料對象有順序，可以重複

--JDK API中List的容器類有ArrayList，LinkList

 

 

10.3.4 Map

--索引值對儲存，鍵不可重複（覆蓋）

--JDK API中Set的容器類有HashMap，和TreeMap

--基本方法

 

 

--打包，解包（強制轉換）

--hashMap的實現原理（JDK7）

54946424

--JDK7 和 JDK8 hashMap的實現原理異同

http://www.importnew.com/23164.html

--各種容器實作類別的實現原理（也有hashMap）

http://wiki.jikexueyuan.com/project/java-collection/hashmap.html

10.3.5 Iterator

（1）三個方法

--hasNext() , next() , remove()

 

 

 

 

10.3.6 Comparable介面

 

 

 

--注意 實現Comparable介面，通過實現comparaTo方法，確定排序方式

10.4 衡量標準（如何選擇資料結構）

--Array 讀 快 改 慢

--Linked 讀 慢 改 快

--Hash 兩者之間

10.5 3個知識點

--增強for

--Generlic（泛型）容器聲明時確定對象的類型

--打包，解包

11. 線程 （Thread）11.1 線程的基本概念

--線程是一個程式的不同執行路徑

 

（1）直接調用run方法

和普通的方法調用沒有區別

11.2 線程的建立和啟動

（1）繼承Thread

（2）實現Runnable介面 (推薦)

11.3 線程的調度和優先順序11.4 線程的狀態控制11.4.1 狀態轉換圖

 

11.4.1 線程式控制制的基本方法

 

（1）sleep方法 是一個靜態方法

Thead.sleep() //當前正在執行的線程睡眠

（2）join方法

11.5 線程的同步

（1）synchronized

synchronized 關鍵字，代表這個方法加鎖,相當於不管哪一個線程(例如線程A)，運行到這個方法時,都要檢查有沒有其它線程B(或者C、 D等)正在用這個方法(或者該類的其他同步方法)，有的話要等正在使用synchronized方法的線程B(或者C 、D)運行完這個方法後再運行此線程A,沒有的話,鎖定調用者,然後直接運行。它包括兩種用法:synchronized 方法和 synchronized 塊。Java語言的關鍵字，可用來給對象和方法或者代碼塊加鎖，當它鎖定一個方法或者一個代碼塊的時候，同一時刻最多隻有一個線程執行這段代碼。當兩個並發線程訪問同一個對象object中的這個加鎖同步代碼塊時，一個時間內只能有一個線程得到執行。另一個線程必須等待當前線程執行完這個代碼塊以後才能執行該代碼塊。然而，當一個線程訪問object的一個加鎖代碼塊時，另一個線程仍可以訪問該object中的非加鎖代碼塊。

（2）wait() 需要使用synchronized ，讓訪問本對象的線程（獲得鎖的線程）等待，釋放鎖

（3）notify() 一般和wait()配對使用，叫醒一個在本對象睡眠的線程。

--ProducerConsumer

package thread;public class ProducerConsumer {    public static void main(String[] args) {        Repository re = new Repository();        Producer p[] = new Producer[4];        Customer c[] = new Customer[2];for (int i = 0; i < p.length; i++) {p[i] = new Producer(re);new Thread(p[i]).start();}for (int i = 0; i < c.length; i++) {c[i] = new Customer(re);new Thread(c[i]).start();}}

} --Book

class Book {    int id ;        public Book(int id) {        super();        this.id = id;    }        @Override    public String toString() {        return "book : " + id;    }

}

--Repository

class Repository {int index = 0 ;Book[] book = new Book[5];public int getIndex() {return index;}public void setIndex(int index) {this.index = index;}public Book[] getBook() {return book;}public void setBook(Book[] book) {this.book = book;}public synchronized void push(Book b){while(index==book.length){try {System.out.println("倉庫滿了，等待");this.wait();} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}this.notifyAll();book[index] =  b;index++;}  public synchronized Book pop(){Book b ;while(index == 0){try {System.out.println("  倉庫沒有書，等待");this.wait();} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}this.notifyAll();System.out.println("index"+index);index--;b = book[index];return b;}

}

--Producer

class Producer implements Runnable{Repository repository = null;public Producer(Repository repository) {this.repository = repository;}@Overridepublic void run() {for (int i = 0; i < 2000; i++) {Book b = new Book(i);repository.push(b);System.out.println("生產了"+b+"   倉庫目前書的數量：" + repository.getIndex());try {Thread.sleep((long) (1000*Math.random()));} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}}

--Customer

class Customer implements Runnable{Repository repository = null;public Customer(Repository repository) {super();this.repository = repository;}@Overridepublic void run() {for (int i = 0; i < 2000; i++) {Book b = repository.pop();System.out.println("消費了"+b+"  倉庫目前書的數量：" + repository.getIndex());try {Thread.sleep((long) (1000*Math.random()));} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}}

}

注意：

while(index==book.length){try {System.out.println("倉庫滿了，等待");this.wait();} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();}}

要用while不用if，否則被叫醒後，不會再判斷是否index==book.lengt，而是繼續往下執行。

12.網路編程 （TCP/UDP）

--網路編程！=網站編程

12.1 網路基礎12.2 TCP/IP協議12.3 IP地址12.4 Socket通訊

（1）TCP/UDP

13. GUI14. Meta Data15 Regex

import java.io.*;import java.util.Scanner;import java.util.regex.*;public class Example {    public static void main( String args [])    {            Scanner read = new Scanner (System.in);                        System.out.println("Please input String :");                        /**********************               *    X+ 表示X出現了1次或多次            *    X？ 表示出現了0次或1次            *    \56表示小數點            *    X{n} 表示恰好出現n次            *    X{n,} 表示X出現次數>=n            *    XY表示X的尾碼為Y            *    X|Y 表示X或Y            *    \\p{Alpha}表示字母            *    \\w  表示可用於標識符的字元            *    [a-z&&[def]] 代表 d e f中任意一個 （交）            *    [a-f&&[^bc]]  代表 adef 的差             *                *    \\d表示0-9中任何一個數字            */            //        String s = "(http://|www)\56?\\w+\56{1}\\w+\56{1}\\p{Alpha}+";  //篩選網址            //        String s  = "[abc]";   //[]表示其中任何一個               //        String s ="[a-d]"; //  a-d 表示從a到d中一個            //例14    String s ="[0-9]+\56?[0-9]*";  //篩選出字串中的浮點數            //String s ="1{3,4}"; //  注意貪婪匹配，輸入1111 111 第一次1111 第二次111            //        String s ="a1*"; //        注意貪婪匹配，輸入1111 111 第一次1111 第二次111                        String s ="P=\\{+.+\\}+";                        Pattern pattern = Pattern.compile(s);   //匹配條件                                    Matcher matcher = pattern.matcher(read.nextLine());  //要匹配的目標字串                                    while(true)            {                if (matcher.find())                {                    System.out.printf("%s can find ! , %d--%d\n",matcher.group(),matcher.start(),matcher.end());                                        break;                }                else                 {                    break;                    }            }//         System.out.println("字母個數為： "+n);        }                      }

JavaSe基本知識