一嫉到、基本語法

1.1 關鍵字

    定義：被Java語言賦予了特殊含義，用做專門用途的字符串（單詞）
    特點：關鍵字中所有字母都為小寫

    用于定義數(shù)據(jù)類型的關鍵字
    class 费封、interface 昂儒、enum、byte瓶蝴、short毒返、int、long舷手、float拧簸、double、char男窟、boolean盆赤、void
    
    用于定義數(shù)據(jù)類型值的關鍵字
    true、false歉眷、null

    用于定義流程控制的關鍵字
    if else switch case default while do for break continue return

    用于定義訪問權限修飾符的關鍵字
    private牺六、protected、public

    用于定義類汗捡，函數(shù)淑际，變量修飾符的關鍵字
    abstract、final扇住、static春缕、synchronized

    用于定義類與類之間關系的關鍵字
    extends、implements

    用于定義建立實例及引用實例艘蹋，判斷實例的關鍵字
    new 锄贼、this、super女阀、instanceof

    用于異常處理的關鍵字
    try宅荤、catch、finally浸策、throw冯键、throws

    用于包的關鍵字
    package 、import

    其他修飾符關鍵字
    native的榛、strictfp琼了、transient、volatile、assert       

1.2 標識符

    標識符：
        Java 對各種變量雕薪、方法和類等要素命名時使用的字符序列稱為標識符
        凡是自己可以起名字的地方都叫標識符昧诱。
    定義合法標識符規(guī)則：
        由26個英文字母大小寫，0-9 所袁，_或 $ 組成  
        數(shù)字不可以開頭盏档。
        不可以使用關鍵字和保留字，但能包含關鍵字和保留字燥爷。
        Java中嚴格區(qū)分大小寫蜈亩，長度無限制。
        標識符不能包含空格前翎。
    注意：在起名字時稚配，為了提高閱讀性，要盡量有意義港华，“見名知意”道川。
    Java中的名稱命名規(guī)范：
    包名：多單詞組成時所有字母都小寫：xxxyyyzzz
    類名、接口名：多單詞組成時立宜，所有單詞的首字母大寫：XxxYyyZzz
    變量名冒萄、方法名：多單詞組成時，第一個單詞首字母小寫橙数，第二個單詞開始每個單詞首字母大寫：xxxYyyZzz
    常量名：所有字母都大寫尊流。多單詞時每個單詞用下劃線連接：XXX_YYY_ZZZ

1.3 變 量

• 1.3.1、變量的概念：

        內存中的一個存儲區(qū)域
        該區(qū)域有自己的名稱（變量名）和類型（數(shù)據(jù)類型）
        Java中每個變量必須先聲明灯帮，后使用
        該區(qū)域的數(shù)據(jù)可以在同一類型范圍內不斷變化
      使用變量注意：
        變量的作用域：一對{ }之間有效    
      初始化值
        定義變量的格式：數(shù)據(jù)類型  變量名  =  初始化值
      變量是通過使用變量名來訪問這塊區(qū)域的

• 1.3.2崖技、變量的分類

        對于每一種數(shù)據(jù)都定義了明確的具體數(shù)據(jù)類型，在內存中分配了不同大小的內存空間施流。
  

  • 按數(shù)據(jù)類型

          變量分基本數(shù)據(jù)類型(byte,short,int,long,float,double,char,boolean)
                引用數(shù)據(jù)類型(類class,接口interface,數(shù)組)兩種响疚。
- 按聲明的位置的不同 
          
           在方法體外，類體內聲明的變量稱為成員變量瞪醋。
           在方法體內部聲明的變量稱為局部變量。
           變量分成員變量和局部變量兩種装诡。
                成員變量：【實例變量(不以static修飾)和類變量(以static修飾)】
                局部變量：【形參(方法簽名中定義的變量)和方法局部變量(在方法內定義)和代碼塊局部變量(在代碼塊內定義)】
        注意：二者在初始化值方面的異同:
             同：都有生命周期      
             異：局部變量除形參外银受，需顯式初始化  

• 1.3.3、整數(shù)類型：byte鸦采、short宾巍、int、long

        Java各整數(shù)類型有固定的表數(shù)范圍和字段長度渔伯，不受具體OS的影響顶霞，以保證java程序的可移植性。
        java的整型常量默認為 int 型，聲明long型常量須后加‘l’或‘L’
        byte (1字節(jié)=8bit) 
        short(2字節(jié))
        int  (4字節(jié))
        long (8字節(jié))

• 1.3.3选浑、浮點類型：float蓝厌、double

        與整數(shù)類型類似，Java 浮點類型也有固定的表數(shù)范圍和字段長度古徒，不受具體OS的影響拓提。
        Java 的浮點型常量默認為double型，聲明float型常量隧膘，須后加‘f’或‘F’代态。
        浮點型常量有兩種表示形式：
        十進制數(shù)形式：如：5.12       512.0f        .512   (必須有小數(shù)點）
        科學計數(shù)法形式:如：5.12e2      512E2     100E-2
        float (4字節(jié))
        double(8字節(jié))
  

• 1.3.4、字符類型：char

        char 型數(shù)據(jù)用來表示通常意義上“字符”(2字節(jié))
        字符型常量的三種表現(xiàn)形式：
        字符常量是用單引號(‘ ’)括起來的單個字符疹吃，涵蓋世界上所有書面語的字符蹦疑。例如：char c1 = 'a';   char c2 = '中'; char c3 =  '9';
        Java中還允許使用轉義字符‘\’來將其后的字符轉變?yōu)樘厥庾址统Ａ俊＠纾篶har c3 = ‘\n’;  // '\n'表示換行符
            直接使用 Unicode 值來表示字符型常量：‘\uXXXX’萨驶。其中歉摧，XXXX代表一個十六進制整數(shù)。如：\u000a 表示 \n篡撵。
            char類型是可以進行運算的判莉。因為它都對應有Unicode碼。
  

• 1.3.5育谬、布爾類型：boolean
  
        boolean 類型適于邏輯運算券盅，一般用于程序流程控制：
        if條件控制語句；                  
        while循環(huán)控制語句膛檀；
        do-while循環(huán)控制語句锰镀；      
        for循環(huán)控制語句；
        boolean類型數(shù)據(jù)只允許取值true和false咖刃，無null泳炉。
        不可以0或非 0 的整數(shù)替代false和true，這點和C語言不同嚎杨。
  

• 1.3.6花鹅、基本數(shù)據(jù)類型轉換

        自動類型轉換：容量小的類型自動轉換為容量大的數(shù)據(jù)類型。數(shù)據(jù)類型按容量大小排序為： 
        char —> 　　　  |
                       |->int ->long ->float ->double
        byte —>short —>|
  
        有多種類型的數(shù)據(jù)混合運算時枫浙，系統(tǒng)首先自動將所有數(shù)據(jù)轉換成容量最大的那種數(shù)據(jù)類型刨肃，然后再進行計算。      
        byte,short,char之間不會相互轉換箩帚，他們三者在計算時首先轉換為int類型真友。
        當把任何基本類型的值和字符串值進行連接運算時(+)，基本類型的值將自動轉化為字符串類型紧帕。 
  

1.4運算符

    運算符是一種特殊的符號盔然，用以表示數(shù)據(jù)的運算、賦值和比較等。
    算術運算符
    賦值運算符
    比較運算符（關系運算符）
    邏輯運算符
    位運算符
    三元運算符

• 1.4.1愈案、算術運算符

        算符              運算                           范例                     結果
         +               正號                                            +3               3
         -               負號                             b=4; -b                       -4
         +               加                          5+5                       10
         -               減                          6-4                       2
         *               乘                              3*4                       12
         /               除                              5/5                       1
         %               取模                         7%5                       2    
         ++              自增（前）：先運算后取值           a=2;b=++a;              a=3;b=3
         ++              自增（后）：先取值后運算         a=2;b=a++;                a=3;b=2
         --              自減（前）：先運算后取值           a=2;b=--a               a=1;b=1
         --              自減（后）：先取值后運算           a=2;b=a--               a=1;b=2
         +               字符串相加                      “He”+”llo”              “Hello”

    算術運算符的注意問題
        如果對負數(shù)取模挺尾，可以把模數(shù)負號忽略不記，如：5%-2=1刻帚。 但被模數(shù)是負數(shù)則不可忽略潦嘶。此外，取模運算的結果不一定總是整數(shù)崇众。

        對于除號“/”掂僵，它的整數(shù)除和小數(shù)除是有區(qū)別的：整數(shù)之間做除法時，只保留整數(shù)部分而舍棄小數(shù)部分顷歌。 
              例如：int x=3510;x=x/1000*1000;  x的結果是锰蓬？
        
        “+”除字符串相加功能外，還能把非字符串轉換成字符串.例如：System.out.println("5+5="+5+5); //打印結果是？
        
        以下二者的區(qū)別：
        System.out.println('*' + '\t' +'*');
        System.out.println("*" + '\t' +'*');    

• 1.4.2、賦值運算符

        符號：= 
        當“=”兩側數(shù)據(jù)類型不一致時问拘，可以使用自動類型轉換或使用強制類型轉換原則進行處理。
        支持連續(xù)賦值舱卡。
  
        擴展賦值運算符： +=, -=, *=, /=, %=
  

• 1.4.3、比較運算符

       運算符          運算                  范例                                結果                      
        ==              相等于              4==3                                false                               
        !=              不等于              4!=3                                true
        <               小于                  4<3                                  false      
        >               大于                  4>3                                true
        <=              小于等于              4<=3                               false      
        >=              大于等于              4>=3                                true      
        instanceof      檢查是否是類的對象     “Hello”  instanceof  String        true

        比較運算符的結果都是boolean型队萤，也就是要么是true轮锥，要么是false。
        比較運算符“==”不能誤寫成“=” 要尔。

• 1.4.4舍杜、邏輯運算符

        &—邏輯與         | —邏輯或         ！—邏輯非
        && —短路與      || —短路或        ^ —邏輯異或 
  

        a       b       a&b     a|b     !a      a^b     a&&b    a||b     
            
        true    true    true    true    false   false   true     true
        true    false   false   true    false   true    false    true   
        false   true    false   true    true    true    false    true
        false   false   false   false   true    false   false    false

        邏輯運算符用于連接布爾型表達式赵辕，在Java中不可以寫成3<x<6既绩，應該寫成x>3 & x<6 。
        “&”和“&&”的區(qū)別：
        單&時还惠，左邊無論真假饲握，右邊都進行運算；
        雙&時蚕键，如果左邊為真互拾，右邊參與運算，如果左邊為假嚎幸，那么右邊不參與運算。
        “|”和“||”的區(qū)別同理寄猩，||表示：當左邊為真嫉晶，右邊不參與運算。
        異或( ^ )與或( | )的不同之處是：當左右都為true時，結果為false替废。
        理解：異或箍铭，追求的是“異”!

• 1.4.5、位運算符

        運算符       運算          范例
          <<        左移           3 << 2 = 12 --> 3*2*2=12
          >>        右移           3 >> 1 = 1  --> 3/2=1
          >>>       無符號右移      3 >>> 1 = 1 --> 3/2=1
          &         與運算        6 & 3 = 2
          |         或運算        6 | 3 = 7
          ^         異或運算        6 ^ 3 = 5
          ~         反碼              ~6 = -7
  
        位運算是直接對二進制進行運算
        
        <<  空位補0椎镣，被移除的高位丟棄诈火，空缺位補0。
        >>  被移位的二進制最高位是0状答，右移后冷守，空缺位補0；最高位是1惊科，空缺位補1拍摇。
        >>> 被移位二進制最高位無論是0或者是1，空缺位都用0補馆截。
        &   二進制位進行&運算充活，只有1&1時結果是1，否則是0;
        |   二進制位進行 | 運算蜡娶，只有0 | 0時結果是0混卵，否則是1;
        ^   相同二進制位進行 ^ 運算，結果是0窖张；1^1=0 , 0^0=0不相同二進制位 ^ 運算結果是1幕随。1^0=1 , 0^1=1
        ~   正數(shù)取反，各二進制碼按補碼各位取反負數(shù)取反荤堪，各二進制碼按補碼各位取反
  

• 1.4.6合陵、三元運算符

        格式:
            (條件表達式)? 表達式1：表達式2；
                |    |
                |    |——>   為true澄阳，運算后的結果是表達式1拥知；
                |——> 為false，運算后的結果是表達式2碎赢；
  
        表達式1和表達式2為同種類型
        三元運算符與if-else的聯(lián)系與區(qū)別：
            1）三元運算符可簡化if-else語句
            2）三元運算符要求必須返回一個結果低剔。
            3）if后的代碼塊可有多個語句
  

1.5 程序流程控制

• 順序結構

  • 程序從上到下逐行地執(zhí)行，中間沒有任何判斷和跳轉肮塞。

• 分支結構

  • 根據(jù)條件襟齿，選擇性地執(zhí)行某段代碼。

  • 有if…else和switch兩種分支語句

  • if語句三種格式：

    1.  if(true){
      執(zhí)行代碼塊枕赵；
       }
    
    2.  if(條件表達式){執(zhí)行代碼塊猜欺；
          }
       else{
              執(zhí)行代碼塊；
        }
    
    3.  if(條件表達式){
          執(zhí)行代碼塊拷窜；
            }
            else if (條件表達式){
          執(zhí)行代碼塊开皿；
            }
             ……
             else{
          執(zhí)行代碼塊涧黄；
             }
    

  • switch和if語句的對比

      if和switch語句很像，具體什么場景下赋荆，應用哪個語句呢笋妥？
      如果判斷的具體數(shù)值不多，而且符合byte窄潭、 short 春宣、int、 char這四種類型嫉你。雖然兩個語句都可以使用月帝，建議使用swtich語句。因為效率稍高均抽。
    
      其他情況：對區(qū)間判斷嫁赏，對結果為boolean類型判斷，使用if油挥，if的使用范圍更廣
    

• 循環(huán)結構

     根據(jù)循環(huán)條件潦蝇，重復性的執(zhí)行某段代碼。
     有while深寥、do…while攘乒、for三種循環(huán)語句。
     注：JDK1.5提供了for each循環(huán)惋鹅，方便的遍歷集合则酝、數(shù)組元素。
  

  • 循環(huán)語句功能

    在某些條件滿足的情況下闰集，反復執(zhí)行特定代碼的功能
    

  • 循環(huán)語句的四個組成部分

     初始化部分（init_statement）
     循環(huán)條件部分（test_exp） 
     循環(huán)體部分（body_statement） 
     迭代部分（alter_statement） 
    

  • 循環(huán)語句分類

      for 循環(huán)
      while 循環(huán)
      do/while 循環(huán) 
    

1.6 數(shù)組

數(shù)組是多個相同類型數(shù)據(jù)的組合沽讹，實現(xiàn)對這些數(shù)據(jù)的統(tǒng)一管理
數(shù)組中的元素可以是任何數(shù)據(jù)類型，包括基本數(shù)據(jù)類型和引用數(shù)據(jù)類型
數(shù)組屬引用類型武鲁，數(shù)組型數(shù)據(jù)是對象(object)爽雄，數(shù)組中的每個元素相當于該對象的成員變量

• 一維數(shù)組

  • 聲明方式:

      type  var[] 或 type[]  var
      例如：
         int a[];
         int[] a1;
         double  b[];
         Mydate[] c;  //對象數(shù)組
    
      Java語言中聲明數(shù)組時不能指定其長度(數(shù)組中元素的數(shù))， 例如： int a[5];    //非法
    

  • 一維數(shù)組初始化

    動態(tài)初始化：數(shù)組聲明且為數(shù)組元素分配空間與賦值的操作分開進行

          int[] arr = new int[3];           
          arr[0] = 3;
          arr[1] = 9;
          arr[2] = 8;
          
          MyDate dates[];
          dates = new MyDate[3];
          dates[0] = new MyDate(22, 7, 1964);
          dates[1] = new MyDate(1, 1, 2000);
          dates[2] = new MyDate(22, 12, 1964);
    

    靜態(tài)初始化：在定義數(shù)組的同時就為數(shù)組元素分配空間并賦值沐鼠。

          int a[] = new int[]{ 3, 9, 8};
          int[] a = {3,9,8};
          
          MyDate dates[] = {
              new MyDate(22, 7, 1964),
              new MyDate(1, 1, 2000),
              new MyDate(22, 12, 1964)
          }
    

  • 數(shù)組元素的默認初始化

       數(shù)組是引用類型挚瘟，它的元素相當于類的成員變量，因此數(shù)組一經(jīng)分配空間饲梭，其中的每個元素也被按照成員變量同樣的方式被隱式初始化乘盖。例如：
    
          public class Test {
          public static void main(String argv[]){
          int a[]= new int[5]; 
          System.out.println(a[3]);   //a[3]的默認值為0
          }
          } 
    

    對于基本數(shù)據(jù)類型而言，默認初始化值各有不同
    對于引用數(shù)據(jù)類型而言憔涉，默認初始化值為null(注意與0不同订框！)

  • 數(shù)組元素的引用

        定義并用運算符new為之分配空間后，才可以引用數(shù)組中的每個元素兜叨；

        數(shù)組元素的引用方式：數(shù)組名[數(shù)組元素下標]
            數(shù)組元素下標可以是整型常量或整型表達式布蔗。如a[3] , b[i] , c[6*i];
            數(shù)組元素下標從0開始藤违；長度為n的數(shù)組合法下標取值范圍: 0 —>n-1；如int a[]=new int[3];  可引用的數(shù)組元素為a[0]纵揍、a[1]、a[2]

        每個數(shù)組都有一個屬性length指明它的長度议街，例如：a.length 指明數(shù)組a的長度(元素個數(shù))
            數(shù)組一旦初始化泽谨，其長度是不可變的

• 多維數(shù)組

  • 二維數(shù)組[][]：數(shù)組中的數(shù)組

    格式1（動態(tài)初始化）：int[][] arr = new int[3][2];

          定義了名稱為arr的二維數(shù)組
          二維數(shù)組中有3個一維數(shù)組
          每一個一維數(shù)組中有2個元素
          一維數(shù)組的名稱分別為arr[0], arr[1], arr[2]
          給第一個一維數(shù)組1腳標位賦值為78寫法是：arr[0][1] = 78;
    

    格式2（動態(tài)初始化）：int[][] arr = new int[3][];

          二維數(shù)組中有3個一維數(shù)組。
          每個一維數(shù)組都是默認初始化值null (注意：區(qū)別于格式1）
          可以對這個三個一維數(shù)組分別進行初始化
          arr[0] = new int[3];    arr[1] = new int[1];   arr[2] = new int[2];
          注：
          int[][]arr = new int[][3];  //非法
    

    格式3（靜態(tài)初始化）：int[][] arr = new int[][]{{3,8,2},{2,7},{9,0,1,6}};

           定義一個名稱為arr的二維數(shù)組特漩，二維數(shù)組中有三個一維數(shù)組
           每一個一維數(shù)組中具體元素也都已初始化
           第一個一維數(shù)組 arr[0] = {3,8,2};
           第二個一維數(shù)組 arr[1] = {2,7};
           第三個一維數(shù)組 arr[2] = {9,0,1,6};
           第三個一維數(shù)組的長度表示方式：arr[2].length;
          
          注意特殊寫法情況：int[] x,y[]; x是一維數(shù)組吧雹，y是二維數(shù)組。
          Java中多維數(shù)組不必都是規(guī)則矩陣形式
    

四種訪問權限修飾符

 Java權限修飾符public涂身、protected雄卷、private置于類的成員定義前，用來限定對象對該類成員的訪問權限蛤售。

    修飾符               類內部        同一個包       子類      任何地方
    private             Yes
    default(缺省)       Yes           Yes
    protected           Yes         Yes           Yes
    public              Yes         Yes           Yes       Yes

    對于class的權限修飾只可以用public和default(缺省)丁鹉。
    public類可以在任意地方被訪問。
    default類只可以被同一個包內部的類訪問悴能。

二揣钦、面向對象編程

• java類及類的成員

    類是有屬性和方法構成
            屬 性：對應類中的成員變量
            行 為：對應類中的成員方法
  

  • 類的語法格式

    修飾符 class 類名 {
    屬性聲明;
    方法聲明;
    }

    說明：修飾符public：類可以被任意訪問
    類的正文要用{ }括起來

      舉例：
          public class  Person{
          private int age ;               //聲明私有變量 age
          public void showAge(int i) { //聲明方法showAge( )
           age = i;
          }
      }
    

  Field = 屬性 = 成員變量，Method = (成員)方法 = 函數(shù)

        public class Person {
            String name; // 屬性
            int age;
            boolean isMarried; // 成員變量
        
            // 構造方法
            public Person() {
            }
        
            // 方法或函數(shù)
            public void walk() {
                System.out.println("人走路漠酿。冯凹。。炒嘲。");
            }
        
            //代碼塊
            {
                name = "張三";
                age = 17;
                isMarried = false;
            }
        
            // 方法或函數(shù)
            public String display() {
                return "人的名字是：" + name + ",年齡是：" + age + ",Married:" + isMarried;
            }
            
            //內部類
            class pet{
                String name;
                float weight;
            }
    }
  

主函數(shù)：

public static void main(String[] args){};
是一個特殊的函數(shù)宇姚。作為程序的入口，可以被jvm調用夫凸。
主函數(shù)的定義：
public：代表著該函數(shù)訪問權限是最大的浑劳。

static：代表主函數(shù)隨著類的加載就已經(jīng)存在了。

void：主函數(shù)沒有具體的返回值寸痢。

main：不是關鍵字呀洲，但是是一個特殊的單詞，可以被jvm識別啼止。

（String[] arr）:函數(shù)的參數(shù)道逗，參數(shù)類型是一個數(shù)組，該數(shù)組中的元素是字符串献烦。字符串類型的是數(shù)組滓窍。

主函數(shù)是固定格式的：jvm識別。

jvm在調用主函數(shù)時巩那，傳入的是new String[0];

類吏夯、對象此蜈、屬性、方法

類：類似于生活中的“類別”噪生，是對事物抽象的描述裆赵。
對象：是類具體的存在。
屬性：絕大部分在生活中是使用“名詞”來描述的跺嗽，可以使用值量化的
方法：在生活中表現(xiàn)為“動詞”的战授，是由一系列的行為構成的，是對行為模式的描述
public class Person {
    String name;
    int height;
    float weight;
    int gender;

    void run() {}
    void eat() {}
    void sleep() {}

}

成員變量與局部變量

成員變量也稱實例變量 
成員變量作用于整個類中桨嫁，存在堆內存中
局部變量作用于函數(shù)中植兰，或者語句中，存在棧內存中

四個關鍵字（this,super,static,final ）

• this

    作用：用于區(qū)分局部變量和成員變量同名情況
    this代表它所在屬函數(shù)的對象引用
    簡單說：哪個對象在調有this所在函數(shù)璃吧，this就代表哪個對象
  
    this的應用：
        當定義類中功能時楣导，該函數(shù)內部要用該函數(shù)的對象時，這時用this來表示這個對象但凡本類功能內部使用了本類對象畜挨，都用this表示
    this語句用于構造函數(shù)之間互相調用
    this語句只能定義在構造函數(shù)的第一行
  

• super

  supper的使用和this的使用幾乎一致筒繁。
  注意：super語句一定定在子類構造函數(shù)的第一行
  

• static

    static關鍵字用于修飾成員(成員變量和成員函數(shù))
    被修飾后的成員具備以下特點：
        1.隨著類的加載而加載
          也就是說：靜態(tài)會隨著類的消失而消失。說明它的生命周期最長朦促。
        2.優(yōu)先于對象存在
          靜態(tài)是先存在的膝晾，對象是后存在的
          實例變量和類變量(被靜態(tài)修飾的成員變量)的區(qū)別：
                a.存放位置：
                     類變量隨著類的加載而存在于方法區(qū)中，
                     實例變量隨著對象建立而存在于堆內存中务冕。
                b.生命周期：
                     類變量生命周期最長血当，隨著類的消失而消失
                     實例變量生命周期隨著對象的消失而消失
        3.被所有對象所共存
        4.可以直接被類名調用
  
    靜態(tài)有利有弊
        1.利處：對對象的共享數(shù)據(jù)進行單獨的儲存，節(jié)省空間禀忆，沒有必要每個對象都存儲一份可以直接被類名調用
    弊端：生命周期過長
         訪問出現(xiàn)局限性(靜態(tài)雖好臊旭，但只能訪問靜態(tài)的)
  
    使用注意事項
        1.靜態(tài)方法只能訪問靜態(tài)成員
          非靜態(tài)方法既可以訪問靜態(tài)也可以訪問非靜態(tài)
        2.靜態(tài)方法中不可以寫this，super關鍵字
        3.主函數(shù)是靜態(tài)的   
  
    用法：是一個修飾符箩退，用于修飾成員(成員變量离熏，成員函數(shù))。
         當成員被靜態(tài)修飾后戴涝，就多了一個調用方式滋戳，除了可以被對象調用外，還可以直接被類名調用啥刻。'類名.靜態(tài)成員'奸鸯。
  
    class Person{
          String name;//成員變量(實例變量)
          static  String country="CN";//靜態(tài)的成員變量(類變量)
    }
  
    什么時候使用靜態(tài)？
    從兩方面下手：
    因為靜態(tài)修飾的內容有成員變量和函數(shù)可帽。
    什么時候定義靜態(tài)變量(類變量)呢娄涩？
        1.當對象中出現(xiàn)共享數(shù)據(jù)時，該數(shù)據(jù)被靜態(tài)所修飾
        2.對象中的特有數(shù)據(jù)要定義成非靜態(tài)存在于堆內存中
  
    什么時候定義靜態(tài)函數(shù)映跟？
        1.當功能內部沒有訪問到非靜態(tài)數(shù)據(jù)(對象的特有數(shù)據(jù))蓄拣，那么該功能可以定義成靜態(tài)的扬虚。
  
    靜態(tài)的應用：
        每一個應用程序中都有共性的功能，可以將這些功能進行抽取球恤，獨立封裝以便復用辜昵。
  

• final

        final可以修飾類，方法碎捺，變量路鹰。
        final修飾的類不可以被繼承成
        final修飾的方法不可以被復寫 
        final修飾的變量是一個常量。只能賦值一次收厨，既可以是修飾成員變量，又可以修飾局部變量
            final int x=3优构；
             當描述事物時诵叁，一些數(shù)據(jù)的出現(xiàn)是固定的，那么這時為了增強閱讀性钦椭，都給這些值起個名字拧额，便于閱讀
             而這個值不需要改變，所以加上final修飾彪腔。作為常量：書寫規(guī)范所有字母大寫侥锦，如果由多個單詞組成。
             單詞之間通過_連接德挣，例如：final int MAX_VALUE=99999;
        
        內部類只能訪問被final修飾的局部變量
  

面向對象三大特性（封裝恭垦，繼承，多態(tài)）

• 1.封裝

        是指隱藏對象的屬性和實現(xiàn)細節(jié)格嗅，僅對外提供公共訪問方式
        好處：將變化隔離
            便于使用
            提高重要性
            提高安全性
        封裝原則：
             將不需要對外提供的內容都隱藏起來
             把屬性都隱藏番挺，提供公共方式對其訪問
  
        private:私有，權限修飾符：用于修飾類中的成員(成員變量屯掖，成員函數(shù))只在本類中有效
        
        注意：私有僅僅是封裝的一種表現(xiàn)形式
  

• 2.繼承

        通過?extends?關鍵字讓類與類之間產(chǎn)生繼承關系玄柏。
        多個類中存在相同屬性和行為時，將這些內容抽取到單獨一個類中贴铜，那么多個類無需再定義這些屬性和行為粪摘，只要繼承那個類即可。
        多個類可以稱為子類绍坝，單獨這個類稱為父類或者超類徘意。
  
        作用：代碼重用、代碼復用
             父類代碼在子類中不用重復編寫
        單繼承：
            一個子類只能有一個父類
            一個父類可以有多個子類
  

• 3.多態(tài)：

        多種形態(tài)陷嘴，在編譯期和運行期是不同的形態(tài)映砖，在需要父類的對象時候，可以使用子類的對象灾挨，在需要抽象的對象時候邑退，可以使用具現(xiàn)的對象竹宋。
        Java源程序需要經(jīng)過編譯后才可以運行，表現(xiàn)為需要使用javac.exe指令對源程序進行編譯地技，將會把源程序(*.java)編譯為字節(jié)碼文件(*.class)蜈七，并使用java.exe指令運行程序
        public class Demo {
             public static void main(String[] args) {
                    int x = 6;
                    int y = 10 + 3;
                    int z = x + y;
                InputStream in = new FileInputStream("xxx");
                 }
            }
        多態(tài)的應用：數(shù)組多態(tài)、參數(shù)多態(tài)莫矗、返回值多態(tài)
  

兩大抽象(抽象類和接口)

• 1.抽象類

    Java中可以定義沒有方法體的方法飒硅，該方法的具體實現(xiàn)由子類完成，該方法稱為抽象方法作谚，包含抽象方法的類就是抽象類三娩。
  
    抽象類的特點：
      抽象類和抽象方法必須用abstract關鍵字來修飾。
      抽象方法只有方法聲明妹懒，沒有方法體雀监，定義在抽象類中。
      格式：修飾符abstract返回值類型函數(shù)名(參數(shù)列表);
      抽象類不可以被實例化眨唬，也就是不可以用new創(chuàng)建對象会前。
      抽象類和一般類的區(qū)別：
            相同點：抽象類和一般類都是用來描述事物的，都在內部定義了成員匾竿。
            不同點：
                  1.一般類有足夠的信息描述事物瓦宜。
                    抽象類描述事物的信息有可能不足。
                  2.一般類中不能定義抽象方法岭妖，只能定義非抽象方法临庇。
                    抽象類中可定義抽象方法，同時也可以定義非抽象方法区转。
                  3.一般類可以被實例化苔巨。
                    抽象類不可以被實例化。
  

• 2.接口

        定義：當一個抽象類中的方法都是抽象的時候废离，這時可以將該抽象類用另一種形式定義和表示侄泽，就是接口
        作用：結構設計工具，用來解耦合
        是一個極端的抽象類
        用interface 代替class
        用implements 代替 extends
        接口中蜻韭，只能定義：
                  公共的常量
                  公共的抽象方法
                  公共的內部類或內部接口
        一個類可以實現(xiàn)多個接口
                class A implements B,C,D{
                    }
                class A extends S implements B,C,D{
                    }
  
    抽象類與接口的異同點
  
    相同點：
        都是不斷向上抽取而來的悼尾。
    不同點：
        1.抽象類需要被繼承，而且只能單繼承肖方。
          接口需要被實現(xiàn)闺魏，而且可以多實現(xiàn)。
        2.抽象類中可以定義抽象方法和非抽象方法俯画，子類繼承后析桥，可以直接使用非抽象方法。
          接口中只能定義抽象方法，必須由子類去實現(xiàn)泡仗。
        3.抽象類的繼承埋虹，是is a關系，定義該體系的基本共性內容娩怎。
          接口的實現(xiàn)是like a關系搔课。
  

重載(Overload)與重寫(Override)

• 1.Overload

        重載是在同一個類中，允許存在若干個同名方法的機制截亦。
        重載的多個方法必須有不相同的參數(shù)列表爬泥，表現(xiàn)為：參數(shù)的數(shù)據(jù)類型、數(shù)量崩瓤、順序不同袍啡。
        判斷是否允許重載，無視返回值類型却桶。
        構造方法也是方法葬馋，所以，構造方法也可以重載肾扰。
  

• 2.Override

        重寫是在類與類之間實現(xiàn)繼承關系以后，在子類中編寫父類中已經(jīng)聲明的方法蛋逾。
        當子類重寫在父類中已經(jīng)聲明的方法時集晚，不可以使用比父類聲明時使用的更嚴格的訪問權限。
        例如父類方法使用的權限是protected区匣，則子類重寫時可以繼續(xù)使用protected偷拔，也可以使用public，但不可以使用private亏钩。
  

四個內部類

    成員內部類
    靜態(tài)(成員)內部類
    局部內部類
    匿名內部類

• 1.成員內部類

    類的聲明與外部類的其它成員(屬性莲绰、方法……)在外部類的結構上是同等級別的。
    例如：
    public class OutterClass {
        private int i;
        public void test() {
            InnerClass ic = new InnerClass();
        }
        private class InnerClass {
        }
    }
    由于成員內部類是外部類的一部分姑丑，所以蛤签，在沒有創(chuàng)建出外部類的對象之前，不可以創(chuàng)建內部類的對象栅哀。
    由于成員內部類是外部類的“成員”震肮，所以，可以使用任何訪問權限修飾符進行修飾留拾。
  

• 2.靜態(tài)(成員)內部類：

    使用了static進行修飾的成員內部類戳晌。
    public class OutterClass {
            private int i;
            public void test() {}
            private static class InnerClass {
  
            }
        }
    由于靜態(tài)成員可以直接加載到內存，所以痴柔，可以在不創(chuàng)建外部類的對象時沦偎，直接創(chuàng)建靜態(tài)內部類的對象。
    由于靜態(tài)內部類使用了static修飾符，則在靜態(tài)內部類中豪嚎，無法直接訪問外部類的非靜態(tài)成員搔驼。
  

• 3.局部內部類：

        在方法中編寫的內部類。例如：
        public class OutterClass {
            public void test() {
                int i = 100;
                class InnerClass {
                    public int x;
                    public void run() {}
            }
        }
    }
    局部內部類不可以使用任何修飾符(public疙渣、private绢馍、static……)，因為這些修飾符是用于修飾類的成員的赋铝。
    由于局部內部類是聲明在方法中的迄薄，而方法中的代碼區(qū)分先后順序，所以啦租，使用局部內部類哗伯，必須在聲明局部內部類之后，且篷角，該局部內部類只能作用于所在的方法焊刹。
    局部內部類不可以直接訪問局部變量，如果一定要訪問該量恳蹲，需要將變量修飾為final虐块，或者提升為全局變量。
  

• 4.匿名內部類：

        直接new出已知的類的子類對象嘉蕾，或者接口的抽象類對象贺奠，例如：
        public class MainActivity extends Activity {
            private View.OnClickListener listener = new View.OnClickListener {
                public void onClick(View view) {
  
                }
            };
  
        protected void onCreate(Bundle bundle) {
                new View.OnClickListener() {
                    public void onClick(View view) {
                    }
                };
            }
        }
        由于匿名內部類是直接創(chuàng)建出對象的，如果是直接在方法中創(chuàng)建對象错忱，則該匿名內部類符合局部內部類的特征儡率，例如不可以直接訪問局部變量等等；
        內部類可以訪問外部類的所有成員以清，無論這些成員是使用什么樣的權限修飾的儿普。
  

異常

是什么？是對問題的描述掷倔。將問題進行對象的封裝眉孩。

    異常體系：
        Throwable
            |--Error
            |--Exception
                |--RuntimeException
    
    異常體系的特點：異常體系中的所有類以及建立的對象都具備可拋性。
                    也就是說可以被throw和throws關鍵字所操作今魔。
                    只有異常體系具備這個特點勺像。

• throw和throws的用法：

    throw定義在函數(shù)內，用于拋出異常對象错森。
    throws定義在函數(shù)上吟宦，用于拋出異常類，可以拋出多個用逗號隔開涩维。
    
    
    當函數(shù)內容有throw拋出異常對象殃姓，并未進行try處理袁波。必須要在函數(shù)上聲明，都在編譯失敗蜗侈。
    注意篷牌，RuntimeException除外。也就說踏幻，函數(shù)內如果拋出的RuntimeExcpetion異常枷颊，函數(shù)上可以不用聲明。
  

  如果函數(shù)聲明了異常该面，調用者需要進行處理夭苗。處理方法可以throws可以try。

• 異常有兩種：

    編譯時被檢測異常
        該異常在編譯時隔缀，如果沒有處理(沒有拋也沒有try)题造，編譯失敗。
        該異常被標識猾瘸，代表這可以被處理界赔。
    運行時異常(編譯時不檢測)
        在編譯時，不需要處理牵触，編譯器不檢查淮悼。
        該異常的發(fā)生，建議不處理揽思，讓程序停止敛惊。需要對代碼進行修正。
  

• 異常處理語句：

    try
    {
        需要被檢測的代碼绰更；
    }
    catch ()
    {
        處理異常的代碼；
    }
    finally
    {
        一定會執(zhí)行的代碼锡宋；
    }
  

• 有三個結合格式：

    1.  try
        {
            
        }
        catch ()
        {
        }
    
    2.  try
        {
            
        }
        finally
        {
        
        }
    
    
    3.  try
        {
            
        }
        catch ()
        {
        }
        finally
        {
        
        }
  

  注意：
  1儡湾，finally中定義的通常是 關閉資源代碼。因為資源必須釋放执俩。
  2徐钠，finally只有一種情況不會執(zhí)行。當執(zhí)行到System.exit(0);fianlly不會執(zhí)行役首。

• 自定義異常：

    定義類繼承Exception或者RuntimeException
    1,為了讓該自定義類具備可拋性尝丐。
    2，讓該類具備操作異常的共性方法衡奥。
  
    當要定義自定義異常的信息時爹袁，可以使用父類已經(jīng)定義好的功能。
    異常異常信息傳遞給父類的構造函數(shù)矮固。
    class MyException extends Exception
    {
        MyException(String message)
        {
            super(message);
        }
    }
  

• 自定義異常：按照java的面向對象思想失息，將程序中出現(xiàn)的特有問題進行封裝。

• 異常的好處：

    1，將問題進行封裝盹兢。
    2邻梆，將正常流程代碼和問題處理代碼相分離，方便于閱讀绎秒。
  

• 異常的處理原則：

    1浦妄，處理方式有兩種：try 或者 throws。
    2见芹，調用到拋出異常的功能時剂娄，拋出幾個，就處理幾個辆童。
        一個try對應多個catch宜咒。
    3，多個catch把鉴，父類的catch放到最下面故黑。
    4，catch內庭砍，需要定義針對性的處理方式场晶。不要簡單的定義printStackTrace，輸出語句怠缸。
        也不要不寫诗轻。
        當捕獲到的異常，本功能處理不了時揭北，可以繼續(xù)在catch中拋出扳炬。
        try
        {
            throw new AException();
        }
        catch (AException e)
        {
            throw e;
        }
  
        如果該異常處理不了，但并不屬于該功能出現(xiàn)的異常搔体。
        可以將異常轉換后恨樟，在拋出和該功能相關的異常。
  
        或者異尘尉悖可以處理劝术，當需要將異常產(chǎn)生的和本功能相關的問題提供出去，
        當調用者知道呆奕。并處理养晋。也可以將捕獲異常處理后，轉換新的異常梁钾。
        try
        {
            throw new AException();
        }
        catch (AException e)
        {
            // 對AException處理绳泉。
            throw new BException();
        }
  
        比如，匯款的例子姆泻。
  

• 異常的注意事項：

        在子父類覆蓋時：
        1圈纺，子類拋出的異常必須是父類的異常的子類或者子集秦忿。
        2，如果父類或者接口沒有異常拋出時蛾娶，子類覆蓋出現(xiàn)異常灯谣，只能try不能拋。
  

線程

• 進程：是一個正在執(zhí)行中的程序蛔琅。
  每一個進程執(zhí)行都有一個執(zhí)行順序胎许。該順序是一個執(zhí)行路徑，或者叫一個控制單元罗售。

• 線程：就是進程中的一個獨立的控制單元辜窑。
  線程在控制著進程的執(zhí)行。

    一個進程中至少有一個線程寨躁。
  
   Java VM  啟動的時候會有一個進程java.exe.
  
    該進程中至少一個線程負責java程序的執(zhí)行穆碎。
    而且這個線程運行的代碼存在于main方法中。
    該線程稱之為主線程职恳。
  
    擴展：其實更細節(jié)說明jvm所禀，jvm啟動不止一個線程，還有負責垃圾回收機制的線程放钦。
  

• 線程的狀態(tài)色徘。

    1，被創(chuàng)建操禀。
    2褂策，運行。
    3颓屑，凍結斤寂。
    4，消亡揪惦。   
  

• 如何在自定義的代碼中扬蕊，自定義一個線程呢？

  通過對api的查找丹擎，java已經(jīng)提供了對線程這類事物的描述。就Thread類歇父。

  • 創(chuàng)建線程的第一種方式：繼承Thread類蒂培。

      步驟：
      1，定義類繼承Thread榜苫。
      2护戳，復寫Thread類中的run方法。
          目的：將自定義代碼存儲在run方法垂睬。讓線程運行媳荒。
      
      3抗悍，調用線程的start方法，
          該方法兩個作用：啟動線程钳枕，調用run方法缴渊。
    
      發(fā)現(xiàn)運行結果每一次都不同。
      因為多個線程都獲取cpu的執(zhí)行權鱼炒。cpu執(zhí)行到誰衔沼，誰就運行。
      明確一點昔瞧，在某一個時刻指蚁，只能有一個程序在運行。(多核除外)
      cpu在做著快速的切換自晰，以達到看上去是同時運行的效果凝化。
      我們可以形象把多線程的運行行為在互相搶奪cpu的執(zhí)行權。
      
      這就是多線程的一個特性：隨機性酬荞。誰搶到誰執(zhí)行搓劫，至于執(zhí)行多長，cpu說的算袜蚕。
    

  • 為什么要覆蓋run方法呢糟把？

    Thread類用于描述線程。
    該類就定義了一個功能牲剃，用于存儲線程要運行的代碼遣疯。該存儲功能就是run方法。
    也就是說Thread類中的run方法凿傅，用于存儲線程要運行的代碼缠犀。

  • 創(chuàng)建線程的第二種方式：實現(xiàn)Runable接口

      步驟：
      1，定義類實現(xiàn)Runnable接口
      2聪舒，覆蓋Runnable接口中的run方法辨液。
          將線程要運行的代碼存放在該run方法中。
      
      3箱残，通過Thread類建立線程對象滔迈。
      4，將Runnable接口的子類對象作為實際參數(shù)傳遞給Thread類的構造函數(shù)被辑。
          為什么要將Runnable接口的子類對象傳遞給Thread的構造函數(shù)燎悍。
          因為，自定義的run方法所屬的對象是Runnable接口的子類對象盼理。
          所以要讓線程去指定指定對象的run方法谈山。就必須明確該run方法所屬對象。
      
      
      5宏怔，調用Thread類的start方法開啟線程并調用Runnable接口子類的run方法奏路。
    

  • 實現(xiàn)方式和繼承方式有什么區(qū)別呢畴椰？

      實現(xiàn)方式好處：避免了單繼承的局限性。
      在定義線程時鸽粉，建立使用實現(xiàn)方式斜脂。
    

  • 兩種方式區(qū)別：

      繼承Thread:線程代碼存放Thread子類run方法中。
      實現(xiàn)Runnable潜叛，線程代碼存在接口的子類的run方法秽褒。
    

• 多線程的運行出現(xiàn)了安全問題。

    問題的原因：
        當多條語句在操作同一個線程共享數(shù)據(jù)時威兜，一個線程對多條語句只執(zhí)行了一部分销斟，還沒有執(zhí)行完，
        另一個線程參與進來執(zhí)行椒舵。導致共享數(shù)據(jù)的錯誤蚂踊。
    
    解決辦法：
        對多條操作共享數(shù)據(jù)的語句，只能讓一個線程都執(zhí)行完笔宿。在執(zhí)行過程中犁钟，其他線程不可以參與執(zhí)行。
  

• Java對于多線程的安全問題提供了專業(yè)的解決方式泼橘。

    就是同步代碼塊涝动。
    
    synchronized(對象)
    {
        需要被同步的代碼
    
    }
    對象如同鎖。持有鎖的線程可以在同步中執(zhí)行炬灭。
    沒有持有鎖的線程即使獲取cpu的執(zhí)行權醋粟，也進不去，因為沒有獲取鎖重归。
    
    火車上的衛(wèi)生間---經(jīng)典米愿。
    
    同步的前提：
    1，必須要有兩個或者兩個以上的線程鼻吮。
    2育苟，必須是多個線程使用同一個鎖。
    
    必須保證同步中只能有一個線程在運行椎木。
  

  • 好處：解決了多線程的安全問題违柏。

  • 弊端：多個線程需要判斷鎖，較為消耗資源香椎，

• 如果同步函數(shù)被靜態(tài)修飾后漱竖，使用的鎖是什么呢？

    通過驗證士鸥，發(fā)現(xiàn)不在是this。因為靜態(tài)方法中也不可以定義this谆级。
    
    靜態(tài)進內存是烤礁，內存中沒有本類對象讼积，但是一定有該類對應的字節(jié)碼文件對象。
    類名.class  該對象的類型是Class
    
    
    靜態(tài)的同步方法脚仔，使用的鎖是該方法所在類的字節(jié)碼文件對象勤众。 類名.class
  

Java中的ApI

String類

        字符串是一個特殊的對象
        字符串是一個常量
        字符串一旦初始化就不可改變
        沒有子類
        
        String s1 ="abc";
        String s2 =new String("abc")
        String s3 ="abc";       
    
        System.out.println(s1==s2);         //false 
        System.out.println(s1==s3);         //true
        System.out.println(s1.equals(s2));  //true  判斷字符串是否相同
        
        //s1和s2有什么區(qū)別？
        //s1在內存中有一個對象
        //s2在內存中有兩個對象

• 字符串常見的操作

    常見的操作有哪些鲤脏？
    "abcd"
  
    1们颜，獲取。
        1.1 字符串中的包含的字符數(shù)猎醇，也就是字符串的長度窥突。
            int length():獲取長度。
        1.2 根據(jù)位置獲取位置上某個字符硫嘶。
            char charAt(int index):
        1.3 根據(jù)字符獲取該字符在字符串中位置阻问。
            int indexOf(int ch):返回的是ch在字符串中第一次出現(xiàn)的位置。
            int indexOf(int ch, int fromIndex) :從fromIndex指定位置開始沦疾，獲取ch在字符串中出現(xiàn)的位置称近。
  
            int indexOf(String str):返回的是str在字符串中第一次出現(xiàn)的位置。
            int indexOf(String str, int fromIndex) :從fromIndex指定位置開始哮塞，獲取str在字符串中出現(xiàn)的位置刨秆。
  
            int lastIndexOf(int ch) ：
  
        
    2，判斷忆畅。
        2.1 字符串中是否包含某一個子串衡未。
            boolean contains(str):
            特殊之處：indexOf(str):可以索引str第一次出現(xiàn)位置，如果返回-1.表示該str不在字符串中存在邻眷。
                所以眠屎，也可以用于對指定判斷是否包含。
                if(str.indexOf("aa")!=-1)
  
                而且該方法即可以判斷肆饶，有可以獲取出現(xiàn)的位置改衩。
  
        2.2 字符中是否有內容。
            boolean isEmpty(): 原理就是判斷長度是否為0. 
        2.3 字符串是否是以指定內容開頭驯镊。
            boolean startsWith(str);
        2.4 字符串是否是以指定內容結尾葫督。
            boolean endsWith(str);
        2.5 判斷字符串內容是否相同。復寫了Object類中的equals方法板惑。
            boolean equals(str);
        2.6 判斷內容是否相同橄镜，并忽略大小寫。
            boolean equalsIgnoreCase();
            
    3冯乘，轉換洽胶。
        3.1 將字符數(shù)組轉成字符串。
            構造函數(shù)：String(char[])
                      String(char[],offset,count):將字符數(shù)組中的一部分轉成字符串裆馒。
  
            靜態(tài)方法：
                    static String copyValueOf(char[]);
                    static String copyValueOf(char[] data, int offset, int count) 
  
                    static String valueOf(char[]):
  
        
        3.2 將字符串轉成字符數(shù)組姊氓。**
            char[] toCharArray():
  
        3.3 將字節(jié)數(shù)組轉成字符串丐怯。
                String(byte[])
                String(byte[],offset,count):將字節(jié)數(shù)組中的一部分轉成字符串。
  
        3.4 將字符串轉成字節(jié)數(shù)組翔横。
                byte[]  getBytes():
        3.5 將基本數(shù)據(jù)類型轉成字符串读跷。
            static String valueOf(int)
            static String valueOf(double)
  
            //3+"";//String.valueOf(3);
  
            特殊：字符串和字節(jié)數(shù)組在轉換過程中，是可以指定編碼表的禾唁。
  
    4效览，替換
        String replace(oldchar,newchar);
  
    5，切割
        String[] split(regex);
  
    6荡短，子串丐枉。獲取字符串中的一部分。
        String substring(begin);
        String substring(begin,end);
  
    7肢预，轉換矛洞，去除空格，比較烫映。
        7.1 將字符串轉成大寫或則小寫沼本。
             String toUpperCase();
             String toLowerCase();
  
        7.2 將字符串兩端的多個空格去除。
            String trim();
  
        7.3 對兩個字符串進行自然順序的比較锭沟。
            int compareTo(string);
  

• StringBuffer是字符串緩沖區(qū)抽兆。

        是一個容器。
            特點：
            1族淮，長度是可變化的辫红。
            2，可以字節(jié)操作多個數(shù)據(jù)類型祝辣。
            3贴妻，最終會通過toString方法變成字符串。
  

• C create U update R read D delete

        1蝙斜，存儲名惩。
            StringBuffer append():將指定數(shù)據(jù)作為參數(shù)添加到已有數(shù)據(jù)結尾處。
            StringBuffer insert(index,數(shù)據(jù)):可以將數(shù)據(jù)插入到指定index位置孕荠。
  
  
        2娩鹉，刪除。
            StringBuffer delete(start,end):刪除緩沖區(qū)中的數(shù)據(jù)稚伍，包含start弯予，不包含end。
            StringBuffer deleteCharAt(index):刪除指定位置的字符个曙。
    
        3锈嫩，獲取。
            char charAt(int index) 
            int indexOf(String str) 
            int lastIndexOf(String str) 
            int length() 
            String substring(int start, int end) 
  
        4，修改呼寸。
            StringBuffer replace(start,end,string);
            void setCharAt(int index, char ch) ;
  
  
        5那槽，反轉。
            StringBuffer reverse();
  
        6等舔，
            將緩沖區(qū)中指定數(shù)據(jù)存儲到指定字符數(shù)組中。
            void getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin) 
  
    
        JDK1.5 版本之后出現(xiàn)了StringBuilder.
  
        StringBuffer是線程同步糟趾。
        StringBuilder是線程不同步慌植。
  
        以后開發(fā)，建議使用StringBuilder
  
        升級三個因素：
        1义郑，提高效率蝶柿。
        2，簡化書寫非驮。
        3交汤，提高安全性。
  

基本數(shù)據(jù)類型對象包裝類劫笙。

byte    Byte
short   short
int     Integer
long    Long
boolean Boolean
float   Float
double  Double
char    Character



基本數(shù)據(jù)類型對象包裝類的最常見作用芙扎，
就是用于基本數(shù)據(jù)類型和字符串類型之間做轉換

• 基本數(shù)據(jù)類型轉成字符串。

    基本數(shù)據(jù)類型+""
  
    基本數(shù)據(jù)類型.toString(基本數(shù)據(jù)類型值);
  
    如： Integer.toString(34);//將34整數(shù)變成"34";
  

• 字符串轉成基本數(shù)據(jù)類型填大。

    xxx a = Xxx.parseXxx(String);
  
    int a = Integer.parseInt("123");
  
    double b = Double.parseDouble("12.23");
  
    boolean b = Boolean.parseBoolean("true");
  
    Integer i = new Integer("123");
  
    int num = i.intValue();
  

• 十進制轉成其他進制戒洼。

    toBinaryString();
    toHexString();
    toOctalString();
  

• 其他進制轉成十進制。

  parseInt(string,radix);
  

集合類

1. 為什么出現(xiàn)集合類允华？

    面想對象語言對事物的體現(xiàn)都是以對象的形式圈浇，所以為了方便對多個對象的操作，就對對象進行存儲靴寂，集合就是存儲對象最常用的一種方式磷蜀。

2. 數(shù)組和集合類同是容器，有何不同

    數(shù)組雖然也可以存儲對象百炬，但長度是固定的褐隆；集合長度是可變的。
    數(shù)組中可以存儲基本數(shù)據(jù)類型，集合只能存儲對象。

3. 集合的特點

集合只用于存儲對象拙吉，集合長度是可變的齐蔽，集合可以存儲不同類型的對象。

集合框架

• 為什么會出現(xiàn)這么多的容器房资？

    因為每一個容器對數(shù)據(jù)的儲存方式都有不同。
    這個存儲方式稱之為：數(shù)據(jù)結構
  

Collection

    |--List:元素是有序的，元素可以重復掉伏。因為該集合體系有索引。
        |--ArrayList:底層的數(shù)據(jù)結構使用的是數(shù)組結構。特點：查詢速度很快斧散。但是增刪稍慢供常。線程不同步。
        |--LinkedList:底層使用的鏈表數(shù)據(jù)結構鸡捐。特點：增刪速度很快栈暇，查詢稍慢。線程不同步箍镜。
        |--Vector:底層是數(shù)組數(shù)據(jù)結構源祈。線程同步。被ArrayList替代了色迂。因為效率低香缺。


    |--Set：元素是無序(存入和取出的順序不一定一致)，元素不可以重復歇僧。图张、
    |--HashSet:底層數(shù)據(jù)結構是哈希表。是線程不安全的诈悍。不同步祸轮。
            HashSet是如何保證元素唯一性的呢？
            是通過元素的兩個方法侥钳，hashCode和equals來完成倔撞。
            如果元素的HashCode值相同，才會判斷equals是否為true慕趴。
            如果元素的hashcode值不同痪蝇，不會調用equals。

            注意,對于判斷元素是否存在冕房，以及刪除等操作躏啰，依賴的方法是元素的hashcode和equals方法。


    |--TreeSet：可以對Set集合中的元素進行排序耙册。
                底層數(shù)據(jù)結構是二叉樹给僵。
                保證元素唯一性的依據(jù)：
                compareTo方法return 0.

                TreeSet排序的第一種方式：讓元素自身具備比較性。
                元素需要實現(xiàn)Comparable接口详拙，覆蓋compareTo方法帝际。
                也種方式也成為元素的自然順序，或者叫做默認順序饶辙。

                TreeSet的第二種排序方式蹲诀。
                當元素自身不具備比較性時，或者具備的比較性不是所需要的弃揽。
                這時就需要讓集合自身具備比較性脯爪。
                在集合初始化時则北，就有了比較方式。

Set集合的功能和Collection是一致的痕慢。

• Collection定義了集合框架的共性功能尚揣。

    1，添加
        add(e);
        addAll(collection);
  
    2掖举，刪除
        remove(e);
        removeAll(collection);
        clear();
  
    3快骗，判斷。
        contains(e);
        isEmpty();
  
    4塔次，獲取
        iterator();
        size();
  
    5滨巴，獲取交集。
        retainAll();
  
    6俺叭，集合變數(shù)組。
        toArray();
  

  1泰偿，add方法的參數(shù)類型是Object熄守。以便于接收任意類型對象。

  2耗跛，集合中存儲的都是對象的引用(地址)

什么是迭代器呢裕照？

    其實就是集合的取出元素的方式。
    如同抓娃娃游戲機中的夾子调塌。

    迭代器是取出方式晋南，會直接訪問集合中的元素。
    所以將迭代器通過內部類的形式來進行描述羔砾。
    通過容器的iterator()方法獲取該內部類的對象负间。

• List集合

  特有方法。凡是可以操作角標的方法都是該體系特有的方法姜凄。

    增
    add(index,element);
    addAll(index,Collection);
  
    刪
    remove(index);
  
    改
    set(index,element);
  
    查
    get(index):
    subList(from,to);
    listIterator();
    int indexOf(obj):獲取指定元素的位置政溃。
    ListIterator listIterator();
  
      List集合特有的迭代器。ListIterator是Iterator的子接口态秧。
      在迭代時董虱，不可以通過集合對象的方法操作集合中的元素。
     因為會發(fā)生ConcurrentModificationException異常申鱼。
     所以愤诱，在迭代器時，只能用迭代器的放過操作元素捐友，可是Iterator方法是有限的淫半，
     只能對元素進行判斷，取出匣砖，刪除的操作撮慨，
     如果想要其他的操作如添加竿痰，修改等，就需要使用其子接口砌溺，ListIterator影涉。
  

  該接口只能通過List集合的listIterator方法獲取。

• LinkedList

    LinkedList:特有方法：
        addFirst();
        addLast();
  
        getFirst();
        getLast();
    獲取元素规伐，但不刪除元素蟹倾。如果集合中沒有元素，會出現(xiàn)NoSuchElementException
  
        removeFirst();
        removeLast();
    獲取元素猖闪，但是元素被刪除鲜棠。如果集合中沒有元素，會出現(xiàn)NoSuchElementException
  
  
    在JDK1.6出現(xiàn)了替代方法培慌。
  
        offerFirst();
        offerLast();
  
        peekFirst();
        peekLast();
    獲取元素豁陆，但不刪除元素。如果集合中沒有元素吵护，會返回null盒音。
  
        pollFirst();
        pollLast();
    獲取元素，但是元素被刪除馅而。如果集合中沒有元素祥诽，會返回null。
  

泛型

    泛型：JDK1.5版本以后出現(xiàn)新特性瓮恭。用于解決安全問題雄坪，是一個類型安全機制。
    
    好處
    1.將運行時期出現(xiàn)問題ClassCastException屯蹦，轉移到了編譯時期维哈。，
        方便于程序員解決問題登澜。讓運行時問題減少笨农，安全。帖渠，
    
    2谒亦，避免了強制轉換麻煩。
    
    
    泛型格式：通過<>來定義要操作的引用數(shù)據(jù)類型空郊。
    
    在使用java提供的對象時份招，什么時候寫泛型呢？
    
    通常在集合框架中很常見狞甚，
    只要見到<>就要定義泛型锁摔。
    
    其實<> 就是用來接收類型的。
    
    當使用集合時哼审，將集合中要存儲的數(shù)據(jù)類型作為參數(shù)傳遞到<>中即可谐腰。

    //泛型類孕豹。
    什么時候定義泛型類？
    當類中要操作的引用數(shù)據(jù)類型不確定的時候十气，
    早期定義Object來完成擴展励背。
    現(xiàn)在定義泛型來完成擴展。

    //泛型類定義的泛型砸西，在整個類中有效叶眉。如果被方法使用，
    //那么泛型類的對象明確要操作的具體類型后芹枷，所有要操作的類型就已經(jīng)固定了衅疙。
    //為了讓不同方法可以操作不同類型，而且類型還不確定鸳慈。
    //那么可以將泛型定義在方法上饱溢。
    
    特殊之處：
    靜態(tài)方法不可以訪問類上定義的泛型。
    如果靜態(tài)方法操作的應用數(shù)據(jù)類型不確定走芋，可以將泛型定義在方法上绩郎。

    ? 通配符。也可以理解為占位符绿聘。
    泛型的限定；
    次舌？ extends E: 可以接收E類型或者E的子類型熄攘。上限。
    彼念？ super E: 可以接收E類型或者E的父類型挪圾。下限

• Map集合

    Map
        |--Hashtable:底層是哈希表數(shù)據(jù)結構，不可以存入null鍵null值逐沙。該集合是線程同步的哲思。jdk1.0.效率低。
        |--HashMap：底層是哈希表數(shù)據(jù)結構吩案，允許使用 null 值和 null 鍵棚赔，該集合是不同步的。將hashtable替代徘郭，jdk1.2.效率高靠益。
        |--TreeMap：底層是二叉樹數(shù)據(jù)結構。線程不同步残揉‰屎螅可以用于給map集合中的鍵進行排序。
  
  
    Map集合：該集合存儲鍵值對抱环。一對一對往里存壳快。而且要保證鍵的唯一性纸巷。
        1，添加眶痰。
            put(K key, V value) 
            putAll(Map<? extends K,? extends V> m) 
  
        2瘤旨，刪除。
            clear() 
            remove(Object key) 
  
        3凛驮，判斷裆站。
            containsValue(Object value) 
            containsKey(Object key) 
            isEmpty() 
  
  
        4，獲取黔夭。
            get(Object key) 
            size() 
            values() 
            entrySet() 
            keySet() 
  
    Map
        |--Hashtable:底層是哈希表數(shù)據(jù)結構宏胯，不可以存入null鍵null值。該集合是線程同步的本姥。jdk1.0.效率低肩袍。
        |--HashMap：底層是哈希表數(shù)據(jù)結構，允許使用 null 值和 null 鍵婚惫，該集合是不同步的氛赐。將hashtable替代，jdk1.2.效率高先舷。
        |--TreeMap：底層是二叉樹數(shù)據(jù)結構艰管。線程不同步〗ǎ可以用于給map集合中的鍵進行排序牲芋。
  
  
  
    和Set很像。
    其實大家捺球，Set底層就是使用了Map集合缸浦。
  

• map集合的兩種取出方式：

    1，Set<k> keySet：將map中所有的鍵存入到Set集合氮兵。因為set具備迭代器裂逐。
        所有可以迭代方式取出所有的鍵，在根據(jù)get方法泣栈。獲取每一個鍵對應的值卜高。
        
  
        Map集合的取出原理：將map集合轉成set集合。在通過迭代器取出南片。
  
  
    2篙悯，Set<Map.Entry<k,v>> entrySet：將map集合中的映射關系存入到了set集合中，
                而這個關系的數(shù)據(jù)類型就是：Map.Entry
  
                Entry其實就是Map中的一個static內部接口铃绒。
                為什么要定義在內部呢鸽照？
                因為只有有了Map集合，有了鍵值對颠悬，才會有鍵值的映射關系矮燎。
                關系屬于Map集合中的一個內部事物定血。
                而且該事物在直接訪問Map集合中的元素。
  

集合框架的工具類诞外。

Collections:集合框架的工具類澜沟。里面定義的都是靜態(tài)方法。

• 1峡谊、Collections和Collection有什么區(qū)別茫虽？

  Collection是集合框架中的一個頂層接口，它里面定義了單列集合的共性方法既们。
  它有兩個常用的子接口濒析，
  List：對元素都有定義索引。有序的啥纸『判樱可以重復元素。
  Set：不可以重復元素斯棒。無序盾致。

  Collections是集合框架中的一個工具類。該類中的方法都是靜態(tài)的
  提供的方法中有可以對list集合進行排序荣暮，二分查找等方法庭惜。
  通常常用的集合都是線程不安全的。因為要提高效率穗酥。
  如果多線程操作這些集合時护赊，可以通過該工具類中的同步方法，將線程不安全的集合迷扇，轉換成安全的百揭。

Runtime對象

該類并沒有提供構造函數(shù)爽哎。
說明不可以new對象蜓席。那么會直接想到該類中的方法都是靜態(tài)的。
發(fā)現(xiàn)該類中還有非靜態(tài)方法课锌。
說明該類肯定會提供了方法獲取本類對象厨内。而且該方法是靜態(tài)的，并返回值類型是本類類型渺贤。

由這個特點可以看出該類使用了單例設計模式完成雏胃。

IO(Input Output)流

• 1. IO流用來處理設備之間的數(shù)據(jù)傳輸
• 2. Java 對數(shù)據(jù)的操作是通過流的方式
• 3. Java 用于操作流的對象都在IO包中
• 4. 流按操作數(shù)據(jù)分為兩種：字節(jié)流與字符流
• 5. 流按流方向分為：輸入流，輸出流志鞍。

流常用基類

    字節(jié)流的抽象基類：
        inputStream, OutputStream瞭亮。
    字符流的抽象基類：
        Reader,Writer。
    注：由這四個類派生出來的之類名稱都是以其父類名作為之類名的后綴固棚。
        如：InputStream的子類FileInputSteam统翩。
        如：Reader的子類FileReader仙蚜。

字符流的特點

    既然IO流是用于操作數(shù)據(jù)的，
    那么數(shù)據(jù)的最常見體現(xiàn)形式是：文件厂汗。
    那么先以操作文件為主來演示委粉。
    找到一個專門用于操作文件的Writer子類對象。FileWriter娶桦。
    后綴名是父類名贾节。 前綴名是該流對象的功能。

flush和close的區(qū)別：

    flush刷新后衷畦，流可以繼續(xù)使用栗涂，它是刷新流中的數(shù)據(jù)
    close刷新后，會將流關閉霎匈。

    需求:在硬盤上戴差，創(chuàng)建一個文件并寫入一些文字數(shù)據(jù)。
     //創(chuàng)建一個FileWriter對象铛嘱。該對象一被初始化就必須要明確被操作的文件暖释。
     //而且該文件會被創(chuàng)建到指定目錄下。如果該目錄下已有同名文件墨吓，將被覆蓋球匕。
    //其實該步就是在明確數(shù)據(jù)要存放的目的地。
     FileWriter fw = new FileWriter("demo.txt");
    //調用write方法帖烘，將字符串寫入到流中亮曹。
    fw.write("abcde");
    //刷新流對象中的緩沖中的數(shù)據(jù)。
    //將數(shù)據(jù)刷到目的地中秘症。
    //fw.flush();
    //關閉流資源照卦，但是關閉之前會刷新一次內部的緩沖中的數(shù)據(jù)。
    //將數(shù)據(jù)刷到目的地中乡摹。
    //和flush區(qū)別：flush刷新后役耕，流可以繼續(xù)使用，close刷新后聪廉，會將流關閉瞬痘。
     fw.close();

IO的異常處理方式。

public static void main(String[] args) {

    FileWriter fw = null;
    try {
        fw = new FileWriter("demo.txt");
        fw.write("helloworld");
        fw.flush();
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        try {
            if (fw != null)
                fw.close();

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

}

IO文件的續(xù)寫

//傳遞一個true參數(shù)板熊，代表不覆蓋已有文件框全。并在已有文件的末尾處進行數(shù)據(jù)續(xù)寫
 \r\n表示換行
FileWriter fw=new FileWriter("demo.txt",true);

IO讀文件讀取

單字符讀取：

    FileReader fr =new FileReader("d:\\demo.txt");
        int ch=0;
        while((ch=fr.read())!=-1){
            System.out.println((char)ch);
        }
          fr.close();
        }

批量字符讀雀汕：

    FileReader fr = new FileReader("d:\\demo.txt");
         char[] buff = new char[1024];
        int num;
         while ((num = fr.read(buff)) != -1) {
         System.out.println(new String(buff, 0, num));// buff數(shù)組津辩，0表示從什么位置開始，
                                                                //num表示讀幾個
            }
            fr.close();

文本文件復制：

    原理：其實就是將C盤下的文件數(shù)據(jù)存儲到D盤的一個文件中。
    步驟：
        1喘沿，在D盤創(chuàng)建一個文件情萤。用于存儲C盤文件中的數(shù)據(jù)。
        2摹恨，定義讀取流和C盤文件關聯(lián)筋岛。
        3，通過不斷的讀寫完成數(shù)據(jù)存儲晒哄。
        4睁宰，關閉資源。

字符流的緩沖區(qū)：

    緩沖區(qū)的出現(xiàn)提高了對數(shù)據(jù)的讀寫效率
        對應類：BufferedWriter
               BufferedReader
    緩沖區(qū)的出現(xiàn)是為了提高流的操作效率而出現(xiàn)的寝凌。
    所以在創(chuàng)建緩沖區(qū)之前柒傻，必須要先有流對象。
    該緩沖區(qū)中提供了一個跨平臺的換行符较木。newLine();

    字符讀取流緩沖區(qū)：
    該緩沖區(qū)提供了一個一次讀一行的方法 readLine红符，方便于對文本數(shù)據(jù)的獲取。
    當返回null時伐债，表示讀到文件末尾预侯。

字節(jié)流：

    InputStream(讀)
    OutPutStraeam(寫)

    字節(jié)流：
    FileInputStream
    FileOutputStream

    BufferedInputStream
    BufferedOutputStream



    通過剛才的鍵盤錄入一行數(shù)據(jù)并打印其大寫，發(fā)現(xiàn)其實就是讀一行數(shù)據(jù)的原理峰锁。
    也就是readLine方法萎馅。

    能不能直接使用readLine方法來完成鍵盤錄入的一行數(shù)據(jù)的讀取呢？


    readLine方法是字符流BufferedReader類中的方法虹蒋。

    而鍵盤錄入的read方法是字節(jié)流InputStream的方法糜芳。
    
    那么能不能將字節(jié)流轉成字符流在使用字符流緩沖去的readLine方法呢？

File

    File類常見方法：
        1魄衅，創(chuàng)建峭竣。
        boolean createNewFile():在指定位置創(chuàng)建文件，如果該文件已經(jīng)存在晃虫，則不創(chuàng)建皆撩，返回false。
                        和輸出流不一樣傲茄，輸出流對象一建立創(chuàng)建文件毅访。而且文件已經(jīng)存在沮榜，會覆蓋盘榨。

            boolean mkdir():創(chuàng)建文件夾。
            boolean mkdirs():創(chuàng)建多級文件夾蟆融。
        2草巡，刪除。
            boolean delete()：刪除失敗返回false型酥。如果文件正在被使用山憨，則刪除不了返回falsel查乒。
            void deleteOnExit();在程序退出時刪除指定文件。


        3郁竟，判斷玛迄。
            boolean exists() :文件是否存在.
            isFile():
            isDirectory();
            isHidden();
            isAbsolute();

        4，獲取信息棚亩。
            getName():
            getPath():
            getParent():

            getAbsolutePath() 
            long lastModified() 
            long length() 

網(wǎng)絡編程

• 網(wǎng)絡模型

  • OSI參考模型

  • TCP/IP參考模型

    OSI參考模型 TCP/IP參考模型
    應用層 |
    表示層 | 應用層
    會話層 |
    傳輸層 傳輸層
    網(wǎng)絡層 網(wǎng)際層
    數(shù)據(jù)鏈路層 |
    物理層 | 主機至網(wǎng)絡層

網(wǎng)絡通訊要素

• IP地址

  • 網(wǎng)絡中設備的標識
  • 不易記憶蓖议，可用主機名
  • 本地回環(huán)地址：127.0.0.1 主機名： localhost

• 端口號

  • 用于標識進程的邏輯地址，不同進程的標識
  • 有效端口：0_{65535讥蟆，其中0}1024系統(tǒng)使用或保留端口勒虾。

• 傳輸協(xié)議

  • 通訊的規(guī)則
  • 常見協(xié)議: TCP UDP
  • UDP
    將數(shù)據(jù)及源和目的封裝成數(shù)據(jù)包中，不需要建立連接
    每個數(shù)據(jù)報的大小限制在64k內
    因無連接瘸彤，是不可靠協(xié)議
    不需要建立連接修然，速度快
  • TCP
    建立連接，形成傳輸數(shù)據(jù)的通道
    在連接中進行大數(shù)據(jù)量傳輸
    通過三次握手完成連接质况，是可靠協(xié)議
    必須建立連接愕宋，效率會稍低

• Socket

  • Socket 就是為網(wǎng)絡服務提供的一種機制
  • 通信的兩端都有Socket
  • 網(wǎng)絡通信其實就是Socket間的通信
  • 數(shù)據(jù)在兩個Socket間通過IO傳輸。