CoreJava基礎筆記 v1.0

********************************COREJAVA**********************************

編譯器默認添加的代碼:

1.   import java.lang.*;

2.   若是一個類沒有定義任何構造方法,編譯器默認添加public 無參,空構造方法

3.   調用方法以前,若是沒寫引用,默認爲"this."

4.   若是一個構造方法的第一行,不是this(...)或者super(...),默認添加"super();"

5.   若是一個類沒有指定父類,默認繼承Object類

6.   5.0以後,編譯器自動完成簡單類型和包裝類之間的轉換

7.   5.0以後,編譯器自動將for-each代碼翻譯爲迭代遍歷

===============================java入門介紹================================

Java 95 Sun

編程語言 程序

人----指令----> 計算機

源程序:文本文檔

  .exe  可執行

編譯: 源文件(文本文件)  (編譯器)---->   機器碼文件(可執行文件)  

      執行效率高  不能跨平臺   (C C++)

解釋: 源文件(文本文件)  (解釋器 逐行翻譯並運行)---->

      執行效率低    (JavaScript Basic)

先編譯 後解釋

源文件(.java)  ----->(編譯)  字節碼文件(.class) ---->(解釋器)

JVM:屏蔽不一樣OS的差別,最終實現跨平臺性.

JRE(Java 運行環境) = JVM + 解釋器 

JDK(Java開發工具包)= JRE + 編譯器 + 類庫 + 工具

跨平臺性

面向對象

簡單性(和C++對比)

================================準備知識============================

javac 源文件的文件名 (包括.java)   一個類對應着生成一個.class文件

java  類名(不包括.class)            

1. 安裝JDK

2. 設置三個環境變量

   Java_Home  =  JDK的安裝目錄

   Path       =  JDK的安裝目錄/bin

   ClassPath  =  .   (類路徑 指示編譯器或虛擬機到哪裏找所須要的類文件)

3. 編寫一個類 編譯運行

公開類的類名,必須和源文件的文件名徹底相同

import 語句   用到某個類的時候,不寫包名

=============================java================================

1.註釋  描述性的文字    可讀性 代碼質量

    //       單行註釋 

    /*  */   多行註釋     /* 不能嵌套

    /** */   多行註釋     被JavaDoc工具所讀取,並單獨生成JavaDoc文檔

    縮進

    每行一句代碼   一句代碼一行

    根據程序層次關係,作好縮進  每進入一個代碼塊,須要縮進一次

    若是一句代碼要換行,也要縮進

2.標識符 程序各個組件的名字

    語法:字母 數字 下劃線 $ 組成  數字不能開頭

         大小寫敏感  沒有長度限制

         不容許使用關鍵字

    習慣:望文知義

            包名           全小寫            helloworld

            類名           單詞首字母大寫    HelloWorld

            方法/變量名    首單詞小寫,後面的單詞首字母大寫  helloWorld

            常量           全大寫            HELLOWORLD

3.變量 表明了JVM內存中一個存儲空間

    強類型 變量的類型和變量中存儲的數據類型必須一致

    數據類型 2種

    簡單類型(基本類型)

        byte    1B      -128 -- 127

        short   2B      -32768 -- 32767

        int     4B      -2147483648 -- 2147483647

        long    8B      -2^63 -- 2^63-1            字面值加L或l

        float   4B      字面值加F或f

        double  8B      字面值加D或不加    1.3E10  1.3*10^10

        boolean         布爾  字面值 true false

        char    2B      字符 採用Unicode編碼 

                        字面值 'A' 65 '\u0041'

                        轉義字符 \n \t \' \" \\

    對象類型

        String  字符串  字面值 ""

4.表達式 

    將常量,變量以及字面值,經過運算符鏈接而成 

    類型自動提高  a+b

        a,b 有double ==> double

        a,b 有float  ==> float

        a,b 有long   ==> long

                     ==> int

    運算符

        + - * / %

        = += -= *= /=     ++ --    a++ ++a   不發生類型提高

        == > < >= <=  !=  

        &&　|| !    

        (布爾表達式)?值1：值2   

        & | ^ ~

        >>  << >>>(無符號右移)

5.局部變量  定義在方法內部的變量

    1. 必須先賦值,再使用

    2. 做用範圍:從定義開始,到它所在的代碼塊結束

    3. 重合範圍內,不容許兩個同名的局部變量

6.程序執行流程

    條件分支

        if(布爾表達式){}

        if(布爾表達式){}   else{}

        if(條件1){}

        else if (條件2){}

        else if (條件3){}

        a = (b>c)?2:1;

        if(b>c){

            a = 2;

        }

        else{

            a = 1; 

        }

        switch-case

        switch(int型表達式)  byte,short,int,char

    循環

        while(布爾表達式){}        0 - n 次    不肯定循環

        do{} while(布爾表達式);    1 - n 次    不肯定循環

        for( 定義循環變量 ; 循環條件  ; 循環變量的變化 ){}   0 - n 次  肯定循環次數

        break       跳出循環

        continue    跳出本次循環

==================================函數=================================

類--函數--語句

冗餘代碼  可維護性  

定義函數(聲明函數):static 返回值類型 函數名 (參數表)  //形式參數 形參

          形參至關於函數內部有效的局部變量

實現函數  {}  return 函數返回  return 返回值;

調用函數  函數名(參數); //實際參數實參給形參賦值

函數做用

減小冗餘代碼,便於維護

可重用性

程序結構清晰 便於分工  非結構化(語句爲單位)-->結構化(函數爲單位)

==============================數組==================================

數組

一次性定義多個同類型的變量

爲數組分配空間 長度爲n

a[0] a[1] a[2] .... a[n-1]   下標 0 -- (n-1)

數組元素的默認值:  數值類型 0  布爾類型 false 對象類型 null

數組名.length : 數組的長度

int[] a ;

a = new int[]{1,2,3};

int[] a ={1,2,3};

==============================面向對象================================

面向過程:從程序執行流程出發

面向對象:從客觀世界出發

    數據 JVM內存中的一塊存儲空間

    客觀世界:任何客觀存在的事物

           有什麼:屬性

           能作什麼:方法

    1.對象的屬性能夠是另一個對象

    2.對象調用另外的對象的方法

    計算機中的對象表明了客觀生活中的對象

生活中的解決需求的思路移植到計算機中

先把解決問題所須要的對象準備好,再讓對象間發生聯繫,從而解決問題

①各司其職: 對象簡單 由簡單的對象組成複雜的系統

②弱耦合性: 對象之間的聯繫儘量的弱

③可重用性: 對象能夠重複使用

④可擴展性: 在原有對象的基礎上,擴展出新的對象

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

類

對象的模板  該類對象具備哪些屬性和方法

對象的抽象 人對對象的主觀認識

屬性:實例變量(成員變量)

1. 有默認值 (0 false null)

2. 做用範圍至少是全類內部

3. 容許和局部變量同名,同名時局部變量優先

方法: 

聲明/定義   修飾符 返回值類型 方法名 (參數表) 拋出的異常

            對象能作什麼

實現   {}   對象怎麼作

重載(Overloading) 方法名相同 參數表不一樣 返回值,修飾符無要求

參數個數不一樣

參數類型不一樣      m(int a)   m(double d)

參數類型排列不一樣  m(int a,double d)  m(double d , int a)

只是參數名不一樣,不算重載  m(int a)  m(int b)  

對象的同類方法,因爲參數表的不一樣所形成的差別,對用戶屏蔽

編譯時多態:由編譯器,根據實參類型,選擇正確的方法來調用

構造方法

1.方法名必須和類名相同

2.沒有返回值類型

3.不容許手工調用,只會在對象構造過程當中,自動調用一次

this 

1. 調用本類其餘的構造方法  必須出如今構造方法的第一行

2. this. 當前對象  區分實例變量和局部變量

建立對象的過程

1.分配空間     屬性被賦予 默認值

2.初始化屬性   屬性被賦予 初始值

3.調用構造方法 屬性被賦予 構造參數

new 類名(參數1，參數2，參數3 ...);

簡單變量: 存值

對象變量(引用):存地址

Java中的方法參數傳遞規則

  簡單類型參數傳值   對象類型參數傳引用 (實參,形參共同指向同一對象)

=============================面向對象的三大特性===============================

三大特性

封裝

    屬性私有,提供set/get方法. 便於控制

繼承

    類之間造成 通常-特殊 關係    父類(超類) --- 子類(派生類)

    子類的共性 放在父類

    

    單繼承  每一個類只能有一個直接父類  類之間造成簡單的樹狀結構

    private    本類內部       不能繼承

    (default)  本類+同包      同包子類能夠繼承 

    protected  本類+同包+子類 能夠繼承 

    public     公開           能夠繼承 

    構造方法不能繼承給子類

  

    方法覆蓋(Override)

    子類用特殊的方法實現,替換掉父類繼承給它的通常實現

    方法名,返回值類型,參數表 必須相同 訪問修飾符相同或更寬 

    

    this

    1. 引用 當前對象  this.  區分實例變量和局部變量

    2. 構造方法 調用本類其餘構造方法 必須放在第一行

    super

    1. 引用 父類對象  super. 訪問父類被遮蓋的屬性,或調用父類被覆蓋的方法

    2. 構造方法 調用父類構造方法 必須放在第一行

    對象構造過程:jmm

    1.分配空間 屬性被賦予默認值 

    2.構造父類對象

    3.初始化本類屬性 屬性被賦予初始值

    4.調用本類構造方法   屬性被賦予構造參數

    A --B --C

    分配空間

    初始化A屬性

    調用A構造方法

    初始化B屬性

    調用B構造方法

    初始化C屬性

    調用C構造方法

多態  子類的對象能夠賦值給父類的引用

    1. 對象類型不變

    2. 只能對引用,調用其引用類型中定義的方法

    3. 運行時,根據對象類型,運行子類覆蓋以後的方法

    屏蔽不一樣子類的差別,靈活.弱耦合性

   

    多態用在方法的參數上: m(A a):m方法接受A類或A的任何子類對象爲參數

    多態用在方法的返回值上: A m():m方法可能返回A類對象,或A類某個子類對象

    

    子類引用賦值給父類引用,能夠直接賦值

    父類引用賦值給子類引用,須要強轉.運行時可能發生類型轉換異常

    引用 instanceof  類名  布爾表達式  判斷引用中的對象和類型是否兼容

    "引用中的對象 是否是 類名"   

    在類型轉換以前,用 instanceof 判斷類型兼容,從而避免類型轉換異常

=============================修飾符========================================

修飾符 

private     屬性 方法 構造方法

public      屬性 方法 構造方法  類

protected   屬性 方法 構造方法

(default)   屬性 方法 構造方法  類

abstract 抽象的

類    只能聲明引用 不能建立對象    

方法  只有定義,沒有實現

若是一個類中有抽象方法,這個類必須是抽象類(抽象類未必有抽象方法)

子類繼承抽象類,若是子類不但願也成爲抽象類,就必須實現父類中全部抽象方法

final

變量   一旦賦值,不能改變 (常量)

       final屬性沒有默認值,用戶必須主動賦值(初始化屬性,構造方法)

類     不能被繼承

方法   不能被覆蓋

 

static 靜態

屬性

    靜態屬性不屬於任何對象,全類公有  能夠用類名訪問

方法

    靜態方法能夠直接用類名調用

    靜態方法不能訪問類的非靜態成員(包括this)

    靜態方法只能被子類的靜態方法覆蓋,並且沒有多態

      對一個引用調用靜態方法,等同於對引用類型調用靜態方法

初始代碼塊  

    靜態初始代碼塊  類加載的時候執行一次

    

    類加載:當JVM第一次使用一個類的時候,經過ClassPath找到這個類對應的.class文件,將這個文件中包含的類的信息讀入JVM並保存起來

    "使用一個類":建立類的對象;調用類的靜態方法;訪問類的靜態屬性

    聲明引用 不會發生類加載!!!!!

 

    類加載的過程:

    1. 若是須要的話,加載父類

    2. 按照定義的順序,初始化靜態屬性或是運行靜態初始代碼塊

修飾符組合

private   

static               abstract

final

===============================接口 interface=============================

接口   特殊的抽象類

    1.全部屬性都是 公開 靜態 常量

    2.全部方法都是 公開 抽象方法

    3.沒有構造方法

一個類實現接口,若是這個類不但願成爲抽象類,就必須實現接口中全部方法

接口之間能夠多繼承

一個類在繼承另一個類的同時,還能夠實現多個接口

用接口實現多繼承,沒有破壞類之間樹狀關係的簡單性

    子類引用賦值給父類引用,能夠直接賦值

    父類引用賦值給子類引用,須要強轉.運行時可能發生類型轉換異常

    不相干的兩個類的引用,不能強轉(編譯不經過)

    兩個引用之中,若是有接口類型,則必定能夠強轉(編譯經過)

解耦合工具

定義接口就是定義標準  把標準的實現者和標準的使用者分離

==================================內部類===================================

1.內部類 :<定義類內部的類----能夠訪問外部類的私有成員 ,獨立的類,編譯後生成單獨的 .class 文件 >

1.成員內部類

使用 外部類類名.this 訪問外部類的當前對象

建立成員內部類對象,必須先建立外部類對象,

外部類對象.new 內部類類名

成員內部類中,不容許定義靜態成員!

Outer out = new Outer();

Outer.Inner in = out.new Inner();

2.靜態內部類

能夠定義靜態成員

只能訪問外部類的靜態成員

經過外部類類名.內部類類名 直接建立對象

Outer.StaticInner in = new Outer.StaticInner();  

3.局部內部類

定義在外部類的方法中

做用範圍:外部類的方法內部 

不只能夠訪問外部類的成員,還能夠訪問外部類聲明爲final的局部變量

4.匿名內部類

特殊的局部內部類

必須是繼承某個類或者實現某個接口

只會建立該類的一個對象(只會new一次)  

不只能夠訪問外部類的成員,還能夠訪問外部類聲明爲final的局部變量

沒法定義構造方法

        格式:

            Teacher t1 = new Teacher(){

                public void teacher(){}

            };

       匿名內部類訪問外部類的局部變量的時候,只能訪問,final修飾的，注意參數

=================================java-API=====================================

1.Object ---java全部類的父類 

    1.Object類的引用能夠存任何對象;

    2.Object 類中的方法便是全部對象的方法,

    3.方法:

           1.getClass():返回對象的實際類型 

類型 引用 = new 類型();

           2.finalize():在對象被垃圾回收器回收時,最後自動調用的方法;

           3.toString():返回對象的字符串形式

public String toString(){}

           4.equals():比較兩個對象的內容是否相等

  class 類{

                   public boolean equals(Object o){

                        //判斷自反性

                        if(this == o)return true;

                        //判斷非空

                        if(o == null) return false;

                        //判斷對象運行時的類型是相同

                        if(this.getClass() != o.getClass()) return false;

                        //類型強轉

                        Student s = (Student)o;

                        //比較對象的內容

                        ……………………………………

                        return true;

                        else return false;  

                   }

}

引用.equals(引用2);

2.包裝類 :8中基本類型的對象類型;

    <int------Integer>              int-->String   int n = Integer.parseInt(str);

    <char-----Character>

    <long-----Long>---id  

    JDK5.0的特性   自動封箱;

================================String類=================================

1.String  ----不變的對象．．．．利用串池實現共享

使用串池累加字符串時,會產生大量的中間對象,影響性能,因此使用StringBuilder/StringBuffer(JDK1.0)

    1.charAt(int pos)//得到字符串中第pos下標的字符

    2.indexOf(String str),//得到str字符的下標

    3.split(String s)//以「s」爲分割符拆分字符串

    4.subString(int start , int end);//得到子串,從start位置開始,到end結束,包括start下標,不包括end下標 

    5.toCharArray()//把字符串拆分紅字符數組 char[]

    6.trim();//去掉字符串先後的空格換行等格式字符

        面試題:String str = new String("abc");//該代碼產生兩個對象,

//首先在串池中產生一個對象,而後再棧內存中new一個對象 

        StringBuilder/StringBuffer  //實現字符串拼接,能夠提升性能

=====================================集合框架===============================

1.集合框架<容器----儲存對象的對象>

    1. interface Collection{接口:元素都是Object}

---子接口<List/Set>

       方法:1. boolean add(Object o);//將對象o放入集合中,成功返回true,不然返回false；

            2. boolean contains(Object o)//判斷o元素是否存在集合中

            3. boolean isEmpty()://判斷集合是不是空的

            4. Iterator iterator()://建立迭代器,用於迭代遍歷

            5. remove(Object o)://刪除o元素;

            6. void clear();//清空

            7. int size();//獲得集合的大小

        1.List<List元素有順序,能夠重複>-----(能夠用下標遍歷)

                1. void add(Object o)//添加o元素到集合中

                2. void add(int index,Object o)//把o添加到index下標位置

                3. Object get(int index)//獲得index位置上的對象

                4. void set(int index,Object o)//將index位置上的元素改變o對象

                5. int indexof(Object o)//返回元素o的下標,若是不存在,則返回-1

6. remove(int pos)//刪掉pos下標的元素

            <實現類>1.ArrayList:查詢快----刪除快(數組實現---線程安全)

<Vector:數組實現,線程安全,重量級>

                    2.LinkedList:查詢慢----刪除慢(鏈表實現)

          /*------------------Sun公司寫得Stack不能用-----------*/

          |  class Stack{

          |     private LinkedList list = new LinkedList();

          |      //進棧操做

          |      public void push(Object o){

          |          list.addFirst(o);

          |      }

          |      //出棧操做---(刪除頭結點--並返回頭結點對象)

          |      public Object pop(){

          |          Object o = list.removeFirst(o);

          |          return o;

          |      }

          |  }

          /*------------------Sun公司寫得Stack不能用------------*/          

            

        2.Set<Set元素無序,對象內容不能重複>-----

            方法所有繼承自Collection接口

                /*----------------------------迭代遍歷---------------------*/

                    Iterator it = set.iterator();

                    while(id.hasNext()){

                        Object o  =  it.next();

                        .....//對單一對象進行操做

                    }

                /*----------------------------迭代遍歷-------------------*/

            <實現類>1.HashSet:(元素不能重複}(必須覆蓋hashCode方法,和equals方法;)

//比較對象是否相同,虛擬機會先比較元素的HashCod,若是其值相等,而後再調用equals方法進行比較.

                                <String 類,Sun公司已經位置寫好了hashCode方法>

自定義對象放入HashSet,爲了保證元素不重複,須要：

①覆蓋hashCode(),保證相同對象返回相同的hashCode,(儘可能)保證不一樣對象返回不一樣的 int;

②覆蓋equals(),保證相同對象,返回true;

                    2.LinkedHashSet(元素不能重複,可是保留元素順序,);

            <子接口>1. interface SortedSet;//其中的元素不可重複,且通過排序

--<因此其中的對象必須實現Comparable接口,並實現其中的comparableTo方法>

                <實現類> TreeSet //因其中的元素通過排序,因此其中對象須要實現Comparable接口

Student{

public int compareTo(Object o){

//第一種

Student s = (Student)o;

this.name.compareTo(s.name);

//第二種

Student s = (Student)o;

if(this.age>s.age)

return 1;

if(this.age<s.age)

return -1;

return 0;<要比較對象的全部屬性,且對象的compareTo()方法返回0時,意味着兩個對象相等(equals)>

}

}

    2. interface Map {}---儲存鍵值對<key-value>

鍵不能夠重複,值能夠重複

            1.Object get(Object key)//得到鍵key對應的值

            2.put(Object key,Object value)//將鍵值對加入Map中,若是元素已經存在,則覆蓋原有值

            3.remove(Object key)//刪除key對應的鍵值對

            4.Set keySet();//返回Map中的全部鍵的Set集合

            5.Collection values();//返回全部元素值的Collection集合

            6.containsKey(Object key)/containsValue(Object value);//是否包含key/value

            7.size();//返回集合中元素的個數

            8.isEmpty();//判斷是否爲空

            9.clear();//清空集合

            10.entrySet():// 返回鍵值對的Set集合,其中存放的是Map.Entry,用來遍歷鍵值對

                /*----------------------------Map.Entry-------------------*/ 

interface Map.Entry

1.getKey();//得到鍵

2.getValue();//得到值

3.setValue();//修改其中的值

                /*----------------------------Map.Entry-------------------*/   

        <實現類>1.HashMap:1.2(其中的元素無順序,的鍵不能重複,採用的是hashCode方法,

因此其中的鍵對象須要覆蓋hashCode和equals方法)容許空指針 null 做爲鍵或者值 

2.Hashtable:1.0,線程安全的重量級---/*小寫t*/,不容許空指針<面試題,類名區別空指針>

                3.LinkedHashMap:其中的鍵對象依然不能重複,可是會保留元素的順序

4.properties:一種map其中的鍵和值都是字符串類型

        <子接口>SortedMap://其中的元素對鍵進行了排序,

                    <實現類> TreeMap //其中的鍵對象須要實現Comparable接口

     3.Collections: //這是個集合類,其中包裝了不少對集合經常使用的操做方法,

            (若是要排序,找大小,須要集合中的對象實現Comparable接口);

4.排序:

TreeSet 自動排序 根據排序規則,相同的元素會過濾掉

List    Collections.sort  

要求集合中的對象必須實現Comparable接口,實現compareTo方法

<   返回負數

>   返回正數

==  返回0

注意:compareTo方法和equals方法必須邏輯一致 (compareTo返回0,equals必須返回true)

5.加強循環接口 for--each-----編譯器自動將for-each翻譯爲迭代遍歷

6.泛型:爲了類型安全.是一個模版編程.實現類型安全的集合;

======================================枚舉=================================

enum 

    1.類：這個類的對象是構造好的，不容許構造該類的新對象

關鍵字：enum

特殊的類 默認是Enum的子類，因此不能再繼承別的父類，同時是final類

全部的構造方法必須是私有的---不可能有子類

枚舉值：枚舉類的對象，也是枚舉類中的公開靜態常量

2.Enum的方法：

        name()返回該枚舉對象對應的枚舉值

        ordinal()返回該枚舉對象對應枚舉值的下標

        枚舉類.value()返回全部的枚舉值對象---數組

        枚舉類中能夠定義抽象方法，且方法是留給枚舉值實現，不一樣的枚舉值各有各的實現--匿名內部類

======================================異常處理=================================

1.增長程序的容錯性,(當程序運行出現異常的時候,可以良好的運行下去)

異常處理,減小異常的損失

try{

插卡

輸入密碼,金額2000

銀行卡餘額-=2000

吐錢2000

}catch(吐錢異常 e){

銀行卡餘額+=2000

}finally{//不管有沒有異常,都能執行<必定會執行>;通常用來釋放資源；

try{

退卡

}catch(退卡異常 e2){

System.out.println("請帶上你的身份");

}

}

2.異常的分類<Throwable---父類 >

<Throwable>

|--Error 錯誤嚴重的底層錯誤--不可避免,沒法處理

|--Exception 異常

|--RuntimeException(運行時異常)的子類 未檢查異常 能夠避免的--可處理也可不處理(優先考慮避免)

|--非RuntimeException()的子類  已檢查異常 不可避免的---必須處理

throw 異常對象(Throwable對象);拋出異常(功能等同於return,使函數返回)

3.處理異常:

1.throws 聲明拋出,若是出現這種異常,我就向上拋出;(後面跟的是已檢查異常的類名)

2.try{}catch(異常引用 e){} //catch結束後,異常將會被消化處理,程序會正常執行到結束;

//也能夠處理未檢查異常;若同時捕獲,必須先捕獲子類異常,後catch父類異常

3.try{}finally{}//利用finally必定執行的特色,在try返回以前,作些操做;

4.方法的覆蓋:

子類的方法,不能比父類的方法拋出更多的異常<範圍>;

=======================================多線程=================================

1.多線程

1.進程:OS併發的一個任務

2.併發原理:CPU分時間片,多任務交替執行,宏觀並行,微觀串行

3.線程:在一個進程中,併發執行的一個順序流程

1.線程3要素:

CPU 

數據 堆空間共享,棧空間獨立, 

代碼 繼承Thread類,覆蓋run()；實現Runnable接口,實現run()；

線程啓動:

1.繼承Thread類

Thread t1 = new ThreadA();//線程對象表明了一個線程

t1.start();//啓動一個線程,執行run方法中的代碼

2.實現Runnable接口,

Runnable target = new Target();//建立目標對象

Thread t2 = new Thread(target);//建立線程對象

t2.start();

2.線程進入阻塞狀態:

等待數據輸入;

sleep();休眠<來自Thread類中的一個靜態方法;>//Thread.sleep();

3.線程同步:<保護原子操做不被破壞>

當多線程訪問同一個對象(臨界資源),若是破壞了原子操做,會致使數據的不一致;

關鍵字: synchronized 同步的----

用法: 1.synchronized(對象o){}//對o加鎖的同步代碼塊

每一個java對象都有一個互斥鎖標記,用來分配線程.只有拿到o鎖標記的線程,

才能進入對o加鎖的同步代碼塊

 2.方法修飾 同步方法 對 this 加鎖的同步代碼塊

 //只有拿到對象鎖標記的線程,才能調用o的同步代碼塊

每一個對象都有一個鎖池,用來存放等待的線程

4.線程死鎖

一個線程能夠同時擁有多個對象的鎖標記<同步帶代碼塊能夠嵌套>-------容易形成死鎖。

-----------------------哲學家進餐問題-------------------

解決死鎖問題:

線程間通訊：waite等待--notify通知。

任何對象都有一個等待隊列，用來存放線程。

Object類方法

t1:object.wait() 必須放在對object加鎖的同步代碼塊中。t1會釋放其擁有的全部鎖標記。同時t1會阻塞在object的等待隊列中;

t2:object.notify()/notifyAll()必須放在對object加鎖的同步代碼塊中,從object的等待隊列中釋放一個/所有線程;

注意:wait和sleep

=====================================I/O框架======================================

1.I/O框架

1.File:表明磁盤上的一個文件或者一個文件夾,

File file = new File("abc/test.txt");//輔助性的類,操做文件不能打開讀寫

file.操做文件;

createNewFile()//建立一個新文件

mkdir()//建立一個新目錄

delete()//刪除文件或空目錄 

exists()//判斷File對象所對象所表明的對象是否存在

getAbsolutePath()//獲取文件的絕對路徑

getName()//取得名字 

getParent()//獲取文件/目錄所在的目錄

isDirectory()//

isFile()//是不是文件

length()//得到文件的長度

listFiles()//列出目錄中的全部內容,

renameTo()//修改文件名爲

2.IO---用來JVM與外部數據傳輸的對象

方向:輸入流/輸出流

字節單位:字節流/字符流<v> 

功能分類：節點流<真正傳輸數據>/過濾流<裝飾模式>

3.字節流:InputStream/OutputStream<字節流的父類 抽象類,沒法建立對象>

1.節點流

<FileInputStream/FileOutputStream>;

int read()/write(): //每次讀寫一個字節,並將內容返回成int類型,打印的時候,須要轉換成char。

read(byte[] bs)/write(byte[] bs)://嘗試讀滿一個數組,返回實際讀入的字節數.(獨到的數據被裝在字節數組中)

read(byte[] bs,int start,int len);

流.close();//流是一種資源,須要關閉

2.過濾流:

1.<DataInputStream/DataOutputStream>(能夠讀寫8中基本類型,和字符串)

----Data流保存數據的方式是採用拆分字節方式,而不是採用文本的方法,

因此保存的dat沒法用文本編輯器直接編輯

3.過濾流的使用步驟:

建立節點流   FileOutputStream fout = new FileOutputSteam("test.dat")

封裝過濾流   DataOutputStream dout = new DataOutputStream(fout);

讀寫數據 dout.操做

關閉外層流   dout.close();

4.緩衝流<過濾流(緩衝流)----提升IO的性能---主要輸出流>:BufferedXXStream 

1.BufferedInputStream/BufferedOutputStream

注意:緩衝流讀寫數據最後,須要flush或者關閉外層流,以清空緩衝區,才能將緩衝區的內容讀寫出去

5.PrintStream<過濾流>緩衝功能,寫8中基本類型數據,和字符串,還能寫對象(寫的是對象的字符串形式toString())

System.out.----out是System類的一個靜態屬性,out是PrintStream類型的數據

6.PipedInputStream/PipedOutPutStream//管道流,用於線程之間的數據通訊

7.RandomAccessFile://隨機文件訪問讀+寫(斷點續傳) 

 

8.ObjectXXXStream(過濾流)://有Data流功能,帶緩衝,還能讀寫對象

<讀寫對象:對象須要可序列化>

2.對象序列化,須要實現Serializable接口(標記 接口)

對象的屬性被 transient 修飾後,成爲臨時屬性,將不參與序列化;

注意:若是要作對象文件追加的時候,須要先讀取全部信息,而後再從新寫入,不然 會破壞對象的結束標誌

/*---------------------存儲對象注意-----------------------*/

問題描述:流對象會記錄對象的地址,當對象內容修改以後,再存儲的時候,流對象不會再讀取新內容

而是將原對象從新存儲一遍

解決辦法:1.更換一個流對象;

2.從新 new 一個新對象,將原對象克隆至新對象

---實現Cloneable接口,調用Object的clone()方法,克隆一個新對象;

/*---------------------存儲對象注意-----------------------*/

                

4.字符流:Reader/Writer----抽象類-字符流父類---更好地解決字符的編碼問題

/*----------------亂碼問題--------英文不會出現亂碼問題-------*/

當編解碼不統一的時候,會形成亂碼

ASCII 美國 1char -- 1B

ISO 西歐 1char -- 1B

GBK2312/GBK 中國大陸 1char -- 2B

Big5 中國臺灣 繁體   中文

Unicode 全球統一

UTF-8 可變長的

UTF-16 java默認的

/*-----------------亂碼問題--------英文不會出現亂碼問題-------*/

1.節點流:FileReader/FileWriter 得到文件字符流(通常不用)

InputStreamReader/OutputStreamWriter

//橋轉換構造方法接受一個XXputStream類型的參數,完成字節流轉字符流

<橋轉換的步驟:>

建立字節流 //xxputStream

橋轉換爲字符流------------//InputStreamReader/OutputStreamWriter

在字符流上封裝過濾流

讀寫數據

關閉 外層流

BufferedReader/PrintWriter(BufferedWriter)  //帶緩衝的字符流

    5.PrintWriter()//1.5版本替代BufferedWriter(直接用字節流構造一個字符流--不能指定編碼格式,採用的是系統默認的編碼格式)

PrintWriter是過濾流,(緩衝,8中基本類型<轉換爲字符串形式,與Data流不一樣>,寫對象)

也能夠是節點流,構造方法能夠接受一個文件名或File對象做爲參數,

得到一個輸出到文件的PrintWriter,採用默認編碼

        PrintWriter pw = new PrintWriter("test.txt");

========================================網絡編程====================================

1.網絡編程

ip：  一臺主機在網絡中的邏輯地址 MAC  物理地址

端口：一個進程綁定一個端口   標識主機的進程

OSI七層模型 TCP/IP模型

應用

表示 應用 HTTP FTP SMTP

會話

傳輸 傳輸 TCP  UDP

網絡 網絡 IP協議:尋址 路由

數據鏈路 網絡接口

物理

1.網絡編程的3要素

IP地址:InetAddress(本地迴環地址:127.0.0.1  localhost)

端口號

用於標識進程的邏輯端口

有效端口:0~65535  0~1024系統使用或保留

傳輸協議

經常使用協議：TCP  UDP

2.UDP用戶數據報協議----面向無鏈接  不可靠(丟包-亂序)

1.特色

1.不須要鏈接

2.每一個數據報大小限制64k

3.不可靠

4.不須要創建鏈接，速度快

2.UDP--Socket編程

3.TCP傳輸控制協議--面向鏈接  可靠的

1.面向鏈接

2.必須創建鏈接,速度慢(三次握手),可靠

客戶端Client代碼;

Socket s = new Socket("127.0.0.1",8888);//客戶端經過Socket對象鏈接服務器(電話機)

服務器端Server代碼:

ServerSocket ss = new ServerSocket(8888);//服務器端建立相應的ServerSocket,綁定8888端口

Socket s = ss.accept();//接受一個客戶端呢請求，監聽端口,阻塞方法

4.Socket

Socket就是爲網絡服務提供的一種機制

========================================反射===============================

1.反射---通用編程

1.類對象,類加載

類對象(類加載的產物)------封裝了一個類的全部信息<類名  父類  接口  屬性  方法  構造方法...---類的信息>

類對象屬於哪一個類-----Class類的對象

概念<類對象-----類的對象>

2.得到類對象的方式:

        1.類名.class(也能得到8種基本類型的類對象)

        2.類的對象.getClass();

        3.Class.forName("類名記得加包名");//能夠加載對象

//直接使用Class 引用，使用類名.Class得到類對象

Class c1 = HashMap.class;

(Class ic = int.class)//8中簡單類型也有類對象

//經過得到對象的類型getClass()；得到類對象

HashMap hashMap = new HashMap();

Class c2 = hashMap.getClass();

//經過類名得到類對象

String className = "java.util.HashMap";//寫類全名，不能省略包 名

Class c3 = Class.forName(className);//加載類--得到類對象.

    /* ---本身寫的類,在得到類對象的時候,須要加包,即要寫類的全名----*/

Objece o = c3.newInstance(c3);

c1.getName();//得到類名<帶包的完整類名>

c1.getSimpleName();//得到類名<僅本類名>

c1.getSuperclass();//得到父類的類對象;

Class[] cc = c1.getInterfaces();//返回該該類實現的接口，放在Class數組中

c1.getFields();//得到Field屬性對象

Method[] ms = c1.getMethods();//得到類中全部的公開方法對象,包括父類

c1.getDeclaredMethods();//得到本類公開和非公開方法在內的全部方法對象;

Method m = c1.getMethod("put",Object.class,Object.class);//得到一個對應的方法對象

m.getReturnType().getName();

m.invoke(o,參數,參數);//對對象o調用m的無參方法;

3.反射更通用;突破封裝限制;

----是用於底層的,不要濫用反射,不安全;

1.標註(JDK 5.0):Annotation----描述代碼的代碼,給機器看的;

傳統的註釋:描述代碼的文字

格式:@Override

標註是一種類型:<類型:類(class)接口(interface)枚舉(enum)標註(annotation)>

1.標記標註:@標註名

2.單值標註:@標註名(屬性名=屬性值)

3.普通標註(多值標註):@標註名(屬性1=值1,屬性2=值2...)

1.特例(前提:單值標註,若是屬性值爲value)"value="能夠省略

@標註名(value="hello")-------單值標註的屬性名--一般都是value

2.標註定義:Target/Retention

package com.test;

import java.lang.annotation.*;

@Target(value={ElementType.TYPE,ElementType.FIELD,ElementType.METHOD})//決定能標註什麼

@Retention(value=RetentionPolicy=RUNTIME)//從編譯到類對象生成，一直存在 

public @interface Test {//注意標註定義的格式

String value();//標註 屬性的定義---既是屬性也是方法

String test()default "Liucy"//有默認值得屬性

}

3.標註的使用:

package com.test;

@Test

public class TestAnnotation {

@Test

private String name;

public static void main(String[] args) {

}

@Test

public String toString(){

return null;

}

}

4.標註的反射使用:

================================設計模式=============================

1.設計模式

1.單例模式:

        /*靜態屬性  建立類的一個對象

          靜態方法  返回類的對象(靜態屬性)

          構造方法私有*/

        /*------------------單例模式的惡漢式實現-----------------------*/

        class MyClass{

            private static instance = new MyClass();//靜態屬性  建立對象

            public static MyClass getInstance(){

                return instance;

            }//靜態方法  返回對象

            private MyClass(){}//構造方法私有化

        }

        /*------------單例模式的懶漢式實現------節約內存---影響效率-----*/

        class MyClass{

            private static instance;//靜態屬性  建立對象

            public static synchronized MyClass getInstance(){

            if(instance == null) instance = new MyClass();

                return instance;

            }//靜態方法  返回對象

            private MyClass(){}//構造方法私有化

        }

     2.工廠模式---減小硬編碼