java

day1

軟件（Software）是一系列按照特定順序組織的計算機數據和指令的集合
人機交互兩種方式：圖形交互，命令交互。
java的特點：安全可靠，面向對象，跨平台(與平台無關，可以運行在任何操作系統之上)
java的三個版本：javaME(過時了)，javaSE(standard editon 即標准版本)，javaEE(enterprise edition 即企業版本)
java如何實現跨平台的：因為有JVM(java虛擬機)，java程序是由JVM來運行的，JVM是跨平台的，所以java程序是跨平台的。安裝jdk時就包含了JVM
       下載JDK時，選擇相應操作系統的JDK。
jre：java runtime environment(java運行時環境)，運行java程序時需要的資源在jre中，
jdk和jre的關系：jdk包括了jre
jre和jvm的關系：jre包括了jvm 
 jdk>jre>jvm
jdk:java development kit(java開發工具包)：編寫java程序時需要的資源在jdk中，
安裝軟件下的目錄：
 bin：(binary)二進制，存放可執行文件，其文件夾下的java.exe和javac.exe是經常使用的程序：
  使用方式：1.切換到c盤；2.切換到jdk下的bin所在的路徑；3.執行javac
配置環境變量：為了讓java,javac這些可執行程序在任何路徑下都可以被執行。
        1.添加一個變量：JAVA_HOME :jdk的安裝地址
        2.在path中：添加%JAVA_HOME%\bin(可執行程序的路徑)，%在win中代表取其地址    
           當執行java或javac這些可執行程序時，系統會去path中配置的路徑下去找相應的程序。
編寫java程序：d.java
編譯程序：由於電腦只認識0,1  所以執行前要先進行編譯，把java源代碼轉成電腦認識的 ---javac
 1.吧路徑切換到源文件的位置；
 2.javac d.java 編譯，編譯完會生成和類名相同的.class文件(字節碼文件)，有多少個類就生成多少個.class文件
執行程序 ：執行字節碼文件，JVM負責 
    執行含有入口的類(字節碼)。java Demo1

第二章：基本語法
2.1關鍵字
關鍵字：被java賦予了特殊含義的單詞
2.2標識符
標識符：程序中需要自己起名字的   如：類名   由字母，0-9，_，$組成，不能以數字開頭，不能和關鍵字同名，
類名：每個類名首字母必須大寫
注釋：// 單行注釋 /*    */多行注釋
縮進
常量：程序中用到的固定不變的數
機制轉換：十進制，二進制，八進制，十六進制

 

最小單位是byte(字節)，如寫4，寫成00000100。

八進制：3位數的二進制轉換為一位數，最大的數為7，說明3位數取值在0-7中，就是8進制。

 

System.out.println(14);
System.out.println(014); //八進制
System.out.println(0x14); //十六進制

原碼，反碼，補碼：
        正數都是本身
        負數原碼首位為1，反碼是符號位不變，其余相反，補碼就是反碼加1。
 6                               -6
原碼    00000110             10000110
反碼    00000110        11111001
補碼    00000110             11111010

一個字節表示的十進制數的范圍(包括負數 )：1000 0000   在機器里和數學不一樣，這里面都是0是最小的。首位僅代表符號位，與數學中無關。
故答案為  -128，127      

　　理解為：1111 1111 是負數，所以0111 1111 是最大的數，為127

　　　　　　1111 1111 是-127，因為第一個1是符號位，故可以再進位到首位，所以是-128

數據類型：決定變量占據多大的內存
 　　　　  分為兩大類：基本數據類型和引用數據類型
 　　         基本數據類型有8種：整數類型：byte 字節類型  內存大小，一個字節   -128---127
                                                     　　          short 短整型，2個字節      -32768----32767
                                                  　　   　　   int   整形，4個字節   
                                              　　       　　   long  長整形，8個字節
                          　　          　　浮點型： float  單精度浮點型，4個字節，精確到7位
                              　　　                     double 雙精度浮點型，8個字節，精確到16位
                                　　　　   布爾類型：boolean  只有兩個數值  true和false  一個字節。
                                　　 　　  字符類型：char         兩個字節  使用的是unicode編碼表，單引號里面只能放一個字符
        　　 引用數據類型：字符串類型 String

 數據類型轉換：數據類型是有級別高低的，從低到高：byte，sort，char>int>long>float>double
       自動類型轉換(低級別到高級別)
       強制類型轉換(高級別到低級別)
轉義字符(就是改變它的意思)：通過反斜杠改變后面所跟字符的含義

class Demo2
{
    public static void main(String args[]){
        /*    
            數據類型：決定變量占據多大的內存
            分為兩大類：基本數據類型和引用數據類型
            基本數據類型有8種：整數類型：字節類型：byte  內存大小，一個字節   -128---127
                                                   short 短整型，2個字節      -32768----32767
                                                   int   整形，4個字節          
                                                   long     長整形，8個字節
                                浮點型：float  單精度浮點型，4個字節，精確到7位
                                        double 雙精度浮點型，8個字節，精確到16位
                                布爾類型：boolean  只有兩個數值  true和false  一個字節。
                                字符類型：char    兩個字節  使用的是unicode編碼表，單引號里面只能放一個字符
            字符串類型   String     
                                        
        */
        float f=66.6f;    //一個小數默認是double類型，所以在后面加f可表示float類型
        boolean b=false;
        char c='m';
        System.out.println(c);
        char c1=97;
        System.out.println(c1);
        
    //    char c2='97';
    //    System.out.println(c2);
        char c3='你';
        System.out.println(c3);    
    }

}
class A
{
    public static void main(String args[]){
        byte b=45;
        short s=56;
        int a=88;
        double d=8900;
        //自動類型轉換
        double sum=b+s+a+d;//從低級別到高級別會自動轉換
        System.out.println(sum);
        //自動類型轉換
        byte m=127;//java中一個整數默認看成double類型
        System.out.println(m);

        //強制類型轉換:從高級別到低級別
        m=(byte)(m+10);  //賦值                                
        System.out.println(m);    //答案為-119
        
        int g='A';//自動類型轉換
        char ch=97; //砍掉前兩個字節

    }
}
class B
{
    public static void main(String args[]){
        //轉移字符：通過反斜杠改變后面所跟字符的含義
        System.out.println("h\'ello\" wor\\ld! 呵呵 \n 哈哈哈");
        System.out.println("-----\t -----");

    }
}

classA的m輸出過程

class B的運行結果為：

day2

   ·java中的運算符：

          算術運算符： + - * / % ++ --
          賦值運算符：=  +=  -=  *=  /=  %=（復合賦值運算符）
 例如：short s=5;
           s=(short)(s+5); //進行強制類型轉換
           s+=5; //使用復合賦值運算符
           //s=s+5   由於左邊的s是short 類型，右邊的5是int類型，自動類型轉換會使數據丟失。
          關系運算符：>  >=  <=  ==  !=
          邏輯運算符：&&(與)    ||(或)   內部執行效率更快
  &   | 
    !(非)
  &&:短路與：math>90 && eng>90:左邊的表達式值為false，右邊的表達式就不計算了，因為結果肯定為false
  ||:短路或：math>90 || eng>90:左邊的表達式值為true，右邊的表達式就不計算了，因為結果肯定為true。
  &：邏輯與：左邊的表達式值為false，右邊的表達式仍然計算
  |: 邏輯或：左邊的表達式值為true，右邊的表達式仍然計算
           位運算符：二進制位    &(按位與，對應位上全是1，才是1)  |(按位或，對應位上只要有1，就是1) 
              ^(按位異或，異即對應位上不同為1，相同為0，一個數異或另一個數兩次，還是原數，可以用來實現加密) 
              ~(按位取反，原數取反的話，得到的數就是-(原數-1)可以很快取到反碼)
              <<左移（低位補0）        >>右移(高位是0就補0，高位是1就補1)       >>>(無符號右移，高位只補0)
                左移就是 原數*2的幾次方     右移要是正數，就是原數/2的幾次方要是負數，就要先看補碼，再回到源碼
               <<< （當不想改變數本身的二進制位時，使用無符號右移，用於進制轉換移位時防止符號位出錯）。
表達式：由運算符和數據組合在一起叫表達式
表達式是有值的，

class  ZQF
{
 public static void main(String[] args) 
 {
  //+:連接符號
  int a=5,b=6;
  //字符串和任何類型的數據相連接，最后都是字符串
  System.out.println("hehe"+a+b); //hehe56
  System.out.println("a="+a+",b="+b);
  System.out.println(a+","+b);
  System.out.println(5/2.0); //結果為2.5
  System.out.println(5%2.0);  //結果為1.0
  System.out.println(-5%2); //-1 ，結果的正負由被除數決定，和除數無關
  System.out.println(-5%-2); //-1
  int num=3456; //求這個整數每一位上的數的和
  int ge =num%10;
  int shi=num/10%10;
  int bai=num/100%10;
  int qian=num/1000;
  int m=5,n;
  n=m++; //先取m的值，取到的值賦給左邊的N,然后m再自身加1
  n=++m; //m先自身加1，然后再賦給左邊的變量n,++在后邊，先取值，再賦值給左邊
  System.out.pritntln("m="+m+",n="+n);
  
  int a=9;//聲明變量
  short s=5;
  //s=(short)(s+5);
  s+=5; //s=s+5
  //關系運算符
  int x=55,y=66;
  //x>y :關系表達式 表達式：運算符和數據組合在一起組成了表達式
  System.out.println(x<y);  //結果只有兩種可能，關系成立--true，關系不成立--false
  System.out.println(x=99);  //賦值表達式
  System.out.println(x!=y);
  
  //邏輯運算符： &&   || !
  int math=90,eng=60;
  math>90 && eng>90; //表達式
  System.out.println(math>90 && eng>90); //表達式
  //true && false=false
  //true && true=true
  System.out.println(math>90 || eng>90); 
  System.out.println(!true);
  System.out.println(!(math==67));

  /*
   &&:短路與：math>90 && eng>90:左邊的表達式值為false，右邊的表達式就不計算了，因為結果肯定為false
   ||:短路或：math>90 || eng>90:左邊的表達式值為true，右邊的表達式就不計算了，因為結果肯定為true。
   &：邏輯與：左邊的表達式值為false，右邊的表達式仍然計算
   |: 邏輯或：左邊的表達式值為true，右邊的表達式仍然計算
  */
  System.out.println(~8);//-9

 } 
}

public class Test{
 public static void main(String args[]){
  System.out.println(~6);
  題目：將一個十進制數轉成十六進制數（使用位運算符）
  int num=60;
  int n1=num&15;
  int n2=num>>>4;
  System.out.println(""+n2+(char)(n1-10+'a')); //把高級別的轉成低級別的，n1-10為Int類型，比char類型大，2加‘a'為99，轉成char類型為'c'


  //對兩個整數變量的值進行交換
   //第一種使用加減
  int a=5,b=6;
  a=a+b;  //a+b的值可能溢出
  b=a-b;
  a=a-b;
  System.out.println("a="+a+",b="+b);
   //第二種使用異或
  a=a^b;
  b=a^b; //a^b^b   即a
  a=a^b; //a^a^b   即b
  System.out.println("a="+a+",b="+b);
   //第三種使用第三個變量
   int c=0;
   c=a;
   a=b;
   b=c;
  System.out.println("a="+a+",b="+b);


  //三元運算符
  int x=3,y=6;
  int m;
  x>y?x:y  //先計算？號前面的表達式，如果表達式的值為true，取：號前邊的值，否則取：后邊的值
  m=a>b?a:b; //賦值是最后進行的
  System.out.println(m);

  //使用三元運算符，獲取最大的整數
  int x=56,y=23,z=125;
  int a,max;
  a=x>y?x:y;
  max=a>z?a:z;
 }

   ·選擇結構：if....else if...elseif...else...switch()   case

class D{
 public static void main(String args[]){
  int a=4;

  //取值，比case
  //直到遇到break或者右大括號
  //當所有都不匹配時，就會執行default。執行后還是要按照第二步走。

  switch(a) //switch:開關　　　　//支持byte char int short ,枚舉，String
  {
   default:
    System.out.println("ok");
   case 1:
    System.out.println("1");//break
   case 2:
    System.out.println("2");//break
   case 3:
    System.out.println("3");break; //break可以攔截
  }

  int month=4;
  switch(month)
  {
   case 3:
   case 4:
   case 5:System.out.println("春季");break;
   case 6:
   case 7:
   case 8:System.out.println("夏季");break;
   case 9:
   case 10:
   case 11:System.out.println("秋季");break;
   case 12:
   case 1:
   case 2:System.out.println("冬季");break;
   default:
    System.out.println("無效月份");

 }  
 } 
}

   ·循環結構：

　　while(條件)     與   do....while...     （區別：do...while...至少能執行一次）        for循環

 1 class D{
 2  public static void main(String args[]){
 3   //while...    //先判斷再執行11
 4   int i=9;
 5   while(i>=0){
 6    System.out.println("hello ");
 7    i--;
 8   }
 9   //do ...  while...//先執行再判斷
10   int j=1;
11   do{
12    System.out.println("hello world");
13    j++;
14   }while(j<=5);
15  
16   //for循環  //先執行表達式1，再執行表達式2，如果表達式2成立，再執行表達式中的代碼4
17      //然后執行表達式3，再執行表達式2，成立執行表達式2，反復直到表達式2不成立，則退出循環。
18   for(int j=1;j<=5;j++ )
19   {
20    System.out.println("--"); 
21   }
22   System.out.println(j); //找不到符號
23   //變量的作用域：從其定義的位置開始，到其所在的大括號結束。
24   //for循環結束，變量j同時釋放內存，所以當循環中使用的變量在循環結束后不再使用適合使用for循環，否則適合使用while()或do{}while循環。
25  }
26 }

 

變量的作用域：從其定義的位置開始，到其所在的大括號結束。

 

 day3

   ·嵌套循環

class  A
{
    public static void main(String[] args) 
    {    
        /*
            嵌套循環： 外層循環控制行數，內層訓話控制列數
            *****
            *****
            *****
            *****
            *****
        */
        for(int j=1;j<=5;j++){
        for(int i=1;i<=5;i++)
        System.out.println("*");
        }
        System.out.println();




        for(int i=1;i<=5;i++){
            for(int j=1;j<=1;j++){
                System.out.print("*");
            }
            System.out.println();
        }

        for(int i=1;i<5;i++){
            for(int j=1;j<=i;j++){
                System.out.print(j);
            }
            System.out.println();
        }

/*打印九九乘法表
1*1=1
1*2=2 2*2=4
1*3=3 2*3=6 3*3=9
1*4=4 2*4=8 3*4=12 4*4=16
*/
        for(int i=1;i<=9;i++){
            for(j=1;j<=i;j++){
                System.out.println(j+"*"+i+"="+j*i+" ");
            }
            System.out.println();

        }

/*打印一個實心菱形圖案
        *
       *** 
      *****
     *******
      *****
       ***
        *
*/
        for(int i=1;i<=4;i++){
            //要先輸出空格
            for(int j=1;j<=4-i;j++){
                System.out.print(" ");
            }
            //再輸出*
            for(int j=1;j<=2*i-1;j++){
                System.out.println("*");
            }
            System.out.println();
        }
        for(int i=1;i<=3;i++){
            //要先輸出空格 1 2 3
            for(int j=1;j<=i;j++){
                System.out.print(" ");
            }
            //再輸出*
            for(int j=1;j<=7-2*i;j++){
                System.out.println("*");
            }
            System.out.println();
        }


/*
        *
       * *
      *   *
     *     *
      *   *
       * *
        *
*/
        for(int i=1;i<=4;i++){
            //要先輸出空格
            for(int j=1;j<=4-i;j++){
                System.out.print(" ");
            }
            //再輸出*
            for(int j=1;j<=2*i-1;j++){
                if(j==1||j==2*i-1)
                System.out.println("*");
                else
                    System.out.println(" ");
            }
            System.out.println();
        }
        for(int i=1;i<=3;i++){
            //要先輸出空格 1 2 3
            for(int j=1;j<=i;j++){
                System.out.print(" ");
            }
            //再輸出*
            for(int j=1;j<=7-2*i;j++){
                if(j==1||j==7-2*i)
                System.out.println("*");
                else 
                    System.out.print(" ");
            }
            System.out.println();
        }

    }
}

 

   ·break和continue

class B
{
    public static void main(String args[]){
        //循環中可以使用的語句： break：結束整個循環   continue:結束某一次循環
        for(int i=1;i<5;i++){
            if(i==3)
                break;        //默認第一條語句屬於if的，
            System.out.println(i);    //這個是if下的第二條語句不屬於if 結果為1,2
        }
        for(int i=1;i<5;i++){
            if(i==3){
                break;        //break后不能加任何代碼
                System.out.println(i);    //程序報錯，由於break已經結束，故不能有此行
            }
        }


        for(int i=1;i<5;i++){    
            for(int j=1;j<=5;j++){
                if(j==3){
                    break;    //結束的是內部的for,不會結束外面的for
                }
            }
            System.out.println(i);    //故輸出1,2,3,4,5
        }


        m:for(int i=1;i<5;i++){
            n:for(int j=1;j<=5;j++){
                if(j==3){
                    break m;    //結束的是外循環
                }
            }
            System.out.println(i); //故無輸出結果
        }



        for(int i=1;i<=5;i++){
            if(i==3){
                continue;//結束的是第三次的循環，也就是直接進入第四次循環，也就是去執行i++
            }
            System.out.print(i);    //1 2 4 5
        }

        for(int i=1;i<5;i++){    
            for(int j=1;j<=5;j++){
                if(j==3){
                    continue;    //結束的是內部的for,不會結束外面的for
                }
            }
            System.out.println(i);    //故輸出1,2,3,4,5
        }

        for(int i=1;i<5;i++){
            for(int j=1;j<=5;j++){
                if(j==3){
                    System.out.println(i); System.out.println(j);//分別是i為1，2，3，4，5 ；j為3，3，3，3，3；  
                    continue ;    
                }
            }
        }

        for(int i=1;i<5;i++){
            if(i==3){
                continue;        //continue后不能加任何代碼
                System.out.println(i);    //程序報錯，由於break已經結束，故不能有此行
            }
        }
        

    }
}

 

import java.util*;
class  C
{
    public static void main(String[] args) 
    {
        //編寫一個程序，最多接收10個數，求這些數的和
        //用戶可以通過輸入999來終止程序，並顯示輸入數的和
        int sum=0,num;
        Scanner sc=new Scanner(System.in);
        
        for(int i=1;i<=10;i++){
            System.out.println("輸入一個數");
            num=sx.nextInt();
            if(num==999)
                break;
            sum=sum+num;
        }
        System.out.println("sum="+sum);//如果注釋了14,15行，for一直循環，則此行不會執行，會在編譯時報錯
    }
}

    ·函數：

為什么用函數：避免代碼重復出現，當一個相同功能被多次使用時，如果沒有函數，每次都要寫重復性的代碼。
函數：具備特定功能的一段獨立的代碼段。什么時候用到這個功能，什么時候就調用
函數關鍵是實現功能，實現功能用到的數據以參數的形式來接收，如果功能最終得到的是一個數值，需要返回值。
函數的返回值類型就是使用return返回的數值的類型。

　　返回值類型  函數名（參數類型 參數1，參數類型 參數2....）{
 　　執行語句
 　　return 返回結果
　　}
　　注：void 代表無返回值，否則函數名前需加返回值類型

 

import java.util.Scanner;
class  D
{    
    //定義函數：具備特定動能的一段獨立的代碼段，什么時候用到這個功能，什么是時候去調用
    //對於函數來說，關鍵是實現功能，功能中用到的數據不是函數考慮的重點，重點是功能。
    public static int add(int a,int b){//形式參數：用參數來接收數據，被調用的
        int sum=a+b;
        return sum;    //把值返回到函數調用的位置
        System.out.println("sum="+sum);        //由於上面已經return了所以這行會報錯，運行不到此行
    }
    
    public static int add(int a,int b){//形式參數：用參數來接收數據，被調用的
        int sum=a+b;
        return sum;    //把值返回到函數調用的位置
        System.out.println("sum="+sum);
    }

    public static void main(String[] args) //主函數
    {    
        int n=add(6,8);//實參，函數調用，實參和形參要在類型，順序，個數上保持一致      n=sum,
        if(n>20)
            System.out.println("n="+n);
        System.out.println("okok");
    }
}
//每次用到相同的動能都要寫重復的代碼，冗余。
//函數是用來解決一個功能被重復使用的功能的。

class E 
{
    public static void main(String[] args) 
    {
        boolean b= isEqual(4,5);
        System.out.println(b);
        int max=getMax(34,56);
        System.out.println(max);

        juXing(5,5);
        jiuJiu();e
    }

    //自己定義函數：確定有沒有參數，確定有沒有返回值
    
    //判斷兩個整數是否相等
    //參數：兩個整數
    //返回值：boolean

    public static boolean isEqual(int a,int b){
        return a==b;    //返回到函數調用的位置

    }
    //求兩個整數中的最大值
    //參數：兩個整數
    //返回值：int
    public static int getMax(int a,int b){
        return a>b?a:b;
    }

    //用*號打印一個矩形
    //參數：行數，列數
    //返回值：無返回值
    public static void juXing(int rows,int col){
        for(int i=1;i<=rows;i++){
            for(int j=1;j<=col;j++){
                System.out.print("*");
            }
            System.out.println();
        }
    }
    
    //打印99乘法表
    //參數：無
    //返回值：無
    public static void jiuJiu(){
        for(int i=1;i<=9;i++){
            for(int j=1;j<=i;j++){
                System.out.print(j+"*"+i+"="+"j*i"+\t);
            }
                System.out.println();
        }
    }
}

   ·函數內存的分配

 

    ·函數的重載

class E 
{
    public static void main(String[] args) 
    {
        boolean b= isEqual(4,5);
        System.out.println(b);
        int max=getMax(34,56);
        System.out.println(max);

        juXing(5,5);
        jiuJiu();e
    }

    //自己定義函數：確定有沒有參數，確定有沒有返回值
    
    //判斷兩個整數是否相等
    //參數：兩個整數
    //返回值：boolean

    public static boolean isEqual(int a,int b){
        return a==b;    //返回到函數調用的位置

    }
    //求兩個整數中的最大值
    //參數：兩個整數
    //返回值：int
    public static int getMax(int a,int b){
        return a>b?a:b;
    }

    //用*號打印一個矩形
    //參數：行數，列數
    //返回值：無返回值
    public static void juXing(int rows,int col){
        for(int i=1;i<=rows;i++){
            for(int j=1;j<=col;j++){
                System.out.print("*");
            }
            System.out.println();
        }
    }
    
    //打印99乘法表
    //參數：無
    //返回值：無
    public static void jiuJiu(){
        for(int i=1;i<=9;i++){
            for(int j=1;j<=i;j++){
                System.out.print(j+"*"+i+"="+"j*i"+\t);
            }
                System.out.println();
        }
    }
}

    ·數組，局部變量，棧，堆

局部變量：在函數或語句中(如：for語句，for(int i=1;i<5;i++)定義的變量
局部變量的特點：作用域結束后，立刻釋放內存。
當函數被調用時，函數入棧，函數內定義的變量在棧中開辟內存，當函數內的代碼全部執行完，函數出棧，也就是釋放內存

數組：數組的作用：解決存儲多個數據的問題
int [] arr=new int[5]是一個局部變量，存的是一個地址值，引用類型的變量， 是數組的一個引用，
int a ; //a存的是一個整數，基本數據類型的變量

class  G
{
    public static void main(String[] args) 
    {
        //數組的作用：解決的是存儲多個數據的問題,數組屬於引用數據類型
        //定義一個可以存儲5個整數的數組
        //new int[5];    //開辟了5個int類型的內存空間   
        //為了方便使用數組，需要定義一個名字
        //arr=new int[500];

        //指定arr代表的數組的類型 
        int[] arr=new int[500];    //int a;數組占據的內存是連續的
        arr[0]=12;
        System.out.println(arr[0]);

        /*
            jvm把內存分為5塊：棧，堆，方法區，本地方法區，寄存器
            棧：局部變量進棧，在函數或語句中定義的變量屬於局部變量，如for語句，for(int i=1;i<5;I++)
                特點：作用域結束立刻釋放內存
            堆：引用數據類型屬於堆
                特點：有默認值為0；
        */
    }
}

    ·數組內存的分配：

 

 

 

 

 

 day4

   ·堆和棧對比

1.堆中有默認值，棧中沒有默認值
2.堆中的垃圾需要垃圾回收線程回收，也就是說當出現垃圾時，不一定會立刻被回收
3.棧是使用完立刻釋放內存
4.局部變量進棧，在方法，語句中定義的變量
5.對象，數組進堆（特點：都是可以存儲多個數據的）

棧和堆的對比：
棧：局部變量進棧，在函數，語句定義的變量
      局部變量的作用域結束，立刻釋放內存
      進棧的局部變量沒有默認值

堆：對象，數組在堆中開辟內存，堆中有默認值，堆中的一旦成為垃圾，需要等待垃圾回收線程回收，不會立刻釋放內存。

 

   ·引用類型的內存的特點

int[] arr=new int[5];
arr 是一個引用類型的變量
new int[5]:在堆中開辟內存
arr存的是數組在堆中的首地址，因為arr存儲了數組的地址，所以可以通過arr來操作數組
arr[0]=66；先從arr中取出地址值，去堆中找到數組，然后給數組下標為0的賦值為66。
arr=new int[3]; arr又創建了一個新的數組，把該數組的地址存儲在arr中，arr不在指向之前的數組，因為arr是一個變量，它的值可以改變

   ·數組：

　　  解決了存儲多個數據的問題，屬於引用數據類型。
         數組的內存是連續的，通過下標的方式來區分，下標固定從0開始。
         int[] arr=new int[5];
         for(int i=0;i<arr.length;i++){
 System.out.println(arr[i]); 
         }

 

   ·數組的初始化及異常

import java.util.*;
class C 
{
    public static void main(String[] args) 
    {
        int[] arr=new int[5];//0-4
        //System.out.println(arr[5]);//ArrayIndexOutOfBoundsException: 5 數組下標越界
        //arr =null;    //arr不指向任何數組
        //System.out.println(arr[0]);//NullPointerException    空指針
        arr[0]=12;
        arr[1]=12;
        arr[2]=12;
        arr[3]=12;
        arr[4]=12;
        for(int i=0;i<5;i++){
            System.out.println("請輸入第"+(i+1)+"個數");
            arr[i]=sc.nextInt();

            arr[i]=12;
        }
    //    for(int i=0;i<5;i++){
    //        System.out.println(arr[i]);
    //    }
        //arr.length得到的是數組的長度
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);
        }
    }
}
 
 class Demo1
 {
     public static void main(String arg[]){
        //數組的初始化
        int[] arr=new int[] {12,34,56,6};    //數組的長度是數值的個數
        for(int i=0;i<arr.length;i++){
            System.out.println(arr[i]);

        int[] b={1,2,3,4,5,6}    
        for(int i=0;i<b.length;i++){
            System.out.println(b[i]);
        }
     }
 }

 

//功能：求數組中的最大值
    //參數：數組
    //返回值：最大值
    public static int getMax(int[] arr){
        int max=arr[0];
        for(int i=1;i<arr.length;i++){
            if(arr[i]>max){
                max=arr[i];
            }
        }
        return max;
    }

   ·數組的選擇排序與冒泡排序

 

 

 

 

 

  

//選擇排序與冒泡排序
class E 
{
    public static void main(String[] args) 
    {
        int [] arr={23,45,12,6,78,4};

        selectSort(arr);
        for(int i=0;i<arr.length;i++)
        System.out.print(arr[i]+" ");
    
        System.out.println("------------------");
    
        bubbleSort(arr);
        for(int i=0;i<arr.length;i++)
        System.out.print(arr[i]+" ");
        
    }
    //選擇排序
    //參數：數組
    //返回值：無
    public static void selectSort(int [] arr){
        for(int i=0;i<arr.length-1;i++){
            for(int j=i+1;j<arr.length;j++){
                if(arr[j]<arr[i]){
                    huan(arr,j,i);
                }
            }
        }
    }
    public static void huan(int[] arr,int m,int n)
    {
        int c;
        c=arr[m];
        arr[m]=arr[n];
        arr[n]=c;
    }
    
    //冒泡排序
    public static void bubbleSort(int [] arr){
        for(int i=0;i<arr.length-1;i++){
            for(int j=0;j<arr.length-i-1;j++){
            if(arr[j+1]<arr[j]){
                huan (arr,j+1,j);
                }
            }
        }    
    }
}

 

 

   ·數組的查找和二分查找

//查找：一個數在數組中第一次出現的下標，沒有返回-1
class F 
{
    public static void main(String[] args) 
    {
        int[] arr={23,12,5,44,77,66,99};
        int key=44;
        int index=find(arr,key);
        System.out.println("index="+index);


    /*    int i=0;
        for(;i<arr.length;i++){
            if(arr[i]==44){
                System.out.println(i);//找到第一個相同的就結束循環，
                break;
            }
        }
        if(i==arr.length){
            System.out.println(-1);
        }

    */
    }

    public static int find(int[] arr,int key){
        for(int i=0;i<arr.length;i++){
            if(arr[i]==key){
                return i;    //返回函數調用的位置
            }
            return -1;        //返回函數調用的位置
        }
    }
}

//二分法查找：前提條件數組必須是有序的
class G
{
    public static void main(String args[]){
        int[] arr={12,34,45,56,67,78,89};
        int index=halfSearch(arr,89);
        System.out.println("index="+index);
    }
        
    public static int halfSearch(int [] arr,int key){
        int min=0,max=arr.length-1,mid;
        while(min<=max){
            mid=(min+max)/2;
            if(key>arr[mid]){
                min=mid+1;
            }else if(key<arr[mid]){
                max=mid-1;
            }else
                return mid;
        }
        return -1;
    }
}

 day5

   ·判斷回文數和質數

class Demo1 
{
    public static void main(String[] args) 
    {
        int  a;  //基本類型的變量
        int[] arr=null;//引用類型的變量
        arr=new int[5];
        arr[0]=77;
        int a;
        int[] arr=null;//  int[] 是一種引用數據類型
        Scanner sc = new Scanner();
    }

    //判斷一個數是不是質數  （只能被1和它自己整除的數）
    //參數：一個數
    //返回值：boolean

    public static boolean isZhiShu(int num)
    {
         for(int i=2;i<num/2;i++)
         {
             if(num%i==0)
                return false;
         }

         return true;
    }

    //判斷一個數是不是回文  121
    //參數：一個數
    //返回值:boolean
    public static boolean isHuiWen(int num)  //121
    {
         int sum=0,n;
         n=num;
         while(num!=0){
             sum=sum*10+num%10;//121
             num=num/10;
         }

         if(sum==n)
             return true;
         else
             return false;
    }
}

   ·十進制轉為二，八，十六進制

class Demo3 
{
    public static void main(String[] args) 
    {
        toHex(60);
        toOctal(60);
        toBinary(60);
    }

    //十進制轉十六進制
    //參數：十進制數
    //返回值：無

    public static void toShiLiu(int num)
    {
        int[] arr=new int[8];
        int index=arr.length;//8

        while(num!=0)
        {
            arr[--index]=num&15;
            num=num>>>4;
        }

        //System.out.println("index="+index);

        for(;index<arr.length;index++)
        {
            if(arr[index]>9)
                System.out.print((char)(arr[index]-10+'a'));
            else
                System.out.print(arr[index]);
        }
    }

    //十進制轉十六進制:查表法
    public static void toShiLiu2(int num)
    {
        char[] ch={'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'};
        char[] arr=new char[8];
        int index=arr.length;

        while(num!=0)
        {
            int x=num&15;  // 13
            arr[--index]=ch[x];
            num=num>>>4;
        }

         for(;index<arr.length;index++)
        {
            System.out.print(arr[index]);
        }
    
    }

    //十進制轉八進制
    public static void toBa(int num)
    {
        char[] ch={'0','1','2','3','4','5','6','7'};
        char[] arr=new char[11];
        int index=arr.length;

        while(num!=0)
        {
            int x=num&7;  // 13
            arr[--index]=ch[x];
            num=num>>>3;
        }

         for(;index<arr.length;index++)
        {
            System.out.print(arr[index]);
        }
    }
    //十進制轉2進制
    public static void toEr(int num)
    {
        char[] ch={'0','1'};
        char[] arr=new char[32];
        int index=arr.length;

        while(num!=0)
        {
            int x=num&1; 
            arr[--index]=ch[x];
            num=num>>>1;
        }

         for(;index<arr.length;index++)
        {
            System.out.print(arr[index]);
        }
    }

    public static void toAny(int num,int base,int offset)
    {
        char[] ch={'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'};
        char[] arr=new char[32];
        int index=arr.length;

        while(num!=0)
        {
            int x=num&base;
            arr[--index]=ch[x];
            num=num>>>offset;
        }

        for(;index<arr.length;index++)
        {
            System.out.print(arr[index]);
        }
    }
    public static void toHex(int num)
    {
        toAny(num,15,4);
    }
    public static void toOctal(int num)
    {
        toAny(num,7,3);
    }
    public static void toBinary(int num)
    {
        toAny(num,1,1);
    }

}

一維數組：
 int[ ] arr=new int[5];  
 求最值

 排序:Arrays.sort();

 查找：二分法查找 int key;   Arrays.binarySearch(arr,key);

 進制轉換:Integer.toHexString()    Integer.toOctalString()   Integer.toBinaryString()

 

   ·數組去重

1：創建兩個一維數組，對兩個有序的數組進行合並，並將重復的數字去掉
class T1 
{
    public static void main(String[] args) {
        int [] num1=new int[]{1,4,5,6,7};
        int [] num2=new int[]{3,5,6,8};
        hebing(num1, num2);
    }
    private static void hebing(int [] num1,int [] num2){
        int[] result=new int[num1.length+num2.length];

        int i=0,j=0,k=0;//定義三個變量。i  j  k分別控制num1 num2  result三個數組的下標

        while(i<num1.length && j< num2.length){//兩個數組都不為空的時候
            if(num1[i]<num2[j]){//若num1的元素小，加入result
                result[k]=num1[i];
                i++;//num1的下標后移
                k++;//result的下標后移
            }else if(num1[i]==num2[j]){//若二者相等 這一步就是去重復。
                result[k]=num1[i];//這里兩個數組的元素把哪個加入result都行
                k++;//result下標后移
                i++;//這里要注意的是  兩個重復了，去重之后，兩個數組的下標都要后移
                j++;
            }else {
                result[k]=num2[j];//若num2的元素小，加入result
                k++;
                j++;
            }    
        }
 
        //下面是當其中一個數組元素全部添加到result了，另一個還沒添加完  繼續添加。
        while(i<num1.length){//
            result[k]=num1[i];
            i++;
            k++;
        }
        while(j<num2.length){
            result[k]=num2[j];
            j++;
            k++;
        }
        for (int i=0;i<result.length;i++) 
        {
            System.out.println(result[i]);
        }
    }

}

   ·生成范圍內的驗證碼

5.生成4位網站驗證碼(要求用數組)
  1 不能重復
  2 只能是數字和大小寫字符, 但是不能包含1,0,o,O,l,L,Z,2,9,g

 import java.util.Random;
class T2 
{
    public static void main(String[] args) 
    {
       char[] arr={'3','4','5','6','7','8','a','b','c','d','e','f','h','i','j','k','m','n','p','q','r','s','t','u','v','w','x','y','z','A','B','C','D','E','F',
              'G','H','I','J','K','M','N','P','Q','R','S','T','U','V','W','X','Y'};

                char[] r=new char[4];//存放驗證碼的數組
        int count=0,num,index=0;
        Random random = new Random();
        boolean flag=true;
        while(count!=4)
        {
            num=random.nextInt(arr.length);//生成隨機的下標
            System.out.println(num);
            flag=true;
            for(int i=0;i<4;i++)
            {
               if(r[i]==arr[num])
                {
                   flag=false;
                   break;
                }
                
            }
            if(flag)
            {
                r[index++]=arr[num];
                count++;
            }
        }
        System.out.println();
        for(int i=0;i<4;i++)
           System.out.print(r[i]);
    }
}

 

   ·二維數組：    內存

 int[ ][ ] arr=new int[5][ ];

 

 

   

   ·類和對象

把對象裝進冰箱
面向過程：打開冰箱，裝大象，關閉冰箱
面向對象：冰箱.打開（）
類是對對象的描述，屬於概念性的東西，
對象：使用new創建的對象才是實實在在存在的實體。

描述對象的類-------》使用類(字節碼)創建的對象--------》對象具備了類中定義的屬性和方法

class Person
{
    String name;//屬性用變量表示
    int num;
    int age;
    public void eat(){    //行為用函數表示
        System.out.println("吃");
    }
}

class Demo5
{
    public static void main(String[] args){
        Car che=new Car();    //創建對象
        Person ren=new Person();//對象具備Person類中定義的屬性和行為
        ren.name="李四";
        ren.age=20;
        System.out.println(ren.name+"   "+ren.age);
        ren.eat();

    }
}
/*jvm先執行main方法，main方法屬於Demo5.class字節碼，所以先加載Demo5.class到方法區
    （原則：用到誰加載誰）
    
  創建Person的對象使用的是Person.class，所以先加載Person.class到方法區
  當常見對象時，在堆中為屬性開辟內存
  eat()方法，使用時直接進棧
  類加載器把字節碼加載到方法區
    */

 

 

   ·成員變量和局部變量的對比：

1.成員變量 有默認值
   局部變量沒有默認值
2.成員變量是隨着對象的創建在堆中開辟內存
   局部變量是隨着其所在函數被調用在棧中開辟內存
3.成員變量是隨着對象被垃圾回收才釋放內存
   局部變量作用域結束立刻釋放內存。
4.成員變量的作用范圍是整個類
   局部變量的作用域是其所在的大括號

   ·面向對象的三大特征-封裝

 

//封裝：只對外界提供有用的屬性和行為
class Person{
     String name;  
     private int age;
     
     public void setAge(int nianling){
        if(nianling<0 || nianling>120)
            System.out.println("年齡不合法");
        else
            age=nianling;
     }
     public int getAge(){
        return age;
     }
    public void eat(){
       System.out.println(age+"吃");
    }
}
class Demo9 {
    public static void main(String[] args) {
        Person ren = new Person();
        ren.setAge(20);
        int age = ren.getAge();
        System.out.println(age);
       
        //ren.age=-200; 報錯        
    }
}

    ·構造方法

/*
構造方法： 只能用來創建對象的，系統會自動在類中加入一個默認的構造方法 類名(){}
            也可以自己定義構造方法，自己一旦寫了構造方法，系統就不會再加入默認的構造方法
            構造方法是必須存在的
            構造方法可以有多個

特點：
   方法名和類名相同
   沒有返回值類型

*/
class Person{
     String name;  
     private int age;

     Person(){}//創建對象時使用的方法

     Person(String mingzi,int nianling)//創建對象時使用的方法
     {
        name=mingzi;
        age=nianling;
     }

     public void setAge(int nianling){
         age=nianling;
     }
     public int getAge(){
         return age;
     }
}
class Demo10 
{
    public static void main(String[] args) {
        Person ren = new Person();//  Person():構造函數，
        Person ren2 = new Person("趙四",20);//創建對象的同時給屬性賦值
        ren2.setAge(21);
        int a = ren2.getAge();
        System.out.println(a);  
    }
}

day6

   ·用數組打印楊輝三角

 楊輝三角

1
1  1
1  2  1
1  3  3  1
1  4  6  4   1
1  5  10 10  5  1
。。。。。。。。。。。

class Demo1 
{
    public static void main(String[] args) 
    {
        int[][] arr=new int[10][];
        arr[0]=new int[]{1};
        for(int i=1;i<10;i++){
            arr[i]=new int[i+1];
            for(int j=0;j<i+1;j++){
                if(j==0||j==i)
                    arr[i][j]=1;
                else
                    arr[i][j]=arr[i-1][j]+arr[i-1][j-1];
            }
        }
        for(int i=0;i<arr.length;i++){
          for(int j=0;j<arr[i].length;j++)
              System.out.print(arr[i][j]+"\t");
           System.out.println();
        }
    }
}

把一個數插入到數組, 第一個參數是被拷貝的數組，第二個參數是新數組的長度：

 

class Demo2 
{
    public static void main(String[] args) {
        //向一個有序的整型數組中插入一個數，插入后該數組還是有序的(二分法)
        int[] arr={12,34,56,67,78,89,99};
        int key=600;

        int index = halfSearch(arr,key);
        System.out.println("index="+index);
        index=-(index+1);
        //把這個數插入到數組, 第一個參數是被拷貝的數組，第二個參數是新數組的長度
        //返回一個新的數組
        
        int[] b=new int[arr.length+1];
        for(int i=0;i<arr.length;i++){
           b[i]=arr[i];
        }
        
        for(int i=arr.length-1;i>=index;i--){
            b[i+1]=b[i];
        }
        b[index]=key;

        for(int i=0;i<b.length;i++){
           System.out.print(b[i]+" ");
        }

    }
        //查找一個數在數組中的位置，並返回下標，
     public static int halfSearch(int[] arr,int key){
         int min=0,max=arr.length-1,mid;
         while(min<=max){
             mid=(min+max)>>1;
             if(key>arr[mid])
                 min=mid+1;
             else if(key<arr[mid])
                 max=mid-1;
             else
                return mid;//如果數存在，返回mid即下標
         }
         return -min-1;//不存在返回-min-1;
     }
}

 

   ·this

this:是一個引用，總是指向當前被使用的對象
構造函數之間的調用： this()；必須寫在構造函數代碼塊的第一行 
this 在函數中，函數棧內存里，指向堆中的對象里的屬性，所以this.變量 后面指的是成員變量，可以表示當前的；

Person(String name,int get)   //局部變量和成員變量同名時，使用的是局部變量，可以使用this來用成員變量

 

//this是一個引用，總是指向當前被使用的對象
class Person
{
     String name;  //成員變量的作用域是整個類
     int age;

     Person(){}

     Person(String name,int age){//局部變量和成員變量同名時，使用的是局部變量
     
        this.name=name;
        this.age=age;
     }

     //判斷兩個人是不是同齡人
     //參數：Person
     //返回值:boolean
     public boolean isAgeEqual(Person person){
          return age==person.age;
     }


     public void show(){
        System.out.println(this);
     }
}
class Demo4 
{
    public static void main(String[] args) {
        Person  ren = new Person("張三",25);//this指向這個對象

        Person  ren2= new Person("李四",25);//this指向這個對象

        boolean boo=ren.isAgeEqual(ren2);//this 指向 張三

        System.out.println(boo);

        //System.out.println(ren);
        //ren.show();
        //System.out.println(ren.name+","+ren.age);

        

    }
}

 

 

 

   ·static:靜態：

　　   只能修飾類中的成員
         被static修飾的成員變量的特點：
         1.隨着所屬類(字節碼)加載到方法區的同時，就在方法區內靜態區中開辟內存
         2.被static修飾的成員變量(局部變量不能被static修飾)是類所有的對象共享的。
         3.可以直接通過類名訪問
什么情況下可以把成員變量修飾為static：當成員變量是類的所有對象共享的變量。

靜態的優先於非靜態的開辟內存
非靜態的成員變量是在創建對象是才開辟內存的，所有非靜態的只能使用對象來訪問
        

   ·靜態成員變量與非靜態成員變量對比：

   1.訪問方式   靜態成員變量既可以通過對象訪問，也可以通過類名直接訪問
      非靜態成員變量只能使用對象訪問
   2.存儲數據   靜態成員變量 存儲的是所屬類的所有對象共享的數據
      非靜態成員變量  存儲的是每個對象特有的數據
   3.存儲位置   靜態成員變量 隨着類的加載在方法區的靜態區開辟內存
      非靜態成員變量 創建對象時在堆中開辟內存
   4.生命周期（從在內存中出現到從內存中消失）
      靜態成員變量   隨着類的加載在方法區的靜態區開辟內存，程序退出時才釋放內存   
      非靜態成員變量   是創建對象時在堆中開辟內存，當所屬對象成為垃圾時等待垃圾回收線程回收

靜態的缺點：占用內存時間長

靜態的方法只能使用靜態的方法或變量
非靜態的方法什么都可以用

 

class Student 
{
    String name;  //實例變量
    static String country="CN"; //類變量

    public void show()  //實例方法:只能使用對象訪問
    {
       System.out.println(country+","+name);
    }

    public static void fun()//類方法 Student.fun()  
    {
       System.out.println(country);//無法從靜態上下文中引用非靜態 變量 name
    }
}
class Demo6 
{
    public static void main(String[] args) 
    {
        Student stu = new Student();
        stu.show();

        Student.fun();

        //System.out.println(Student.country);//隨着所屬類的加載在方法區的靜態區中開辟內存
        //System.out.println(Student.name);
        //System.out.println(stu.country);

        //stu.country="USA";
        //Student stu2 = new Student();
        //System.out.println(stu2.country);
        
    }
}

   ·解析main()函數

public:說明是公共的
static:說明是靜態的，隨着類的加載進入靜態區，可以直接通過類來調用
void:說明沒有返回值
String[] args:參數是字符串數組 

class Test
{
    public static void main(String[] args){
       String[] arr={"haha","hehe","xixi"};
       Demo7.main(arr);
    }
}
class Demo7 
{
    public  static void main(String[] args){ //java Demo7 hello hehe haha xixi   命令行參數
        System.out.println(args.length);
        //for(int i=0;i<args.length;i++)
            //System.out.println(args[i]);
        Demo7 d = new Demo7();
        d.main(77);
    }
    public void main(int a){ //非靜態方法，通過對象訪問
       System.out.println(a);
    }
}

什么情況下成員變量可以被static修飾：
 　　當成員變量的值被所屬類的所有對象共享時
什么情況下方法可以被static修飾：
 　　當該方法沒有用到所屬類中的非靜態成員

class Person{
    int age;
    Person(int age){
       this.age=age;
    }
    public static void isEqual(Person person){
         System.out.println(person.age);
    }
}
class Demo8 
{
    public static void main(String[] args) {
        Person ren = new Person(20);
        Person.isEqual(ren);
    }
}

靜態的應用：工具類（此代碼省略）

   ·靜態代碼塊：

static{...} 隨着類(字節碼)的加載而執行，只執行一次，優於main函數的執行
 把程序中初始化功能通常寫在靜態代碼塊中。

class Test
{
    static int num=10;
    static{
       System.out.println("C");
    }
    public static void show(){
        System.out.println(num);
    }
}
class Demo10 
{
    static{
       System.out.println("A");
    }

    public static void main(String[] args) {
        //Test t=new Test();
        //Test.show();//加載Test.class
        Test t=null;
    }
    static{
       System.out.println("B");
    }
}

   ·構造代碼塊：{...}

對象一創建就執行，優先於構造函數
 所有對象共性的功能可以寫在構造代碼塊中。

/*
構造代碼塊：對象一創建就執行，優先於構造函數執行

所有對象共性的功能可以寫在構造代碼塊中
*/
class Person
{
    String name;

    {                                    //構造代碼塊
       System.out.println("呵呵");
    }

    Person(String name)
    {
       this.name=name;
       System.out.println(name);
    }
}
class Demo11 
{
    public static void main(String[] args) {
        new Person("李四");

        new Person("張三");
    }
}

 day7

class Point
{
    private int x;
    private int y;
    Point(){}
    Point(int x,int y){
       this.x=x;
       this.y=y;
    }
    public void movePoint(int dx,int dy){
        x=dx;
        y=dy;
    }
    public void setX(int x){
       this.x=x;
    }
    public void setY(int y){
       this.y=y;
    }
    public int getX(){
       return x;
    }
    public int getY(){
       return y;
    }
}
class Test2 
{
    public static void main(String[] args) {
        /*
        定義一個點類Point,包含2個成員變量x,y,分別表示x和y坐標，創建兩個構造方法Point()和Point(int x,int y),
        創建一個方法movePoint(int dx,int dy)實現點的位置的移動，在main方法中創建兩個Point對象p1,p2，分別調用movePoint方法后，
        顯示p1和p2的坐標
        */
        Point p1=new Point(5,8);
        Point p2=new Point(6,10);
        p1.movePoint(6,9);
        p2.movePoint(8,8);
        System.out.println("p1的坐標:x="+p1.getX()+",y="+p1.getY());
        System.out.println("p2的坐標:x="+p2.getX()+",y="+p2.getY());
    }
}

class Test4 {
    public static void main(String[] args) {
        /*
          某個公司采用公用電話傳遞數據，數據是四位的整數，在傳遞過程中是加密的，加密規則如下：
          每位數字都加上5,然后用和除以10的余數代替該數字，再將第一位和第四位交換，第二位和第三位交換。
        */
        int num=6789,c;
        int[] arr=new int[4];
        int index=arr.length;
        while(num!=0){
            arr[--index]=num%10;
            num=num/10;
        }
        for(;index<arr.length;index++){
            arr[index]=(arr[index]+5)%10;
        }
        for(int i=0,j=arr.length-1;i<j;i++,j--){
             c=arr[i];
             arr[i]=arr[j];
             arr[j]=c;
        }
        for(int i=0;i<arr.length;i++)
            System.out.print(arr[i]+" ");
    }
}

   ·對象初始化的過程

//對象的初始化過程：
/*
1:因為對象的創建是使用字節碼，所以先加載字節碼到方法區
2：如果有靜態代碼塊執行靜態代碼塊
3：在堆中開辟內存
4：給屬性賦默認值
5：如果有初始值再賦初始值
6：執行構造代碼塊
7：執行構造函數
8：把對象在堆中的地址賦給在棧中的變量
*/
class Person{
    private String name="xiaohong";
    private int age=23;
    private static String country="CN";{
        System.out.println(name+"  "+age);
    }
    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }
    public void setName(String name){
       this.name = name;
    }
    public String getName(){
        return name;
    }
}
class  Demo1{
    public static void main(String[] args) {
        Person p = new Person("小白",20);
        //p.setName("小黑");
    }
}

 

 

    ·設計模式-單例模式

設計模式：解決某一類問題最有效的方式
單例設計模式：解決的是類在內存中只有一個對象的問題
 　　1.一個類不能有多個對象，那么構造方法不能被使用（構造方法私有化）
  　　　　private 類名(){}
 　　2.構造方法private之后，一個對象都不能創建了
   　　 私有的構造方法在本類中是可以使用的
   　　 在本類中創建一個對象
 　　3.為了防止外界隨意操作這個對象，修飾為private
 　　4.為了能讓外界得到這個唯一的對象,需要定義一個方法
           因為類不能創建對象，所以該方法必須是public static的， 由於方法是靜態的，所以創建對象也必須是static的，

   ·單例設計模式中的：懶漢式與餓漢式

//餓漢式
class QianFeng
{
   private static QianFeng qf=new QianFeng();
   private QianFeng(){}
   public static QianFeng getInstance(){
       return qf;
    }   
}
//懶漢式
class Single{
    private static Single single;//null
    private Single(){}
    public static Single getInstance(){
         if(single==null)
             single=new Single();
         
         return single;
    }
}

class Demo2 {
    public static void main(String[] args) {
        //QianFeng qianfeng = QianFeng.getInstance();
        //QianFeng qianfeng2 = QianFeng.getInstance();
        //System.out.println(qianfeng==qianfeng2);

        Single s1=Single.getInstance();
        Single s2=Single.getInstance();

        System.out.println(s1==s2);
    }
}

   ·繼承（extends）：

　　子類繼承父類的屬性和行為
       作用： 1.  實現了代碼的重復使用   2.使類和類之間產生了關系。

java中的繼承是單繼承的：
    單繼承：一個類可以繼承另外一個類
    多繼承：一個類可以繼承多個類
    java支持多層繼承。A extends B, B extends C。
為什么是單繼承的： 因為多繼承會出現調用的不確定性。

父類中定義的是子類共性的東西，子類除了具備父類的東西還可以定義自己特有的東西，所以子類比父類功能更多

class Demo6 {
    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}
class Person  //父類 是子類的共性的屬性和行為
{
    String name;
    int age;

    public void eat(){
       System.out.println("吃吃吃");
    }
}
class Student extends Person{
    public void study(){
       System.out.println("study");
    }
}

class Worker extends Person
{
    public void work(){
       System.out.println("工作");
    }

}

class A{
    public void laugh(){
       System.out.println("傻笑");
    }
}
class B extends A{
    public void eat(){
       System.out.println("吃飯");
    }
}
class C extends A{
}
class D extends B{
}

   ·繼承中成員變量的特點：

   當子父類中出現同名的屬性或方法時，使用super來區分，super表示訪問他的父類，super. 。
   父類中的屬性都定義成private的，子類繼承了但是無權使用，所以父類需要定義public的set和get方法，子類通過這些public方法來使用屬性

//繼承中成員變量的特點
// 當子父類中出現同名的屬性或方法時，使用super來區分
class Fu{
    private int num=6;
    public void setNum(int num){
       this.num=num;
    }
    public int getNum(){
       return num;
    }
}
class Zi extends Fu{
    public void show(){
       System.out.println(getNum());//繼承過來了，但無權使用,通過public的方法來使用屬性
    }
}
class Demo7 {
    public static void main(String[] args) {
        Zi z = new Zi();
        z.show();
    }
}

 

   ·重寫

繼承中成員方法的特點：
       子類和父類有相同的行為，但是行為的表現方式不同，java認為子類沒有必要單獨再定義一個方法，所以有了重寫，也叫覆蓋，
重寫(覆蓋)：子類中出現了和父類一樣的方法，當創建子類對象，調用這個方法時，執行的總是重寫之后的。

重寫的前提：存在繼承。

重寫注意事項：
   父類中private的方法不能被子類重寫
   子類在重寫時，方法權限要大於等於父類中方法的權限   public>=public
   父類中的方法是靜態的，子類在重寫時必須是靜態的。

class Fu{
    public void show(){
       System.out.println("show fu");
    }
    public static void ff(){
       System.out.println("static fu");
    }
}
class Zi extends Fu{
    public void show(){
       System.out.println("show fu");
    }
    public static void ff(){
       System.out.println("static zi");
    }
}
class Demo8 {
    public static void main(String[] args) {
         Zi z = new Zi();
         z.show();

        //ZhangXiaoSan xiaosan =new ZhangXiaoSan();
        //xiaosan.eat();
    }
}
class ZhangSan{
    public void eat(){
        System.out.println("細嚼慢咽的吃");
    }
}
class ZhangXiaoSan extends ZhangSan{
     //子類和父類有相同的行為，但是行為的表現方式不同
    //java認為子類沒有必要單獨再定義一個方法
    public void eat(){
       //super.eat();
       System.out.println("狼吞虎咽的吃");
    } 
}

   ·繼承中構造函數的特點：

在創建子類對象時，總是先執行父類的構造函數，再執行子類的構造方法。
 原因是系統自動在子類的構造方法的第一行加入了super();調用父類中無參的構造方法。

 構造方法不能被繼承。

為什么先執行父類的構造方法：因為子類繼承父類必然會繼承父類的屬性，先執行父類的構造方法可以利用父類構造方法中為屬性賦值的語句

注意：一個類都要寫空參的構造方法
系統默認有無參構造函數，如果自己寫了，系統默認的無參構造函數就沒了，自己可以再加一個無參構造函數。

class Fu{
    private int age;
    private String name;
    String address;
    int weight;

    Fu(){}

    Fu(int age,String name,String address,int weight){
      this.age=age;
      this.name=name;
      this.address=address;
      this.weight=weight;
    }
    public int getAge(){
      return age;
    }
    public String getName(){
       return name;
    }
}
//構造方法不能被繼承
class Zi extends Fu{
    Zi(){//super();}

    Zi(int age,String name,String address,int weight){
      super(age,name,address,weight);//自己寫了super語句，系統就不再加入super();
    }
}
class Demo9 {
    public static void main(String[] args) {
        Zi z = new Zi();
         //Zi z = new Zi(20,"李四","北京",200);
         //System.out.println(z.getAge()+","+z.getName());
    }
}

   ·繼承中this與構造函數

　　下列代碼第11行，由於this調用構造方法時，this（）必須在第一行，而super()是系統自帶的，所以super()加不進去，不會執行super()

class Fu{
    int age;
    
    Fu(int age){
      this.age=age;
    }
}

class Zi extends Fu{
    Zi(){
      this(20);//super(); 加不進來，因為第一行已經被占用
    }
    Zi(int age){
      super(age);
    }
}
class Demo10 {
    public static void main(String[] args){
        Zi z = new Zi();
        System.out.println(z.age);
    }
}

 day8

   ·final修飾符

1.final:是一個修飾符，可以修飾類，方法，成員變量，局部變量

final 修飾類：該類不能被繼承
final 修飾方法：該方法不能被子類重寫（覆蓋）
final 修飾成員變量，變量的值不能被修改
final 修飾局部變量，變量的值不能被修改

   ·單例和final

 引用類型被final修飾，意思是該引用不能指向其他對象

/*
class Test
{
   public final void show()
    {
       System.out.println("show");
    }
}
class B extends Test
{
    public  void show()
    {
       System.out.println("hello");
    }
}
*/
//計算圓形的面積
class Circle
{
    public static final double PI=3.1415;//值不能被修改，符號常量，程序中用到的固定的數據，用符號常量表示

    //public static final int PAY=1;
    //public static final int NOPAY=2;
    private double radius;

    Circle(){}

    Circle(double radius){
       this.radius=radius;
    }
    public double area(){
       return  PI*radius*radius;
    }
}
class Demo1{
     public static void main(String[] args) {
         final int a=6;
         //a=99;//無法為最終變量a分配值
         int num=add(5,5);
         System.out.println(num);
    }
    public static int add(final int a,final int b)//當希望接收到的值不能被修改時
{
        //a=66;
        //b=99;
        return a+b;
    }
}
//單例
class Single {
    private static final Single single=new Single();//引用類型被修飾為final，意思是該引用不能指向其它對象
    private Single(){}
    public static Single getInstance(){
        //single=new Single();
        return single;
    }
}

   ·abstract 抽象  

例：public abstract void 吼叫();    //沒有實現的方法----抽象方法

抽象方法不能被調用，因為該方法沒有實現
抽象類，是在對子類提取共性的過程中，出現了無法確定如何實現的行為，因為子類對該行為有各自的表現方式，
那么父類不確定該如何實現該方法，所以父類就不實現該方法，該方法就成了抽象方法，所以這個父類就是抽象類了。

abstract class 犬科動物{    
    int age;
    public void eat(){
      System.out.println("吃肉");
    }
    public abstract void 吼叫();// 沒有實現的方法----抽象方法
}
class 狼 extends 犬科動物{   
    public void 吼叫(){
        System.out.println("嗷嗷叫");
    }
}
class 狗 extends 犬科動物{
    public void 吼叫(){
        System.out.println("汪汪叫");
    }
    public static void main(String[] args){
       犬科動物 d=new 犬科動物();
       d.吼叫();//抽象方法不能被調用，因為該方法沒有實現
    }
}

   ·抽象類的特點：

   1.抽象類不能創建對象
   2.一個類繼承了抽象類，如果沒有重寫父類中的抽象方法，那么這個類也是抽象類
      （子類含有抽象方法，那么該子類也是抽象類）
抽象類一定是父類嗎    一定

抽象類和普通類的區別：
   共同點：都是類 能被繼承
   不同點：抽象類不能創建對象，普通類可以創建對象
 抽象類含有抽象方法，普通類不含有抽象方法

抽象類有構造函數嗎
   不能創建對象，但是有構造函數，構造函數是給子類使用的。

abstract不能喝哪些關鍵字同時使用：
   static：靜態方法可以通過類名調用，abstract修飾的方法不能被調用 ；（一起用會報錯非法的修飾組合：abstract和static）
   final:   final修飾的方法不能被重寫，abstract方法必須能被重寫。
   private:私有的方法不能被重寫，abstract方法必須能被重寫。

抽象類不一定含有抽象方法 （當希望一個類不能被創建對象時，這個類修飾為abstract，但是這個類中沒有抽象方法）
但是含有抽象方法的類一定是抽象類

 

abstract class Person{
  public void eat()
  {
  }
  public void sleep()
  {
  }
}
//計算圓形和長方形面積
abstract class Shape{
   public  abstract double area();//非法的修飾符組合: abstract和static  Shape.area()  非法的修飾符組合: abstract和private
}

abstract class Circle extends Shape{
    public static final double PI=3.1415;
    private double radius;

    Circle(){}
    Circle(double radius){
      this.radius=radius;
    }

    //該子類含有抽象方法，那么該子類也是抽象類

    /*
    public double area()//需要重寫父類中的抽象方法，否則該子類也是抽象類
    {
       return PI*radius*radius;
    }
    */
}

 class Rectangle extends Shape{
    private double length;
    private double width;

    Rectangle(){}
    Rectangle(double length,double width){
       this.length=length;
       this.width=width;
    }
    public double area(){
        return length*width;
    }
}
class Demo3 {
    public static void main(String[] args) {
        //Shape shape=new Shape();//Shape是抽象的; 無法實例化
        Rectangle rectangle=new Rectangle(8,5);
        double mianji = rectangle.area();
        System.out.println(mianji);
        Person ren = new Person();
    }
}

/*
需求：公司中程序員有姓名，工號，薪水，工作內容。
項目經理除了有姓名，工號，薪水，還有獎金，工作內容。
對給出需求進行數據建模。
*/
abstract class Employee{
    private String name;
    private int number;
    private double salary;
    Employee(){}
    Employee(String name,int number,double salary){
       this.name=name;
       this.number=number;
       this.salary=salary;
    }
   public abstract void work();
}
class Programmer extends Employee{
    Programmer(){}
    Programmer(String name,int number,double salary){
        super(name,number,salary);
    }
    public  void work(){
       System.out.println("敲代碼");
    }
}
class Manager extends Employee{
    private double bonus;
    Manager(){}
    Manager(String name,int number,double salary,double bonus){
        super(name,number,salary);
        this.bonus=bonus;
    }
    public void work(){
       System.out.println("管理程序員");
    }
}
class Demo4 {
    public static void main(String[] args) {
    Programmer yuan=new Programmer("猿","007",20000);
    yuan.work();
    Manager manager=new Manager("老猿","009",50000,10000);
    manager.work();
        System.out.println("Hello World!");
    }
}

   ·接口：interface 

interface 接口名
{      
     public static final 成員變量                 //注意：這里不寫public static final，屬性也是這種
     public abstract 成員方法                   
 }
接口是用來實現的，用implements ，
接口解決java單繼承的問題，接口是可以多實現的：因為接口中的方法都是抽象的，當創建子類對象調用這個方法時，
   很明確是在調用重寫之后的方法，不會出現調用不確定的情況。

interface inter{
     public static final int NUM=66;
     public abstract void show();
     //jdk1.8開始，可以定義實現了的方法
     public default void fun(){
        System.out.println("ok");
     }
}
interface inter2{
     public abstract void show();
     /*
     public default void fun()
     {
        System.out.println("kk");
     }*/
}
class Test implements inter,inter2 //類就繼承了接口中的成員
{
     public  void show(){
         System.out.println("Hello");
     }
}
class Demo5 {
    public static void main(String[] args) {
         Test t = new Test();
         System.out.println(inter.NUM);
         System.out.println(Test.NUM);
         System.out.println(t.NUM);
         t.fun();
    }
}

   ·Lambda表達式

lambda表達式jdk1.8之后推出的新特性。本質上來說，lambda表達式就是一個匿名函數。可以使用lambda表達式簡潔的實現接口中的方法。

interface Calculate {
    int calculate(int a, int b);
}
class Addition implements Calculate {
    @Override
    public int calculate(int a, int b) {
        return a + b;
    }
}

class Program {
    public static void main(String[] args) {
        // 給接口類型的引用進行賦值，右側需要是這個接口的實現類類型對象。
        Calculate calculate = new Addition();
        int result = calculate.calculate(10, 20);
        
        // 如果使用lambda表達式來完成同樣的操作
        Calculate calculate2 = (a, b) -> a + b;
        int result2 = calculate2.calculate(10, 20);
    }
}

lambda表達式對接口的要求

並不是所有的接口都可以使用lambda表達式來實線。lambda表達式畢竟只是一個匿名方法，如果接口中只有一個方法必須要實現，則可以使用lambda表達式；但是如果接口中必須要實現的方法比較多。

lambda表達式只能對 函數式接口 進行簡潔的實現。

   ·lambda表達式的基礎語法

lambda表達式，從本質來講，就是一個匿名方法。一個方法的組成，有 返回值、方法名、參數、方法體 部分。

而lambda表達式是匿名方法，所以，方法名可以忽略。另外，在lambda表達式中，返回值類型也可以忽略。

因此，對於lambda表達式只需要關注兩點即可：

• 參數 ： 以（）括起來，將參數寫入到（）中。

• 方法體 ： 以 {} 括起來，將方法體寫入到 {} 中。

對於lambda表達式，還需要記住一個新的語法： ->

• lambda運算符 -> : 可以分隔參數和方法體。

// 說明需要實現一個無參、無返回值的方法
() -> { System.out.println("hello world"); }
// 說明需要實現一個 (int, int) 參數的、int返回值的方法
(int a, int b) -> { return a + b; }

// 無參無返回
NoneParameterNoneReturn lambda1 = () -> {
    System.out.println("hello world");
};
lambda1.test();            // 最終的實現，是lambda表達式中的實現


// 多個參數、有返回
MutipleParameterSingleReturn lambda2 = (int x, int y) -> {
    return x + y;
};
int ret2 = lambda2.test(10, 20);
System.out.println(ret2);

   ·lambda表達式的語法進階

lambda表達式是為了簡潔的實現接口的，所以某些部分是可以省略的。

1、參數的類型，已經在接口的方法中有明確規定了，因此在lambda表達式中，可以省略參數的類型。

   注意：如果要省略形參的類型，則每一個形參都必須省略。不能出現有的形參帶類型，有的沒有。

MutipleParameterNoneReturn lambda1 = (a, b) -> {
    System.out.println("a = " + a + ", b = " + b);
};
lambda1.test(10, 20);

2、如果參數列表中，形參的數量只有一個，此時可以省略小括號。

SingleParameterNoneReturn lambda2 = a -> {
    System.out.println("a = " + a);
};
lambda2.test(10);

lambda表達式的函數引用

---

推理：

lambda表達式可以簡潔的實現一個接口，但是，一般情況下，在lambda表達式中的都是簡單的邏輯。如果需要處理的邏輯比較復雜，不推薦將復雜的邏輯直接的寫到lambda表達式中。

 

如果需要在lambda表達式中進行的復雜的邏輯處理，已經在其他的方法中實現過了，可以直接調用這個方法即可。或者可以使用函數引用，將引用的函數，實現接口中的方法。

public class CSyntax {
 public static void main(String[] args) {
  // 需求: 
  // 計算a和b的最大公約數
  
  // 這是個函數引用，使用calculate方法實現接口中的方法
  MutipleParameterSingleReturn lambda = CSyntax::calculate;
  
  int result = lambda.test(12, 8);
  System.out.println(result);
 }
 
 public static int calculate(int a, int b) {
  // 1、找出最小值
  int min = a > b ? b : a;
  // 2、從最小值開始，向下遞減直到1，找到一個能夠同時整除a和b的數字
  for (int i = min; i >= 1; i--) {
   if (a % i == 0 && b % i == 0) {
    return i;
   }
  }
​
  return -1;
 }
}

 

構造方法的引用

如果接口中的方法，需要返回一個對象，則此時，可以引用構造方法。

public class DSyntax {
 public static void main(String[] args) {
  /*
  GetPerson lambda = () -> new Person();
  Person xiaoming = lambda.get();
  System.out.println(xiaoming);
  */
  // 引用的構造方法
  GetPerson lambda2 = Person::new;
  System.out.println(lambda2.get("xiaoming", 10));
 }
}
​
interface GetPerson {
 Person get(String name, int age);
}
​
​
class Person {
 String name;
 int age;
 
 public Person() {
  super();
  System.out.println("Person的無參構造方法執行了");
 }
 public Person(String name, int age) {
  super();
  this.name = name;
  this.age = age;
  System.out.println("Person的有參構造方法執行了");
 }
 
 @Override
 public String toString() {
  return "Person [name=" + name + ", age=" + age + "]";
 }
}

   ·繼承和實現結合：

 類和類之間是繼承關系，類和接口之間是實現的關系，接口和接口之間是繼承的關系
 通過繼承可以得到體系中的基本的功能和屬性
 通過實現可以得到體系以外的功能和屬性

interface inter{
    public abstract void show();
}
class Person{
    int age;
    String name;
    public void eat()
    {}
}
class Student extends Person implements inter{
    public  void show()
    {
    }
}
interface a{
}
interface b {
}
interface c extends a,b{
}

 

/*
狗生活在陸地上（是一種陸生動物），既是哺乳類的也是肉食性的。
狗通常的時候和人打招呼會通過“搖搖尾巴”，在被撫摸情緒很好的時候，
會“旺旺叫”，而在受到驚嚇情緒煩躁時，會發出“嗚嗚”聲；

貓也生活在陸地上（是一種陸生動物），既是哺乳類的也是肉食性的。
貓通常的時候和人打招呼會發出“喵～”的聲音，在被撫摸情緒很好時，
會發出“咕嚕咕嚕”聲，而在受到驚嚇時，會發出“嘶嘶”聲；

青蛙是一種兩棲動物（既是水生動物也是陸生動物），既不是哺乳類的也不是肉食性的，
屬於卵生。青蛙通常的時候和人打招呼會通過“呱呱叫”，當青蛙情緒好的時候，
會在岸邊“呱呱呱”的唱歌，而在受到驚嚇時，會“撲通一聲跳入水中”
*/
abstract class Animal
{
    public static final int HAPPY=1; // 1表示情緒好
    public static final int UNHAPPY=2;//2表示情緒不好
    protected boolean mammal;//哺乳
    protected boolean carnivorous;//肉食
    private int mood;

    public boolean isMammal(){
        return mammal;
    }
    public boolean isCarnivorous(){
        return carnivorous;
    }
    public void setMood(int mood){
        this.mood=mood;
    }
    public int getMood(){
       return mood;
    }
    public abstract String sayHello();
    public abstract String sayHello(int mood);
}
interface Land{
    public abstract int getNumberOfLegs();
}
interface Warter{
    public abstract boolean getGillFlags();
    public abstract boolean getLayEggsFlags();
}
class Dog extends Animal implements Land{
    private int numberOfLegs=4;//幾條腿
    Dog(){
       this.mammal=true;
       this.carnivorous=true;
    }
    public  String sayHello(){
       return "搖搖尾巴";
    }
    public  String sayHello(int mood){
         setMood(mood);
         switch(getMood()){
           case HAPPY:
                 return "旺旺叫";//break;
           case UNHAPPY:
                 return "嗚嗚";

           default:
                 return "搖搖尾巴";
         }
    }
    public  int getNumberOfLegs(){
        return numberOfLegs;
    }
}
class Demo7 {
    public static void main(String[] args){
        Dog gou = new Dog();
        if(gou.isMammal())
            System.out.println("狗是哺乳動物");
        else
            System.out.println("狗不是哺乳動物");

        if(gou.isCarnivorous())
            System.out.println("狗是肉食動物");
        else
            System.out.println("狗不是肉食動物");

        System.out.println("狗通常情況下打招呼的方式是:"+gou.sayHello());

        System.out.println("狗情緒好時打招呼的方式是:"+gou.sayHello(Animal.HAPPY));

        System.out.println("狗受到驚嚇時打招呼的方式是:"+gou.sayHello(Animal.UNHAPPY));

        System.out.println("狗是陸生動物，狗有"+gou.getNumberOfLegs()+"條腿");

    }
}

   ·多態

　　父類類型的引用指向子類對象，即把子類對象看成父類類型 ，
多態的弊端：在多態中只能使用父類中定義的行為，父類中未定義的不能使用
多態的前提：存在繼承或實現
多態的優點：通常都是方法的參數使用多態，這樣可以接收所有父類的子類類型的對象，節省了很多函數的定義

abstract class Animal{
    public abstract void eat();
}
class Cat extends Animal{
    public  void eat(){
       System.out.println("貓吃魚");
    }
    public void catchMouse(){
       System.out.println("貓抓耗子");
    }
}
class Demo9 {
    public static void main(String[] args) {
        //Cat mao = new Cat();
        //mao.eat();
        //mao.catchMouse();

        Animal mao = new Cat();
        mao.eat();
        //mao.catchMouse();//錯誤: 找不到符號 mao.catchMouse();
    }
}

   ·多態中如何使用子類特有的功能 ---轉型

向上轉型

• 由子類類型轉型為父類類型。

• 向上轉型一定會成功，不需要任何額外的操作，是一個隱式轉換。

• 向上轉型后的對象，將只能夠訪問父類中存在的成員，子類特有的成員將無法訪問。

向下轉型

• 由父類類型轉型為子類類型。

• 向下轉型存在失敗的可能性，需要額外進行強制操作，是一個顯式轉換。

• 向下轉型后的對象，將可以訪問子類中特有的成員。

 由於多態中，父類引用指向子類對象，只能使用父類中定義的行為；
 方法如：Animal mao=new Animal(); //向上轉型
       Cat m=(Cat)mao; //向下轉型   強轉
                      instanceof(實例)用於判斷對象具體是什么類型的

abstract class Animal{
    public abstract void eat();
}
class Cat extends Animal{
    public  void eat(){
       System.out.println("貓吃魚");
    }
    public void catchMouse(){
       System.out.println("貓抓耗子");
    }
}
class Dog extends Animal{
    public  void eat(){
       System.out.println("狗吃肉");
    }
    public void kanJia(){
        System.out.println("狗看家");
    }
}
class Demo11 {
    public static void main(String[] args) {
        //在多態中使用子類特有的功能
        Animal  mao = new Cat();//向上轉型
        //使用子類特有的功能
        Cat m=(Cat)mao;//向下轉型
        //m.eat();
        //m.catchMouse();

        Cat cat = new Cat();
        chi(cat);

        Dog gou = new Dog();
        chi(gou);
    }

     //使用子類特有的功能
    public static void chi(Animal dongwu)//Animal dongwu=new Dog();
    {
        dongwu.eat();

        if(dongwu instanceof Cat)//使用instanceof判斷對象具體是什么類型的
        {
            Cat mao = (Cat)dongwu;
            mao.catchMouse();
        }
        if(dongwu instanceof Dog){
           Dog gou = (Dog)dongwu;
           gou.kanJia();
        }
    }
}

day9

   ·重寫的特殊情況

重寫總結：
 public father run(){}
 public son run(){}  //是重寫

 

 protect a run(){}
 public a run(){}  //是重寫
 

 私有的private修飾的方法不能被重寫
 

    子類在重寫父類中的方法時，如果父類中的方法返回值是本身，本身當引用數據類型，那么子類在重寫時，可以和父類方法的返回值一致，也可以是父類方法返回值類型的子類類型

class Test{
       public Fu show(){
           return new Z1();
       }
}
class Tests extends Test{
     public Z2 show() //子類在重寫時返回值類型可以和父類方法一致，也可以是父類方法返回值的子類類型
     {
         return new Z2();
     }
}
class Fu{
    public void fun(){
        System.out.println("fun");
    }
}
class Z1 extends Fu{    
}
class Z2 extends Fu{
}
class Demo2 {
    public static void main(String[] args) {
        Tests t = new Tests();
        Z2 z = t.show();
        z.fun();
    }
    public static Fu ff(){
       return new Z2();
    }
}

 

   ·接口和多態

多態同樣適用於接口
 一個方法的參數類型可以是接口類型
 一個方法的返回值類型可以是接口類型

interface inter //接口是引用數據類型 inter.class{
    public abstract void show();
}
class Test1 implements inter{
    public  void show(){
       System.out.println("show1");
    }
}
class Test2 implements inter{
    public  void show(){
       System.out.println("show2");
    }
}
class Demo3 {
    public static void main(String[] args) {
        Test1 t1 = new Test1();
        ff(t1);

        Test2 t2 = new Test2();
        ff(t2);

        inter t=fun(); //inter t=new Test1()　　 注釋的此行就是接口可用於多態的核心
        t.show();
    }
    public static inter fun()//返回值類型是接口類型
    {
       return new Test1();
    }
    public static void ff(inter in)//inter in=new Test2();父接口類型的引用指向了子類對象
    {
        in.show();
    }
}

   ·多態中成員的特點

/*
多態中成員的特點：

成員變量的特點：編譯時期看父類，運行結果看父類
非靜態成員方法的特點: 編譯時期看父類, 運行結果看子類
靜態成員方法的特點：編譯時期看父類，運行結果看父類

非靜態成員方法看子類，其它的都看父類
*/
class Fu{
    int num=5;
    
    public void show(){
       System.out.println("show fu");
    }
    public static void ff(){
        System.out.println("fu static");
    }
}
class Zi extends Fu{
    int age=6;

    public void show(){
       System.out.println("show zi");
    }
    public void fun(){
       System.out.println("fun");
    }
    public static void ff(){
        System.out.println("zi static");
    }
}
class Demo4 {
    public static void main(String[] args) {
        Fu zi=new Zi();
        //System.out.println(zi.num);
        //System.out.println(zi.age);
        //zi.show();
        //zi.fun();
        zi.ff();
    }
}

   ·object

是任何一個類的直接或間接父類，超類，最大的那個類，Object沒有父類
 Object提取的是所有對象的共性：Object中定義的屬性和行為是任何一個對象都具備的
 構造方法Object(){}

object中的方法：equals()方法，
 toString()方法，返回的是對象的字符串表示形式，由類名加哈希值(16進制)組成。
 如果直接輸出對象，默認調用了對象的toString的方法
 hashCode()方法，返回對象的哈希值(10進制)

   ·模板設計模式

模板設計模式：實現一個功能，功能的一部分是能確定，一部分是不能確定的，確定的那部分會用到不確定的部分，
                把不確定的部分暴露出去，讓子類去實現

/*
模板設計模式：實現一個功能時，功能的一部分是能確定如何實現的，一部分不能確定如何實現，確定的那部分會用到不確定的部分
              把不確定的部分暴露出去，讓子類去實現

 計算程序的運行時間

*/
abstract class Test{
    public final void runTime(){
        //記錄開始時間
        long start = System.currentTimeMillis();
        //程序代碼
        fun();
        //記錄結束時間
        long end = System.currentTimeMillis();
        System.out.println("程序運行時間:"+(end-start));
    }
    public abstract void fun();
}
class Demo extends Test{
    public  void fun(){
        for(int i=1;i<=3000;i++){
            System.out.println(i);
        }
    }
}
class Demo6 {
    public static void main(String[] args) {
        Demo d = new Demo();
        d.runTime();
    }
}

   ·內部類

在一個類內部定義的類，屬於外部了的成員，成員內部類，成員之間可以相互使用

外部類Outer，內部類Inner，使用的時候，為Outer.Inner
非靜態內部類對象的創建：由於內部類是非靜態的，需要外部類對象調用，所以使用外部類對象創建內部類對象
 Outer.Inner inner=new Outer().new Inner();

      內部類看成外部類的成員
      內部類既然是成員，所以可以被修飾為static的
      內部類中含有靜態成員，那么內部類必須是靜態的
      內部類得到外部類對象 : 外部類名.this

//內部類：在一個類內部定義的類,屬於外部類的成員，成員內部類，成員之間可以相互使用
//static可以修飾成員
class Outer{
    private int num=66; //成員變量
    class Inner //成員內部類
    {
        public void show(){
           System.out.println(num);
           fun();
        }
    }
    public  void  fun()//成員方法
    {
       Inner in = new Inner();
       in.show();
    }
}

class Person{
   class Heart{
    }
}

class Demo7 {
    public static void main(String[] args) {
        //Outer out = new Outer();
        //out.fun();
        //創建內部類對象，因為內部類是非靜態的，所以需要創建Outer的對象
        Outer.Inner inner=new Outer().new Inner();
        inner.show();
    }
}

class Outer{
    private static int num=6;
    static class Inner  //內部類中的成員是靜態的，那么內部類必須是靜態的
    {
        public static void show() // new Outer().new Inner().show()   new Outer.Inner() Outer.Inner.show()
        {
           System.out.println(num);
        }
    }

}

class Demo8 {
    public static void main(String[] args) {
        //因為show方法不是靜態的，所以必須通過Inner的對象來調用
        //訪問靜態內部類中的非靜態方法
        Outer.Inner in = new Outer.Inner();
        in.show();

        //訪問靜態內部類中的靜態方法
        Outer.Inner.show();
    }
}

//內部類得到外部類對象:  外部類名.this
class Outer{
    private int num=6;
    class Inner{
        int num=8;
        public void show(){
           int num=7;
           System.out.println(Outer.this.num);
        }
    }
    
    public void fun(){
       Inner in = new Inner();
       in.show();
    }
}
class Demo9{
    public static void main(String[] args) {
        Outer out = new Outer();
        out.fun();
    }
}

   ·局部內部類

在一個類的函數里的類

//局部內部類
class Outer{
    public void fun(){
       class Inner{
           public void show(){
              System.out.println("Hello");
           }
       }
       new Inner().show();
    }
}
class Demo10 
{
    public static void main(String[] args) 
    {
        Outer out = new Outer();
        out.fun();
    }

 

   ·匿名內部類

在類的方法里，   new  類 (){};

/*
匿名內部類：作用是為了簡化書寫
*/
abstract class Test{
    public abstract void show();
}
class Outer{
    /*
   class Inner extends Test{
       public  void show(){
          System.out.println("show");
       }
       public void fun(){
           System.out.println("fun");
       }
   }
   */
   public void ff(){
        //Inner in = new Inner();
        //in.show();
        //in.fun();
        //創建的是Test的子類對象
        new Test(){
            public  void show(){
              System.out.println("show");
            }
            public void fun(){
               System.out.println("fun");
            }
        }.show();

        //父類類型的引用指向了子類對象
        Test t = new Test(){
            public  void show(){
              System.out.println("show");
            }
            public void fun(){
               System.out.println("fun");
            }
        };
        t.show();//只能調用show方法

        System.out.println(new Object(){
            String name="李四";
            int age=20;
             
            public String toString(){
               return name+","+age;
            }
        });
    }
}
class Demo11 {
    public static void main(String[] args) {
        Outer out = new Outer();
        out.ff();
    }
}

 

   ·private

子類繼承父類，子類擁有了父類的所有屬性和方法。（private 自己的，私有的）
　　私有屬性不能直接得到，私有屬性可以通過public修飾的getter和setter方法訪問到，但是私有方法不行。

       私有方法不能被重寫可以被重載，私有方法可通過public方法得到。

day10

   ·接口(interface)與匿名內部類

注意
 a.run().start(); //因為.start()需要對象調用，所以run()的返回值是一個對象

 

interface T{
    abstract void start();
}
class A{
    public static void main(String args[]){
        A a=new A();
        a.run().start();
    }
    public static T run(){
        return new Test();
    }
}
class Test implements T{
    public void start(){
        System.out.println("start方法被調用了");
    }
}

 

   ·String : 字符串類

   java把字符串面向對象，定義了一個描述字符串的類 String
   特點：字符串是不能改變的，它們的值在創建后不能更改
            字符串是存儲在方法區中的常量池中 (如果常量池中已經存在一個字符串那么直接使用已有的字符串)
   常量：不能被修改的量，由於字符串存儲在方法區的常量池中，所以雙引號里的內容不能被修改

 

String類重寫了Object中的boolean equals(Object obj)方法和toString方法
equal：比較雙引號中的內容(字符串中的內容是否一樣)
   String str1=new String("1000"); //有兩個對象，一個是new的對象，一個是字符串對象
   String str2="1000";
   String str3="1000";2
   str1.equals(str2); 
//返回值是false，由於str1指向的是new String 在堆中的地址
   str2.equals(str3); //返回值是true，由於兩個都直接取了"1000"的值

總之：equals比較“”里面的，（老師說的）

 

數組中的length是屬性

獲取字符串的長度 int length()；
String中的length() 如"1000".length(), 是方法

 

//判斷用戶名和密碼是否正確
     //參數：用戶名和密碼 admin,admin
     //返回值：boolean

     public static boolean check(String username,String password){
        if(username!=null && password!=null){
             if(username.equals("admin") && password.equals("admin"))
                 return true;
             else
                 return false;
         }
         else
             return false;
     }

   ·String類中的各種方法

length(), char charAt(int index),int indexOf(char ch),int indexOf(String ch,int start), int lastIndexOf(char ch)

/*
  獲取：
     獲取字符串的長度
        int length()
     獲取某一個位置上的字符
        char charAt(int index)
     獲取字符在字符串中的位置
     如果要找的字符或者字符串不存在，返回值為-1
        int indexOf(char ch)//返回字符在字符串中第一次出現的位置
        int indexOf(int ch, int fromIndex)//第二個參數用於指定開始找的位置

        int indexOf(String str) //獲取一個字符串在字符串中出現的位置
        int indexOf(String str, int fromIndex)//第二個參數用於指定開始找的位置

        int lastIndexOf(char ch)//最后一次出現的位置
*/

class Demo4 {
    public static void main(String[] args) {   
        int num = "oiwueroieuro".length();
        sop(num);//數組的length,是屬性

        char ch="hello".charAt(1);
        sop(ch);

        int index = "hello wo ".indexOf('o');//返回第一次出現的下標
        sop(index);//4

        index = "hello wo hoo".indexOf('o',6);// 指定開始查找的位置
        sop(index);//7

        index="hello world".indexOf("llo");
        sop(index);//2

        index="hello world llo".indexOf("llo",5);
        sop(index);//12

        index="hello world llo".lastIndexOf("llo");//最后一次出現的下標
        sop(index);//12

        index="haha".indexOf('w');
        sop(index);//-1
    }
    public static void sop(Object obj){
       System.out.println(obj);
    }
}

   ·String類中的其它方法

 length(), char charAt(int index),int indexOf(char ch),int indexOf(String ch,int start), int lastIndexOf(char ch)

     contains()  equals() startsWith() endsWith() equalsIgnoreCase()

     new String(char[] ch)  "lsjdkl".toCharArray()    new String(byte[] arr)  "oiwueori".getBytes()

     "   oiwueroe   ieri    ".trim()  toUpperCase()  toLowerCase()   replace(old,new)

/*
   判斷：
        判斷是否包含一個字符串
          boolean contains(CharSequence s) 
        判斷兩個字符串的內容是否相同
          boolean equals(Object anObject) 
        忽略大小寫判斷兩個字符串的內容是否相同
          boolean equalsIgnoreCase(String anotherString) 
         判斷是否以某字符串開頭
           boolean startsWith(String prefix)
         判斷是否以某字符串結尾
           boolean endsWith(String suffix) 
    轉換：將字符數組轉換成字符串
              1:使用構造方法
                 String(char[] value) 
                 String(char[] value, int offset, int count) 
              2:使用靜態方法
                 static String copyValueOf(char[] data) 
                 static String copyValueOf(char[] data, int offset, int count) 
          將字符串轉成字符數組
              char[] toCharArray() 
 
          將字節數組轉成字符串
              String(byte[] bytes) 
              String(byte[] bytes, int offset, int length)
              String(byte[] bytes, String charsetName)//使用指定的編碼將字節數組轉換成字符成
          將字符串轉成字節數組
              byte[] getBytes() 
 

          將基本數據類型轉換成字符串
              String.valueOf()
    替換：
         String replace(char oldChar, char newChar) 
 
    子串:
         String substring(int beginIndex)  
         String substring(int beginIndex, int endIndex) //包含起始位置，不包含結束位置，到結束位置的前一位
 
    轉換，去除空格，比較:
         大小寫轉換
             String toLowerCase() 
             String toUpperCase()
         將字符串兩端的空格去掉
             String trim() 
         按字典順序比較兩個字符串
             int compareTo(String anotherString)
    切割: String[] split(String)

*/
class Demo5 {
    public static void main(String[] args) {
        //panDuan();
        //zhuanHuan();
        //qiTa();
        lasts();
    }

    public static void lasts(){
        //按字典順序比較兩個字符串  int compareTo(String anotherString)
        int num = "a".compareTo("c");//前邊的小於后邊的返回負數，前邊大於后邊，返回一個正數，前邊等於后邊返回0
        sop(num);//0

        //切割: String[] split(String str)
        String str="zhangsan,lisi,wangwu,zhaoliu";
      
        String[] arr=str.split(",");  
        sop(arr.length);
        for(int i=0;i<arr.length;i++){
          sop(arr[i]);
        }
    }

    public static void qiTa(){
        // String replace(char oldChar, char newChar)
        String  ss="hello".replace('e','w');  //"hello"沒有被改變，是根據hello得到了一個新的字符串
        sop(ss);

        String s1="hello world".substring(6);
        sop(s1);

        s1="hello world".substring(6,9);//包含起始位置，不包含結束位置，到結束位置的前一位
        sop(s1);

        s1="hello world".substring(6,7);//StringIndexOutOfBoundsException 第二個值不要小於第一個值
        sop(s1);

        sop("hello".toUpperCase());
        sop("HELLO".toLowerCase());

        sop("   hehe     ".trim());
    }

    public static void zhuanHuan()
    {
        //將字符數組轉換成字符串
        char[] arr={'a','b','c','d'};  //"abcd"

        //使用構造方法 String(char[] value) 
        String str = new String(arr);
        sop(str);//abcd
        
        //static String copyValueOf(char[] data)
        String ss = String.copyValueOf(arr,1,3);
        sop(ss);//bcd

        //將字符串轉成字符數組   char[] toCharArray() 
        char[] b = "hello".toCharArray();
        for(int i=0;i<b.length;i++){
          sop(b[i]+"  ");
        }

        //將字節數組轉成字符串
        byte[] c={65,66,67,68};
        String ss2=new String(c);
        sop(ss2);

         //將字符串轉成字節數組
        byte[] d = ss2.getBytes();
        for(int i=0;i<d.length;i++){
          sop(d[i]+"  ");
        }

        //將基本數據類型轉換成字符串 String.valueOf()
        String ss3=String.valueOf(new Demo5());
        sop(ss3);
    }

    public static void panDuan(){
        boolean b = "hello world".contains("wo");
        sop(b);

        b = "hello".equals("hello");
        sop(b);

        b="hello".equalsIgnoreCase("HELLO");//忽略大小寫
        sop(b);//true

        b="my.java".endsWith(".java");
        sop(b);

        b="my.java".startsWith("my");
        sop(b);
    }

    public static void sop(Object obj){
       System.out.println(obj);
    }
}

   ·StringBuffer

　　字符串緩沖區
　　可以被改變的字符串序列（與String類的區別）
append();往字符串中添加， 里面可以是任意類型的

Object中的toString()輸出的是類名+哈希值
StringBuffer中的toString()重寫了Object中的toString()，輸出的是字符串

StringBuffer:jdk1.0，線程安全的，可以安全地被多個線程使用 （適合多線程）
StringBuilder：多線程不安全的，提高代碼執行效率

//StringBuffer:可變的字符序列
/*
存儲：
    StringBuffer append(boolean b) 
    StringBuffer insert(int offset, boolean b) 
刪除：
     StringBuffer delete(int start, int end) 
     StringBuffer deleteCharAt(int index)
修改：
     StringBuffer replace(int start, int end, String str) 
     void setCharAt(int index, char ch) 
獲取：
     char charAt(int index) 
     int indexOf(String str)
     int indexOf(String str, int fromIndex)
     int lastIndexOf(String str) 
          返回最右邊出現的指定子字符串在此字符串中的索引。 
     int lastIndexOf(String str, int fromIndex) 
          返回最后一次出現的指定子字符串在此字符串中的索引。 
     int length() 
          返回長度（字符數）。 
反轉：
     StringBuffer reverse() 


StringBuffer:JDK1.0,線程安全的，可以安全地被多個線程使用

StringBuilder:可變的字符序列,jdk1.5,多線程不安全的，提高代碼執行效率

*/
class Demo6 {
    public static void main(String[] args) {
        //String str= new String("hello");

        StringBuffer sb = new StringBuffer("hello"); //添加，修改，刪除

       // StringBuffer sb1=sb.append(false);//添加完之后返回的還是原來的StringBuffer對象
        //sop(sb==sb1);

         //加入對象時加入的是對象的字符串表示：類名+哈希值
        sb.append(66).append(true).append(new Object());//加入到StringBuffer的都被轉成字符串


        //得到StringBuffer中的字符串
        //sop(sb.toString());//StringBuffer重寫了Object中的toString方法,返回的是存儲的字符串
        

        sb.insert(5,"world");
        sop(sb);

       //刪除
       sb.delete(5,10);//不包括結束位置
       sop(sb);

       sb.deleteCharAt(5);
       sop(sb);

       //修改
       sb.replace(6,10,"false");
       sop(sb);

       sb.setCharAt(5,'8');
       sop(sb);

      //反轉
      sb.reverse();
      sop(sb);        
    }
    public static void sop(Object obj){
       System.out.println(obj);
    }
}

   ·StringBuilder

StringBuffer:jdk1.0，線程安全的，可以安全地被多個線程使用 （適合多線程）
StringBuilder：多線程不安全的，提高代碼執行效率（適合單線程）

class Demo7 {
    public static void main(String[] args) {
        boolean b =checkEmail("zhangsan163.com");
        //System.out.println(b);
        juXing(5,10);
    }
    //顯示一個矩形，用StringBuilder存儲一個矩形，並打印
     //參數：行，列
     //返回值:無
     public static void juXing(int row,int col){
         StringBuilder sb = new StringBuilder();
         for(int i=1;i<=row;i++){
            for(int j=1;j<=col;j++){
                sb.append("*");
             }
             sb.append("\r\n");
         }
        System.out.print(sb.toString());
     }

    //驗證郵箱格式是否正確  [e-mail]
    //參數：字符串類型的郵箱
    //返回值：boolean

    public static boolean checkEmail(String email) {
        if(email!=null){
            if(email.indexOf("@")==-1)
                return false;
            else if(email.indexOf(".")==-1)
                return false;
            else if(email.indexOf("@")>email.indexOf("."))
                return false;
            else
                return true;
        }else
            return false;
    }
}

   ·包裝類 及 String的相關轉換

把基本類型變為引用類型，即java的面向對象的思想，由類來調用方法，提高程序的編寫。

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

/*
包裝類：
  基本類型轉字符串類型三種方式
　　　String new String(int a);　//String new String (int[] arr)   數組轉字符串
　　
　　　String String.valueOf(double d)
  String Double.toString(double d)

　　　String String.valueOf(int a);
  String Integer.toString(int a)

  字符串類型轉基本類型兩種方式
  int    Integer.parseInt("66")
  Integer i=Integer.valueOf("66"); int i2=i;

 十進制轉其他進制
        String s1=Integer.toHexString(60);
        String s2=Integer.toOctalString(60);
        String s3=Integer.toBinaryString(60);

其他進制轉十進制
       Integer.parseInt("3c",16)
       Integer.parseInt("74",8)
       Integer.parseInt("110",2)
*/
class Demo8 {
    public static void main(String[] args) {
        char ch='我';
        int max=Integer.MAX_VALUE;
        sop(max);

        String str = Integer.toString(66);//String.valueOf()
        sop(str);
        sop(""+66);

        int age = Integer.parseInt("66");
        sop(age);
        double weight=Double.parseDouble("88.88");
        sop(weight);

        //十進制轉其他進制

        String s1=Integer.toHexString(60);
        sop(s1);
        String s2=Integer.toOctalString(60);
        sop(s2);
        String s3=Integer.toBinaryString(60);
        sop(s3);

        //其他進制轉十進制
        sop(Integer.parseInt("3c",16));
        sop(Integer.parseInt("74",8));
        sop(Integer.parseInt("110",2));
    }
    public static void sop(Object obj){
       System.out.println(obj);
    }
}

   ·裝箱與拆箱  

自動裝箱 Integer num=6;   //jdk1.5之后     相當於Integer num=new Integer(6)

自動拆箱　int n=num;　　//自動拆箱，
自動拆箱   num=num+5;     //num.intValue()+5       先拆箱，再裝箱    
裝箱與拆箱的具體細節，由系統內部完成

在一個字節的范圍內（-128---127），如果已經使用過，那么再定義時使用已有的

class Demo9 {
    public static void main(String[] args) {
        //jdk1.5之前的寫法
        Integer shu = new Integer(6);
        System.out.println(shu.intValue());//此方法能得到6

        Integer num=6;// new Integer(6)  自動裝箱
        System.out.println(num);
　　　　　　
　　　　　　int n=num;　　　　//自動拆箱，將num拆成了int

        num=num+5;//num.intValue()+5  先拆箱 11--->Integer  再裝箱

        Integer m=127;  //new Integer(127) int m=127;
        Integer n=127;
        System.out.println(m==n);//true

        m=128;
        n=128;
        System.out.println(m==n);//false

        //在一個字節的范圍內（-128---127），如果已經使用過，那么再定義時使用已有的
    }
}

 

package com.zqf;
public class Test{
    public static void main(String args[]){
        int n=128;
        int x=128;
        Integer m=128;
        Integer z=128;
        System.out.println(z==m);//不在-128---127內，所以z用的對象是新創建的對象
        
        System.out.println(m==n);
        System.out.println(n==x);
        
        System.out.println(z==n);
        Integer d=127;
        Integer e=127;
        System.out.println(d==e);    //在-128---127內，所以e用的對象還是d的對象
    }    
}

 

day11

   ·異常

定義：程序在運行時出現的不正常情況

java把程序運行時出現的各種不正常情況面向了對象，為各種不正常情況封裝了實體類，
實體類應該實現顯示異常名稱，異常信息，異常發生的位置

 

   Throwable:（Error類和Exception類的父類）
      -- Error： 錯誤

      --Exception：異常

當發生異常時,因為這種異常對應的異常類在Java內部已經定義了，所以系統會創建對應該異常的異常類對象，因為main處理不了這種異常，
拋給了JVM，JVM默認的處理方式是調用異常類對象的printStackTrace()方法，該方法會顯示異常名稱，異常信息，異常發生的位置， 然后程序中斷

class Demo10 {
    public static void main(String[] args) {
        int[] arr=new int[3];
        System.out.println(arr[3]);  //throw  new ArrayIndexOutOfBoundsException()  printStackTrace()方法
        System.out.println("hehe");    
    }
}

 

 try{
 可能發生異常的代碼
}catch(異常類 e){
 e.getMessage()
 e.toString()
 e.printStackTrack()
 }finally{

 　　　　//finally中的代碼一定會執行，除非catch中有system.exit(1);

}

默認情況下，可以處理也可以不處理，存在的問題是程序編譯通過，運行時發生異常，應該讓問題在編譯時期就發現，
而不是編譯正常，運行出問題，使用throws

沒有使用throws時，調用者處理或不處理編譯都通過，存在的問題是編譯正常，運行出問題，
使用了throws，調用者必須處理，不處理編譯不通過

一個方法使用了throws聲明了異常，必須進行處理
兩種處理方式：
   使用try{}catch{}
   使用throws繼續聲明異常

 

多重異常：
 try{}catch{}...catch{}
當catch中有子類異常，也有父類異常時，子類異常在父類異常之前。（要是父類異常在子類異常之前，就都能處理了，會在編譯時報錯）

異常：
 Excepiton的子類,編譯時檢測的異常
 RuntimeException或其子類
 其子類有arithmeticException,NullPointException(),ArrayIndexOutOfBoundsException()等...

編譯時不檢測，運行時檢測的異常：RuntimeException或其子類，這種異常是因為傳遞數據出錯，
java認為此時應該程序中斷，希望人為的將參數改成正確的，否則影響后面的代碼使用

是因為數據錯誤造成的，當發生這種異常時，不該處理，就應該中斷程序，去修改錯誤

//定義了一個被除數為負數時，會產生的異常
package com.zqf;
class fuShuException extends Exception{
    public fuShuException(String message) {
        super(message);
    }
    public static void run(int a,int b) {
        if(a<0){
            try{throw new fuShuException("負數異常啊 ，秀啊");  //手動創建異常類對象
            
            } catch (fuShuException e) {
                System.out.println(e.getMessage());
                e.printStackTrace();
            }
        }
        int c=a/b;
        System.out.println(c);
    }
    public static void main(String[] args)  {
        run(-1,2);
    }
}

 

任何執行try 或者catch中的return語句之前，都會先執行finally語句，如果finally存在的話。
                  如果finally中有return語句，那么程序就return了，所以finally中的return是一定會被return的，

 　　　　注：finally子句是異常處理的出口，釋放資源、關閉文件、關閉數據庫都是由finally子句完成

day12

   ·異常總結

throw: 拋出異常類對象，java定義的異常類不需要自己手動創建異常類對象，自定義的需要字節手動創建異常類對象
           在方法內部使用了throw，該方法必須處理，處理方式有兩種，捕獲或聲明，如果不處理，編譯不通過

throws：在方法的后邊聲明可能發生異常，調用了有throws聲明的方法，調用者必須處理，處理方式有兩種，捕獲或聲明，如果不處理，編譯不通過

非運行時異常符合上邊的規則

運行時異常：
 傳參錯誤的是運行時異常
 特殊的異常，不符合上邊的規則RuntimeException或其子類
 在方法內部使用了throw拋出了運行時異常對象，那么可以不處理
 使用throws聲明了運行時異常，可以不處理
 
 因為運行時異常都是因為數據錯誤造成的，如果處理了，比如使用try{}catch{}處理了，那么發生異常時，
 會執行catch，然后程序繼續執行，但是應該讓程序停下來，去解決錯誤的數據，所以不該處理

 運行時異常可以處理，但是不好

自定義異常：
   如果是運行時異常不需要處理，非運行時異常處理

 

   ·Date及SimpleDateFormat

import java.util.Date;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
//java.lang.System;
class Demo2 {
    public static void main(String[] args) {
        Date date = new Date();
        //sop(date);//Wed Sep 11 10:43:26 CST 2019

        long time=System.currentTimeMillis();// 1970.1.1 0點
        //sop(time);

        //把一個long類型的時間的毫秒值轉成Date類型
        Date d=new Date(time);
        //sop(d);

        //把Date類型的日期格式進行轉換，轉成成容易看的格式
        //得到具備格式化功能的對象
        DateFormat  df =DateFormat.getDateTimeInstance(DateFormat.FULL,DateFormat.SHORT);
        //String format(Date date) 
        String str = df.format(new Date());
        //sop(str);

        //創建日期格式化對象，同時指定格式
        SimpleDateFormat sdf =new SimpleDateFormat("yyyy-MM-dd  HH:mm:ss");
        String ss = sdf.format(new Date());
        sop(ss);
    }

    public static void sop(Object obj){
        System.out.println(obj);
    }
}

 

1、將一個Date對象轉成指定格式的時間字符串

```java
Date date = new Date();
// 1、實例化SimpleDateFormat對象
//   但是，一般情況下，實例化的同時，會設置格式化的格式
//   2019-10-14 10:58:45
//   y:年    M:月        d:日     H:時(24)        h:時(12)        m:分        s:秒        S:毫秒
//   年: yyyy長年分    yy短年份
//   月: MM    如果月份不到10，會往前補0         M
//   
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
// 2、將date進行格式化
String timeStr = sdf.format(date);
```



2、將指定格式的時間字符串轉成Date對象

```java
String str = "2019-10-14 17:54:68";

// 1、實例化一個SimpleDateFormat對象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

// 2、解析
try {
    Date date = sdf.parse(str);
    System.out.println(date);
    
} catch (ParseException e) {
    e.printStackTrace();
}
```

 

   ·calendar

import java.util.Calendar;
class Demo3 {
    public static void main(String[] args) {
        Calendar cal=Calendar.getInstance();
        //sop(cal.toString());

        String[] months={"1月","2月","3月","4月","5月","6月","7月","8月","9月","10月","11月","12月"};
        String[] weeks={"","星期日","星期一","星期二","星期三","星期四","星期五","星期六"};

        int nian = cal.get(Calendar.YEAR);
        int yue = cal.get(Calendar.MONTH);
        int ri = cal.get(Calendar.DAY_OF_MONTH);

        int week=cal.get(Calendar.DAY_OF_WEEK);

        sop(nian+"年"+months[yue]+ri+"日,"+weeks[week]);
    }
    public static void sop(Object obj){
        System.out.println(obj);
    }
}

 

   ·Math及Random

import java.util.Random;
class Demo4{
    public static void main(String[] args) {
        sop(Math.ceil(56.6));//返回大於這個數的最小整數，返回值是double類型

        sop(Math.floor(56.6));//返回小於這個數的最大整數，返回值是double類型

        sop(Math.pow(2,3));//計算2的3次方

        sop(Math.sqrt(4));//開方

        sop(Math.abs(-5));//絕對值

        sop(Math.round(5.8));//四舍五入取整

        sop(Math.random());//生成大於等於0.0小於1.0的隨機數，

        //生成1-10之間的隨機數
        /*
        for(int i=1;i<=5;i++){
            sop((int)(Math.ceil(Math.random()*10)));
        }*/

        Random r = new Random();
        for(int i=1;i<=5;i++){
           sop(r.nextInt(10)+1);// >=1 <11
        }
    }
    public static void sop(Object obj){
        System.out.println(obj);
    }
}

 

   ·正則表達式

　　專門針對字符串的，為了簡化操作

　　正則表達式，最主要是用來做字符串的校驗、匹配。校驗一個字符串是否滿足指定的規則。

1.正則表達式匹配的規則：依次比較字符串中的每一個字符，和正則表達式中定義的規則進行校驗。

2.字符串的邊界匹配

// ^: 匹配一個字符串的開頭
// $: 匹配一個字符串的結尾
// 在java中matches，正則表達式會自動的添加一個^$
System.out.println("hello world".matches("^hello world$"));

3.一位字符的匹配

// []: 匹配一位字符
// [abc]: 這一位字符可以是a，也可以是b，也可以是c
System.out.println("aello world".matches("[hwl]ello world"));
// [^abc]: 這一位的字符可以是除了a、b、c之外的任意字符
System.out.println("aello world".matches("[^hwl]ello world"));
// [a-z]: 這一位的字符可以是[a,z]之間的任意字符
System.out.println("Hello world".matches("[a-z]ello world"));
// [^a-z]: 這一位的字符可以是除了 [a,z] 之外的任意字符
System.out.println("Hello world".matches("[^a-z]ello world"));
// [a-zA-Z0-9]: 這一位的字符可以是任意的字母或數字
System.out.println("Hello world".matches("[a-zA-Z0-9]ello world"));
// [^a-z[klt]]: 這一位的字符不可以是a-z之間的任意字符，但是klt除外
System.out.println("lello world".matches("[^a-z[klt]]ello world"));

// .: 表示通配符，可以匹配任意的一位字符
System.out.println("hello world".matches(".ello world"));
// 轉義字符: \
System.out.println(".ello world".matches("\\.ello world"));


// \d: 匹配所有的數字 [0-9]
// \D: 匹配所有的非數字 [^0-9]
// \w: 匹配所有的單詞字符 字母數字下划線
// \W: 匹配所有的非單詞字符 非字母數字下划線
System.out.println("hello world".matches("\\Dello world"));

4.多位匹配

// +: 前面的一位或者一組字符，連續出現了1次或多次。
// ?: 前面的一位或者一組字符，連續出現了0次或1次。
// *: 前面的一位或者一組字符，連續出現了0次、1次或多次。
System.out.println("helo".matches("hell+o"));
System.out.println("heo".matches("hel?o"));
System.out.println("hello".matches("hel*o"));

// {m}: 前面的一位或者一組字符，連續出現了m次。
// {m,}: 前面的一位或者一組字符，連續出現了至少m次。
// {m,n}: 前面的一位或者一組字符，連續出現了至少m次，最多n次。
System.out.println("helllllllllo".matches("hel{2,10}o"))

5、或 |

一般是用在一個分組中，表示這個分組中的內容可以是幾種情況之一。組成的幾種情況，長度可以不一樣。

System.out.println("fine, thank you, and you".matches("hello|hi|nihao|你好"));

 

 

 

 

class Demo5{
    public static void main(String[] args) {
        //正則表達式:專門針對字符串的

        boolean b = checkQQ("7654320987aaa");

        String regex="[1-9]\\d{4,14}";//正則本身也是字符串    兩個\表示一個\，代表轉義的作用，\d表示第二個為數字，{4，14}表示數字字少有4，最多14個
        
        boolean boo = "928349sddtt493".matches(regex);

        sop(boo);
        //sop(b);
    }

    //驗證QQ號的功能 ：5-15，不能以0開頭，全是數字 "923y98374908"
    public static boolean checkQQ(String qq){
          int length=qq.length();
          if(length>=5 && length<=15){
              if(!qq.startsWith("0")){
                  try{
                    long num= Long.parseLong(qq);//NumberFormatException
                    return true;
                  }catch(NumberFormatException e)
                  {   
                  }
              }else
                  sop("qq號以0開頭了");
          }else
              sop("qq號長度不合法");
          return false;
    }
    public static void sop(Object obj){
        System.out.println(obj);
    }
}

class Demo6 
{
    public static void main(String[] args) {
        String regex="bo?k";  // * 0次或多次，？ 0次或1次    +  1次或多次
        boolean b = "bok".matches(regex);
        sop(b);
    }
    public static void sop(Object obj){
        System.out.println(obj);
    }
}

   ·正則表達式針對字符串的常用操作：

正則：專門針對字符串的
匹配：  boolean matches(String regex)
切割：  String[] split(String regex)
替換：  String replaceAll(String regex,String str)
獲取：1：根據要獲取的內容定義正則表達式
          2：根據正則表達式得到Pattern對象
          3：使用Pattern對象得到Matcher對象
          4：使用Matcher對象的find()方法來查找，找到了返回true，否則返回false
          使用Matcher對象的group()方法獲取找到的內容

import java.util.regex.Pattern;
import java.util.regex.Matcher;
class Demo7 {
    public static void main(String[] args) {
        //piPei();
        //qieGe();
        // tiHuan();
        huoQu();
    }
    public static void huoQu(){
        //從字符串中獲取四個字母構成的詞兒
        String str="zhu yi la, ming tian fang jia";
        String regex="[a-z]{4}";

        //把正則表達式轉換成Pattern類型的對象
        Pattern pattern = Pattern.compile(regex);

        //使用Pattern類型的對象得到Matcher類型的對象，Matcher對象具備獲取的功能
        Matcher m = pattern.matcher(str);

        while(m.find()) //find()方法找到了返回true，沒找到返回false
        {
           System.out.println(m.group()); // group()方法返回找到的符合正則表達式的內容
        }    
    }
    public static void tiHuan(){
        //String str="zhangsan*****lisi############wangwu&&&&&&&&zhaoliu";
        //String regex="(.)\\1+";
        //String ss = str.replaceAll(regex,"$1");//在正則表達式之外取某一組的值使用$

        //String str="owieuowe9827349287498324iwsjdhfkshd049586045860456wesdf765432109";
        //String regex="\\d{8,}";
        //String ss = str.replaceAll(regex,"****");

        String str="15699788866";
        String regex="(\\d{3})\\d{4}(\\d{4})";
        String ss = str.replaceAll(regex,"$1****$2");
        System.out.println(ss);
    }
    public static void qieGe(){
        //String str="zhangsan.lisi.wangwu.zhaoliu";
        //String regex="\\.";//普通字符點兒

        //String str="zhangsan   lisi      wangwu         zhaoliu";
        //String regex=" +";

        String str="zhangsan*****lisi############wangwu&&&&&&&&zhaoliu";
　　　　　　//下面的(.)中，.是代表任意字符，()代表分組，\\1被轉義為第二組要和第一組的數相同，+表示這個組至少還有一個或多個
        String regex="(.)\\1+";//()用來分組，從左到右，依次是第一組，第二組

        String[] arr = str.split(regex);
        for(int i=0;i<arr.length;i++){
          System.out.print(arr[i]+"  ");
        }
    }
    public static void piPei(){
        //驗證手機號是否合法
        String regex="1[34578]\\d{9}";

        boolean b = "12838384381".matches(regex);

        System.out.println(b);
    }
}

 

   ·集合（包裝類）

用於存儲不同類型的對象，

集合和數組的區別：

　　集合：可以存儲不同類型的對象，隨着存儲的對象的增加，集合的容量也會隨着增大

　　數組：數組的長度是固定的，另外java提供的數組的功能有限

 

 

class Cat{}
class Person{}
class BoSiMao extends Cat{}
class Demo8 {
    public static void main(String[] args) {
         Object[] arr=new Object[10];
         arr[0]=new Cat();
         arr[1]=new Person();
         arr[2]=new Object();

         Cat[] mao = new Cat[5];
         mao[0]=new BoSiMao();
    }
}

   ·collection接口

　　(不能操作下標，子接口list可以)

/*
Collection中定義的是整個集合體系最共性的功能

添加：
   boolean add(Object o) 
   boolean addAll(Collection<? extends E> c)  
刪除:
   boolean remove(Object o)  
   boolean removeAll(Collection<?> c)
   void clear()
判斷:
   boolean contains(Object o) 
   boolean containsAll(Collection<?> c)
   boolean isEmpty() //判斷集合是否為空
   boolean equals(Object o) 
獲取：
   Iterator<E> iterator() //獲取集合中的對象
   int size() //獲取集合中對象的個數
集合變數組：
   Object[] toArray()
*/
import java.util.*;
class Demo9 {
    public static void main(String[] args) {
        Collection coll=new ArrayList();

        coll.add("java1");
        coll.add("java2");
        coll.add("java3");
        coll.add(88);

        //sop(coll);

        Collection c = new ArrayList();
        c.add("hadoop");
        c.add("mysql");

        coll.addAll(c);//把別的集合中的數據加入到當前集合中
        sop(coll);

        //刪除集合中某個對象
        coll.remove(88);
        sop(coll);

        coll.removeAll(c);
        sop(coll);

        //coll.clear();//清空集合，刪除集合中所有對象
        //sop(coll);

        boolean boo = coll.contains("java1");
        //sop(boo);

        //coll.clear();
        //sop(coll.isEmpty());//判斷集合是否為空

        boo = coll.equals(c);
        sop(boo);

        sop(coll.size());//3

         //Object[] toArray()

         Object[] arr = coll.toArray();
         for(int i=0;i<arr.length;i++)
             sop(arr[i]);
    }

    public static void sop(Object obj){
        System.out.println(obj);
    }
}

 

 day13

    ·迭代器

因為集合中存儲的是多個數據，需要一個一個的取到每個數據，這就叫集合的遍歷
//Iterator<>  iterator()    //該方法返回一個Iterator接口的子類對象

 

 

 

package com.zqf;

import java.util.*;
class  Demo1{
    public static void main(String[] args) {   
        //因為集合中存儲的是多個數據，需要一個一個的取到每個數據，這就叫集合的遍歷

        // Iterator<E> iterator() //該方法返回一個Iterator接口的子類對象(也是ArrayList的內部類對象)，該對象可以實現對集合的遍歷
        ArrayList coll =new ArrayList();

        coll.add("java");
        coll.add("hadoop");
        coll.add("mysql");

        Iterator ite = coll.iterator();//拿到了內部類對象

        while(ite.hasNext()){
            Object obj =  ite.next();
            String str = (String)obj;
            sop(str.toUpperCase());
        }
    }
    public static void sop(Object obj){
       System.out.println(obj);
    }
}

 

   ·list接口   ArrayList類

　　（需要掌握）

/*
Collection中定義的是整個集合體系最共性的功能
    ---List(子接口)：存儲的數據是有序的（集合中數據的順序和添加數據的順序是一致的），存儲的數據是可以重復的
        
List接口特有的功能都是可以操作下標的功能

增：
    void add(int index, E element) 
    boolean addAll(int index, Collection<? extends E> c) 

刪
   E remove(int index) 

改
   E set(int index, E element)

查
     ListIterator<E> listIterator() 
     返回此列表元素的列表迭代器（按適當順序）。 
     ListIterator<E> listIterator(int index) 

     List<E> subList(int fromIndex, int toIndex) 
     E get(int index) 
*/
import java.util.*;
class Demo2 {
    public static void main(String[] args) {
        List coll =new ArrayList();

        coll.add("java");
        coll.add("hadoop");
        coll.add("mysql");

        coll.add(1,"h5");
        //sop(coll);

        //coll.remove(1);
        //sop(coll);

        coll.set(1,"python");
        //sop(coll);

        //List<E> subList(int fromIndex, int toIndex)  截取子集合
        List list = coll.subList(1,3);
        //sop(list);

        //Object obj = coll.get(1);
        //sop(obj);
      /*
        Iterator ite = coll.iterator();
        while(ite.hasNext()){
           Object obj = ite.next();
           sop(obj);
        }

        for(Iterator it=coll.iterator();it.hasNext();){
            Object o=it.next();
            sop(o);
        }

        for(int i=0;i<coll.size();i++){
           sop(coll.get(i));
        }*/

        while(!coll.isEmpty()){
            sop(coll.remove(0));//remove會返回被刪除的對象
        }

        sop(coll.size());
    }

    public static void sop(Object obj){
       System.out.println(obj);
    }
}

 

   ·list接口     Vector類

　　（了解即可）

/*
Collection中定義的是整個集合體系最共性的功能
    ---List(子接口)：存儲的數據是有序的（集合中數據的順序和添加數據的順序是一致的），存儲的數據是可以重復的
            ArrayList：底層使用的數據結構是數組，線程不安全的，查找數據的速度快(內存是連續的)，增刪速度慢
            Vector:底層使用的數據結構是數組,線程安全的,查找數據的速度快，增刪速度慢
*/
import java.util.*;
class Demo3 {
    public static void main(String[] args) {
        Vector v = new Vector();
        v.add("java01");
        v.add("java02");
        v.add("java03");

        Enumeration en = v.elements();
        while(en.hasMoreElements()){
            Object obj=en.nextElement();
            sop(obj);
        }
    }
    public static void sop(Object obj){
       System.out.println(obj);
    }
}

   ·List接口   LinkedList類

　　（了解即可）

/*
Collection中定義的是整個集合體系最共性的功能
    ---List(子接口)：存儲的數據是有序的（集合中數據的順序和添加數據的順序是一致的），存儲的數據是可以重復的    
            ArrayList：底層使用的數據結構是數組，線程不安全的，查找數據的速度快(內存是連續的)，增刪速度慢
            Vector:底層使用的數據結構是數組,線程安全的,查找數據的速度快，增刪速度慢
            LinkedList:底層使用的數據結構是鏈表，線程不安全的，查找數據的速度慢，增刪速度快

LinkedList特有的功能：

void addFirst(E e) 
void addLast(E e) 

getFirst() 
getLast() 

removeFirst() 
removeLast() 

jdk1.6才出現以下方法（暫不掌握）

offerFirst()  
offerLast()

peekFirst()
peekLast()

pollFirst()
pollLast()
*/
import java.util.*;
class Demo4 {
    public static void main(String[] args) {
        LinkedList list=new LinkedList(); 

        list.addFirst("java1");
        list.addFirst("java2");
        list.addFirst("java3");

        //sop(list);
        while(!list.isEmpty()) {
           sop(list.removeFirst());//先進后出
        }
        //list.getFirst();//集合中沒有則異常
        list.peekFirst();//集合中沒有不會異常

        //list.removeFirst();//NoSuchElementException
        list.pollFirst();//集合中沒有不會異常
    }
    public static void sop(Object obj){
       System.out.println(obj);
    }
}

 

import java.util.*;

//使用LinkedList實現隊列，使隊列面向對象
//自定義一個隊列（先進先出）
class Queues{
     private LinkedList link;

     Queues(){
         link=new LinkedList();
     }
     //入隊
     public void enQueue(Object obj){
         link.addLast(obj);
     }
     //出隊
     public Object deQueue(){
        return link.removeFirst();
     }
     //隊列是否為空
     public boolean isNull(){
        return link.isEmpty();
     }    
}
class Demo5 {
    public static void main(String[] args) {
        Queues duilie = new Queues();

        duilie.enQueue("hehe");
        duilie.enQueue("haha");
        duilie.enQueue("xixi");
        
        while(!duilie.isNull()){
            sop(duilie.deQueue());
        }
    }
    public static void sop(Object obj){
       System.out.println(obj);
    }
}

   ·小練習

import java.util.*;
class Demo6 {
    public static void main(String[] args) {
        ArrayList list =new ArrayList();

        list.add("java01");
        list.add("java02");
        list.add("java03");
        list.add("java01");
       
        ArrayList lists=quChong(list);

        System.out.println(lists);
    }
    //去除集合中的重復數據 :參數：集合，返回：集合
    public static ArrayList quChong(ArrayList list){ 
        ArrayList list2=new ArrayList();
        for(int i=0;i<list.size();i++){
            Object obj = list.get(i);
            if(!list2.contains(obj))
                list2.add(obj);
        }
        return list2;
    }
}

 

abstract class Drink{
    abstract void taste();
    public void getDrink(int drinkType){
        switch(drinkType){
            case 1:System.out.println("咖啡");
            case 2:System.out.println("牛奶");
            case 3:System.out.println("啤酒");
       }
        return ;
    }
}
abstract class Coffee extends Drink{
    private int drinkType;
    void taste(int drinkType){
        this.drinkType=drinkType;
    }
    void taste(){
        System.out.println("咖啡的味道:香味濃郁，有持久水果味。 ");
    }
    }
    abstract class Milk extends Drink{
        private int drinkType;

        void taste(int drinkType){
            this.drinkType=drinkType;
    }
    void taste(){
        System.out.println("牛奶的味道:淡而醇");
    }
}
abstract class Beer extends Drink{
    private int drinkType;

    void taste(int drinkType){
       this.drinkType=drinkType;
    }
    void taste(){
        System.out.println("啤酒的味道:苦而辣");
    }
}
public class Test{
    public static void main(String[]args){
        Coffee c1=new Coffee(){};
        Milk m1=new Milk() {};
        Beer b1=new Beer() {};
        c1.taste(1);
        c1.taste();
        m1.taste(2);
        m1.taste();
        b1.taste(3);
        b1.taste();
    }
}

 

 day14

Collection

   List:有序，可以重復（ 可以存儲相同的對象）

      ArrayList:數組，內存連續，查找速度快

      LinkedList:鏈表，內存不連續，查找慢，增刪快

         contains方法是依據equals方法，當有特殊需求時，需要重寫equals方法

   Set:無序，不可以重復（ 不可以存儲相同的對象）

      HashSet:無序，不可以重復，底層是哈希表 ，線程不安全，保證不重復：int hashCode()(哈希算法)    boolean equals(Object obj)
             

      TreeSet:排序，無序，不可以重復 ，底層是二叉樹，線程不安全 ，在使用add方法添加對象時，就調用compareTo方法進行了比較大小 

       Comparable：默認TreeSet調用加入到集合的對象的compareTo方法來確定誰大誰小，所以通常只要對象所屬的類實現了
     Comparable接口的compareTo方法，就可以排序，compareTo返回值為0認為是同一個對象，不加入集合

       Comparator：如果對象所屬的類實現了 Comparable接口的compareTo方法，但是比較方式不是我們需要的，那么需要自定義
     比較方式，自定義的比較方式需要實現Comparator接口的int compare方法，compare返回值為0認為是同一個對象，不加入集合

 

   ·contains的具體實現

/*
  Collection中定義的是整個集合體系最共性的功能    Iterator hasNext()  next()

    ---List(子接口)：存儲的數據是有序的（集合中數據的順序和添加數據的順序是一致的），存儲的數據是可以重復的
            
            ArrayList：底層使用的數據結構是數組，線程不安全的，查找數據的速度快(內存是連續的)，增刪速度慢
                 
            Vector:底層使用的數據結構是數組,線程安全的,查找數據的速度快，增刪速度慢
                   Enumeration   hasMoreElements()   nextElement()

            LinkedList:底層使用的數據結構是鏈表，線程不安全的，查找數據的速度慢，增刪速度快
*/
import java.util.*;
class Student{
    private String name;
    private int  age;

    Student(){}

    Student(String name,int age){
       this.name=name;
       this.age = age;
    }

    public boolean equals(Object obj){
        if(!(obj instanceof Student))
            throw new RuntimeException("類型不對");

        Student stu=(Student)obj;

        System.out.println(this.name+"對比:"+stu.name);
        return this.name.equals(stu.name)&&this.age==stu.age;
    }

    public String toString(){
      return name+","+age;
    }
}
class  Demo1{
    public static void main(String[] args) {
        //需求：姓名年齡相同的認為是同一個人，對集合去重
        ArrayList list =new ArrayList();

        list.add(new Student("lisi",12));
        list.add(new Student("wangwu",27));
        list.add(new Student("zhaoliu",19));
        list.add(new Student("lisi",12));

        ArrayList jihe = quChong(list);
        sop(jihe);    
    }
    public static ArrayList quChong(ArrayList list){ 
        ArrayList list2=new ArrayList();
        for(int i=0;i<list.size();i++){                                                        
            Object obj = list.get(i);                          
            if(!list2.contains(obj))//判斷是不是包含某個對象，內部依據的是equals方法
                list2.add(obj);
        }
        return list2;
    }
    public static void sop(Object obj){
       System.out.println(obj);
    }
}

   

   ·Set接口   HashSet類

/*
   ----Set:沒有特有的功能

           存儲的數據是無序的（集合中數據的順序和添加數據的順序不一致），存儲的數據是不可以重復的
        
       HashSet:如何保證對象不重復的：依據的是int hashCode()方法（哈希值）和 boolean equals(Object obj)方法
                （底層使用的數據結構是哈希表，線程是不安全的）
               向集合中添加對象時，先用要添加的對象的哈希值和集合中已有的對象的哈希值分別比較，當哈希值都不相同
               時，對象直接加入集合，當出現了哈希值相同的對象時，再調用equals方法對兩個對兩個對象比較，equals方法
               返回true，怎認為是同一個對象，不加入集合，否則認為是不同的對象，加入集合

               注意:哈希值相同的不一定是同一個對象，同一個對象哈希值一定相同
                    考慮不可重復時，使用HashSet
       
*/
import java.util.*;
class Person{
    public int hashCode(){
       return 88;
    }
    public boolean equals(Object obj){
      return true;
    }
}
class Demo2 {
    public static void main(String[] args) {
        HashSet hs = new HashSet();

        hs.add(new Person());
        hs.add(new Person());// 88  new Person().equals(new Person()); false
        hs.add(new Person());//88
        
        sop(hs);
        /*
       //在使用add方法添加對象時就保證了對象的唯一
       hs.add(66);  66.hashCode()
       hs.add(77);
       hs.add(99);
       hs.add(66);*/

       sop(hs);   
    }
    public static void sop(Object obj){
       System.out.println(obj);
    }
}

   HashSet的運用

import java.util.*;
class Student{
    private String name;
    private int  age;

    Student(){}

    Student(String name,int age){
       this.name=name;
       this.age = age;
    }

    public int hashCode(){
       return name.hashCode()+age*66;
    }

    public boolean equals(Object obj){
         if(!(obj instanceof Student))
             throw new RuntimeException("類型錯誤");

         Student stu = (Student)obj;
         return this.name.equals(stu.name)&&this.age==stu.age;
    }

    public String toString(){
      return name+","+age;
    }
}
class Demo3 {
    public static void main(String[] args) {  
        HashSet hs = new HashSet();
         //需求：姓名年齡相同的認為是同一個對象，不能被加入集合

        hs.add(new Student("lisi",19));
        hs.add(new Student("zhaoliu",29));//不同的對象哈希值肯定不同（前提：沒有重寫hashCode方法）
        hs.add(new Student("wangwu",17));
        hs.add(new Student("lisi",19));

        sop(hs);

        boolean boo=hs.contains(new Student("lisi",19)); //也是依據 hashCode() 方法和equals方法
        sop(boo);//true

        hs.remove(new Student("lisi",19));//也是依據 hashCode() 方法和equals方法
        sop(hs.size());
    }
    public static void sop(Object obj){
       System.out.println(obj);
    }
}

 

   ·Set接口   TreeSet類

/* 
       TreeSet: 具備Set的基本特征，還可以進行排序

                TreeSet排序是調用添加到集合中的對象的compareTo()方法確定下來誰大誰小
                才能排序的，所以如果添加到集合中的對象所屬的類沒有實現compareTo方法，TreeSet是不能排序的

                底層數據結構使用的是二叉樹(紅黑樹):
*/
import java.util.*;
class Person implements Comparable  //只要是實現了Comparable接口的就是可以排序的
{
    public int compareTo(Object obj){
         return 9;
    }
}
class Demo4{
    public static void main(String[] args) {
        TreeSet ts = new TreeSet();

        ts.add(new Person());//
        ts.add(new Person());// new Person().compareTo(new Person())
        ts.add(new Person());//new Person().compareTo(new Person())  new Person().compareTo(new Person())

        sop(ts);

        /*
        //在使用add方法添加時就比較大小了  因為String類實現了Comparable接口中的compareTo方法，所以TreeSet可以對字符串進行排序
        ts.add("hello");
        ts.add("aaabbbccc");
        ts.add("dell");
        ts.add("hello");  //"hello".compareTo("hello")==0  compareTo方法的返回值為0，認為是同一個對象，不加入集合

        sop(ts);
        */
    }
    public static void sop(Object obj){
       System.out.println(obj);
    }
}

   ·comparable接口與compareTo()

   Comparable: 默認是TreeSet調用加入到集合的對象的cmopareto方法來確定誰大誰小， 所以通常只要對象所屬的類實現了comparable接口的compareTo方法，就可以排序

 

package com.zqf;
import java.util.*;
public class Test{
    public static void main(String[] args) {
        Set<Person> set=new TreeSet<Person>();
        set.add(new Person("zhangsan",12));
        set.add(new Person("lisi",14));
        set.add(new Person("wanger",13));
        System.out.println(set);
    }
}
class Person implements Comparable<Person>{
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public Person() {
        super();
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
    @Override
    public int compareTo(Person p) {
        //按照年齡
/*        if(this.age>=p.age) {
            return 1;
        }else {
            return -1;
        }
*/        
        //按照姓名
        int compareTo = this.name.compareTo(p.name);
        return compareTo;
    }
}

 

   ·HashSet和TreeSet的應用

import java.util.*;
class Demo6 {
    public static void main(String[] args) {
        //隨機生成5個互不相同的1--10之間的隨機數  Set，HashSet
        Random r = new Random();
        HashSet hs =new HashSet();

        while(hs.size()<5){
           int num = r.nextInt(10)+1;
           hs.add(num);
        }
        System.out.println(hs);
    }
}

import java.util.*;
class Demo7 {
    public static void main(String[] args) {
        String str="12,4,56,123,67";//對字符串中的數值進行排序
        String[] arr=str.split(",");
        TreeSet ts = new TreeSet();
        for(int i=0;i<arr.length;i++){
            //ts.add(arr[i);            //    不能用這個，這個使用的是字符串中的compareTo,是字典順序    
           ts.add(Integer.parseInt(arr[i]));
        }
        System.out.println(ts);
    }
}

   ·Comparator接口   compareTo()方法

 /*
 TreeSet: 具備Set的基本特征，還可以進行排序

                TreeSet排序是調用添加到集合中的對象的compareTo()方法確定下來誰大誰小
                才能排序的，所以如果添加到集合中的對象所屬的類沒有實現compareTo方法，TreeSet是不能排序
                底層數據結構使用的是二叉樹(紅黑樹)
                排序的第二種方式：Comparator  int compare(Object obj1,Object obj2)

                當類本身具備的排序方式不能滿足我們的需求時，那么使用自定義比較方法

package com.zqf;
import java.util.*;
public class Test{
    public static void main(String[] args) {
        //Set<Person> set=new TreeSet<Person>((l1,l2) -> l1.getName().compareTo(l2.getName()));　　//按姓名排序
        Set<Person> set=new TreeSet<Person>((l1,l2) -> l1.getAge()-l2.getAge());　　　　　　　　　　　//按年齡排序
        
        set.add(new Person("zhangsan",12));
        set.add(new Person("lisi",14));
        set.add(new Person("wanger",13));
        System.out.println(set);
    }
}
class Person {
    private String name;
    private int age;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    public Person() {
        super();
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
    
    
}

 

 

 

  ·泛型

　　通過<引用數據類型>指定集合中存儲的對象的類型，在程序編譯時就會檢查集合中存儲的數據是不是泛型指定的類型
      如果不是，那么編譯不通過，從而把運行時期的問題轉移到了編譯時期，是程序更安全，提高了程序的安全性

import java.util.*;
class Demo10 {
    public static void main(String[] args) 
    {   //使用了泛型，只要編譯通過，運行就不會出問題
        //ArrayList<E>
        ArrayList<String> list=new ArrayList<>();//通過泛型限定集合中存儲數據的類型，使程序更安全

        list.add("66");
        list.add("77");
        list.add("44");
        //list.add(55);

        Iterator<String> ite = list.iterator();
        while(ite.hasNext()){
            //Object obj = ite.next();
            //String str=(String)obj;
            String str = ite.next();
            System.out.println(Integer.parseInt(str));
        }
    }
}

 day15

   ·泛型

在類上定義泛型
 　　class Demo<T>
　　 {
　　 }
　　 Demo<String > demo=new Demo<String>(); //在創建類的對象時才能確定泛型，泛型屬於非靜態類型
在方法上定義泛型
 　　class Test<E>{
  　　public void ff(E e){
 　　 }
  　　public <E> void show(E e){
 　　 }
 　　 public static <T> void fun(T t){  //靜態方法只能自己用泛型
 　　 }
 　　}

在接口上定義泛型
　　 interface inter<E>{
 　　 void ff(E e);
 　　}

   ·泛型中的通配符：？

//通配符:  ?
import java.util.*;
class Demo3 {
    public static void main(String[] args) {
        ArrayList<String> list1=new ArrayList<>();
        list1.add("java");
        list1.add("mysql");
        list1.add("hadopp");

        //bianLi(list1);
        dieDai(list1);

        ArrayList<Integer> list2=new ArrayList<>();
        list2.add(77);
        list2.add(88);
        list2.add(99);

        //bianLi(list2);
        dieDai(list2);
    }
    //通配符: ?  表示什么類型都行
    public static  void dieDai(Collection<?> coll){
         Iterator<?> ite=coll.iterator();
         while(ite.hasNext()){
             //? obj=ite.next();非法的表達式開始
             System.out.println(ite.next());
         }
    }

    //通用的遍歷的方法:泛型方法
    public static <E> void bianLi(Collection<E> coll){
         Iterator<E> ite=coll.iterator();
         while(ite.hasNext()){
            E obj=ite.next();

            System.out.println(obj);
         }
    }
}

 

   ·泛型限定

泛型限定:  ? extends E:限定了上限（E類型或其子類類型）  ? super E:限定了下限，E類型或其父類類型

//泛型限定:  ? extends E:限定了上限（E類型或其子類類型）  ? super E:限定了下限，E類型或其父類類型
import java.util.*;
class Person implements Comparable<Person>{
    private String name;
    private int  age;

    Person(){}

    Person(String name,int age){
      this.name=name;
      this.age=age;
    }
    public int compareTo(Person ren){
        return this.age-ren.age;
    }
    public String getName(){
       return this.name;
    }
    public String toString(){
      return name+","+age;
    }
}
class ComByName implements Comparator<Person>{
    public int compare(Person p1,Person p2){
        return p1.getName().compareTo(p2.getName());
    }
}
class Student extends Person{
     Student(){}
     Student(String name,int age){
       super(name,age);
     }
}
class Worker extends Person{
    Worker(){}
    Worker(String name,int age){
       super(name,age);
    }
}
class Demo4 {
    public static void main(String[] args) {
        ArrayList<Student>  list=new ArrayList<>();

        list.add(new Student("lisi",20));
        list.add(new Student("wangwu",18));
        list.add(new Student("amen",28));

        dieDai(list);

        ArrayList<Worker>  list2=new ArrayList<>();

        list2.add(new Worker("zhangsi",29));
        list2.add(new Worker("zhaoliu",38));
        list2.add(new Worker("liming",18));

        dieDai(list2);

        ArrayList<Integer>  list3=new ArrayList<>();
        list3.add(66);
        list3.add(666);
        list3.add(6666);
        
        //dieDai(list3);
    }
    public static  void dieDai(Collection<? extends Person> coll)//集合中對象的類型必須是Person或Person的子類類型
    {
         Iterator<?> ite=coll.iterator();
         while(ite.hasNext()){
             System.out.println(ite.next());
         }
    }
}

 

   ·Map接口   HashMap類

Map<k,v>接口
 　　是一個單獨的接口，屬於集合，但沒有繼承Collection，存儲的是簡直對，一對一對的存，鍵不能重復，值可以重復
 　　（當存在映射關系的情況下，使用Map）

Map<String,String> m = new HashMap<>();
m.put("name","lisi");
m.remove("name")
m.get("name");
m.size()
m.isEmpty()
m.containsKey("name")
m.containsValue("lisi")
Collection<String> v = m.values()
HashMap:保證鍵唯一，原理和HashSet一樣 
TreeMap:根據鍵排序，原理和TreeSet一樣

/*
Map<K,V>:是一個單獨的接口，屬於集合，但沒有繼承Collection,存儲的是鍵值對兒，一對一對的存，鍵不能重復

    HashMap:

    TreeMap:

Map接口中定義的功能：

添加:
 V put(K key, V value) 
 void putAll(Map<? extends K,? extends V> m)  //addAll()
 
刪除:
 V remove(Object key) 
 void clear() 
         
獲取：
  V get(Object key) 

  Set<K> keySet() 
  Set<Map.Entry<K,V>> entrySet() 

  int size() 
  Collection<V> values() 
判斷:
   boolean isEmpty() 
   boolean containsKey(Object key) 
   boolean containsValue(Object value)
*/
import java.util.*;
class Demo6{
    public static void main(String[] args) {
        Map<String,String>  map = new HashMap<>();
        /*
        //String v=map.put("aa","lisi");//返回的是被覆蓋的鍵值對的值
        //sop(v);//null

        String vv=map.put("aa","zhangsan");//把上一個同名的鍵值對覆蓋掉
        //sop(vv);//lisi

        */
        //鍵不能重復
        map.put("name","zhangsan");
        map.put("age","20");
        map.put("address","上海");

        //map.remove("address");//根據鍵刪除鍵值對
        //map.clear();

        //sop(map.size());//得到集合中鍵值對兒的對兒數
        //sop(map.isEmpty());

        // Collection<V> values()  得到集合中所有的值
        Collection<String>  vs = map.values();

        Iterator<String> ite=vs.iterator();
        while(ite.hasNext()){
          sop(ite.next());
        }
        // V get(Object key) 根據鍵獲取值
        String zhi = map.get("age");
        sop(zhi);

        //boolean containsKey(Object key) 判斷集合是否包含某個鍵
         boolean b = map.containsKey("names");
         sop(b);

        //boolean containsValue(Object value)判斷集合是否包含某個值
         b=map.containsValue("上海");
         sop(b);
    }
    public static <E> void sop(E obj){
        System.out.println(obj);
    }
}

 

   ·Map接口   兩種遍歷方法

/*
Set<K> keySet() :   取到所有的鍵存到一個Set集合，並返回該集合對象，因為Set有迭代器，所以得到迭代器，每次迭代出來的是一個鍵
                    根據鍵獲取值


Set<Map.Entry<K,V>> entrySet() : 得到每個鍵值對兒對應一個Map.Entry(映射關系)類型的值，存到一個Set集合中，Set有迭代器
                                 沒次迭代出來的是一個Map.Entry(映射關系)類型的值，這個值中既包括鍵，也包括值
                                 Entry是定義在Map內部的靜態成員，Entry是對Map集合內部的鍵值對的映射關系的描述，所以定義在Map
                                 的內部

*/
import java.util.*;
class Demo7{
    public static void main(String[] args) {
        //Map沒有迭代器
        //Map 實現遍歷的方法: Set<K> keySet()   Set<Map.Entry<K,V>> entrySet() 

        Map<String,String> map = new HashMap<>();

        map.put("name","zhangsan");
        map.put("age","20");
        map.put("address","上海");

       Set<Map.Entry<String,String>> en= map.entrySet();

       Iterator<Map.Entry<String,String>> ite=en.iterator();
       while(ite.hasNext()){
            Map.Entry<String,String> e=ite.next();
            String jian=e.getKey();
            String zhi=e.getValue();

            System.out.println(jian+"="+zhi);
        } 
       /*
        Set<String> keys=map.keySet();
        Iterator<String> ite=keys.iterator();

        while(ite.hasNext()){
            String key=ite.next();
            String value=map.get(key);
            System.out.println(key+"="+value);
        }
       */        
    }
}

   ·HashMap詳解

底層使用數據結構是哈希表，HashSet:保證對象不重復
保證鍵不重復：int hashCode()    boolean equals(Object obj)

 import java.util.*;
 class Student implements Comparable<Student>{
     private String name;
     private int age;
     Student(){}
     Student(String name,int age){
       this.name=name;
       this.age=age;
     }
     public int compareTo(Student stu){
         int num=this.age-stu.age;
         return num==0?this.name.compareTo(stu.name):num;
     }
     
     public int hashCode(){
         return name.hashCode()+age*56;
     }
     public boolean equals(Object obj){
        if(!(obj instanceof Student))
            throw new ClassCastException("類型錯誤");

        Student stu = (Student)obj;

        return this.name.equals(stu.name)&&this.age==stu.age;
     }

     public String getName(){
        return name;
     }
     public int getAge(){
        return age;
     }
     public String toString(){
       return name+","+age;
     } 
 }
class Demo8 {
    public static void main(String[] args) {
        //什么情況下使用Map：當存在映射關系的時候，每個學生有一個住址

        //底層數據結構是哈希表，HashSet：保證對象不重復
        //保證鍵唯一：int hashCode()  boolean equals(Object obj) 
        HashMap<Student,String> map = new HashMap<>();

        //姓名，年齡相同認為是同一個對象
        map.put(new Student("zhangsan",28),"北京");
        map.put(new Student("wangwu",18),"上海");
        map.put(new Student("lisi",38),"深圳");
        map.put(new Student("lisi",38),"紐約");

        Set<Student> keys = map.keySet();
        Iterator<Student> ite=keys.iterator();

        while(ite.hasNext()){
            Student stu =ite.next();

            String address=map.get(stu);

            sop(stu+"="+address);
        }
    }
    public static void sop(Object obj){
      System.out.println(obj);
    }
}

 

   ·Map接口   TreeMap類

TreeMap,按照鍵的順序排序，方法與TreeSet相同

import java.util.*;
//自定義比較方式
class ComByName implements Comparator<Student>{
    public int compare(Student stu1,Student stu2 ){
         int num = stu1.getName().compareTo(stu2.getName());

         return  num==0?stu1.getAge()-stu2.getAge():num;
    }
}
class Demo9 {
    public static void main(String[] args) {
        //底層是二叉樹    TreeSet:add
        //根據鍵排序,無序
        ComByName cn = new ComByName();
        TreeMap<Student,String> map = new TreeMap<>(cn);
        
        //使用put添加鍵值對的時候就排序了
        map.put(new Student("zhangsan",28),"北京");
        map.put(new Student("wangwu",18),"上海");
        map.put(new Student("lisi",38),"深圳");
        map.put(new Student("lisi",38),"紐約");


        Set<Map.Entry<Student,String>>  en = map.entrySet();
        Iterator<Map.Entry<Student,String>> ite=en.iterator();

        while(ite.hasNext()){
             Map.Entry<Student,String> e=ite.next();
             Student key=e.getKey();
             String value=e.getValue();

             sop(key+"="+value);
        }
    }
    public static void sop(Object obj){
      System.out.println(obj);
    }
}

    ·Map的運用

import java.util.*;
class Demo10 {
    public static void main(String[] args) {
        //每個班級對應多個學生

        HashMap<String,List<Student>> school=new HashMap<>();

        List<Student> list1=new ArrayList<>();
        list1.add(new Student("lisi",20));
        list1.add(new Student("wangsi",28));
        list1.add(new Student("zhaosi",19));

        List<Student> list2=new ArrayList<>();
        list2.add(new Student("lisi2",22));
        list2.add(new Student("wangsi2",25));
        list2.add(new Student("zhaosi2",18));

        school.put("gp1905",list1);
        school.put("gp1904",list2);

        Set<String> keys = school.keySet();

        Iterator<String> ite=keys.iterator();
        while(ite.hasNext()){
             String banji = ite.next();
             sop("班級名稱:"+banji);
             sop("班級人員有:");

             List<Student>  stus=school.get(banji);

             //sop(stus);
             
             Iterator<Student> it=stus.iterator();
             while(it.hasNext()){
                  Student ss=it.next();
                  sop(ss);
             }
        }
    }
    public static void sop(Object obj){
      System.out.println(obj);
    }
}

   ·數組轉集合，數組轉字符串

數組轉字符串：Arrays.toString()
數組轉集合：Arrays.asList()

import java.util.*;
class Demo12 {
    public static void main(String[] args) {
        
        //數組轉字符串
        int[] arr={12,34,56,67,23,8};
        String str = Arrays.toString(arr);
        sop(str);
        
        //static <T> List<T> asList(T... a)  

        //數組轉集合：使用集合的方法
        String[] arr2={"hello","java","mysql","hadoop"};
        List<String> list = Arrays.asList(arr2);
        //sop(list);
        //數組轉成的集合不能執行添加，刪除，否則異常
        //list.add("h5");//UnsupportedOperationException

        boolean b = list.contains("java");
        sop(b);

        int[] c={3,4,5,6};
        List<int[]> jihe = Arrays.asList(c); //集合中存的是引用類型的數據，數組是引用數據類型，所以把整個數組存到集合中
        sop(jihe.get(0)[0]);//  1
    }
    public static void sop(Object obj){
        System.out.println(obj);
    }
}

   ·集合轉數組

集合轉數組:<T> T[] toArray(T[] t)

import java.util.*;
class Demo13 {
    public static void main(String[] args) {
        
        //集合轉數組  <T> T[] toArray(T[] a)  
        List<String> list= new ArrayList<>();

        list.add("hello");
        list.add("java");
        list.add("mysql");

        //給定的數組的長度大於集合中數據的個數，使用給定的
        //給定的數組的長度小於集合中數據的個數，不使用給定的
        //最好給定義一個長度和集合相同的數組
        String[] arr = list.toArray(new String[list.size()]);
        sop(arr.length);

        for(int i=0;i<arr.length;i++){
           sop(arr[i]);
        }
    }
    public static void sop(Object obj){
        System.out.println(obj);
    }
}

   ·增強for循環

 for(數據類型  變量名:被遍歷的Collection集合或數組){}                

可用來遍歷collection集合和數組

/*
增強的for循環
    for(數據類型  變量名:被遍歷的Collection集合或數組){   }
*/
import java.util.*;
class Demo14 {
    public static void main(String[] args) {
        int[] arr={23,4,67,12,78};

        for(int num:arr){
            sop(num);
        }

        List<String> list= new ArrayList<>();

        list.add("hello");
        list.add("java");
        list.add("mysql");

        for(String str:list){
           sop(str.toUpperCase());
        }

        Map<String,String> lm = new HashMap<>();
        lm.put("name","lisi");
        lm.put("age","20");
        lm.put("weight","200");

        Set<String> keys = lm.keySet();
        for(String key:keys){
             String v = lm.get(key);
             sop(key+"="+v);
        }

        Set<Map.Entry<String,String>> en=lm.entrySet();
        for(Map.Entry<String,String> me:en){
           String key = me.getKey();
           String value=me.getValue();

           sop(key+"="+value);
        }        
    }
    public static void sop(Object obj){
        System.out.println(obj);
    }
}

 day16

   ·Collections集合工具類

 Collections集合工具類
 Collections.sort(list);   //排序
 Collections.reverseOrder()
 Collections.reverse()
 Collections.max()
 Collections.min()

List<Integer> list = new ArrayList<>();
List<Integer> dest = new ArrayList<>();

// 1、向集合中添加元素
Collections.addAll(list, 10, 20, 30, 10, 0, 9, 8, 11, 17, 21);
Collections.addAll(dest, 0,0,0,0,0,0,0,0,0,00,0,0,0,0,0,0,0,0,0);

// 2、找出一個集合中的最大值
System.out.println(Collections.max(list));

// 3、找出一個集合中的最小值
System.out.println(Collections.min(list));

// 4、將集合中的元素進行隨機排列
Collections.shuffle(list);

// 5、排序
// 使用這個方法進行排序的時候，需要保證集合中的元素對應的類實現Comparable接口
Collections.sort(list);    
// 使用指定的排序規則，對集合中的數據進行排序
Collections.sort(list, (e1, e2) -> e2 - e1);

// 6、元素拷貝
Collections.copy(dest, list);

// 7、翻轉
Collections.reverse(dest);

// 8、交換兩個下標的元素
Collections.swap(list, 0, 1);

// 9、用指定的元素填充滿集合
Collections.fill(dest, 1);

// 10、將指定的集合轉成線程安全的集合。
// Collection Collections.synchronizedCollection(list);
// List Collections.synchronizedList(list);
// Set Collections.synchronizedSet(s);
// Map Collections.synchronizedMap(m);

System.out.println(dest);

 

   ·可變參數

　　簡化書寫，原理是數組，注意：可變參數必須位於參數列表的最后。
 　　fun(1,2,3,53,65,3);
　　 fun(int ... a) 

/*
可變參數：簡化書寫,原理是數組，注意：可變參數必須位於參數列表的最后
*/
class Demo2 {
    public static void main(String[] args) {

         //int[] b={12,34,45,23,5,67};
         int he = add(12,34,45,23,5,67,12,3);
         sop(he);
    }

    public static int add(int ... arr){
        int sum=0;
        for(int i=0;i<arr.length;i++){
           sum=sum+arr[i];
        }
        return sum;
    }
    public static void sop(Object obj){
        System.out.println(obj);
    }
}

   ·properties類

 Map的子類，屬於集合，存儲的鍵和值必須是String類型的，適合存儲屬性  （了解即可）
 得到所有的鍵：stringPropertyNames();
 存放鍵值對：   setProperty(String key,String value);
 根據鍵獲取值：getProperty(String key);

import java.util.*;
class Demo3 {
    public static void main(String[] args) {
        //  Properties: 是一個Map集合類，存儲的鍵和值必須是String類型的，適合存儲屬性

        //得到系統屬性
        Properties pro =  System.getProperties();
        sop(pro);

        //得到集合中所有的鍵  keySet()
        /*
        Set<String> keys= pro.stringPropertyNames();
        for(String key:keys){
            //根據鍵獲取值
            String value = pro.getProperty(key);
            sop(key+"="+value);
        }*/
        pro.setProperty("user.country","china");//put

        Set<String> keys= pro.stringPropertyNames();
        for(String key:keys){
            //根據鍵獲取值
            String value = pro.getProperty(key);
            sop(key+"="+value);
        }
    }

    public static void sop(Object obj){
        System.out.println(obj);
    }
}

// 1、實例化一個Properties對象
Properties properties = new Properties();

// 2、加載某一個.properties文件，讀取這個文件中的信息
try {
    properties.load(new FileReader("file\\info.properties"));
} catch (IOException e) {
    e.printStackTrace();
}

// 3、獲取
String name = properties.getProperty("name");
System.out.println(name);

String height = properties.getProperty("height", "111");
System.out.println(height);

// 4、修改、添加
properties.setProperty("name", "xiaohei");
properties.setProperty("weight", "123");


// 5、對Properties進行操作，結束之后，一定要同步到文件中，否則這些數據只能存在於內存
try {
    properties.store(new FileWriter("file\\info.properties"), "hello world");
} catch (IOException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
}

// 6、遍歷
properties.forEach((k, v) -> System.out.println(k + " : " + v));

 

import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Properties;

public class Test1 {
    public static void main(String[] args) throws IOException {
        Properties pro = new Properties();
        FileInputStream fis = new FileInputStream("a.properties");
        FileOutputStream fos  = new FileOutputStream("a.properties");

        pro.load(fis);

    pro.setProperty("name","lisi");

    pro.store(fos,"ok");

    fis.close();
        fos.close();
    }
}

 

   ·靜態導入

　　例：  import static java.util.Ararys.*;
             類名相同，通過包名區分
  　　   方法名相同，通過類名區分

import java.util.*;
import static java.util.Arrays.*;//靜態導入
class Demo4 //toString(){
    public static void main(String[] args) {
        int[] arr={12,34,45,56,67,78};
        sort(arr);
        int index =binarySearch(arr,56);
        String str=java.util.Arrays.toString(arr);//方法名相同，類名不能省略,類名相同，通過包名區分
        System.out.println(str);
    }
}
class Arrays {}

   ·IO流（Input ,Output）

輸入輸出流：用來實現設備之間的數據傳輸

 分類： 按照方向分類：輸入流，輸出流（相對於內存） 對內存是進數據就是輸入流，出數據就是輸出流保存文件是輸出，打開是輸入
  　　    按照操作的數據分類：
  　　　　 字節流：可以操作任何類型的數據，文本，圖片，視頻，音頻
  　　　　 字符流：只能操作文本數據，因為字符涉及到編碼，在字節流的基礎上加入了編碼方便操作文本數據。
    　　　　　　ASCII  GBK   utf-8

字節流：
　　InputStream 字節輸入流父類
　　OutputStream 字節輸出流父類

字符流
　　Reader   字符輸入流父類
　　Writer     字符輸出流父類 

　　　　　　　　　　　　　　　　　　記住：Writer輸出流可以對文本寫入，Reader輸入流對文本讀出

輸入設備：鍵盤，文件，網絡，內存

輸出設備：控制台，文件，網絡，內存
以硬盤設備為例

 

   ·向文本寫入數據

 （從內存中讀取數據）

import java.io.*;
class Demo5 {
    public static void main(String[] args) throws IOException{
        //向文本文件寫入數據
        //因為是文本文件所以使用字符流，又因為是寫入所以使用字符輸出流(Writer),又因為是文件(硬盤),
         //所以使用 Writer的可以操作文件的子類FileWriter

        //1:創建文件輸出流對象和文件相關聯  FileWriter(String fileName) 
        //文件可以事先不存在，系統會自動創建
        FileWriter fw = new FileWriter("temp.txt");

        //2：使用輸出流對象向與其關聯的文件中寫入數據
        fw.write("abc");//寫入到內部的數組了，因為需要查表
        
        //fw.flush();//把內部數組的數據刷到文件中

        fw.write("def");//刷完之后還可以繼續寫

        //釋放資源：流對象
        fw.close();//關閉流的同時會刷新流

        //fw.write("ww");//流已關閉，不能繼續寫入數據
    }
}

import java.io.*;
class Demo6 {
    public static void main(String[] args) {
        FileWriter fw=null;
        try{
            fw = new FileWriter("temp.txt");//系統找不到指定的路徑
            fw.write("abcdef"); 
        }catch(IOException e){
            e.printStackTrace();
        }finally{
           try{
               if(fw!=null)    //這個意思是當文件存在時，可以關閉，否則會報空指針異常
                   fw.close();//null.close();
           }catch(IOException ee){
               throw new RuntimeException("字符輸出流關閉失敗");
           }    
        }
    }
}

   ·文件的續寫

import java.io.*;
class Demo7 {
    public static void main(String[] args) throws IOException{
          String SEPARATOR=System.getProperty("line.separator");

          //文件的續寫：默認都是從文件的末尾寫入數據
          FileWriter fw= new FileWriter("temp.txt",true);
          fw.write("hello");
          fw.write(SEPARATOR);
          fw.write("world");
          fw.close();
    }
}

   ·讀取文本文件數據的兩種方式

　　使用字符時，num=fr.read();   num表示每一個字符的編碼，當num到最后時，變成-1

　　使用數組時，char[] arr=new char[1024] ; num=fr.read(arr),   num此時表示字符的個數，當到最后時，變成-1

　　使用字符

import java.io.*;
class Demo8 {
    public static void main(String[] args) throws IOException{
        //從文本文件中讀取數據  1.先確定是字符流還是字節流，2再確定用輸入流還是輸出流，3最后確定什么設備

        //因為是文本文件，所以使用字符流，又因為是讀取所以使用輸入流，因為是文件所以使用Reader的可以操作文件的子類FileReader

        //1：創建文件輸入流對象和文件相關聯
        //文件需要事先存在
        FileReader fr =new FileReader("temp.txt");

        //2:使用輸入流對象讀取數據

        //int read()  讀一個字符 效率低

        int num;
        while((num=fr.read())!=-1){
            System.out.print((char)num);
        }
        fr.close();
    }
}

　　使用數組

import java.io.*;
class Demo9 {
    public static void main(String[] args)throws IOException {
        FileReader fr =new FileReader("temp.txt");

        char[] arr=new char[1024];
        int num;

        while((num=fr.read(arr))!=-1){
           System.out.print(new String(arr,0,num));
        }

        fr.close();
    }
}

   ·文本復制

import java.io.*;
class Demo10 {
    public static void main(String[] args) throws IOException {
        //實現復制一個文本文件，Demo3.java, 讀取Demo3.java寫入到一個新的文件

        FileReader fr=new FileReader("Demo3.java");
        FileWriter fw = new FileWriter("Demo3_copy.java");
        int num;

        while((num=fr.read())!=-1){
            fw.write(num);
        }
        
        fr.close();
        fw.close();
    }
}

import java.io.*;
class Demo11{
    public static void main(String[] args) {
        FileReader fr = null;
        FileWriter fw = null;
        try{
             fr=new FileReader("Demo5.java");
             fw=new FileWriter("Demo5_copy.java");

             char[] arr=new char[1024];
             int num;
             while((num=fr.read(arr))!=-1){
                 fw.write(arr,0,num);
             }    
        }catch (IOException e){
             e.printStackTrace();

        }finally{
            if(fr!=null)
               try{
                  fr.close();
               }
               catch (IOException ee){
                   throw new RuntimeException("字符讀取流關閉失敗");
               }

           if(fw!=null)
               try{
                  fw.close();
               }
               catch (IOException ee){
                   throw new RuntimeException("字符輸出流關閉失敗");
               }
        }
    }
}

   ·文件夾的復制

package com.zqf;

/**
 * 
 * 復制文件夾d:/java下面所有文件和子文件夾內容到d:/java2。
    提示：涉及單個文件復制、目錄的創建、遞歸的使用
 */
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Scanner;

public class Test{
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.print("From：");
        String sourcePath = scanner.nextLine();
        System.out.print("To：");
        String newPath = scanner.nextLine();
        copyDir(sourcePath, newPath);
    }
    
    //文件夾的拷貝
    public static void copyDir(String sourcePath, String newPath) {
        File start = new File(sourcePath);
        File end = new File(newPath);
        String[] filePath = start.list();       //獲取該文件夾下的所有文件以及目錄的名字
        if(!end.exists()) {
            end.mkdir();
        }
        for(String temp:filePath) {
            //查看其數組中每一個是文件還是文件夾
            if(new File(sourcePath+File.separator+temp).isDirectory()) {
                //為文件夾，進行遞歸
                copyDir(sourcePath+File.separator+temp, newPath+File.separator+temp);
            }else {
                //為文件則進行拷貝
                copyFile(sourcePath+File.separator+temp, newPath+File.separator+temp);
            }
        }
    }
    
    //文件的拷貝
    public static void copyFile(String sourcePath, String newPath) {
        File start = new File(sourcePath);
        File end = new File(newPath);
        try(BufferedInputStream bis=new BufferedInputStream(new FileInputStream(start));
            BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream(end))) {
            int len = 0;
            byte[] flush = new byte[1024];
            while((len=bis.read(flush)) != -1) {
                bos.write(flush, 0, len);
            }
            bos.flush();
        }catch(FileNotFoundException e) {
            e.printStackTrace();
        }catch(IOException e) {
            e.printStackTrace();
        }
    }
}

 

 

 

day17

   ·字符緩沖流

字符緩沖流：只是用來提高讀或寫的效率
    緩沖流本身不具備讀或寫的功能
    使用緩沖流必須結合着讀流或寫流

純粹來提高效率的

字符輸入緩沖流：BufferedReader 就只有一個特殊的方法，String readLine();   讀一行，返回的一行字符不包括換行符

字符輸出緩沖流：BufferedWriter 就只有一個特殊的方法，void newLine()   換行

    ·字符緩沖流文本寫入數據-BufferedWriter

import java.io.*;
class Demo1 {
    public static void main(String[] args)throws IOException{
        //使用緩沖流向文本文件中寫入數據  FileWriter（具備寫入功能的流類）

        //1.因為緩沖流不具備寫入的功能，所以需要先創建FileWriter對象
        FileWriter fw = new FileWriter("tt.txt");

        //2.為了提高FileWriter對象fw 寫入的效率，創建輸出緩沖流對象
        //BufferedWriter(Writer out) 
        BufferedWriter bw=new BufferedWriter(fw);

        for(int i=1;i<=5;i++){
           bw.write("java"+i);
           bw.newLine();//跨平台的寫入換行符  
           bw.flush();
        }
        bw.close();
    }
    public static void sop(Object obj){
        System.out.println(obj);
    }
}

   ·字符緩沖讀取文本數據-BufferReader

import java.io.*;
class Demo2 {
    public static void main(String[] args)throws IOException{
        //使用緩沖流讀取文本文件

        //1.因為緩沖流不具備讀取的功能，所以需要先創建FileReader對象
        FileReader fr = new FileReader("tt.txt");

        //2.為了提高FileReader對象fr 讀的效率，創建輸入緩沖流對象
        //  BufferedReader(Reader in) 
        BufferedReader br=new BufferedReader(fr);
        String line = null;

        while((line=br.readLine())!=null){//返回的一行字符不包括換行符
        
              System.out.println(line);
        }

        br.close();//關閉緩沖流就是關閉文件讀取流
    }
}

 

   ·字符緩沖流文件的復制

import java.io.*;
class Demo5 {
    public static void main(String[] args){
        //使用緩沖流實現文件的復制
        BufferedReader br=null;
        BufferedWriter bw = null;
        try{
               br=new BufferedReader(new FileReader("Demo3.java"));
               bw=new BufferedWriter(new FileWriter("Demo3_copy.java"));

               String line=null;
               while((line=br.readLine())!=null){
                  bw.write(line);
                  bw.newLine();//加入換行
               }    
        }catch (IOException e){
            e.printStackTrace();
        }finally{
            try{
                if(br!=null)
                    br.close();
            }
            catch (IOException ee){
                throw new RuntimeException("文件讀取流關閉失敗");
            }
            try{
                if(bw!=null)
                    bw.close();
            }
            catch (IOException ee){
                throw new RuntimeException("文件寫入流關閉失敗");
            }
        }
    }
    public static void sop(Object obj){
        System.out.println(obj);
    }
}

   ·字節流

字節流：可以操作任何類型的數據
InputStream
OutputStream

import java.io.*;
/*
字節流：可以操作任何類型的數據
InputStream
OutputStream
*/
class Demo8 {
    public static void main(String[] args)throws IOException{
        //writeFile();
        //readFile();
        //readFile2();
        fun();
    }
    public static void fun()throws IOException{
         //int available() 
         FileInputStream fis = new FileInputStream("temp.txt");
         int n = fis.available();//得到總的字節數 3
         byte[] arr=new byte[n];//創建一個和文件大小相同的字節數組，不用循環讀取了
         int num = fis.read(arr);
         sop(new String(arr,0,num));
    }

    public static void readFile2()throws IOException{
       //int read(byte[] b) 返回的是讀取的字節的個數
       
       FileInputStream fis = new FileInputStream("temp.txt");
       int num;
       byte[] arr=new byte[1024];

       while((num=fis.read(arr))!=-1){
           System.out.println(new String(arr,0,num));    
        }
       fis.close();
    }

    //從文件中讀取數據
    public static void readFile()throws IOException{
       FileInputStream fis = new FileInputStream("temp.txt");
       //int read()  一次讀一個字節
       int num;
       while((num=fis.read())!=-1){
         System.out.print((char)num);
       }
       fis.close();    
    }

    //向文件中寫入數據
    public static void writeFile()throws IOException{
       FileOutputStream  fos = new FileOutputStream("temp.txt");
       fos.write("abc".getBytes());//byte[] getBytes()
       fos.close();
    }
    public static void sop(Object obj){
        System.out.println(obj);
    }
}

   ·字節流復制文件

import java.io.*;
class Demo9 {
    public static void main(String[] args)throws IOException{
        //復制一張圖片
        FileInputStream fis =new FileInputStream("m.jpg");
        FileOutputStream fos =new FileOutputStream("m_copy.jpg");

        int num;
        while((num=fis.read())!=-1){
           fos.write(num);
        }

        fis.close();
        fos.close();
    }
    public static void sop(Object obj){
        System.out.println(obj);
    }
}

   ·緩沖字節流

import java.io.*;
class Demo10 {
    public static void main(String[] args){
        //使用字節緩沖流實現圖片復制
        BufferedInputStream bis = null;
        BufferedOutputStream bos =null;
        try{
            bis = new BufferedInputStream(new FileInputStream("m.jpg"));
            bos= new BufferedOutputStream(new FileOutputStream("mm.jpg"));

            byte[] arr=new byte[1024];
            int num=0;

            while((num=bis.read(arr))!=-1){
               bos.write(arr,0,num);
            }    
        }catch (IOException e){
            e.printStackTrace();
        }finally{
            if(bis!=null)
                try{
                    bis.close();
                }
                catch (IOException ee){
                    throw new RuntimeException("字節緩沖讀取流關閉失敗");
                }
            if(bos!=null)
                try{
                    bos.close();
                }
                catch (IOException ee){
                    throw new RuntimeException("字節緩沖寫入流關閉失敗");
                }
        }
    }
    public static void sop(Object obj){
        System.out.println(obj);
    }
}

    ·轉換流

import java.io.*;

/*

使用System.in實現一次讀一行的功能，代碼實現很麻煩

代碼實現和BufferedReader的readLine()方法的代碼實現類似

能不能使用 BufferedReader的readLine()方法實現鍵盤輸入

System.in        InputStream  字節輸入流

BufferedReader   Reader       字符輸入流


轉換流：把字節流轉成字符流

InputStreamReader：是從字節流到字符流的橋

OutputStreamWriter:
*/
class Demo12 {
    public static void main(String[] args) throws IOException{
        InputStream  in = System.in;//字節輸入流

        InputStreamReader ir = new InputStreamReader(in);//轉換流

        BufferedReader  br = new BufferedReader(ir);

        PrintStream  out=System.out;//字節輸出流

        OutputStreamWriter os=new OutputStreamWriter(out);

        BufferedWriter bw = new BufferedWriter(os);

        
        String line=null;

        while((line=br.readLine())!=null)//讀鍵盤讀不到null
        {
             if("over".equals(line))
                 break;
             bw.write(line);
             bw.newLine();
             bw.flush();
             //System.out.println(line);
        }
       br.close();
    }
}

day18

   ·File文件流

把文件和文件夾面向對象的描述類
  createNewFile()
  mkDir()
  isFile()
  isDirectory()
  getName()
  getPath()
  getAbsolutePath()
  lastModified()
  File[] listFiles()
  delete()

import java.io.*;
import java.util.*;
import java.text.*;
class Demo2 {
    public static void main(String[] args)throws IOException {
        // File: 把文件和文件夾面向對象的描述類

        //File(String pathname) 
        File f1=new File("e:\\1905\\day18\\Demo1.java");


        //File(String parent, String child) 
        File f2=new File("e:\\1905\\day18","Demo1.java");

        //File(File parent, String child) 
        File ff =new File("e:\\1905\\day18");
        File f3=new File(ff,"Demo1.java");


        //method1();
        method2();
    }
    public static void method2(){
        File file = new File("test.txt");

        sop(file.getName());//得到文件名
        sop(file.getPath());
        sop(file.getParent());
        sop(file.getAbsolutePath());//得到絕對路徑（全路徑）

        //long lastModified()  
        sop(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date(file.lastModified())));//得到的是最后一次修改時間

        sop(file.delete());
    }

    public static void method1()throws IOException{
        File file1 = new File("f:\\hehe.txt");
        File file = new File("f:\\haha");

        if(!file.exists())
            //file.createNewFile();//創建文件
            file.mkdir();//創建文件夾

       sop(file1.isFile());//判斷是不是文件 true

       sop(file.isDirectory());//判斷是不是文件夾

       sop(file.isHidden());
    }
    public static void sop(Object obj){
       System.out.println(obj);
    }
}

   ·獲取文件夾中的文件目錄：String[] list()     File[] listFiles()

import java.io.*;
class Demo3 {
    public static void main(String[] args) throws IOException {

        //String[] list()
        
        File file=new File("e:\\1905\\day17");

        /*
        String[] arr = file.list();//得到某個文件夾下的所有的目錄內容
        for(String str:arr){
           sop(str);
        }*/

        //File[] listFiles() 
        
        File[] arr=file.listFiles();//得到某個文件夾下的所有的帶絕對路徑的內容
        for(File ff:arr){
            sop(ff);
        }

        //File[] listRoots() 
        /*
        File[] arr = File.listRoots();//
        for(File file:arr){
          sop(file);
        }*/
    }
    public static void sop(Object obj){
       System.out.println(obj);
    }
}

   ·以...結尾的文件判斷

import java.io.*;
/*
class FilterByName implements FilenameFilter{
    private String ends;

    FilterByName(){}

    FilterByName(String ends){
       this.ends=ends;
    }
    public boolean accept(File dir, String name)  {
         if(name.endsWith(ends))
              return true;
         else
             return false;
    }
}*/
class Demo4 {
    public static void main(String[] args) throws IOException {
        File dir = new File("e:\\1905\\day17");

        File[] arr = dir.listFiles(new FilenameFilter(){
            
            public boolean accept(File dir, String name)  {
                 if(name.endsWith(".txt"))
                      return true;
                 else
                     return false;
            }
        });
        for(File ff:arr){
            sop(ff.getName());
        }
        /*
        File [] arr = dir.listFiles(new FilterByName(".txt"));

        for(File ff:arr){
            sop(ff.getName());
        }
        */
    }
    public static void sop(Object obj){
       System.out.println(obj);
    }
}

   ·遞歸

函數自己調用自己

//遞歸：函數自己調用自己,當函數調用次數太多的時候，容易內存溢出
class Demo5 {
    public static void main(String[] args) {
        int n = sum(3);
        System.out.println(n);
    }
    public static int sum(int num){
        if(num==1)
            return 1;
        else
            return num+sum(--num);
    }
}

 

   ·列出某個目錄下的所有文件名，包括子目錄下的文件名

import java.io.*;
public class Test2 {
    public static void main(String[] args) throws IOException{
        //列出某個目錄下的所有內容，包括子目錄中的內容
        File dir=new File("C:\\Users\\machenike\\Desktop\\培訓\\java\\作業");
        lists(dir);
    }
    //列出某個目錄下的所有內容，包括子目錄中的內容
    public static void lists(File dir){
        System.out.println("dir:"+dir);

        File[] ff=dir.listFiles();

        for(File file:ff){
            if(file.isDirectory()){
                lists(file);
            }else
                System.out.println("file:"+file);
        }
    }
}

   ·刪除某個目錄下的內容，包括子目錄里的內容

import java.io.*;
class Demo7 {
    public static void main(String[] args) throws IOException{
         //刪除指定目錄下的內容，包括子目錄中的內容  文件夾中的內容全部刪除，這個文件夾才能刪除

        File dir=new File("e:\\1905\\day171");
        delDir(dir);
    }
    //刪除指定目錄下的內容，包括子目錄中的內容
    public static void delDir(File dir)throws IOException{
        File[] files=dir.listFiles();
        for(File ff:files){
            if(ff.isDirectory()){
               delDir(ff);
            }else
                System.out.println(ff.getAbsolutePath()+":"+ff.delete());
        }
        System.out.println(dir.getAbsolutePath()+":"+dir.delete());
    }
}

   ·Scanner類

這個類，其實本質來說，不是一個流。它是一個瀏覽器、掃描器。可以從一個流中讀取數據，也可以直接從一個文本中讀取數據。
雖然Scanner不是一個流，在使用結束之后，也需要調用close()方法，進行關閉操作。
Scanner類也是AutoCloseable接口的實現類，因此，可以直接在try小括號中進行實例化，完成自動關閉。

package com.zqf;
import java.io.*;
import java.util.Scanner;
public class Test{
    public static void main(String[] args) throws FileNotFoundException, IOException {
        Scanner sc=new Scanner(new File("C:\\Users\\machenike\\Desktop\\a.txt"));
        while(sc.hasNextLine()) {
            
            System.out.println(sc.nextLine());
        }
    }
}

 

   ·打印流和直接輸入輸出流

package com.zqf;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.PrintStream;

//重定向輸出流: 標准輸出流可以將數據寫到控制台展示
        // 我們可以重定向標准輸出流，實現將數據寫入到某一個文件中

public class Test{
    public static void main(String[] args) throws FileNotFoundException  {
        PrintStream ps =new PrintStream(new File("C:\\Users\\machenike\\Desktop\\a.txt"));
        System.setOut(ps);
        System.out.println("你好啊");
    }
}

public class Test{
    public static void main(String[] args) throws FileNotFoundException  {
        File f=new File("C:\\Users\\machenike\\Desktop\\a.txt");
        System.setIn(new FileInputStream(f));
        Scanner sc=new Scanner(System.in);
        while(sc.hasNextLine()) {
            System.out.println(sc.nextLine());
        }
    }
}

 

 

 

 

 

   ·SequenceInputStream序列流

import java.io.*;
import java.util.*;
class Demo10 {
    public static void main(String[] args) throws IOException{
        
        //序列流：SequenceInputStream

        //Demo7,Demo8,Demo9  合並到一個新的文件中
        FileInputStream fis1 =new FileInputStream("Demo7.java");
        FileInputStream fis2 =new FileInputStream("Demo8.java");
        FileInputStream fis3 =new FileInputStream("Demo9.java");

        Vector<FileInputStream> v=new Vector<>();
        v.add(fis1);
        v.add(fis2);
        v.add(fis3);

        Enumeration en = v.elements();

        SequenceInputStream ss =new SequenceInputStream(en);

        FileOutputStream fos = new FileOutputStream("other.java",true);

        byte[] arr=new byte[1024];
        int len;
        while((len=ss.read(arr))!=-1){
           fos.write(arr,0,len);
        }
        ss.close();
        fos.close();
    }
}

   ·文件的分割

import java.io.*;
import java.util.*;
class Demo11 {
    public static void main(String[] args) throws IOException{
        //文件的分割
        File file = new File("ok.jpg");
        qieGe(file);
    }
    //文件的分割
    public static void qieGe(File file) throws IOException{
        //判斷是不是文件
        if(!file.isFile())
            return;

        //把分割出的多個文件同一放在同一個文件夾下
        File dir = new File("fenge");
        if(!dir.exists())
            dir.mkdir();

        //讀取被拆分的文件
        FileInputStream fis = new FileInputStream(file);

        FileOutputStream fos=null;

        byte[] arr=new byte[1024*1024*2];//每讀夠2M，就寫入到一個新的文件

        int len=0,num=1;
        while((len=fis.read(arr))!=-1)
        {
            fos=new FileOutputStream(new File(dir,(num++)+".suipian"));
            fos.write(arr,0,len);
        }

        //附加說明信息，說明文件的類型，說明文件的個數
        Properties pro = new Properties();
        
        String fileName=file.getName();//ok.jpg
        String ext=fileName.substring(fileName.lastIndexOf(".")+1);

        pro.setProperty("fileType",ext);//put

        pro.setProperty("fileNumber",String.valueOf(--num));

        //把集合中的說明信息寫入到文件
        //void store(OutputStream out, String comments)  
        fos=new FileOutputStream(new File(dir,"readme.txt"));
      
        pro.store(fos,"切割信息說明");//集合會把自己的鍵值對通過輸出流對象寫入到文件

        fis.close();
        fos.close();  
    }
}

   ·Serializable   序列化接口

對象的序列化：向文件中寫入對象

對象的反序列化：從文件中讀取對象

注意：如果需要序列化多個對象到本地，可以將這多個對象放到一個集合中，直接將這個集合序列化到本地即可。此時要求集合中的元素對應的類，必須實現Serializable接口。
誤區: 序列化的文件中，不要同時存儲多個對象的信息。

import java.io.*;
class Person  implements Serializable  //序列化接口 java.io.NotSerializableException: Person
{
    static final long serialVersionUID = 42L; //建議自己定義UID

    private   transient String name;  //瞬態 不參與序列化     //-6731926871520872939 52943123420856159
    private int age;

    Person(){}
    Person(String name,int age){
       this.name=name;
       this.age=age;
    }

    public String getName(){
       return name;
    }
    public int getAge(){
      return age;
    }
   
    public String toString(){
       return name+","+age;
    }
}
class Demo12 {
    public static void main(String[] args)throws IOException, ClassNotFoundException {
        // ObjectOutputStream  ObjectInputStream
        writeObj();

        readObj();
    }

    //從文件中讀取對象--反序列化(依據Person.class)
    public static void readObj()throws IOException, ClassNotFoundException{
        ObjectInputStream ois=new ObjectInputStream(new FileInputStream("object.txt"));
        
        //Object readObject()  
        Person ren=(Person)ois.readObject();////-6731926871520872939 Person.class

        System.out.println(ren.getName()+","+ren.getAge());
    }

    //向文件中寫入對象
    //輸出對象---對象的序列化(要求：對象所屬的類必須實現 Serializable接口)
    public static void writeObj()throws IOException {
        ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("object.txt"));
        
        oos.writeObject(new Person("李四",28));//-6731926871520872939

        oos.close();
    }
}

   ·RandomAccessFile隨機訪問流

隨機訪問流
                      只能訪問文件
       　　　　 內部既有字節輸入流，也有字節輸出流
                       內部使用了數組，使用指針實現隨機訪問

 

可以使用指針

import java.io.*;
class Demo13 {
    public static void main(String[] args) throws IOException,FileNotFoundException{
         //writeFile();
         readFile();
    }

    public static void readFile()throws FileNotFoundException,IOException{
       RandomAccessFile rf =new RandomAccessFile("random.txt","r");

       //默認從文件開頭開始讀
       byte[] arr=new byte[4];
       int len=rf.read(arr);

       int age=rf.readInt();
       System.out.print(new String(arr,0,len)+","+age);

       rf.seek(16);
       len = rf.read(arr);
       age=rf.readInt();

       System.out.print(new String(arr,0,len)+","+age);
    }

    public static void writeFile()throws FileNotFoundException,IOException{
       RandomAccessFile rf =new RandomAccessFile("random.txt","rw");
       
       //默認從文件的開頭開始寫入
        rf.write("趙四".getBytes());
        rf.writeInt(48);

        //獲取指針指向的位置  long getFilePointer()  

        long num = rf.getFilePointer();//8
        System.out.println(num);

        rf.seek(16);//控制指針指向的位置

        rf.write("劉能".getBytes());
        rf.writeInt(58);

        num = rf.getFilePointer();//24
        System.out.println(num);

        rf.close();
    }
}

 day19

   ·內存流

ByteArrayInputStream:從內存中讀     ByteArrayInputStream(byte[] buf)
ByteArrayOutputStream：向內存中寫   ByteArrayOutputStream() 該類內部有一個字節數組，把數據寫入到內部的字節數組

import java.io.*;
class  Demo1{
    public static void main(String[] args) throws IOException{
        //內存流: ByteArrayInputStream:從內存中讀     ByteArrayInputStream(byte[] buf) 
        
        //        ByteArrayOutputStream：向內存中寫   ByteArrayOutputStream() 該類內部有一個字節數組，把數據寫入到內部的字節數組

         byte[] arr = "owieuroeuroeir".getBytes();

         ByteArrayInputStream bis =new ByteArrayInputStream(arr);
         ByteArrayOutputStream bos = new ByteArrayOutputStream();

         byte[] b=new byte[1024];
         int len=0;

         while((len=bis.read(b))!=-1){
             bos.write(b,0,len);
         }

         byte[] c = bos.toByteArray();//得到內部的字節數組
         System.out.println(new String(c));
    }
}

   ·數據字節流

import java.io.*;
class  Demo2{
    public static void main(String[] args) throws IOException{
        // DataInputStream  DataOutputStream    
        writeData();
        readData();
    }
    public static void readData()throws IOException{

        DataInputStream dis = new DataInputStream(new FileInputStream("data.txt"));

        double d = dis.readDouble();
        boolean b = dis.readBoolean();
        long l=dis.readLong();

        System.out.println(d+","+b+","+l);
    }
    public static void writeData()throws IOException{
       DataOutputStream  dos = new DataOutputStream(new FileOutputStream("data.txt"));

       dos.writeDouble(6.66);
       dos.writeBoolean(false);
       dos.writeLong(77);

       dos.close();
    }
}

 

   ·轉換流設置編碼

import java.io.*;
class  Demo3{
    public static void main(String[] args) throws IOException{
        //轉換流可以設置編碼
        //writeFile();
        readFile();
    }
    public static void readFile()throws IOException{
        InputStreamReader isr = new InputStreamReader(new FileInputStream("utf.txt"),"GBK");

        char[] arr=new char[10];// char ch;
        int num = isr.read(arr);
        System.out.println(new String(arr,0,num));    
    }
    public static void writeFile()throws IOException{
        //平台默認編碼是GBK
        OutputStreamWriter isr = new OutputStreamWriter(new FileOutputStream("utf.txt"),"UTF-8");

        isr.write("你好");
        isr.close();   
    }
}

import java.util.*;
/*
編碼：把字符轉成字節
      byte[] getBytes() 
             使用平台的默認字符集將此 String編碼為字節序列，將結果存儲到新的字節數組中。  
      byte[] getBytes(Charset charset) 
             使用給定的charset將該String編碼為字節序列，將結果存儲到新的字節數組中。

解碼：把字節轉成字符
      String(byte[] bytes) 
             通過使用平台的默認字符集解碼指定的字節數組來構造新的 String 。 
      String(byte[] bytes, Charset charset) 
             構造一個新的String由指定用指定的字節的數組解碼charset 。 
*/
class  Demo4{
    public static void main(String[] args)throws Exception {

         byte[] arr = "你好".getBytes();  //編碼 [-60, -29, -70, -61]

        System.out.println(Arrays.toString(arr));

        System.out.println(new String(arr));//解碼


         arr = "你好".getBytes("UTF-8");  //編碼 [-28, -67, -96, -27, -91, -67]

        System.out.println(Arrays.toString(arr));

        System.out.println(new String(arr,"UTF-8"));//解碼

        //解碼用的碼要和編碼用的碼一致，否則亂碼

        //編碼編對了，解碼解錯了，處理方式：再編碼，再解碼

        byte[] b="你好".getBytes();//GBK編碼

        String str=new String(b,"ISO8859-1");//解碼 ????
        
        System.out.println(str);

        byte[] c=str.getBytes("ISO8859-1"); //再編碼

        str=new String(c);//再解碼

        System.out.println(str);    
    }
}

   ·進程與線程

/*
進程：
     正在進行中的程序
     也就是在內存中開辟的一塊空間

線程：負責程序執行的一條執行路徑
      也稱為一個執行單元
      進程的執行實際上是線程在執行
      一個進程至少包括一個線程
      如果一個進程包括多個線程，那么就是多線程程序了

多線程實現了同時執行的效果，多個線程在互相爭搶cpu，誰搶到誰執行，直到
線程把自己的代碼全部執行完，線程結束

多線程一定能提高效率嗎？不一定，但是能合理的利用cpu資源，關鍵是實現了
不同功能或相同功能的同時執行的效果 

java程序是多線程程序嗎？
有一個負責程序正常執行的線程，主線程---》執行的是main方法中的代碼
有一個負責垃圾回收的線程，垃圾回收線程 --》執行的是finalize方法中的代碼

任務：線程執行的代碼
      任務代碼都有其存放位置

      主線程的任務代碼在main方法中
      垃圾回收線程的任務代碼在finalize方法中

線程是隨着任務的存在而存在，隨着任務的執行結束而結束
*/
//垃圾回收的功能定義在Object中   void  finalize()
class Test{
    public void finalize(){
       System.out.println("被回收了...");
    }
}
class Demo5 {
    public static void main(String[] args){ //一個程序至少會有一個線程：主線程，主線程負責執行main中的代碼
           new Test();  //new Test().finalize()
           new Test();
           new Test();  //垃圾回收線程執行的垃圾回收的代碼，任何一個對象都能被回收

           System.gc();//主線程執行完這行代碼，說明主線程和垃圾回收線程掙搶cpu

           System.out.println("hello");    
    }
}

   ·線程創建一

/*
張三和李四同時show：

給張三創建一個線程
給李四創建一個線程

創建線程的方式：

1 創建一個Thread的子類
2.該子類重寫run方法
    創建線程是為了執行任務，任務需要有存放位置
    run方法就是任務代碼的存放位置
3.創建子類的對象
4.啟動 start()：
     具備啟動線程的功能
     啟動的線程當得到cpu時會去執行run方法中的任務代碼



public static void main(String[] args) //主線程
    {
           Thread t1=new Thread();
           Thread t2=new Thread();

           t1.start();
           t2.start();

           Thread 類中的run方法沒有實現任何功能，任務代碼又必須寫在run方法中
           只能是繼承Thread類，重寫run方法
    }
*/
class Test extends Thread{
    private String name;
    Test(){}
    Test(String name){
       this.name=name;
    }
    public void run(){//該方法中寫的是子線程的任務代碼
       for(int i=1;i<=10;i++){                           //子線程的名字： Thread-編號  編號從0開始
            System.out.println(Thread.currentThread().getName()+":"+name+"......show"+i);
        }
    }
}
class Demo6 {
    public static void main(String[] args){ //主線程

        Test t1=new Test("張三");//創建了一個線程  子線程
        Test t2=new Test("李四");//創建了一個線程

        t1.start();
        t2.start();

        System.out.println(Thread.currentThread().getName());//main
    }
}

   ·線程間異常互不影響

//每個線程發生異常只是這個線程自己的事兒，不會影響其它線程
class Test extends Thread{
    private String name;
    Test(){}
    Test(String name){
       this.name=name;
    }
    public void run(){
        //int[] arr=new int[5];
       for(int i=1;i<=10;i++){       
            //System.out.println(arr[5]);
            System.out.println(Thread.currentThread().getName()+":"+name+"......show"+i);
        }
    }
}
class Demo7{
    public static void main(String[] args) {
        Test t1=new Test("張三");
        Test t2=new Test("李四");

        t1.start();
        t2.start();

        //System.out.println(5/0);
        System.out.println(Thread.currentThread().getName());
    }
}

   ·線程狀態

 day20

   ·創建線程第二種方法（常用）

/*

四個窗口同時賣票：

因為是同時所以使用多線程
創建四個線程，每個線程的任務都是賣票
因為都是賣票，所以只需要創建一個繼承Thread的子類

創建四個線程，出現了200張票，所以需要把票修飾為static的

並不是每個成員變量都適合修飾為static，那么在不使用static的情況下怎么讓
4個線程共享50張票？

創建線程的第二種方式：

1: 定義一個類實現Runnable接口
2：子類重寫run方法
3：創建子類的對象
4：創建Thread對象，同時把子類對象作為參數傳遞給Thread對象
*/

//定義任務類：把任務面向對象，這個任務類和線程沒關系
//線程執行什么任務不再重要了，只要是實現了Runnable接口的子類對象都可以作為參數傳遞給線程對象
//這種方式更面向對象，任務有任務類，線程有線程類，把線程執行的任務作為參數傳遞給線程

//實現接口的同時還可以再繼承其它類
class Ticket implements Runnable//extends Thread{
    private  int num=50;
    //任務：賣票
    public void run(){
        while(true){
            if(num>0){
                System.out.println(Thread.currentThread().getName()+"...sale..."+num--);
            }
        }
    }
}
class Demo2 {
    public static void main(String[] args) {
        Ticket t=new Ticket();//任務對象
        
        Thread t1=new Thread(t);//線程對象，創建一個線程
        Thread t2=new Thread(t);
        Thread t3=new Thread(t);
        Thread t4=new Thread(t);
        t1.start();t2.start();t3.start();t4.start()    
    }

 

   ·多線程安全   鎖機制 同步synchronized

/*
多線程程序的安全問題：
          因為每個線程再次搶到cpu，直接執行后邊的代碼，所以會出現0,-1,-2

          出現安全問題的原因：
          1：多個線程用到了共享數據
          2:操作共享數據的語句有多條，當操作共享數據的多條語句還沒執行完就被搶走了cpu

          解決方式：一個線程在執行操作共享數據的多條語句時，只有全部執行完這多條語句其它線程才能執行

          同步代碼塊:
          synchronized(對象){
              需要被同步的代碼（操作共享數據的多條語句）
          }

          使用同步代碼塊解決了安全問題：
                同時程序性能會降低，因為需要獲取鎖，釋放鎖，沒有拿到鎖的線程還得反復的判斷鎖
*/
class Ticket implements Runnable
{
    private  int num=50;
    private Object obj = new Object();

    public void run()//throws InterruptedException//重寫的方法，需要和父類中的方法一致
    {
        while(true)
        {
            synchronized(obj)//獲取鎖：鎖可以是任意對象
            {
                if(num>0)
                {
                    //睡眠的線程放棄cpu了,睡眠的線程不會釋放鎖
                    try{Thread.sleep(10);}catch(InterruptedException e){e.printStackTrace();}
                    System.out.println(Thread.currentThread().getName()+"...sale..."+num--);//1 0 -1  -2
                }
            }//釋放鎖
        }
    }
}

class Demo4 
{
    public static void main(String[] args) 
    {
        Ticket t=new Ticket();
        
        Thread t1=new Thread(t);
        Thread t2=new Thread(t);
        Thread t3=new Thread(t);
        Thread t4=new Thread(t);

        t1.start();t2.start();t3.start();t4.start();
        
    }
}

 

 

   ·設計一個死鎖

package com.zqf;

public class Test {
    public static void main(String[] args) {
        Lock l=new Lock();
        Lock2 l2=new Lock2();
        Thread A=new Thread(l);
        Thread B=new Thread(l2);
        A.start();B.start();
    }
}
class Lock implements Runnable{
    public void run() {
        synchronized ("A") {
            System.out.println("A線程A鎖已經獲得，等B鎖");
            synchronized ("B") {
                System.out.println("A線程B鎖也獲得了");
                "B".notify();
            }
        }
    }    
}
class Lock2 implements Runnable{
    public void run() {
        synchronized ("B") {
            System.out.println("B線程B鎖獲得了，等A鎖");
            try {
                "B".wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
            synchronized ("A") {
                System.out.println("B線程A鎖也獲得了");            
            }
        }
    }    
}

 

   ·銀行存錢

 

public synchronized  void save(double money)//同步函數:函數中的代碼全部放在了同步代碼塊中那么該函數可以是同步函數

//這個是我自己寫的
package com.zqf;
public class Test{
    public static void main(String[] args) {
        Cun c=new Cun();
        Thread t=new Thread(c,"小明");
        Thread t2=new Thread(c,"小黃");
        t2.start();t.start();
    }
}
class Cun implements Runnable{
    int num=0;
    @Override
    public void run() {
        
            for(int i=0;i<20;i++) {
                synchronized (Cun.class) {
                num=num+100;
                System.out.println(Thread.currentThread().getName()+num);
            }
        }
        
    }
    
}

//下面為老師寫的

/*
有一個銀行，可以存錢
有兩個客戶，同時存錢，每人存3次，每次存100
*/
class Bank{
    private double sum;//總的錢數
    private Object obj = new Object();
    //存錢
    public synchronized  void save(double money)//同步函數:函數中的代碼全部放在了同步代碼塊中那么該函數可以是同步函數
    {
       // synchronized(obj)
        //{
            sum=sum+money;
            System.out.println("sum="+sum);
        //}
    }
}
//任務類
class Comstomer implements Runnable{
     private Bank bank = new Bank();
     public void run() {
        for(int i=1;i<=3;i++){
             bank.save(100);
         }
     }
}
class Demo5 {
    public static void main(String[] args) {
        Comstomer com=new Comstomer();

        Thread t1=new Thread(com);
        Thread t2=new Thread(com);

        t1.start();
        t2.start();
    }
}

   ·同步函數與異步函數的鎖

/*
 同步函數的鎖是this
 靜態同步函數：靜態進內存的時候沒有對象，只有那個字節碼，所以鎖是其所在類的字節碼
*/
class Ticket implements Runnable{
    private static int num=50;
    private Object obj = new Object();
    boolean flag=true;

    public void run(){
        if(flag){
            while(true){
                synchronized(Ticket.class)//t1 obj 字節碼也是對象
                {
                    if(num>0){                        
                        try{Thread.sleep(10);}catch(InterruptedException e){e.printStackTrace();}
                        System.out.println(Thread.currentThread().getName()+"...sale..."+num--);
                    }
                }
            }
        }else{ 
             while(true) //t2 this
                 fun();
        }
    }
    public static synchronized void fun(){
        if(num>0){        
            try{Thread.sleep(10);}catch(InterruptedException e){e.printStackTrace();}
            System.out.println(Thread.currentThread().getName()+"...sale..."+num--);
        }
    }
}
class Demo6 {
    public static void main(String[] args) {
        Ticket t=new Ticket();
        
        Thread t1=new Thread(t);
        Thread t2=new Thread(t);
        
        t1.start();

        try{Thread.sleep(10);}catch(InterruptedException e){e.printStackTrace();}
         
        t.flag=false;

        t2.start();    
    }
}

   ·單例設計模式懶漢式多線程安全問題

//單例設計模式懶漢式多線程安全問題

//餓漢式
class Single {
    private static Single s;
    private Single(){}

    public static Single getInstance(){
       synchronized(Single.class){
            if(s==null)    {  
                 try{Thread.sleep(10);}catch(InterruptedException e){e.printStackTrace();}
                 s = new Single();
            }
        }
         return s;
    }
}
class Task implements Runnable{
    public void run(){
        Single ss = Single.getInstance();
        System.out.println(ss);
    }
}
class Demo7 {
    public static void main(String[] args) {
        Task task = new Task();

        Thread t1 = new Thread(task);
        Thread t2 = new Thread(task);

        t1.start();   t2.start();
    }
}

   ·多線程通信

線程間的通信：多個線程的任務不同，但是操作的數據相同

共同操作的數據

 

wait(),notify()(喚醒一個線程),notifyAll(）（喚醒所有線程）這些方法必須使用鎖
鎖是任意的對象，說明這些方法wait(),notify(),notifyAll(）是任意對象都能方法用的方法

//線程間的通信：多個線程的任務不同，但是操作的數據相同

//共同操作的數據

/*

wait(),notify()(喚醒一個線程),notifyAll(）（喚醒所有線程）這些方法必須使用鎖
鎖是任意的對象，說明這些方法wait(),notify(),notifyAll(）是任意對象都能方法用的方法
*/
class Res{
    String name;
    String sex;
    boolean flag;
}

//實現賦值的線程的任務
class Input implements Runnable{
    private Res res;
    Input(Res res){
       this.res=res;
    }
    public void run(){
         int i=0;
         while(true){
           synchronized(res){
                //先判斷能不能賦值
                if(res.flag==true){
                    try{
                          res.wait();//等待的線程會釋放鎖
                    }catch(InterruptedException e){
                        e.printStackTrace();
                    }
                 }
                if(i==0){
                   res.name="張征";
                   res.sex="男";
                 }else{
                   res.name="王財昌";
                   res.sex="女";
                 }
                 res.flag=true;
                 res.notify();//如果沒有等待的線程則是空喚醒  
             }
            i=(i+1)%2;
         }
    }
}

//實現輸出值的線程任務
class Output implements Runnable{
    private Res res;

    Output(Res res){
       this.res=res;
    }
    public void run(){
       while(true){
           synchronized(res){
               //先判斷能不能輸出值
               if(res.flag==false){
                   try{
                          res.wait();//等待的線程會釋放鎖  讓res這個鎖上的線程去等待
                    }catch(InterruptedException e){
                        e.printStackTrace();
                    }
                }
               System.out.println(res.name+"..."+res.sex);

               res.flag=false;
               res.notify(); //喚醒res這個鎖上的線程
            }
        }
    }
}

class Demo9 {
    public static void main(String[] args) {
        //創建數據
        Res res =new Res();

        //創建賦值線程的任務對象
        Input in=new Input(res);

        //創建輸出值線程的任務對象
        Output out = new Output(res);

        //創建賦值的線程
        Thread t1 = new Thread(in);

        //創建輸出值的線程
        Thread t2 = new Thread(out);

        t1.start();
        t2.start();
    }
}

　　第二種方法：

class Res{
    private String name;
    private String sex;
    private boolean flag;

    //賦值功能
    public synchronized void set(String name,String sex){
       if(flag){
           try{
               this.wait();
           }catch(InterruptedException e){
               e.printStackTrace();
           }
        }

       this.name=name;
       this.sex=sex;

       flag=true;
       this.notify();
    }

    // 輸出值
    public synchronized void out(){
          if(!flag){
               try{
                   this.wait();
               }catch(InterruptedException e){
                   e.printStackTrace();
               }
           }
          System.out.println(name+"..."+sex);

          flag=false;
          this.notify();
    }
}

//實現賦值的線程的任務
class Input implements Runnable{
    private Res res;
    Input(Res res){
       this.res=res;
    }
    public void run(){
         int i=0;
         while(true){
                if(i==0){
                    res.set("張征","男");
                 }else{
                    res.set("王財昌","女");
                 }                
               i=(i+1)%2;
         }
    }
}

//實現輸出值的線程任務

class Output implements Runnable{
    private Res res;
    Output(Res res){
       this.res=res;
    }
    public void run(){
       while(true){
            res.out();
        }
    }
}

class Demo10{
    public static void main(String[] args) {
        //創建數據
        Res res =new Res();

        //創建賦值線程的任務對象
        Input in=new Input(res);

        //創建輸出值線程的任務對象
        Output out = new Output(res);

        //創建賦值的線程
        Thread t1 = new Thread(in);

        //創建輸出值的線程
        Thread t2 = new Thread(out);

        t1.start();
        t2.start();
    }
}

   ·消費者與生產者

//自己寫的
package com.zqf;

import com.sun.swing.internal.plaf.synth.resources.synth;

public class Test2{
    public static void main(String[] args) {
        Product p=new Product();
        ShengChan sc=new ShengChan(p);
        XiaoFei xf=new XiaoFei(p);
        Thread t=new Thread(sc,"商家");
        Thread tw=new Thread(xf,"買家");
        t.start();tw.start();
    }
}
class Product{
    private String name;
    private int count=0;
    private boolean flag;
    public Product() {
        super();
    }
    public Product(String name, int count) {
        super();
        this.name = name;
        this.count = count;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getCount() {
        return count;
    }
    public void setCount(int count) {
        this.count = count;
    }
    @Override
    public String toString() {
        return "Product [name=" + name + ", count=" + count + "]";
    }
    
    public synchronized void sheng(String name) {
        if(flag==true) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }else {
            this.name=name;
            count+=1;
            System.out.println(Thread.currentThread().getName()+"---生產---"+name+"有"+count);
            flag=true;
            this.notify();
        }
    }
    public synchronized void xiao() {
        if(flag==false) {
            try {
                this.wait();
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }else {
            System.out.println(Thread.currentThread().getName()+"---消費---"+name+"有"+count);
            flag=false;
            this.notify();
        }
    }
}
class ShengChan implements Runnable{
    private Product p;
    public ShengChan(Product p) {
        super();
        this.p = p;
    }
    public  void run() {
        while(true) {
            p.sheng("哆啦A夢");
        }
    }    
}
class XiaoFei implements Runnable{
    private Product p;
    public XiaoFei(Product p) {
        super();
        this.p = p;
    }
    public  void run() {
        while(true) {
            p.xiao();
        }
    }    
}

 

/*
生產者消費者問題

生產者負責生產
消費者負責消費

生產者有生產任務
消費者有消費任務

需要定義生產任務
需要定義消費任務

還需要定義產品
*/
class Product {
    private String name;
    private int count;
    private boolean flag;

    //生產功能
    public synchronized void produce(String name){
         if(flag==true)
             try{this.wait();}catch(InterruptedException e){e.printStackTrace();}

         this.name=name+"..."+count;
         count++;

         System.out.println(Thread.currentThread().getName()+"...生產了..."+this.name);

          flag=true;
          this.notify();
    }
    //消費功能

    public  synchronized void consume(){
        if(!flag)
           try{this.wait();}catch(InterruptedException e){e.printStackTrace();}
        
        System.out.println(Thread.currentThread().getName()+"...消費了..."+this.name);

        flag=false;
        this.notify();
    }
    
}

//生產任務
class Produce implements Runnable{
     private Product  pro;

     Produce(Product pro){
        this.pro = pro;
     }

     public void run(){
        while(true){
           pro.produce("筆記本");
         }
     }
}

class Consume implements Runnable{
     private Product  pro;

     Consume(Product pro){
        this.pro = pro;
     }

     public void run(){
        while(true){
            pro.consume();
         }
     }
}

class Demo11 {
    public static void main(String[] args) {
        Product pro = new Product();

        Produce produce = new Produce(pro);

        Consume consume = new Consume(pro);

        Thread t1 = new Thread(produce);
        Thread t2 = new Thread(consume);

        t1.start();
        t2.start();
    }
}

 

   ·線程池

　　線程池，可以理解為是一個容器，存儲線程對象。
　　當我們需要開辟一個線程的時候，就去開辟一個新的線程。當這個線程使用結束之后，這個線程就會被銷毀。然后再使用到線程的時候，再去開辟新的線程。這樣的過程，對CPU來講，是一種消耗。
 　   線程池，最核心的原理是“復用”。當我們需要使用到一個線程的時候，從線程池中獲取；如果線程池中沒有線程，此時再去實例化新的線程。當一個線程使用結束之后，再把這個線程不是銷毀掉，而是放入線程池，以便下次繼續使用。

public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              RejectedExecutionHandler handler)

在上述的構造方法中，有幾個參數說明:

int corePoolSize: 核心池的大小。
int maximumPoolSize: 線程池中最多有多少線程。（包括核心線程和臨時開辟的線程）
long keepAliveTime: 臨時開辟的線程最多可以空閑的時間。
TimeUnit unit: 空閑時間的單位。
BlockingQueue<Runnable> workQueue: 任務的等待隊列。
    ArrayBlockingQueue、LinkedBlockingQueue、SynchronousQueue
RejectedExecutionHandler handler: 拒絕訪問策略。
    AbortPolicy                : 丟棄新的任務，並拋出異常 RejectedExecutionException
    DiscardPolicy            : 丟棄新的任務，但是不拋出異常
    DiscardOldestPolicy        : 丟棄等待隊列中最早的任務
    CallerRunsPolicy        : 不會開辟新的線程，由當前線程執行這個任務

注意事項:
 在使用線程池的時候，不需要我們手動的開辟線程。在使用線程池的時候，需要注意的地方，就是任務的處理。在線程池中有一個方法 execute(Runnable r) ，往線程池中添加任務。線程池內部的線程開辟與銷毀由自己處理，與我們無關。

execute(Runnable r)：向線程池中添加任務，線程池會自動的分配線程去處理這個任務。

shutdown()：停止線程池。
　　　　 線程池的停止，是需要我們手動關閉的。而且，這個方法並不是立即停止掉線程池。
　　　　 如果線程池中還有線程在處理任務，此時這個方法不會讓線程池立即停止，而是發出一個停止的信號。等這個線程處理完了任務，線程池才會終止。

 shutdowNow(): 立刻停止線程池。

 

   ·使用工具類獲取線程池

工具類：Executors

// 1、獲取一個線程池，這個線程池中只有一個核心線程，等待隊列中的任務數量是 Integer.MAX_VALUE
ExecutorService executor1 = Executors.newSingleThreadExecutor();
executor1.submit(new MyTask(1));
executor1.shutdown();

// 2、獲取一個線程池，這個線程池中有指定數量的核心線程和最大線程，等待隊列中的任務數量是 Integer.MAX_VALUE
ExecutorService executor2 = Executors.newFixedThreadPool(5);
executor2.submit(new MyTask(1));        
executor2.submit(new MyTask(2));        
executor2.submit(new MyTask(3));        
executor2.submit(new MyTask(4));        
executor2.submit(new MyTask(5));        
executor2.submit(new MyTask(6));        

executor2.shutdown();

// 3、獲取一個線程池，這個線程池中沒有核心線程，有Integer.MAX_VALUE數量的臨時線程
ExecutorService executor3 = Executors.newCachedThreadPool();
executor3.submit(new MyTask(1));        
executor3.submit(new MyTask(2));        
executor3.submit(new MyTask(3));        
executor3.submit(new MyTask(4));        
executor3.submit(new MyTask(5));        
executor3.submit(new MyTask(6));

        executor3.shutdown();

 

   ·線程池的應用

package com.zqf;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Test {
    public static void main(String[] args) {
        // 1、實例化一個線程池對象
        /*
         public ThreadPoolExecutor(int corePoolSize,
                              int maximumPoolSize,
                              long keepAliveTime,
                              TimeUnit unit,
                              BlockingQueue<Runnable> workQueue,
                              RejectedExecutionHandler handler)
         */
        ThreadPoolExecutor pool = new ThreadPoolExecutor(5, 
                                                         10, 
                                                         1, 
                                                         TimeUnit.SECONDS, 
                                                         new ArrayBlockingQueue<>(5), 
                                                         new ThreadPoolExecutor.CallerRunsPolicy());
        
        // 線程池屬性的設置:
        // pool.setCorePoolSize(5);
        // pool.setMaximumPoolSize(10);
        // pool.setKeepAliveTime(2, TimeUnit.DAYS);
        // pool.setRejectedExecutionHandler(handler);
        
        for (int i = 0; i < 16; i++) {
            // 往線程池中添加任務
            pool.execute(new MyTask(i));
        }
        
        // 關閉線程池
        pool.shutdown();        
        // pool.shutdownNow();
    }
}
class MyTask implements Runnable {

    private int id;
    public MyTask(int id) {
        this.id = id;
    }

    @Override
    public void run() {
        System.out.println("線程: " + Thread.currentThread().getName() + "准備處理" + id + "號任務");
        
        // 模擬任務的處理
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }    
        
        System.out.println("線程: " + Thread.currentThread().getName() + "已經處理完" + id + "號任務!");
    }
}

 

 

 

 

·反射   獲取字節碼對象

 Class<?> aClass = Class.forName("com.reflect.Person");//Person.class    最常用，其它兩個了解即可

Class claz =  Person.class;

Person person = new Person();
          Class<? extends Person> claz = person.getClass();//Person.class

package com.reflect;

public class Person {
    private String name;//Field
    private int age;

    public Person() { }

    public Person(String name, int age){ //Constructor
    
        this.name = name;
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public static void ff(){
        System.out.println("hello");
    }
    public void show(){ //Method
   
        System.out.println("show");
    }
    public void fun(String name){
        System.out.println(name);
    }
    public String toString() {
        return "Person{" +"name='" + name + '\'' +", age=" + age +'}';
    }
}

package com.reflect;

public class Demo1 {
    //反射:動態獲取字節碼對象，並對其執行
    public static void main(String[] args) throws ClassNotFoundException{
        // m1();
         //m2();
         //m3();
    }
    /*
    // alt+enter   alt+insert
    public static void m3() throws ClassNotFoundException{    //static Class<?>    forName(String className)
        Class<?> aClass = Class.forName("com.reflect.Person");//Person.class
        Class<?> aClass2 = Class.forName("com.reflect.Person");
        System.out.println(aClass==aClass2);
    }

    public static void m2(){
        //每種數據類型都有一個class類型的屬性，這個屬性得到的就是字節碼對象
        Class claz =  Person.class;
        Class claz2 = Person.class;
        System.out.println(claz==claz2);
    }

    //得到Person.class   Class<?>  getClass()
    //這種方式需要事先創建一個Person對象
    public static void m1(){
          Person person = new Person();
          Class<? extends Person> claz = person.getClass();//Person.class
          Class<? extends Person> claz2 = person.getClass();//Person.class

           System.out.println(claz==claz2);
    }
    */
}

   ·反射   創建類對象

package com.reflect;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class Demo2 {

    //動態得到字節碼，並創建對象
    public static void main(String[] args) throws IllegalAccessException, InstantiationException, ClassNotFoundException, NoSuchMethodException, InvocationTargetException {
        m2();
    }

    public static void m2() throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        Class claz=Class.forName("com.reflect.Person");
        // 得到構造方法對應的Constructor類型的對象
       Constructor con = claz.getConstructor(String.class,int.class);

       //使用帶參數的構造方法創建對象 newInstance(Object... initargs)
        Object obj = con.newInstance("李四", 20);

        System.out.println(obj);
    }

    public static void m1() throws ClassNotFoundException, IllegalAccessException, InstantiationException {

        Class claz=Class.forName("com.reflect.Person");//Person.class

        //創建對象  Person ren = new Person();

        Person o = (Person) claz.newInstance();//使用的空參的構造方法，使用Class類提供的newInstance()方法創建對象

        System.out.println(o);
    }
}

   ·反射   獲取屬性並賦值

package com.reflect;
import java.lang.reflect.Field;
public class Demo3 {
    //動態得到字節碼對象，並給屬性賦值
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException, InstantiationException {

        Class claz=Class.forName("com.reflect.Person");

        //給name屬性賦值   Field     getField(String name)

        //Field field=claz.getField("name");//只能得到public權限的屬性
        //System.out.println(field);//java.lang.NoSuchFieldException: name
       Field field= claz.getDeclaredField("name");

       //void set(Object obj, Object value)
        //name是非靜態屬性，必須通過對象來賦值
        Person obj=(Person)claz.newInstance();

        //void setAccessible(boolean flag)
        field.setAccessible(true);// 設置為可訪問的
        field.set(obj,"張三");

        System.out.println(obj);
    }
}

   ·反射   獲取類方法並使用

package com.reflect;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class Demo4 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        m3();
    }
    public static void m3() throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        Class claz=Class.forName("com.reflect.Person");

        Method m = claz.getMethod("ff",null);

        m.invoke(null,null);
    }
    public static void m2() throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {
        Class claz=Class.forName("com.reflect.Person");

        Method m = claz.getMethod("fun",String.class);

        Person ren = (Person)claz.newInstance();

        m.invoke(ren,"呵呵");
    }
    public static void m1() throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {

        Class claz=Class.forName("com.reflect.Person");

       //getMethod(String name, Class<?>... parameterTypes) 

        Method method = claz.getMethod("show", null);

        //執行方法，這個方法是非靜態方法 invoke(Object obj, Object... args)
        Person ren = (Person)claz.newInstance();
        method.invoke(ren,null);
    }
}

 day21

   ·sql

DDL**（Data Definition Language）：數據定義語言，用來定義數據庫對象：庫、表、列等； CREATE、 ALTER、DROP

DML***（Data Manipulation Language）：數據操作語言，用來定義數據庫記錄（數據）；     INSERT、 UPDATE、 DELETE

DCL（Data Control Language）：數據控制語言，用來定義訪問權限和安全級別；grant

DQL*****（Data Query Language）：數據查詢語言，用來查詢記錄（數據）。select

 

       數據庫創建好以后，需要指定使用哪一個數據庫：use 數據庫名;

       查看當前被使用的數據庫:   select database();

       刪除數據庫: drop database 數據庫名;

 

數據庫是用表來存放數據的：在數據庫中創建表

        create table 表名(
  字段名   數據類型，
  字段名   數據類型，
  字段名   數據類型,

  。。。。
  字段名   數據類型
 );

        數據類型:
      數值型：int,tinyint,bigint

      小數: float(x,y)  double(x,y)  decimal(x,y)

      字符型: varchar(50)  實際需要的字符個數小於50，只分配需要的空間大小，

              lisi 分配4個字符的空間

       char(50)    實際需要的字符個數小於50,依然分配50個字符的空間大小

       lisi 分配50個字符的空間

       text:大文本

             日期時間類型：
              date:日期   年月日
              time：時間  時分秒 
              datetime： 日期時間類型  年月日時分秒
       timestamp：時間戳類型  年月日時分秒  2023

              二進制類型: blob

 
         查看所有表： show tables;

  修改表的時候添加字段:   alter table worker add image blob;

  修改表的時候修改字段:   alter table worker modify name varchar(60);

  修改表的時候刪除字段:   alter table worker drop age;

  修改表名: rename table worker to yuangong;

  查看創建表的sql語句： show create table 表名;

  修改表的編碼：alter table 表名 character set utf8;

  刪除表: drop table 表名;

  表的編碼默認和所在的數據庫的編碼一致

 

向表中添加記錄：一次添加一條記錄

         insert into 表名 values(數值1，數值2，。。。)

         
         向表中所有字段上添加值

  insert into yuangong  values(110,'lisi','nan','2009-12-10',120.5,'hehe');

  向表中部分字段添加值，需要把字段名列出來

  insert into yuangong(number,name,sex) values(119,'zhangsan','nv');

  注意：  數值要和表中字段在個數，順序，類型上保持一致

 

修改表中記錄:

         update 表名 set 字段名=值,字段名=值,...[where 條件]

 

刪除記錄：delete from 表名 [where 條件]

          truncate table 表名

一個網站的訪問的用戶是不能添加，修改，刪除數據的

我們從京東網站上看到的商品信息是從數據庫中查詢出來的

查詢：

 

-- 條件查詢
SELECT * FROM stu

-- 查詢性別為女，並且年齡15的記錄
SELECT * FROM stu WHERE gender='female' AND age=15

-- 查詢學號為S_1001，或者姓名為liSi的記錄
SELECT * FROM stu WHERE sid='S_1001' OR sname='liSi'

-- 查詢學號為S_1001，S_1002，S_ 1003的記錄
SELECT * FROM stu WHERE sid='S_1001' OR sid='S_1002' OR sid='S_1003'

SELECT * FROM stu WHERE sid IN('S_1001','S_1002','S_1003') 

SELECT * FROM stu WHERE sid NOT IN('S_1001','S_1002','S_1003')

-- 查詢年齡為null的記錄
SELECT * FROM stu WHERE age IS NULL  -- 查詢年齡未知的學生

-- 查詢年齡不為null的記錄 -- 查詢有年齡的學生
SELECT * FROM stu WHERE age IS NOT NULL

-- 查詢年齡在20到40之間的學生記錄
SELECT * FROM stu WHERE age>=20 AND age<=40
SELECT * FROM stu WHERE age BETWEEN 20 AND 40

-- 查詢性別非男的學生記錄
SELECT * FROM stu WHERE gender!='male'
SELECT * FROM stu WHERE gender<>'male'
SELECT * FROM stu WHERE gender='female'
SELECT * FROM stu WHERE NOT gender='male'

-- 模糊查詢

-- 查詢姓名由5個字母構成的學生記錄

   SELECT * FROM stu WHERE sname LIKE '_____'

-- 查詢姓名由5個字母構成，並且第5個字母為“i”的學生記錄
   SELECT * FROM stu WHERE sname LIKE '____i'

-- 查詢姓名以“z”開頭的學生記錄
   SELECT * FROM stu WHERE sname LIKE 'z%'

-- 查詢姓名中第2個字母為“i”的學生記錄
   SELECT * FROM stu WHERE sname LIKE '_i%'

-- 查詢姓名中包含“a”字母的學生記錄
   SELECT * FROM stu WHERE sname LIKE '%a%'

  
  
   SELECT * FROM emp

-- 去除重復 DISTINCT

   SELECT DISTINCT deptno FROM emp

-- 查雇員的月薪與佣金之和 :任何類型的數據和NUll運算，結果是NULL
   SELECT ename,sal+IFNULL(comm,0)  FROM emp

-- 給字段起別名
   SELECT ename,sal+IFNULL(comm,0) AS 總工資  FROM emp

-- 查看雇員的月薪與佣金之和
   SELECT ename,sal+IFNULL(comm,0) 總工資  FROM emp
  
  
   -- 排序  order by 字段 默認是升序排序(ASC)  降序(DESC)

SELECT * FROM stu
-- 查詢所有學生記錄，按年齡升序排序--默認是升序排序
SELECT * FROM stu ORDER BY age ASC

-- 查詢所有學生記錄，按年齡降序排序
SELECT * FROM stu ORDER BY age DESC

-- 查詢所有學生記錄，按姓名降序排序
SELECT * FROM stu ORDER BY sname DESC

SELECT * FROM emp
-- 查詢所有雇員，按月薪降序排序，如果月薪相同時，按編號升序排序
SELECT * FROM emp ORDER BY sal DESC,empno   -- 先按照前邊的字段排序，再按照后邊的字段排序

 day22

數據庫：存儲、維護和管理數據

mysql，oracle,db2,sql server屬於關系型數據庫

mysql是一個數據庫服務: 有自己占用的端口 3306 (0-65535,0-1024)

使用mysql必須保證服務是啟動的:

啟動方式：手動：到服務中找到mysql服務名，然后右擊啟動
          使用命令啟動：net start mysql     net stop mysql

 

連接到mysql  ：  
        mysql -u root -p

SQL：Structure Query Language。（結構化查詢語言）

SQL的分類：
DDL： 數據定義 create alter drop

DML:  數據操作 insert  delete  update

DCL:  數據控制

DQL:  數據查詢 select

使用mysql首先需要創建數據庫：

   create  database 數據庫名;

   show databases; 查看數據庫

   數據庫中存儲的是文本數據，所以數據庫有編碼，編碼就是在安裝mysql時設置的，查看數據庫編碼的方式如下:

        show create database d2;
 +----------+-------------------------------------------------------------+
 | Database | Create Database                                             |
 +----------+-------------------------------------------------------------+
 | d2       | CREATE DATABASE `d2` /*!40100 DEFAULT CHARACTER SET utf8 */ |
 +----------+-------------------------------------------------------------+
     
       create database d3 character set GBK;  -- 在創建數據庫時指定編碼

       show character set;  -- 查看所有編碼

       create database d4 character set gbk collate  gbk_chinese_ci;  --  設置編碼，同時設置排序方式

       alter database d4 character set utf8;  -- 修改數據庫的編碼

       --正常都使用默認的編碼和默認的排序方式

       數據庫創建好以后，需要指定使用哪一個數據庫：use 數據庫名;

       查看當前被使用的數據庫:   select database();

       刪除數據庫: drop database 數據庫名;

 

數據庫是用表來存放數據的：在數據庫中創建表

        create table 表名(
  字段名   數據類型，
  字段名   數據類型，
  字段名   數據類型,

  。。。。
  字段名   數據類型
 );

        數據類型:
      數值型：int,tinyint,bigint

      小數: float(x,y)  double(x,y)  decimal(x,y)

      字符型: varchar(50)  實際需要的字符個數小於50，只分配需要的空間大小，

              lisi 分配4個字符的空間

       char(50)    實際需要的字符個數小於50,依然分配50個字符的空間大小

       lisi 分配50個字符的空間

       text:大文本

             日期時間類型：
              date:日期   年月日
              time：時間  時分秒 
              datetime： 日期時間類型  年月日時分秒
       timestamp：時間戳類型  年月日時分秒  2023

              二進制類型: blob

 
         查看所有表： show tables;

  修改表的時候添加字段:   alter table worker add image blob;

  修改表的時候修改字段:   alter table worker modify name varchar(60);

  修改表的時候刪除字段:   alter table worker drop age;

  修改表名: rename table worker to yuangong;

  查看創建表的sql語句： show create table 表名;

  修改表的編碼：alter table 表名 character set utf8;

  刪除表: drop table 表名;

  表的編碼默認和所在的數據庫的編碼一致

 

向表中添加記錄：一次添加一條記錄

         insert into 表名 values(數值1，數值2，。。。)

         
         向表中所有字段上添加值

  insert into yuangong  values(110,'lisi','nan','2009-12-10',120.5,'hehe');

  向表中部分字段添加值，需要把字段名列出來

  insert into yuangong(number,name,sex) values(119,'zhangsan','nv');

  注意：  數值要和表中字段在個數，順序，類型上保持一致

 

修改表中記錄:

         update 表名 set 字段名=值,字段名=值,...[where 條件]

 

刪除記錄：delete from 表名 [where 條件]

          truncate table 表名

一個網站的訪問的用戶是不能添加，修改，刪除數據的

我們從京東網站上看到的商品信息是從數據庫中查詢出來的

查詢：select * from 表名

      =  !=  <>   >  >=  <  <=
      in 
      between and
      not
      and
      or
      is null
      is not null

      模糊查詢： like  適用於字符串數據   _  %

      distinct

      order by  字段 ASC DESC

 

     聚合函數：sum()  count()  avg()  max()  min()

     分組:group by

     注意: group by后邊的字段才能用在select后邊

     select 字段 .... from 表名 where 條件 order by 。。 group by  。。 having

 

數據的完整性:保證表中的數據准確可靠

     實體完整性：
                 表中的一條記錄對應一個實體，實體具備獨一無二性，那么記錄也應該是獨一無二的

                 所以在創建表的時候就得保證表中每條記錄必須是互不相同的

     實現實體完整性的三種方式:

                 主鍵：primary key   被設置為主鍵的字段上的值是不能重復的,不能為null，一個表只能有一個主鍵

   Unique(唯一約束)： 被設置為unique的字段，該字段上的值不能重復，但是可以為null

   AUTO_INCREMENT(自動增長):適合於整型字段，被設置為自動增長的字段上的值是由數據庫來生成的 這個值從1開始，每次增加1

 

     域完整性：
             域：每個字段上的值都有一個取值范圍，保證用戶添加的數據在字段的取值范圍內

             所以在創建表的時候就得保證域完整性

      create table tt(
          id int primary key,
   name varchar(20) not null,-- 默認name字段的值是可以為null的
                 sex varchar(4) default '男'
   )
     
      數據類型

      非空約束（not null）
     
      默認值約束(default)
         
     引用完整性：外鍵，一個表可以有多個外鍵

                foreign  key(字段名)  references 被引用的表(被引用的字段)

  數據庫需要維護外鍵，會增加數據庫開銷，降低性能

   

  三個完整性都是為了保證表中數據的准確可靠。

  一張表對應同一類實體
  因為實體和實體之間有關系
  所以表和表之間有關系
  關系型數據庫

  表和表之間的關系: 一對一，一對多，多對多

  多表查詢：

  1：?合並結果集；
 
       UNION
       UNION ALL

-- UNION 會去除重復的記錄
SELECT * FROM a
UNION
SELECT * FROM b

-- UNION all 不會去除重復的記錄
SELECT * FROM a
UNION ALL
SELECT * FROM b

2：?連接查詢

     內連接：  inner join

     外連接
        左外連接  left outer join
 右外連接  right outer join

3:子查詢

4：自連接

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

package com.zqf;
import java.util.*;
public class Test{
 public static void main(String[] args) {
  Set<Person> set=new TreeSet<Person>();
  set.add(new Person("zhangsan",12));
  set.add(new Person("lisi",14));
  set.add(new Person("wanger",13));
  System.out.println(set);
 }
}
class Person implements Comparable<Person>{
 private String name;
 private int age;
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public int getAge() {
  return age;
 }
 public void setAge(int age) {
  this.age = age;
 }
 public Person(String name, int age) {
  super();
  this.name = name;
  this.age = age;
 }
 public Person() {
  super();
 }
 @Override
 public String toString() {
  return "Person [name=" + name + ", age=" + age + "]";
 }
 @Override
 public int compareTo(Person p) {
  //按照年齡
/*  if(this.age>=p.age) {
   return 1;
  }else {
   return -1;
  }
*/  
  //按照姓名
  int compareTo = this.name.compareTo(p.name);
  return compareTo;
 }
}