1. 程式人生 > >Java基礎知識學習筆記總結

Java基礎知識學習筆記總結

Java學習筆記總結

java基礎複習

1、 抽象類可以有構造器,可以有一個非抽象的父類

2、 垃圾回收機制回收的是堆裡面的記憶體,棧裡面的資料自動入棧自動出棧

3、 引用型別的資料在堆當中,記憶體中操作的只有棧,new關鍵字在堆裡面分配一塊記憶體

4、 java中是值傳遞

5、 String是不可變字元,即一旦分配了記憶體,此記憶體的值將不會改變,又將String賦值是,會重新分配一塊記憶體,字串池: StringBuffer

6、 在堆中的東西叫物件

Ø  執行時異常:

    ArithmeticException  當出現異常的運算條件時,丟擲此異常。例如,一個整數“除以零”時,丟擲此類的一個例項。

   ArrayIndexOutOfBoundsException用非法索引訪問陣列時丟擲的異常。如果索引為負或大於等於陣列大小,則該索引為非法索引。

   ArrayStoreException試圖將錯誤型別的物件儲存到一個物件陣列時丟擲的異常。如:

   Objectx[] = new String[3];

   x[0]= new Integer(0);

   ClassCastException檢視將物件轉換為不是例項的子類時,丟擲該異常。如:

   Objectx = new Integer(0);

   System.out.println((String)x);

   illegalArgumentException表明向方法傳遞了一個不合法或不正確的引數

   NegativeArraySizeException如果應用程式檢視建立大小為負的陣列,則丟擲該異常

Ø  編譯時異常:

   NoSuchMethodException無法找到某一特定方法時,丟擲該異常

7、 unicode碼範圍

  漢字:[\u4e00,\u9fa5]

  數字:[0x30,0x39]

  小寫字母:[0x61,0x7a]

  大寫字母:[0x41,0x5a]

8、 final類

   final類能夠修飾非抽象類、非抽象類成員方法和變數(靜態變數、例項變數、區域性變數)

   final類不能被繼承,沒有子類

   final方法可以被繼承,但不能被子類的方法覆蓋

   final成員變量表示常量,宣告成員變數時,必須賦值(要麼在宣告的時候賦值,要麼在構造器中賦值),賦值後不能被改變

   publicfinal

int E; //final空白,必須在初始化物件的時候賦初值public Test3(int x) {
                E= x;
        }

   final不能用於修飾構造方法2.5

9、 static只能修飾成員變數,表示所有物件共享這個資料

   static能夠修飾成員變數和方法,內部類,也可以形成靜態static程式碼塊,不能修飾區域性變數

   被static修飾的成員變數可以直接用類名來呼叫,語法如下:

   類名.靜態放大名();

   類名.靜態變數名;

   靜態方法中不能用this和super關鍵字,不能直接訪問不帶static的成員變數和成員方法

   因為static方法獨立於任何例項,因此static方法必須被實現,而不能是抽象的abstract

   先執行靜態程式碼塊,再執行構造器

10、static和final一塊表示什麼

   staticfinal用來修飾成員變數和成員方法,可理解為全域性變數(java中沒有全域性變數的概念)

   staticfinal修飾變數,表示一旦給值就不可修改,並且通過類名就可以訪問

   staticfinal修飾方法,表示不可覆蓋,並可通過類名直接訪問 

   staticfinal修飾一些容器型別(ArrayList、HashMap)的變數,不可以改變容器變數本省,但可以修改容器中存放的物件

11、類成員變數分類

    被static修飾的變數叫靜態變數或者類變數;

    沒有被static修飾的變數叫例項變數。

12、命令列引數

    java主類引數(即命令列引數)

    eclipse中java輸入命令列引數,在選定的類中,點選右鍵run as—Runconfigurations—Arguments-Program arguments-Variables-選擇string_prompt

13、Integer.valueOf(String)將字串轉換成Integer包裝類

14、一個.java檔案中可以有很多類。不過注意以下幾點:  

a、public 許可權的類只能有一個(也可以一個都沒有,但最多隻有1個)

b、這個.java檔案的檔名必須是public類的類名(一般的情況下,這裡放置main方法是程式的入口。)

c、若這個檔案中沒有public的類,則檔名隨便是一個類的名字即可

d、用javac 編譯這個.java檔案的時候,它會給每一個類生成一個.class檔案

15、面向物件、面向過程

    面向物件的三大特性:封裝、繼承、多型

    面向過程:C語言的底層語言的特性

16、類和物件:

    一個類中可以有多個物件,類是對物件的描述

    一個類中的成員:

        欄位:封裝private

        方法:類的行為

    構造器:與類同名,沒有返回值。作用:初始化成員變數。預設構造器:無參且同名沒有返回值,當一個類顯示的表明構

造器,則類不自己建立預設構造器

        內部類

17、類之間的關係:繼承耦合度最高

    A.繼承(is-a): 單繼承多實現 extends 優點:減少了程式碼的冗餘、缺點:耦合度太高

    B.實現:

    C.組合(has-a):

        合成:個體和整體的關係,個體與整體生命週期相同,公司和部門的關係

        聚合:個體和整體的關係,生命週期不同,學生和學校的關係

        關聯:雙向關聯

            Class Person{

                Petpet;}

            ClassPet{

                Personowner;

            }

    D.依賴(use-a):一個類作為另一個類方法的引數或者是返回值,稱為依賴

18、java設計原則

低耦合高內聚

可擴充套件性和可維護性

19、繼承:

  子類中的成員:

     1)從父類中繼承的視覺化(非私有的)的成員(欄位、方法),不能繼承父類的構造器

     2)子類所特有的成員(欄位、方法、構造器)

     3)過載父類的成員(方法)  多型

        過載的條件:

            a)發生在同一個類或者父子類之間

           b)方法名稱相同,引數列表(引數的個數,引數的資料型別、引數的順序)不同

           c)返回值無所謂

           d)訪問許可權無所謂

         歧義過載:

            ma(12,34)//歧義過載,編譯錯誤

            publicvoid ma(int i,double j){//列印1}

            publicvoid ma(double i,int j){//列印2}

         構造器過載:

           this:

                 this.成員(欄位、方法):呼叫本類的欄位、方法

                 this(引數列表):呼叫本類的其他構造方法,必須在構造方法的第一句

    public Person(int age){

                        this(age,””);//呼叫下面那個構造器

                    }

publicPerson(int age,String name){

                        this.age= age;//呼叫本類的欄位

                        this.name= name;

                    }

           super:父類的物件

               super.成員:呼叫父類的成員(方法、欄位)

               super(引數列表):呼叫父類的構造方法,必須位於子類構造方法的第一句

               如果父類中沒有無參的構造器,在子類中必須顯式的呼叫父類帶引數的構造方法(super(引數類表或者this(引數列表)));  如果父類有無參的構造器,則子類中可以不用顯式呼叫父類的構造器,因為系統預設呼叫super();

     4)重寫父類的成員(方法)  多型

          重寫的條件 :

            a)發生在父子類之間

            b)方法名稱相同,引數列表(引數的個數,引數的資料型別、引數的順序)相同

            c)返回值必須相同

            d)子類覆蓋方法的訪問許可權大於等於父類被覆蓋方法的訪問許可權

            e)子類不能丟擲比父類異常更大的異常(RuntimeException例外)

     5)隱藏父類的成員(欄位)   

多型物件:呼叫隱藏成員,呼叫的是父類的

                      呼叫覆蓋成員,呼叫的是子類的        

20、static:類成員

欄位:所有物件共享

    方法:靜態方法不能直接訪問非靜態的成員,如果需要訪問,產生例項訪問;

          非靜態方法能夠直接訪問靜態成員和非靜態成員

          靜態方法中不能有this、super關鍵字

    塊:記憶體中只執行一次,通常用來初始化靜態成員

    內部類

21、final:終態的

    變數:不能第二次賦值,而且必須有初始值

    方法:不能被重寫

類:不能被繼承

22、abstract:

   抽象方法必須在抽象類中,抽象類中不一定要有抽象方法

   抽象類沒有例項

   抽象類可以有父類,父類可以是抽象類也可以是非抽象類

   抽象類有構造器,不能用來產生本類例項,構造器用來間接產生子類例項時使用

  abstract不能與static、final、private一起使用

23、異常處理:

   1)try{}catch()finally{}

   2)throws   方法聲明後 throws 異常類

   3)throw    句子(通常是if)後throw 異常類的例項

   4)自定義異常類  extends  Exception或者RuntimeException 

24、方法重寫(override)和 過載(overlord)的區別

重寫override:子類中出現與父類中籤名相同的方法、訪問修飾符要等於高於父類、返回值型別,引數列表都相同

過載overlord:一個類內部出現兩個及兩個以上方法名相同、引數列表不同(引數型別,引數個數,引數型別的順序)的方法

25、動態多型和靜態多型

動態多型(執行時多型):執行過程中才知道呼叫那個方法,指的是方法重寫

靜態多型(編譯時多型):編譯時就知道所呼叫的方法,指的是方法過載

26、如果父類中沒有空參構造

那麼子類必須同super()的方式顯示的呼叫父類構造

建議:如果父類中出現帶參構造,那麼必須手動新增空參構造

例:下列程式碼的執行結果是( B

classA{

     public  A(int a){System.out.println(“A”);}

}

class B extends A{

    publicB(){

        super(5);//必須加上這一塊,用super()顯示的呼叫父類中的方法

    }

    public voidma(){System.out.println(“ma”);}

}

public class test{

    public static void main(String[]args){

B b=new B();

b.ma();

    }

}

A.  列印輸出ma

B.  編譯錯誤

C.  列印輸出A

D.  列印輸出A  ma

27、 static

表示靜態的,修飾的內容屬於類成員;被該類的所有物件共享,建議使用類名.的方式訪問;修飾的內容在類載入的時候,執行;只能訪問被static修飾的內容;修飾的內容只在類載入的時候執行一次。

可以修飾的內容:修飾屬性、修飾方法、作為程式碼塊使用 jdbc 載入驅動的時候

static{

Class.forName("");//作為程式碼塊使用

}

特點:

1.修飾的內容屬於類成員

2.修飾的方法,不能被重寫,可以被過載

3.修飾的內容,執行一次

例:public class HelloWorld{

public staticvoid main(String args[]){

method();

}

public voidmethod(){

try{

System.out.println("hello我執行");

}

finally{

System.out.println("我就不執行");

}

  }

}

編譯執行後,輸出結果是什麼?(D )

A."hello 我執行"

B."我就不執行"

C."hello 我執行"

"我就不執行"

  D.程式碼不能編譯

因為main方法是用static修飾的靜態方法,呼叫的方法也必須用static修飾,而method();方法沒有被static修飾

28hashcode()返回的是物件的記憶體地址對應的int型別資料,但是我們可以重寫hashCode()方法,返回的就不再是記憶體地址。

hashcode()相同的物件,這兩個物件不一定相同;如果兩個物件相同,則hashcode()一定相同。

29、java中的訪問修飾符

public: 所有

protected: 自己、同一包中、子類可以訪問

default: 預設什麼都不加,就是default,自己、同一包中可以訪問,但是比protected級別要低即限制更多

friendly: 自己、同一包中可以訪問

private: 自己

以下程式碼的執行結果是:( C  )

1. abstract class abstrctIt {

2.   abstractfloat getFloat ();

3. }

4. public class AbstractTest extends AbstractIt {

5.   privatefloat f1 = 1.0f;

6.   privatefloat getFloat () {return f1;}

7. }

A. 編譯成功

B. 第6行產生錯誤,導致執行失敗

C. 第6行產生錯誤,導致編譯失敗

D. 第5行產生錯誤,導致編譯失敗

預設什麼不加的訪問修飾符是default,default比private限制少(即更高階),比protected限制多,所有第六行重寫方法用的private訪問修飾符比父類低階,所有會出現編譯失敗

30、Math.random()獲取[0,1)的值,取不到1;

用法:(int)Math.random()*n+1;取到1到n之間的整數

31、陣列、集合、字串之間的轉換

a. Arrays.asList() //將陣列轉換成集合

例:List list = Arrays.asList(names);//將陣列轉換成集合。

b.String.valueOf() //將陣列轉換成字串、也可將整數轉換成字串

例:char []ch1 = {'a','c','a','b','a'};

     String str2 = String.valueOf(ch1);

例:int num = 123456;

     String str =String.valueOf(num);

c.toCharArray()將字串轉換成陣列

例:String str = "gdfgdfgd";

char[] ch = str.toCharArray();

d.Arrays.toString()將字元陣列變成字串特定格式輸出,如[1,2,3]

 例:String str1 = Arrays.toString(ch);

    System.out.println(str1);

 e.str.reverse();將字串反轉

例:StringBuffersb =new StringBuffer("adfsdsd");

    sb.reverse();

f.

32、replace();函式

例1//將字串"abcdabcdabdcadcbadcb"的字元出現的次數輸出

    Stringnum = "abcdabcdabdcadcbadcb";

    String t = num.replace("a","");

    System.out.println(num.length()-t.length());

        replaceAll(),用正則表示式

例2//將字串中的數字去除  

String num1 = "ab23c7da45bc5da65bd5c67ad7cb9adcb";

    String t1 = num1.replaceAll("[0-9]", "");

    System.out.println(t1);

例3//計算字串的長度,一個字元算兩個       

    byte[]b =str.getBytes();

    System.out.println(b.length);//若出現一個漢字代表3個位元組的情況,將Utf-8換成GBK就可以了

    String m = str.replaceAll("[\u4e00-\u9fa5]", "xx");

    System.out.println(m.length());

33、DecimalFormat();將數字轉換成特定的格式

例://陣列格式化 int num = 1234567; 換成123,4567

int num = 1234567;

DecimalFormat f =new DecimalFormat("#,####");

String t =f.format(num);

System.out.println(t);

例: //將陣列轉換成123,4567.89的格式

doubled = 1234567.88898890;

DecimalFormat  f =new DecimalFormat("#,####.##");

System.out.println(f.format(d));

34、String型別是否可以被繼承,為什麼?

不能被繼承,因為是被final修飾的類

35、String型別是否是基本型別,比較String型別變數時,== 和equals有何區別?

不是,是引用型別

a.如果 String型別是直接賦值 == 和 equals 效果相同

 String a = “abc “;

 String b = “abc”;

  a ==b 和 a.equals(b)都為true

b.如果String是通過new構建的 == 和equals效果不同

 String a = new String(“abc”);

 String b = new String(“abc”);

  a ==b 結果為false

  a.equals(b)結果為true

36、char型別中是否可以存放一個漢字,為什麼?

可以,char型別中存放的資料以Unicode碼存放。

37、Random()函式

//獲取1-35之間的隨機數

//第一種方法

Random r = new Random();

int n = r.nextInt(35)+1;

//第二種方法Math.random()是取得[0,1)之間的隨機小數,取不到1。

int n =(int) (Math.random()*35+1);

java工具類

Object:引用型別的根,是所有類的超類,是java中唯一一個沒有父類的類

1、toString():將物件轉成字串

2、equals()和==的區別:

     ==:可以判斷基本資料型別和引用資料型別

         引用資料型別,表示兩個物件的引用是否相等,即棧裡面引用的地址是否相等

     equals:可以判斷引用資料型別

引用資料型別:表示兩個物件的引用是否相等,但是包裝類、String、Date、File除外(這些判斷的是物件的值是否相等,即堆記憶體裡面的值是否相等)

Stringstr1 = “abc”;

//建立一個字串池中的物件,如果裡面有此物件了就不再建立了,直接用即可

Stringstr2 = “abc”;

Stringstr3 = new String(“abc”);

Stringstr4 = new String(“abc”);

//可能產生兩個或一個物件,在堆記憶體中首先new出一個物件,再複製到字串池當中,如果字串池中有此物件,即不復制。所有堆記憶體中的物件是肯定存在的,字串池中的物件不一定

System.out.println(str1==str2);true

System.out.println(str3==str4);false

//str3在堆記憶體中new出一個記憶體、str4在堆記憶體中重新new出一個記憶體,在堆記憶體中相當於等號的右邊。在棧記憶體中,指向堆記憶體中的引用值不一樣,所有為false

System.out.println(str1==str3);false

//str1是在堆記憶體中的字串池裡,為“abc”,str3在堆記憶體new出一個物件‘abc‘佔用一塊記憶體,並且複製到字串池中,如果字串池中有abc了,即不復制。

System.out.println(str1.equals(str2));true

System.out.println(str3.equals(str4));true

System.out.println(str1.equals(str3));true

//equals在String型別比較的堆記憶體的值是否相等,str1字串池中的記憶體為abc,str3在堆記憶體中new出的物件是abc,這兩個物件雖然分配的記憶體不同,但是值相等,所以為true

3、重寫equals方法必須先重寫hashcode方法

相等的物件必須具有相同的雜湊碼,具有相同雜湊碼的物件不一定相等

3、clone()克隆

淺表克隆:複製原物件的所有變數的備份,但是引用型別的變數指向原物件的資料

     必須實現一個介面implements Cloneable

     重寫Object類的克隆方法clone()

深表克隆:複製原物件的所有變數的備份,包括引用型別

4、反射Class.forName(“com.A”);

破壞了底層的封裝性

5、包裝類

byteByte

shortShort

longLong

floatFloat

doubleDouble

BooleanBoolean

intIntegar

charCharacter

包裝類與字串轉換:

     xxxValue():轉換成其他基本型別

    包裝類-à字串 toString()

        System.out.println(i.toString());

    字串-à整形 parseXxx()

        int i4 =Integer.parseInt(“123”);

        double i5 =Double.parseDouble(“123.456”);

裝箱和拆箱:JDK1.5只會自動裝箱和拆箱

     裝箱:基本資料型別轉換為引用資料型別

         Integer i5 = 10;

     拆箱:引用資料型別轉換為基本資料型別

         Integer i5 = 10;

         int i6 = i5;

6、String類

charAt()方法:一般與for迴圈一起,遍歷字串

    Stringstr = “Hello Java,Hello World”;

     for(int i=0;i<str.length();i++){

         System.out.println(charAt(i));

     }

concat()方法;拼接字串,將指定字串連線到此字串的結尾

     str.concat(“s”);  //得到Hello Java,Hello Worlds

startWith()方法;測試此字串是否已指定的字首開始,boolean

     str. startWith(“Hello”); //true

format()方法:將字串按照某種格式輸出

        inti=1;intj=2;

     System.out.println(String.format("%d+%d=%d",i,j,i+j));//1+2=3

indexOf(String)方法:輸出字串第一次出現的索引,沒有的話輸出-1

     System.out.println(str.indexOf("Hello"));//0

lastIndexOf()方法:輸出字串最後一次出現的索引

replace(old String, new String)方法:替換字串

split()方法:分割字串

substring(int start,int end)方法:擷取字串

toCharArray()方法:變成字元陣列

trim()方法:去掉字串兩端的空格,字串中間的去不掉

toUpperCase()方法:將字串轉化為大寫

7、StringBuffer和StringBuilder區別

StringBuffer執行緒安全的,同步的,效率比較低,JDK1.0之後出現

StringBuilder執行緒不安全,不同步的,效率比較高,JDK1.5之後出現

8、StringBuffer方法

StringBuffersb = new StringBuffer(“aaa”);

append 追加字串

sb.append(“bb”).append(“bb”);

delete 刪除

sb.delete(1,2).delete(1,2);

insert 插入

sb.insert(1,”22”).insert(1,false);

setCharAt 修改

sb.setCharAt(1,’Q’);

replace 替換

sb.replace(1,3,”MMM”);

reverse 反轉

sb.reverse();

10、Math方法

    Math.ceil(2.4);//3取比值大的最小整數

    Math.ceil(-2.4);//-2

    Math.floor(2.5);//2取比值小的最大整數

    Math.round(2.5);//3四捨五入

    Math.round(-2.5);//-2

Math.random()//範圍是[0,1)

Math.random()*40+60;//取60到99的成績

    Random方法:範圍是[0,1)

        Randomran  = new Random();

        for(inti=0;i<10;i++){

            intscore = ran.nextInt(41)+60;//從60到100

            System.out.println(score);

        }

11、Date方法

SimpleDateFormat類:改變時間的格式

SimpleDateFormatsdf = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");

Datedate = new Date();

//將日期格式轉換成指定的字串

Stringtime = sdf.format(date);

System.out.println(time);//現在的時間以yyyy/MM/dd HH:mm:ss格式輸出

//將格式化的字串轉換成日期物件

Datedate = sdf.parse(“1995/07/12 03:00:00”);

System.out.println(date);

TimeZone()設定時區

TimeZonetime=TimeZone.getTimeZone("America/Los_Angeles");

    Calendar c2=Calendar.getInstance(time,Locale.US);

    Date d=c2.getTime();

GregorianCalendar單獨獲取年、月、日

GregorianCalendar gc =newGregorianCalendar(2017,3,5);

    System.out.println(gc.get(Calendar.MONTH));

System.currentTimeMillis();通常用於迴圈運算的時間

        long startTime = System.currentTimeMillis();

        for(){}

        longendTime = System.currentTimeMillis();

        longtime = endTime- startTime//計算出運算的時間

集合:

1、集合和陣列的區別:

    陣列:可以包含基本資料型別或者引用資料型別的物件,資料定長的,訪問較快

    集合:只能包含引用資料型別的物件,不定長。

2、集合分類:

    Set:集 無序,不重複,父介面為Collection

        add();新增元素

        addAll(Collection);新增子集合

        contains();是否包括元素

        containsAll();是否包含子集合

        isEmpty();Boolean判斷集合長度是否為0

        remove();移除元素

        removeAll();移除一個子集合

        size();集合的大小

        toArray();將集合轉換成資料

        Set集合的遍歷  Iterator 迭代器

        Setset = new HashSet();

        Iteratorit = set.iterator();

        while(it.hasNext()){

            Objectobj = it.next();

            System.out.println(obj);

}

Set集合的遍歷  增強for迴圈

for(Object obj:set){

System.out.println(obj);

}

HashSet和TreeSet的區別:

HashSet:內部物件雜湊存取,順序和輸入的順序不同

TreeSet:元素會進行升序排序(元素是可比較的),順序和輸入的順序也不同

    List:列表 有序,重複,父介面為Collection

        add();新增元素

        addAll(Collection);新增子集合

        add(key,元素);插入元素

        get(key);獲取元素

        indexOf(元素);返回元素的索引值,如果沒有則返回-1

        remove(key);移除元素

        removeAll();移除一個子集合

        set(key,元素);修改元素

        toArray();轉換成陣列

        List集合的遍歷  普通for迴圈

Listlist = new ArrayList();

for(inti;i<list.size();i++){

    Object obj = list.get(i);

    System.out.println(obj);

}

List集合的遍歷  增強for迴圈

for(Object obj:list){

System.out.println(obj);

}

List集合的遍歷  Iterator 迭代器

        Iterator it = list.iterator();

        while(it.hasNext()){

            Objectobj = it.next();

            System.out.println(obj);

}

        ArrayList和LinkedList區別:

            ArrayList底層物理儲存為線性的(陣列的儲存方式),查詢效率高,刪除、新增等操作效率比較低

            LinkedList底層物理儲存為連結串列的,查詢效率低,刪除、新增效率高

        ArrayList和Vector區別:

兩者底層物理儲存為線性的

            ArrayList:執行緒不安全,不同步的,資料不安全,效率比較高

            Vector:執行緒安全的,同步的,資料安全,效率比較低

Map:字典 鍵值對儲存 key唯一,value可重複

    put(key,values);新增元素

    putAll(map);新增集合

    remove(key);移除一對元素

    size();集合長度

    containkey(key);是否包含某個鍵

    containvalue(value);是否包含某個值

    Map集合的遍歷 keySet()

    Set set = map.keySet();

    Iterator it = set.iterator();

    while(it.hasNext){

        Object key = it.next();

        Object value = map.get(key);

        System.out.println(key+”:”+value);

    }

    Map集合的遍歷 entrySet()

    Iterator it = map.entrySet().iterator();

    while(it.hasNext()){

        Map.Entry entry = (Map.Entry)it.next();

        System.out.println(entry.getKey()+”:”+entry.getValue());

    }

    HashMap和Hashtable的區別:

        HashMap:鍵值對允許為null,執行緒不安全,不同步,效率比較高

        Hashtable:鍵值對不允許為null,執行緒安全,同步,效率比價低

    HashMap和TreeMap的區別:

HashMap:基於雜湊,是無序的

        TreeMap:基於樹型結構的,按照鍵升序排序

3、Collections類:

Collections.sort():只針對List集合,集合中的元素必須是可比較的,如果為引用型別,則必須實現Comparator、Compareable(常用)介面

Collections.shuffle(list):打亂順序

Collections.rotate(list,int i):根據指定的長度,輪換指定列表中的長度

Collections.reverse(list):反轉集合

泛型:資料型別引數化

1、public<T> void arr(T t1,T t2){

        Ttemp = t1;

        t1= t2;

        t2= temp;

}

2、泛型:安全的,避免了資料型別轉換的風險

3、泛型約束:entends:如果有多個約束則使用&連線,約束只能有一個類,可以有多個介面

4、萬用字元?

    上屆萬用字元:? extends A:表示A或者A的子類

    下屆萬用字元:? super A:表示A或者A的父類型別

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

    List<?extends Object> listobj = list;//成立

    List<Object>listobj = list;//不成立 在泛型中<String>和<Object>是同級關係

檔案

1、構造方法

        Filefile1 =new File("D:\\a.txt");

File file2 =new File("d:\\UI","a.txt");

File file3 = new File("D:\\UI");

Filefile4 =new File(file3,"a.txt");

2、mkdirs()建立多層資料夾

    File file5 = new File("D:\\UI\\aaa");

if(!file5.exists()){

file5.mkdirs();

        }

3、getAbsolutePath()列印檔案路徑

   getPath()列印檔案路徑

    System.out.println(file5.getAbsolutePath());//D:\UI\aaa

4、getName()()獲取檔名//aaa

5、getParent()獲取檔案目錄,不包含檔名//D:\UI

6、isHidden()檔案是否被隱藏//false

7、isDirectory()判斷是否是資料夾//true

8、isFile() 判斷是否是檔案

9、exists() 判斷是否存在

10、newDate(file5.lastModified()) 獲取最後一次修改的日期

11、length() 檔案的位元組數

12、file5.list() 檔名的遍歷

  String[]str =file5.list();

  for(String s :str){

      System.out.println(s);

}// 3.doc

5.FEM

e.txt

13、file5.listFiles() 檔案的遍歷

    File[]files = file5.listFiles();  

for(File f :files){

if(f.isFile()){

System.out.println("檔案"+f.getName()+"\t"+new Date(f.lastModified()));

}else{

System.out.println("資料夾"+f.getName());

}

}//檔案3.docFri Feb 24 10:33:28 CST2017

檔案5.FEM   Fri Feb 24 10:33:37 CST 2017

檔案e.txt   Fri Feb 24 10:33:32 CST 2017

14、File.listRoots(); 碟符的遍歷

File[] f1 = File.listRoots();

for(Filef :f1){

System.out.println(f.toString());

}// C:\

D:\

檔案IO流

1、 位元組流

FileInputStream 輸入流 讀檔案

BufferedInputStream輸入流讀檔案

FileOutputStream輸出流寫入檔案

BufferedOutputStream輸出流寫入檔案

字元流

FileReader輸入流讀檔案

DataInputStream輸入流 讀檔案

FileWriter輸出流 寫入檔案

DataOutputStream輸出流 寫入檔案

2、FileInputStream 讀取英文檔案

    FileInputStreamfis = new FileInputStream("D:\\UI\\bbb.txt");

    intch = 0;

    while((ch= fis.read()) != -1){ //read從此輸入流中讀取一個數據位元組,返回值為int

        System.out.print((char)ch);

    }

fis.close();//此程式不能讀中文

3、FileInputStream 讀取中文檔案

    FileInputStreamfis = n