欧美性猛交XXXX免费看蜜桃,成人网18免费韩国,亚洲国产成人精品区综合,欧美日韩一区二区三区高清不卡,亚洲综合一区二区精品久久

打開(kāi)APP
userphoto
未登錄

開(kāi)通VIP,暢享免費電子書(shū)等14項超值服

開(kāi)通VIP
j2se學(xué)習筆記
j2se基礎:
掌握要求:讀懂、分析、調試(運行,改數據)、復述、應用(類(lèi)似編程)、反復的寫(xiě)
從案例出發(fā),要會(huì )用,再去考慮為什么
(0530):java概述 1
(0531): 標識符、關(guān)鍵字、數據類(lèi)型、變量、常量: 4
(0601)運算符、類(lèi)型轉換: 10
(0602)字符串、String類(lèi): 14
(0603)結構語(yǔ)句: 17
(0607):格式化輸出、面向對象 20
(0608):方法對象調用、方法重載、構造器、this、final、printf 22
(0609):靜態(tài)變量(類(lèi)變量)、(靜態(tài))初始化塊、包 24
(0610): (常用類(lèi))基本類(lèi)型封裝類(lèi)、StringBuffer & StringBuilder、Date、DateFormat、SimpleDateForma、Calendar、Scanner 、GreforianCalendar 27
(0613):數組、Arrays、正則表達式 36
(0614):繼承(基本結構) 43
(0615):繼承(遞歸、super) 44
(0617):多態(tài) 47
(0618):最終類(lèi)、最終方法、強制類(lèi)型轉換、抽象類(lèi) 48
(0620):接口、自定義接口 49
(0622):接口與回調、內部類(lèi)(匿名)、容器(Collection) 52
(0623):Set接口(子接口SortedSet)、List接口及實(shí)現類(lèi)(Collections工具) 56
(0624):遍歷、Map接口(子接口SortedMap)、泛型 62
(0627):異常處理、throws、throw、創(chuàng )建異常類(lèi) 67
(0629):流與文件 70
(0630):文件字符輸入輸出流、緩沖流、處理流 76
(0704):對象流、數據流、轉換流、打印流、鍵盤(pán)輸入 80
(0705):Java 多線(xiàn)程機制 89
(0706):網(wǎng)絡(luò )程序設計 94
一、計算機網(wǎng)絡(luò ):不同地理范圍有獨立功能,通過(guò)通信介質(zhì),在網(wǎng)絡(luò )操作系統控制下,通信雙方遵守共同的通訊規則,實(shí)現相互信息的傳遞,同時(shí)達到資源共享的計算機群 94

(0530):java概述                                                        
一:1、Java、程序以類(lèi)為單位,一個(gè)程序有很多個(gè)類(lèi)組成
class表示一個(gè)類(lèi)
2、英文單詞或字母 +()表示方法,方法是要將內容展示到屏幕上去。(見(jiàn)到小括號就是方法)
如:System.out.println ();
public static void main ( String[] args)
3、public class 指的是公共的類(lèi),一個(gè)程序中只有一個(gè)公共的類(lèi),文件名要與公共類(lèi)名稱(chēng)一致。
4、“文件名”表示按我指定類(lèi)型存盤(pán)
5、cmd(打開(kāi)命令窗口)
F:(磁盤(pán)切換到f盤(pán))
Cd +“文件夾名”切換到此文件夾
Dir(查看目錄)
Javac + “文件名”.java(編譯此文件)
Java + “文件名”.class (解釋執行此文件,但class不能加)
6、JAVA_HOME說(shuō)明儲存java程序的安裝路徑(安裝位置地址)
Path 告訴操作系統按照你指定的路徑尋找可執行軟件
7、主類(lèi):包含了主方法的類(lèi)稱(chēng)為主類(lèi),主方法是程序執行的入口。
8、一個(gè)程序中有多少個(gè)類(lèi),編譯后就會(huì )產(chǎn)生多少個(gè)字節碼文件。
二:1、程序執行順序:加載主類(lèi)(java Test)、執行主方法、延主方法執行程序
2、java中嚴格區分大小寫(xiě)、中英文狀態(tài)標點(diǎn)符號
3、看到“[ ]”表示為一個(gè)數組,表示一組數據
4、“()”里面的都叫參數,數據類(lèi)型:4類(lèi)8種
5、“加號”的左邊或右邊有一個(gè)字符串時(shí) 其起連接作用。
6、void 表示沒(méi)有返回值,int+類(lèi)名表示返回為int型。
7、兩個(gè)類(lèi)之間調用規則(類(lèi)名dian變量名)
如:public class Test {
public static void main (String[] args) {
Second.add(20 , 30);
}
}
class Second {
public static void add(  int a , int b) {

System.out.println(a * b);
}
}

(0531): 標識符、關(guān)鍵字、數據類(lèi)型、變量、常量:
程序員的要求:第一步:用想到的方法解決問(wèn)題
第二步:優(yōu)化(換位作為用戶(hù),是否能看懂)
第三步:回頭考慮(作為技術(shù)人員,所用技術(shù)是否符合)
1、 注釋?zhuān)?
單行注釋?zhuān)?nbsp; “//”后跟要注釋的內容
多行注釋?zhuān)?以“/*”開(kāi)頭,以“*/”結尾,里面寫(xiě)要注釋的內容。
文檔注釋?zhuān)?以“/**”開(kāi)頭,以“*/”結尾,里面寫(xiě)要注釋的內容。
注釋注意:/* */注釋不能嵌套。
Java中的注釋不會(huì )出現在字節碼文件中。
單行注釋的內容必須在一行上。
注釋作用:注釋就是程序員為讀者作的說(shuō)明,是提高程序可讀性的一種手段。
2、 標識符:指得是以字母或者下劃線(xiàn)或者美元符號開(kāi)頭后跟字母,數字下劃線(xiàn)美元符號組成的字符串稱(chēng)之為表示符號
作用:作為為變量、方法、類(lèi)名以及接口名命名的一個(gè)規則。
注意:有嚴格的大小寫(xiě)區分,不能使用關(guān)鍵字
3、 關(guān)鍵字:賦以特定的含義,用做專(zhuān)門(mén)用途的字符串
4、數據類(lèi)型:

byte字節型 【-128,127】 占1B
short短整型【-32768,32767】 占2B
int整型【-2147483648,2147483647】 占4B
long長(cháng)整型【-2^63,2^63-1】 占8B

char 字符型 【0,65535】 占2B
float 單精度浮點(diǎn)型  占4B
(系統輸出2.0-1.1為0.899999999)若避免需用:BigDecimal類(lèi)
double 雙精度浮點(diǎn)型 占8B
boolean 邏輯類(lèi)型 (布爾型)
是一種特殊的類(lèi)型,用true表示真,用false表示假。
3、 在java語(yǔ)言中整數有三種表示形式
1)十進(jìn)制數: 5,36,105
2)八進(jìn)制數: 用0開(kāi)頭,如:015
3)十六進(jìn)制:用0x或0X開(kāi)頭,如:0x15,0X3A
4、在java語(yǔ)言中整數默認為int型。
5、特殊情況下,當把一個(gè)整數存放到byte short型變量中時(shí),只要不超過(guò)他們的范圍就是合法的。
例如:byte b1 = 36,byte b2 = 128 //error
6、當把一個(gè)整數看成是long型數據時(shí),則必須在該數的末尾加上l或者L。
例如:long a = 125468972456L;
  Long b = 356;
7、float和double用來(lái)管著(zhù)小數。在java語(yǔ)言中,小數默認為double型;若要將小數看成是float型,則必須在其末尾加字母f或者F。
例如:float f1 = 3.56f;

8、在java語(yǔ)言中小數有兩種表示形式
1)十進(jìn)制 如:0.156、7.00
注:在java語(yǔ)言中小數點(diǎn)前后的零在不改變數值大小的情況下可以省略,例如:3.0可以寫(xiě)成3.
2)科學(xué)計數法:3.15e6 、315.78e-3
注:在科學(xué)計數法中,字母e的前后必須有數,在字母e的后面必須是整數,在字母e的前后不能有空格。
9、字符型char:用一對單引號將一個(gè)字符括起來(lái),特殊的除外
例如:‘a(chǎn)’ ‘A’ ‘6’
在java語(yǔ)言中字符型數據占2B,每一個(gè)字符都對應著(zhù)一個(gè)編碼值,該編碼值是一個(gè)整數,其范圍是【0,65535】。
注意:根據以上特點(diǎn)可知,可將一個(gè)整數直接存放到char類(lèi)型中,可得到該字符的編碼值。
如: char c = 21;
System.out.println( c );
了解:一個(gè)字符型的變量可以直接給一個(gè)整數,也可以直接給一個(gè)十六進(jìn)制編碼值,如:char ch = ‘\u0041’;
10、特殊字符:
轉義字符:\n 換行
\b 退格:將光標左移一位
\r 回車(chē):讓光標左移到本行行頭
\t 制表符:讓光標跳到下一個(gè)制表位
(一個(gè)制表位默認為8位)
等等



作業(yè):
1消化所有案例
2自己編寫(xiě)程序測試所有基本類(lèi)型變量的特性
3自己編寫(xiě)程序測試所有的轉移符號特點(diǎn)
4編程測試局部變量與實(shí)例變量的特點(diǎn)

11、變量:
1)隨著(zhù)程序的運行其值可以改變
2)組成:類(lèi)型 變量名 變量聲明(賦值 初始化)
3)注意:要先定義后使用
4)按聲明位置不同分為:
局部變量:在方法中或語(yǔ)句塊中聲明 (無(wú)默認值)
注:使用時(shí)聲明后要賦值,否則不可操作
實(shí)例變量:方法外部 類(lèi)的內部 (有默認值)
注:靜態(tài)方法中(static)不可直接訪(fǎng)問(wèn)實(shí)例變量。要通過(guò)對象來(lái)訪(fǎng)問(wèn)非靜態(tài)變量。
{1、創(chuàng )建一個(gè)本類(lèi)對象: (類(lèi)名  新名 = new 類(lèi)名();)
2、使用規則:(新名 dian變量名(非靜態(tài)))
}
5):語(yǔ)句塊:用一對大括號將一個(gè)或多個(gè)語(yǔ)句括起來(lái)構成一個(gè)整體。
12、常量
1)關(guān)鍵字final表示可以對變量賦一次值,且它的值一旦設定,便不可改變。
2)字面常量:見(jiàn)到的是什么,那它本身就是什么
符號常量:用一個(gè)標識符來(lái)代替某個(gè)字面常量
注意:符號常量必須先定義,后使用。
(final 類(lèi)型 變量名 = 值)
符號常量也稱(chēng)為最終常量或不可變常量。標識符通常均使用大寫(xiě)。
好處:為后期維護提供方便,程序穩定
(0601)運算符、類(lèi)型轉換:
1、命名規范:
1)見(jiàn)名知意
2)表示常量的標識符全部大寫(xiě)
3)表示類(lèi)名的標識符是以大寫(xiě)字母開(kāi)頭,如果名字有多個(gè)單詞組成,每個(gè)單詞的第一個(gè)字母都應該大寫(xiě)。如:HelloWorld
4)表示變量的標識符用小寫(xiě)字母開(kāi)始,后面的描述性詞以大寫(xiě)開(kāi)始。如:getName
“駝峰式”書(shū)寫(xiě)
2、運算符:


思考:a、已知一個(gè)整數為5864,利用/和%的特點(diǎn)將該數的每一位分離。分離之后分別輸出1 2 3 4 或逆著(zhù)輸出為: 4321.
b、利用% /任意一個(gè)整數分離,并逆著(zhù)輸出
c、用條件語(yǔ)句寫(xiě)一語(yǔ)句,求三個(gè)數的最大值
instanceof:判斷某個(gè)對象是否屬于某類(lèi);
關(guān)系運算符、邏輯運算符的結果一定為邏輯值即:true或false;

注意:1)“/”除號:當除號兩邊均為整數時(shí),則結構為整數(即:商)
      2)“%”取膜,取余:兩端可以為小數如:1.3%2=0.1
      3)兩運算符之間不能有空格。a >= b
      4)“&&”短路與:運算符左邊為false時(shí),右邊不用運算
      5)“||”短路或:運算符左邊為true時(shí),右邊不用運算
補充內容:
A. 所有數據在計算機中以二進(jìn)制方式參與運算及其處理
B. 計算機內數據最高位為符號位1為負(-)
C. 十進(jìn)制(二、八、十六)進(jìn)制關(guān)系;十進(jìn)制轉成二進(jìn)制(除以基數取余倒寫(xiě))基數:目的進(jìn)制的基礎數據個(gè)數;其他進(jìn)制數轉成十進(jìn)制數(按權展開(kāi)求和)權:目的基數的(n-1)方,n表示所在的位數。
D. 原碼:十進(jìn)制數轉成二進(jìn)制數后,最高位作為符號位得到的編碼。如:byte b1 = -5;則為 10000101
(整數只有原碼,或者說(shuō)整數的原碼、反碼、補碼一樣)
反碼:按位取反,符號位不變;則為11111010
補碼:反碼 + 1所得的編碼; 則為 11111011
由補碼求原碼:(補碼的補碼就是原碼)
原則:(1)將補碼看做原碼
(2)求其反碼
  (3)求其補碼
注意:在計算機中,如果運算的最高位為1,則它是一個(gè)負數且是補碼。~a(取反時(shí))按位取反,且符號位參與運算;(如果是一個(gè)負數,要以補碼參與運算)
如: 求 a = 5;
c = ~a;//取反結果
System.out.println( "~" + a + " 其結果是: " + c  );
/*  注: 在計算機中,運算時(shí)得到結果,若它的最高位為1,則它是一個(gè)負數且是補碼。
   a=5
原碼:  00000000 00000000 00000000 00000101
~a得:  11111111 11111111 11111111 11111010/為補碼,要求其原碼。
反碼:  10000000 00000000 00000000 00000101
補碼:  10000000 00000000 00000000 00000110
故,所得補碼就是原碼,即:-6  */
4、 移位運算符
<<左移運算符:每左移一位,將擴大一倍
>>右移運算符:每右移一位,將縮小一倍
>>>無(wú)符號右移運算符:(同右移運算符)
5、 擴展賦值運算符
+=、-=、*=、/=、%=、&=、|=、^=、>>=、<<=、>>>=
格式:變量 擴展賦值運算符 表達式;
如:a += 5+6; a = a + (5+6);
注意:擴展賦值賦值運算符中不能有空格。
6、 強制轉換
規則:(類(lèi)型)數據
如:byte b1 = (byte)300;
b1輸出時(shí)值為44;因為byte型占1B,只有八位,強制轉換時(shí)只能取后八位即:300 = 100101100 B;
00101100B = 44;
注意(表達式類(lèi)型判斷):
A:有double型數據時(shí),最終結果為double型;
B:沒(méi)有double型,但有float型時(shí),最終結果為float型;
C:沒(méi)有double、float型時(shí),但有long型時(shí),最終結果為long型;
D:沒(méi)有double、float、long、型時(shí),最終結果為int型;
如:byte b1 = 2;
short s1 = 99;        s1為short,b1為byte其和
s1 =(short) (s1 + b1);     為int型,必強制轉換    
(0602)字符串、String類(lèi):
1、 字符串:用一對雙引號括起來(lái)的字符序列稱(chēng)。屬于引用類(lèi)型中的“類(lèi)”。
2、java中用String類(lèi)來(lái)管理字符串,該類(lèi)來(lái)源:java.lang.String
3、一對聯(lián)系的“”表示一個(gè)長(cháng)度為0的空串;
null表示字符串不存在;
4、字符串通常由多個(gè)字符組成,而每個(gè)字符都有一個(gè)索引號。
索引號從0至n-1,其中n為字符串中字符的個(gè)數,即:字符串長(cháng)度。例如: "ABCDEFG"  ,其中'A'字符的索引號為0, 'G'索引號為6。該字符串的長(cháng)度為7。
4、 字符串常用操作方式方法。字符串的連接,可通過(guò)”+”實(shí)現。
(符號兩端中有一個(gè)為字符串,另一個(gè)自動(dòng)轉換成字符串)如:
String str = “l(fā)ove” + 2011;(輸出為:love2011)
String類(lèi):
int len = str.length( );求字符串str長(cháng)度;
char ch = str.charAt( 0 );求字符串str第0個(gè)位置的字符;
String sub = str .substring( 0 , 3); 字符串從第零個(gè)開(kāi)始輸出三(3 - 0)個(gè)字符;
String sub = str.substring( 3 );字符串第三個(gè)字符到最后;
boolean flag = str.equals( str1 );比較str與str1字符串是否相等(區分大小寫(xiě));
boolean flag = str. equalsIgnoreCase( str1 );比較str與str1字符串是否相等(不區分大小寫(xiě));
int loc = str.indexOf( “in” );得出字符串“in”在字符串str中的位置(索引號);
int loc = str.indexOf( “in” , 3 ); 得出字符串“in”在字符串str中的位置(索引號),并且是從第三個(gè)開(kāi)始搜索;
String newstr = str.replace(‘i’ , ‘I’);將字符串str中的字符“i”替換為“I”得以新串;
String newstr = str.replace(“in” , “IN”); 將字符串str中的字符串“in”替換為“IN”得以新串;
boolean flag = str.startsWith( “in” );判斷字符串str是不是以“in”開(kāi)頭
boolean flag = str.endsWith( “in”);判斷字符串str是不是以“in”結尾
String newstr = str.toLowerCase( );將字符str中的字符都變成小寫(xiě)生成新串
String newstr = str.toUpperCase( );將字符串str中的字符都變成大寫(xiě)生成新串
String newstr = str.trim( );刪除字符串str頭部和尾部的空格生成一新串
s4 = s1.concat("  Welcome to Beijing!  ") + 2008;//字符串連接;
int mm = s1.compareTo(s2);//將s1和s2兩個(gè)串進(jìn)行大小的比較。(結果大于0為大于,小于0為小于,等于0為等于)(比較時(shí),對應字母從第一個(gè)字母開(kāi)始比較,得出結果后不在比較;)
char[]  chs = s1.toCharArray();//將s1對應的串轉換成一個(gè)字符數組。
System.out.println("s1對應的串是\"" + s1 + "\"其中包含的字符如下:");
for(char  tem  :   chs  ){(將數組chs中元素挨個(gè)輸出)
System.out.println("\'" + tem + "\'");}
s1 = String.valueOf( true );//將各種類(lèi)型的數據轉換成字符串
控制流程:
條件語(yǔ)句:
1)有else一定有if,但有if不一定有else
2)if語(yǔ)句中的大括號在控制一個(gè)語(yǔ)句時(shí)可省略
3)else與最近的未配對的且沒(méi)有被大括號隔離的if配對
Math類(lèi):
1、 類(lèi)的來(lái)源:java.lang.Math
2、 它提供了許多與數學(xué)有關(guān)的函數,在java語(yǔ)言中稱(chēng)之為方法。
Math.abs ( n ); 求n的絕對值
Math.random( n );產(chǎn)生一隨機數,范圍【0 , 1】
Math.sqrt( n );求n的平方根
Math.round( n );對n的四舍五入
Math.pow ( x ,y);求x的y次方
3、提供PI的值()

(0603)結構語(yǔ)句:
while、do-while、for循環(huán)(嵌套)(符合條件參與循環(huán))
break、continue中斷(帶標簽)
switch選擇
1、while循環(huán)
格式:
while( 條件 ){
循環(huán)體;
}
規則: 先判斷條件,若條件成立,則執行循環(huán)體一次;之后,再去判斷條件,若條件還成立,則繼續執行循環(huán)體;
2、do -- while 循環(huán)
格式:
do {
循環(huán)體;
}while( 條件 );(分號不能省略)
規則: 先執行循環(huán)體一次,之后,再判斷條件,若條件不成立,則立即結束do--while循環(huán);若條件成立,則再執行循環(huán)體,之后,再去判斷條件,若條件還成立,則繼續執行循環(huán)體;依次這樣下去,直到條件為假而結束整個(gè)循環(huán)。
3、for循環(huán)
格式:
for(表達式1 ;  條件;  表達式3 ){
循環(huán)體;
}
規則:先執行表達式1, 再判斷條件,若條件成立,則執行循環(huán)體一次; 之后,執行表達式3,接著(zhù)再去判斷條件,若條件依然成立,再繼續執行循環(huán)體;如此下去,直到條件為假而結束整個(gè)循環(huán)。
for循環(huán)的變化: 指的是三個(gè)表達式的變化。
1)標準化;
2)三個(gè)表達式的省略; (注意: for循環(huán)中的 兩個(gè)分號不可省略 )3)三個(gè)表達式的擴展。
注意: 在for循環(huán)中,由表達式1定義的變量,其作用域只在for循環(huán)中;for循環(huán)之外,該變量不存在。(大括號內有效)
如:for( int i = 1 , sum = 0; i <= 100;  sum += i , tem = sum , i++ )  ;(不建議使用)
4、switch( 表達式 ) {
case 值1 : 語(yǔ)句系列1;  [break;]
case 值2 : 語(yǔ)句系列2;  [break;]
case 值3 : 語(yǔ)句系列3;  [break;]
......
case 值n : 語(yǔ)句系列n;  [break;]
default  : 語(yǔ)句系列m;
}
5、 break語(yǔ)句:標簽必須放置在最外層的循環(huán)之前,并且有一個(gè)冒號。
作用:跳出該循環(huán)即結束本循環(huán);如有標簽則結束標簽所指循環(huán)。
continue語(yǔ)句:
作用:控制其轉移到最內層循環(huán)的首部,準備開(kāi)始新一次循環(huán)。
如有標簽,則轉移到標簽所在循環(huán)的首部,準備新一次循環(huán)。
6、 鍵盤(pán)輸入:
1)import java.util.Scanner;(頂部)
2)Scanner scan = new Scanner( System.in );(類(lèi)體內new新對象)
3)int grade = scan nextInt ( );( 鍵盤(pán)輸入數值 )
如:
import java.util.Scanner; //1導入類(lèi)
public class  KeyBoardInputTest{
public static void main(String[] args){
Scanner  sc = new Scanner(System.in);//2實(shí)現鍵盤(pán)輸入
System.out.print("請輸入你的成績(jì)[0 , 100]>>>");
int grade = sc.nextInt();//3 數據接收
System.out.println("你輸入的成績(jì)是: " + grade);
}
}
(0607):格式化輸出、面向對象
格式化輸出:  System.out.printf();()
1、它是java5.0新特性;
2、它應用格式 
printf("信息 <格式符號>"  , 數據 );
3、 格式符號有哪些
%d 表示控制十進(jìn)制整數。
%f  表示控制小數的輸出。
%c  表示控制字符的輸出。
%s  表示控制字符串輸出。
n   表示控制數據輸出的位數。
n.m 表示數據占n位,小數位占m位。
0   表示空位補零。
-   表示左對齊。
+   表示顯示數據的正負號。
,  表示數據每隔三位加一逗號。
n$  表示格式符號對應第n個(gè)數據。
<   表示從前。
%n  只能用格式化輸出中,表示換行。
%tT  表示此時(shí)的時(shí)間
%tF  表示此時(shí)的日期
面向對象:
1、 面向對象的思想
2、 面向對象的好處
3、 面向對象的本質(zhì):數據+處理數據的過(guò)程構成一個(gè)整體(屬性+方法)即封裝
4、 面向對象的核心:如何構造一個(gè)類(lèi)(封裝)
5、 面向對象的特性:封裝性、繼承性、多態(tài)性
6、 類(lèi)的構架結構:(五部分)
1)實(shí)例變量(域、字段、屬性)
2)構造器(一個(gè)方法的方法與類(lèi)名完全一致,且沒(méi)有返回值的類(lèi)型)通常與關(guān)鍵字new配合起來(lái)構造成一個(gè)對象的初始化。
3)設定器(用來(lái)設置或修改對象的屬性值)
4)訪(fǎng)問(wèn)器(用來(lái)獲取對象的屬性值)
5)功能性的方法(它體現了對象的特有價(jià)值)
7、類(lèi)的應用
1)聲明一個(gè)該類(lèi)型的對象變量并初始化為null;
2)關(guān)鍵字new與構造器配合起來(lái)構造一個(gè)對象
3)通過(guò)設定器讓對象擁有實(shí)際屬性值。
(0608):方法對象調用、方法重載、構造器、this、final、printf
1、方法:方法是一段用來(lái)完成特定功能的代碼,用來(lái)描述該類(lèi)對象所共有的功能或行為,進(jìn)而封裝起來(lái)構成以整體。    
2、方法調用:static表示靜態(tài)
1)靜態(tài)方法可以直接調用靜態(tài)的方法;非靜態(tài)的方法可以直接調用非靜態(tài)的方法和靜態(tài)方法;即:方法名();
2)非靜態(tài)的方法必須通過(guò)對象(或對象變量)被調用;即:類(lèi)名 新名 = new 類(lèi)名();
3)原因:靜態(tài)的方法屬于類(lèi),非靜態(tài)的方法屬于對象;
4)不同類(lèi)之間的調用:類(lèi)名.方法();
3、結構:
[修飾詞][static][返回值類(lèi)型][方法名](){
方法體;
return();
}
4、特殊關(guān)鍵字this的用途?
它有兩種使用方式:
1) this.屬性或this.方法
2) this();或this(參數列表);
它代表什么?
1) 當this關(guān)鍵字以 “this.” 方式出現時(shí),代表當前對象。
2) 當this關(guān)鍵字以 “this();或this(參數列表);” 方式出現時(shí),代表本類(lèi)中的某個(gè)構造器。
5、在使用特殊關(guān)鍵字this時(shí)應注意什么?
1) this關(guān)鍵字不能在靜態(tài)方法中使用。
2) 當this以 “this();或this(參數列表);”  方式出現時(shí),它必須在本類(lèi)的構造器中使用,且必須在第一行。
6、最終的實(shí)例變量
1)用final修飾的實(shí)例變量。
2)它的特點(diǎn):最終實(shí)例變量的值一旦確定,則中途不允許改變。(最終實(shí)例變量沒(méi)有設定器)
最終實(shí)例變量在定義時(shí)若沒(méi)有給它賦值,則在每一個(gè)構造器中必須進(jìn)行初始化



(0609):靜態(tài)變量(類(lèi)變量)、(靜態(tài))初始化塊、包
靜態(tài)變量或類(lèi)變量
1、用static修飾的實(shí)例變量稱(chēng)之為靜態(tài)變量,也稱(chēng)之為類(lèi)變量。
2、它的特點(diǎn):
1) 靜態(tài)變量(類(lèi)變量),它是屬于類(lèi)的,而不屬于對象。即:
    在沒(méi)有對象存在時(shí),靜態(tài)變量是存在的。
當有一個(gè)對象或多個(gè)對象存在時(shí),靜態(tài)變量被他們共享。
2) 靜態(tài)變量(類(lèi)變量)用來(lái)解決或管理共享資源。即:
當一個(gè)對象針對共享資源操作時(shí),會(huì )影響其他對象。
3) 靜態(tài)變量通常通過(guò)類(lèi)名來(lái)訪(fǎng)問(wèn),如:  類(lèi)名.類(lèi)變量;
4) 靜態(tài)變量的設定器和訪(fǎng)問(wèn)器通常為靜態(tài)的方法。
3、在什么情況下將實(shí)例變量定義成靜態(tài)的。
當某個(gè)實(shí)例變量用來(lái)管理共享資源時(shí),將此實(shí)例變量用static修飾,使其成為類(lèi)變量。
靜態(tài)方法
1、用static 修飾的方法稱(chēng)之為靜態(tài)方法。
2、靜態(tài)方法有何特性:
1) 靜態(tài)方法不屬于對象,而屬于類(lèi)。
2) 靜態(tài)方法通常通過(guò)類(lèi)名去訪(fǎng)問(wèn),如:  類(lèi)名.靜態(tài)方法;
3) 在靜態(tài)方法中不可直接訪(fǎng)問(wèn)非靜態(tài)的實(shí)例變量?!?
4) 在靜態(tài)方法中不可使用 this 關(guān)鍵字。
3、在什么情況下將方法定義為靜態(tài)的?
1) 當一個(gè)方法只針對靜態(tài)變量(類(lèi)變量)操作時(shí)。
2) 當一個(gè)方法只用來(lái)完成特定的業(yè)務(wù),且完成業(yè)務(wù)所需要的數據來(lái)源于類(lèi)的外部,即:它不針對實(shí)例變量操作。
初始化塊
1、什么是初始化塊?
在一個(gè)類(lèi)中,用來(lái)對實(shí)例變量實(shí)現初始化的語(yǔ)句塊。
2、實(shí)例變量的初始化有三種形式?
1) 顯示初始化,即在定義時(shí)就給它一個(gè)值。
2) 通過(guò)構造器實(shí)現實(shí)例變量的初始化。
3) 通過(guò)初始化塊實(shí)現實(shí)例變量的初始化。
3、初始化塊在何時(shí)被執行?
它在每一次構造對象時(shí)被執行,且比構造器先執行。

靜態(tài)初始化塊
1、什么是靜態(tài)初始化塊?
用static修飾的初始化塊就稱(chēng)之為靜態(tài)初始塊。
2、靜態(tài)初始化塊有何特點(diǎn)。
1) 它由static關(guān)鍵字修飾。
2) 在靜態(tài)初始化塊中不能處理非靜態(tài)的實(shí)例變量,只能處理類(lèi)變量(靜態(tài)變量)。即:它通常用來(lái)對靜態(tài)變量(類(lèi)變量)作初始化。
3、靜態(tài)初始化塊在何時(shí)被執行。
在第一次加載這個(gè)類(lèi)時(shí)被執行,且只執行一次。出現類(lèi)名時(shí)。

1、什么是包?
在java語(yǔ)言中,將一個(gè)或多個(gè)類(lèi)或接口收集起來(lái)構成一組,存放在同一個(gè)文件夾中。我們把這個(gè)文件夾稱(chēng)為包。
2、如何打包?
在java語(yǔ)言中,通常關(guān)鍵字 package 來(lái)實(shí)現。
格式為:  package  包名; 或 package  包名[.子包名][.子包名]....注意: 該語(yǔ)句必須放在java源程序的第一行。
3、為什么要打包?
原因: 在java語(yǔ)言中,規定同一個(gè)位置(同一個(gè)文件夾)下類(lèi)名或接口名是唯一的。
4、如何使用包中的類(lèi)或接口。
需要通過(guò)關(guān)鍵字 import 導入。
如:  import java.util.Scanner;
#5、在命令窗口下如何編譯打包的源程序,如何運行打包的字節碼文件?

6、java5.0及以上版本的新特性: 靜態(tài)導入(指的是導入類(lèi)中的靜態(tài)方法和靜態(tài)變量)import  static  包名.類(lèi)名.靜態(tài)方法名;
或import  static  包名.類(lèi)名.靜態(tài)變量;
(0610): (常用類(lèi))基本類(lèi)型封裝類(lèi)、StringBuffer & StringBuilder、Date、DateFormat、SimpleDateForma、Calendar、Scanner 、GreforianCalendar

一、基本類(lèi)型封裝類(lèi):
基本類(lèi)型的封裝類(lèi):8個(gè)類(lèi)。
1、它們均來(lái)源于 java.lang.*;
2、基本類(lèi)型的數據可通過(guò)它們構造成對象,從而可處理其它業(yè)務(wù)。
3、java5.0新增的特性:自動(dòng)裝箱和自動(dòng)拆箱。
功能舉例:
Integer  iObj = new Integer(100);
double x = iObj.doubleValue();(將100封裝為一個(gè)對象,然后將其轉換成double型)
Double  dObj = new Double(3.95678);
int y = dObj.intValue();(將3.95678封裝成一個(gè)對象,然后將其轉換成int型)
int max = Integer.MAX_VALUE;
int min = Integer.MIN_VALUE;(獲取int型的最大值、最小值)
Integer  jObj = new Integer("156");//將數字字符串封裝成一個(gè)Integer類(lèi)的對象。
int y = jObj.intValue();//將jObj對應對象中的整數取出。
int y = Integer.parseInt("365");//直接將數字字符串轉換成int型整數。
int x = Double.parseDouble("15.3678");將\"15.3678\"數字字符串轉換成double型數;
float f1 = Float.parseFloat("21.578");將\"21.578\"數字字符串轉換成float型數;
自動(dòng)裝箱:先將1563整數封裝成一個(gè)Integer類(lèi)的對象,再將對象的地址賦給tt儲存。
Integer  mm = new Integer(1563); //人為封裝成對象
int tt = mm;
boolean flag = tt.equals( mm );//比較兩個(gè)對象是否相等。
自動(dòng)拆箱:先將對象中的數據取出,再將其賦給變量?jì)Υ妗?
int tem = mm; //將mm對象中的數據取出,再賦給tem存儲。
int temp = 1563;//比較兩對象是否相等(拆箱成功)
String s1 = Integer.toBinaryString(11);
s1 = Integer.toOctalString(11);
s1=Integer.toHexString(11); //將11轉換成二進(jìn)制(八進(jìn)制、十六進(jìn)制)數組成的串


二、可變字符串類(lèi):  StringBuffer 或 StringBuilder
1、它們來(lái)源于 java.lang.*;
2、它們構建的對象是一個(gè)可變的字符串,或可看成是一個(gè)用來(lái)存儲字符序列的容器。
3、它們有一些方法針對可變字符串操作,如:添加,插入,刪除,修改,查找,逆序等。
用法舉例:
StringBuilder  vs = new StringBuilder();//構一個(gè)可變字符串對象
vs.append("ABC");//將數據添加到vs容器中。
vs.delete(3, 7); //(從第3個(gè)開(kāi)始刪除達7個(gè))
vs.insert(0, "中國");//在vs的第0個(gè)位置上插入字符串"中國"
vs.setCharAt(1, '華');//將第一個(gè)位置上的字符修改為'華'
vs.delete(0, vs.length()); //將vs中的可變字符串(所有字符)刪除
vs.reverse();//將vs中的可變字符串逆續,即:頭變尾,尾變頭。
vs.replace(0, 5, "Beijing");//將0至5-1位置上的所有字符替換為"Beijing"
vs.deleteCharAt(0).deleteCharAt(0).deleteCharAt(0);
//連續刪除第0個(gè)位置上的字符
int loc = vs.indexOf("321");//查出vs中含321的位置;
loc = vs.indexOf("jing", 3);//從指定的第3個(gè)位置查找“jing”


三、與日期時(shí)間相關(guān)的類(lèi):   Date類(lèi):
1、它來(lái)源于 java.util.Date;
2、它用來(lái)獲取系統日期和時(shí)間,或在給定一個(gè)參數情況下創(chuàng )建一個(gè)Date類(lèi)的對象。
3、日期和時(shí)間的格式化輸出?
1) System.out.printf();
2) String.format(); //它與 1)使用的格式完全一樣,只不反饋的是字符串。
3) 借助其它類(lèi)實(shí)現。
應用舉例:
import java.util.Date;//1 導入類(lèi)
Date  d1 = new Date();//2 構建一個(gè)對象
System.out.printf("%tF  %<tT" , d1 ); 輸出日期時(shí)間
long dt = d1.getTime();//將d1對應的時(shí)間轉換成毫秒數
Date d2 = new Date( dt-1000 );//將時(shí)間提前1s
boolean flag = d1.after(d2);//判斷d1是在d2之后嗎?
flag = d1.equals(d2);//判斷d1與d2是否相等;
String str = String.format("現在日期是: %tF\n",  new Date());
(格式化輸出當時(shí)時(shí)間,反饋字符串)
SimpleDateFormat類(lèi)實(shí)現日期和時(shí)間的靈活格式化。
1、它來(lái)源于 java.text.*;
2、它可創(chuàng )建一個(gè)對象并可預先指定日期和時(shí)間的格式。
import java.text.DateFormat; //1導入類(lèi)
Date d1 = new Date();//獲取當前系統的日期和時(shí)間
String str = DateFormat.getDateInstance().format( d1 ); //使用DateFormat類(lèi)的方法實(shí)現其格式化輸出 ;//得到日期
str = DateFormat.getTimeInstance().format( d1 );//得到時(shí)間
str = DateFormat.getDateTimeInstance().format( d1 );得到日期時(shí)間
String dt = "2008-8-8";           (設定日期)
//parse()方法有一個(gè)要求: 你給定的字符串必須符合"yyyy-MM-dd"格式;否則,轉換失敗。//
Date date1 = DateFormat.getDateInstance().parse( dt );
dt = "20:08:08";      (設定時(shí)間)
//要求你給定的時(shí)間必須符合"hh:mm:ss"格式; 否則轉換失敗。
Date date2 = DateFormat.getTimeInstance().parse( dt );
dt = "2008-8-8  20:08:08";   (設定日期時(shí)間)
Date date3 = DateFormat.getDateTimeInstance().parse( dt );

四、日歷類(lèi): Calendar類(lèi) 和 其子類(lèi) GregorianCalendar類(lèi).
1、它們用管理日歷(包含過(guò)去、現在和未來(lái)的日期和時(shí)間).
2、Calendar類(lèi)是一個(gè)抽象的類(lèi),而其子類(lèi)GregorianCalendar不是。
3、在日歷類(lèi)中提供的常用方法有:
get(); 從日歷中獲取所需要的年、月、日、時(shí)等信息。
set(); 將當前日歷中的某個(gè)時(shí)間(如:年)修改為指定的時(shí)間(年)。
add(); 將當前日歷中的某個(gè)時(shí)間使其增加一個(gè)量。
4、注意:
在日歷中用0----11分別表示1----12月。
在日歷中用1----7 分別表示星期日、星期一、二、...、六。
應用舉例:
import java.util.Date;
import java.util.Calendar;
import java.util.GregorianCalendar;(類(lèi)的導入)
Calendar  dt = new GregorianCalendar();//構建了一個(gè)日歷對象,當前正好定位在系統對應的日期上。
int year = dt.get( Calendar.YEAR );//獲取年份
int month = dt.get( Calendar.MONTH )+1; //獲取月份
int today = dt.get( Calendar.DAY_OF_MONTH );//當月的幾號
int weekday = dt.get( Calendar.DAY_OF_WEEK )-1;//獲取當前日期對應的星期幾
dt.add(Calendar.DAY_OF_MONTH, 11);//定位到當前日歷中當前的日子再加11天上。
//直接讓當前的日歷定位到2008-8-8上?
dt.set(Calendar.YEAR, 2008);
dt.set(Calendar.MONTH, 7);//由于日歷中用7來(lái)表示8月,所以在設定時(shí)需要實(shí)際月份減1。
dt.set(Calendar.DAY_OF_MONTH,
;
五、Scanner
鍵盤(pán)輸入,java5.0新增的功能。
* 1、通過(guò)Scanner類(lèi)實(shí)現,它來(lái)源于java.util.*;
* 2、該提供了各種基本類(lèi)型數據輸入的方法。
* nextByte(); nextInt();
*
* 3、輸入字符串的方法: 
* next();
* nextLine(); 

應用舉例:
import java.util.Scanner;//1
Scanner  sc = new Scanner(System.in);//2
System.out.print("請輸入你的成績(jì)[0 , 100]>>>>");
int score = sc.nextInt();//3
String str = sc.next ();//可輸入字符串,空格為界
String str = sc.nextLine();//可輸入字符串,看為一串





(0613):數組、Arrays、正則表達式
一、數組
1、什么是數組?
2、數組的特性?
1) 數組中所有元素的類(lèi)型相同,有不同的位置編號,該編號是從0至n-1;
2) 數組有一個(gè)屬性為 length ,表示數組的長(cháng)度,即元素的個(gè)數。
3) 數組一旦確定,其元素個(gè)數就固定了,不可更改。
4) 在訪(fǎng)問(wèn)數組元素值時(shí)要注意:不要超出范圍:a[0] 至 a[n-1],假設數組名為a.
5) 數組通常與循環(huán)語(yǔ)句配合使用。
6) 數組的元素,其類(lèi)型可以是基本類(lèi)型,也可是引用類(lèi)型。3、數組的聲明和創(chuàng )建(以一維數組為例)?
聲明數組的格式:
類(lèi)型[]  數組名 ;   或  類(lèi)型  數組名[];

創(chuàng )建數組的格式:
數組名 = new 類(lèi)型[元素個(gè)數];
聲明與創(chuàng )建數組同時(shí)完成,格式為:
類(lèi)型[]  數組名 = new 類(lèi)型[元素個(gè)數];
*
注意:數組一旦創(chuàng )建,其元素擁有默認值,不同類(lèi)型的數組其默認值不同。
4、顯示數組的所有元素的值
往往與for循環(huán)配合實(shí)現
5、對數組的所有元素進(jìn)行初始化。
往往通常for循環(huán)來(lái)實(shí)現。
6、對數組進(jìn)行排序?
往往通過(guò)雙重for循環(huán)來(lái)實(shí)現。
7、以直接賦值的方式創(chuàng )建數組
類(lèi)型[]  數組名 = {值1, 值2, 值3, ... , 值n};
8、數組的復制
1) 將一個(gè)數組的引用直接賦給另一個(gè)數組名。
2) 通過(guò)System.arraycopy();方法實(shí)現復制。
9、命令行的參數?
在運行應用程序時(shí),所給定的數據且由主方法main的args數組來(lái)接收的參數。
注意:命令行的參數用空格隔開(kāi);
當參數本身包含空格時(shí),則該參數必須用一對雙引號括起來(lái)。
命令行的參數由args接收后,均變?yōu)樽址?lèi)型。
應用舉例:

for( int  tem :  a ) {    //數組輸出
System.out.printf( "%3d " , tem );
}
for(int i = 0;  i < a.length;  i++ ){ //一維數組初始化
a[i] = (int)(30 * Math.random())-6;
}
for(int i = 0;  i < a.length;  i++ ){ //一維數組由大到小排序
for(int j = i+1;  j < a.length;  j++ ){
if( a[i] < a[j] ){
int tem = a[i];
a[i] = a[j];
a[j] = tem;
}
}
}
1)int[] a = {32,12,98,78,23,65};//數組的復制
int[] b = null;
b = a; //將數組a的引用(地址)直接賦給數組b存放。
2)int[]  c = new int[a.length];//真正的復制
System.arraycopy(a, 0, c, 0, a.length);


二、對數組操作的工具類(lèi):  Arrays
1、它來(lái)源于  java.util.Arrays;
2、它提供了針對數組操作的常用方法:
toString(數組名);  將數組的所有元素值轉變成一個(gè)字符串。
sort(數組名);  對給定的數組進(jìn)行由小到大排序
eqauls(數組1 , 數組2); 對給定的兩個(gè)數組進(jìn)行比較相等判斷。binarySearch( 數組名, 要找的數 );
//采用二分查找法在指定的數組中查找指定的數。
若找到了,其結果定是大于等于零的數。若找不到,其結果定是一個(gè)負數。
1、多維數組是指什么?
具有相同類(lèi)型,相同名稱(chēng),不相同的多個(gè)下標的多個(gè)變量的有序集合。
2、以二維數組為例講解多維數組的聲明與創(chuàng )建及其應用。
1) 二維數組的聲明
int[][]  a;   或  int  a[][];
2) 二維數組的創(chuàng )建
a = new int[n][m];

a = new int[n][];
3、二維數組的特性:
1) 在java語(yǔ)言中,多維數組實(shí)質(zhì)上是由多個(gè)一維數組構成。 2) 在聲明數組時(shí),不能指定下標。如: int[3][4] a; //error
3) 在創(chuàng )建多維數組時(shí),應先創(chuàng )建高維后創(chuàng )建低維。
如:  a = int[][4]; //error
4、二維數組的輸出:
往往通過(guò)嵌套的for來(lái)實(shí)現
5、二維數組的初始化
往往通過(guò)嵌套的for來(lái)實(shí)現
6、不規則的二維數組,如何創(chuàng )建?
先創(chuàng )建行數,再針對每一行創(chuàng )建其元素個(gè)數。
如:
int[][]  b = new int[3][];
b[0] = new int[2];
b[1] = new int[3];
b[2] = new int[1];
7、通過(guò)直接賦值的方式創(chuàng )建一個(gè)二維數組
int[][] a = {{3,2},{1,4,9},{8,7,6,5}};
8、思考:用java5.0新增的for循環(huán)如何實(shí)現二維數組的輸出?
先將二維變量一維,再將一維變成普通變量。
通過(guò)嵌套循環(huán)實(shí)現。
9、思考:用工具類(lèi)Arrays 與 新增的for 循環(huán)結合實(shí)現二維數組的輸出。

應用舉例:
System.out.println(Arrays.toString(x));/打印數組x[];
String str = Arrays.toString( a );//將數組a的元素轉變成一字符串
Arrays.sort( a );//對數組a的元素進(jìn)行由小到大排序
boolean flag = Arrays.equals( a, b );//判斷兩個(gè)數組是否完全相等。
int loc = Arrays.binarySearch( a, temp );//查找字符temp在數組a中的位置
for(int r = 0;  r < a.length;  r++){ //二維數組元素輸出
for(int c = 0;  c < a[r].length;  c++){
System.out.printf( "%3d" , a[r][c] );
}
System.out.println();
}
for(int[] aa : c){ //采用新增的for循環(huán)實(shí)現二維數組c的輸出
for(int  bb :  aa){
System.out.printf("%3d" , bb);
}
System.out.println();//換行
}
for(int i = 0;  i < a.length;   i++){ //二維數組的初始化
for(int j = 0;  j < a[i].length;   j++){
a[i][j] = (int)(10 * Math.random());
}
}
int n = (int)(6 * Math.random());//創(chuàng )建不規則二維數組(未初始化)
int[][]  b = new int[n][];
for(int i = 0;  i < b.length;  i++){
int m = (int)(10 * Math.random());
b[i] = new int[m];
}
三、特殊方法: String類(lèi)中的split( String s1 );
它可以將一個(gè)大的字符串按照給定的分隔符將其分成多個(gè)字符串組成的數組。
1、什么是正則表達式?
2、正則表達式的作用?
3、正則表達式的特殊符號:
1)預定義符號:  \d \D \w \W  \s  \S 等
2)沒(méi)有預定義的符號通常用一對中括號括起來(lái)。
3)量詞: *  +  ?
4、正則表達式的應用方式
1) split(String regex);
2) String類(lèi)的matches()方法,如:str.matches(regex);

Pattern.matches(regex, str);方法來(lái)實(shí)現
3) 先導入Pattern和Matcher這兩個(gè)類(lèi);
再準備一個(gè)正則表達式regex;
接著(zhù)通過(guò)Pattern.compile( regex );方法將正則表達式轉換成一個(gè)編譯模式;
再通過(guò)編譯模式調用matcher( str );方法將字符串轉換成一個(gè)匹配器。
然后通過(guò)Matcher類(lèi)的find()進(jìn)行查找,
若查找成功,則調用group()方法獲取匹配的字符串。
若查找失敗,表示結束。
應用舉例:
1) String[]  words = str.split("[\\s\\d;!?]{1,}");
2) String regex = "[a-zA-Z]\\w*[@]\\w+[.]\\w{2,}";
  boolean flag = email.matches(regex);
或flag = Pattern.matches(regex, email);

(0614):繼承(基本結構)

1、什么是繼承?
注意:
1)Java語(yǔ)言中的類(lèi)都有一個(gè)父類(lèi),boject類(lèi)除外。
2)java語(yǔ)言中只支持單繼承,一個(gè)類(lèi)只有一個(gè)親父類(lèi)。
3)java語(yǔ)言中盡管不支持多繼承但可通過(guò)接口實(shí)現多繼承。
2、如何實(shí)現繼承?
通過(guò)關(guān)鍵字 extends 來(lái)實(shí)現。
格式為:
public class SubClass  extends  SuperClass{
}
3、為什么要繼承?
實(shí)現代碼的重用性,提高生成類(lèi)的效率。
4、 重寫(xiě):從父類(lèi)繼承的方法,由于當前業(yè)務(wù)的需要將該方法實(shí)現重寫(xiě),往往只改變方法的方法體,方法頭部通常不變。
為什么:當前業(yè)務(wù)需要。
注意:
通過(guò)一個(gè)現存的類(lèi)擴展生成一個(gè)新類(lèi)(子類(lèi))
//若實(shí)現了繼承,則在子類(lèi)中只要將子類(lèi)的個(gè)性描述出來(lái)即可。
(0615):繼承(遞歸、super)
特殊關(guān)鍵字:  super
1、它的使用方式有兩種形式:
1) super.屬性

super.方法
2)  super();  或  super(參數列表);
2、super關(guān)鍵字代表什么?
1) 當它以 "super." 方式出現時(shí),代表父類(lèi)的。
2) 當它以 "super(); 或 super(參數列表); " 方式出現時(shí),
代表父類(lèi)的某個(gè)構造器。 注意: 這種方式必須在子類(lèi)構造器的第一行使用。
3、注意事項:
super關(guān)鍵字一定是在子類(lèi)中使用。
"super.方法;" 往往是在子類(lèi)的重寫(xiě)方法中使用,表示調用父類(lèi)的方法。
4、在子類(lèi)的構造器,若沒(méi)有人為調用其它構造器,則會(huì )自動(dòng)調用父類(lèi)的默認構造器。
super();它代表父類(lèi)的默認構造器。
super(參數);它代表父類(lèi)的有參數的自定義構造器。
5、super.方法; 和 super();及super(參數); 這三種現象使用較多。
而 super.屬性; 這種現象使用較少。

1、什么是遞歸?
在一個(gè)方法的方法體出現了調用本身的現象。
2、遞歸在解決問(wèn)題時(shí)比較巧妙,但效率較低。
3、遞歸的案例
1+2+3+...+100 = ?
1+2+3+...+99 = ?
假設 f(n) 為: 1+2+3+...+n 的一個(gè)函數。
f(100) = 100 + f(99);
f(n) = n + f(n-1);
同時(shí),當n= =1時(shí),則f(1) 結果為 1;


!n ===>>> 1*2*3*...*n
!(n-1) ===>>>1*2*3*...*(n-1)
得:  !n == n * !(n-1);
假設 f(n) 為 !n 的函數
則有: f(n) == n * f(n-1);
再根據數學(xué)規則可知:  n == 1 ,則有 f(1) == 1
!0 == 1
//編寫(xiě)一個(gè)方法求1+2+3+...+n = 的結果
public static int f(int n){
if( n = = 1 ){
return 1;
}else{
return  n + f( n-1 ); //在方法體中出現調用本身的現象
}
}
(0617):多態(tài)
java語(yǔ)言的第三大特性:  多態(tài)性
1、什么是多態(tài)性?
多個(gè)對象在接收到同一個(gè)消息時(shí),卻產(chǎn)生了不同的反映和效果。
2、在java語(yǔ)言中多態(tài)有兩種形式.
1) 靜態(tài)的多態(tài)。 如:方法的重載。
當你在調用重載的方法時(shí),可通過(guò)實(shí)際參數的個(gè)數或類(lèi)型與
形式參數的個(gè)數和類(lèi)型進(jìn)行對比即可知調用了那個(gè)方法。
2) 動(dòng)態(tài)的多態(tài)。 如: 方法的重寫(xiě)。
一個(gè)父類(lèi)有多個(gè)子類(lèi)。
在每一個(gè)子類(lèi)中都對繼承自父類(lèi)的同一方法實(shí)現了重寫(xiě)。
在應用時(shí)通過(guò)父類(lèi)的對象變量調用了重寫(xiě)的方法。
多態(tài)通過(guò)指的是: 對象變量是多態(tài)的。即:父類(lèi)的對象變量引用了不同的子類(lèi)對象。
3、為什么要實(shí)現多態(tài)?
目的就是實(shí)現業(yè)務(wù)的統一性,高效性。
動(dòng)態(tài)綁定:通過(guò)父類(lèi)的對象變量去調用重寫(xiě)的方法。
在源程序中無(wú)法直接判斷調用了哪個(gè)重寫(xiě)的方法,需要在程序運行期間,根據as[i]所引用對象來(lái)確定。動(dòng)態(tài)綁定實(shí)現了多態(tài)的價(jià)值。因為,所有的子類(lèi)對象可由父類(lèi)的對象變量來(lái)統一管理。
(0618):最終類(lèi)、最終方法、強制類(lèi)型轉換、抽象類(lèi)
1、最終類(lèi)是指什么?
由關(guān)鍵字final修飾的類(lèi)。只要在生成類(lèi)時(shí)的class前面增加一個(gè)final。
2、最終類(lèi)的特性?
最終類(lèi)不可以被繼承,即:它不可能有子類(lèi)。
3、最終方法?
由關(guān)鍵字final修飾的方法。
4、最終方法的特性?
最終方法不可被重寫(xiě)。即:用來(lái)防重寫(xiě)。
注意:最終類(lèi)不可以有子類(lèi)。不可被繼承。防繼承。
最終方法可以被繼承,但不可被重寫(xiě)。

1、強制類(lèi)型的轉換: 父類(lèi)的身份還原成子類(lèi)的身份。
2、要實(shí)現強制轉換,必須具備以下幾個(gè)前提:
1) 父類(lèi)的對象變量引用了子類(lèi)對象。
2) 要調用子類(lèi)對象特有的方法。
3、強制類(lèi)型的轉換的格式如下:
(子類(lèi)名稱(chēng))父類(lèi)的對象變量;

子類(lèi)名 子類(lèi)的對象變量 = (子類(lèi)名稱(chēng))父類(lèi)的對象變量;
4、在進(jìn)行強制轉換時(shí),往往先判斷一下。
boolean flag = 父類(lèi)的對象變量 instanceof 子類(lèi)名;


注意: f1表面的身份是 Father類(lèi)型,而它的實(shí)際身份(它引用的對象)是Son類(lèi)型。
//f1.sub( a, b ); //以表面的身份去調用實(shí)際身份擁有的方法是不可以的,是錯誤的。

//若要調用實(shí)際身份所擁有的方法,則必須將表面身份去掉,還原它的實(shí)際身份。
//辦法就是:  強制轉換
boolean flag = f1 instanceof Son;//判斷f1所引用的對象是Son類(lèi)型嗎?
(0620):接口、自定義接口
1、如何理解接口?
2、什么是接口?
抽象方法和靜態(tài)常量的集合和抽象。接口是一種標準,是一種規則。
是對所有實(shí)現類(lèi)的要求。
3、在java語(yǔ)言中為什么要出現接口?
目的是實(shí)現多繼承。
4、在java語(yǔ)言中接口有兩種形式
1) 現存的接口(該接口由專(zhuān)家提供,存放在庫中。)
2) 自己定義接口(通過(guò)interface關(guān)鍵字來(lái)定義)
5、接口的特性
1) 接口中的方法全部是抽象的。
2) 接口中沒(méi)有實(shí)例變量。
3) 接口中還可有公共的、靜態(tài)的、最終的變量。即:常量。
4) 接口是一種標準,是一種規則。
5) 接口必須被實(shí)現,且在實(shí)現類(lèi)中必須對繼承自接口中的所有方法要一一實(shí)現其功能。
6) 接口永不能實(shí)例化。
6、如何應用現存的接口?
1) 導入現存的接口(import)
2) 編寫(xiě)一個(gè)類(lèi)實(shí)現該接口(implements)
3) 在實(shí)現類(lèi)中對繼承自接口中的所有抽象方法要一一實(shí)現其功能(即:重寫(xiě)這些方法)
4) 編寫(xiě)一個(gè)測試類(lèi)(應用程序)測試應用。
案例1:對所有學(xué)生按入學(xué)成績(jì)進(jìn)行排序。
要排序就必須比較大小,java語(yǔ)言規定對象比較大小
由Comparable接口提供的int compareTo(Object obj);方法來(lái)實(shí)現,但該的具有過(guò)程由用戶(hù)決定。
7、如何自定義接口并應用它?
1) 自定義接口(interface)
2) 導入自定義接口(import)
3) 編寫(xiě)一個(gè)類(lèi)實(shí)現該接口(implements)
4) 在實(shí)現類(lèi)中對繼承自接口中的所有抽象方法一一實(shí)現其功能,即:重寫(xiě)這些方法。
5) 編寫(xiě)一個(gè)測試類(lèi)(應用程序)測試應用。
6) 在測試類(lèi)中必須人為調用重寫(xiě)后的方法。
注意:
1、 接口是一標準,都按此標準是一種規則,是對所有現實(shí)類(lèi)的要求。
2、 抽象方法和靜態(tài)常量的集合
3、 對象比較大小用compareTo,如沒(méi)有則必用comparable接口重寫(xiě)comparTo接口。
4、 當某類(lèi)型無(wú)法比較大小時(shí)要將其轉換成自己知道的類(lèi)型。
inty=String.valueOf(this.sex).compareTo(stu2.sex+"");(性別無(wú)法比較大小,需將其轉換成字符串)
a、 在自定義接口時(shí),接口允許有父接口,也允許有多個(gè)父接口,還允許沒(méi)有父接口。
對比:任何一個(gè)類(lèi)有且只有一個(gè)父類(lèi);
通過(guò)關(guān)鍵字 interface 來(lái)生成一個(gè)接口
B、在接口中,定義的常量可省略public static final
這些修飾詞。
在接口中,定義的方法可省略public abstract 這些修飾詞。
原因是:接口中只能包含常量和抽象方法。
接口要發(fā)揮它的作用,則它必須被類(lèi)實(shí)現。、
一個(gè)類(lèi)可以實(shí)現一個(gè)接口,也可實(shí)現多個(gè)接口。
(0622):接口與回調、內部類(lèi)(匿名)、容器(Collection)
接口與回調
1、什么是回調?
當某事件發(fā)生時(shí),自動(dòng)調用某方法執行動(dòng)作。
2、通過(guò)設置一個(gè)報時(shí)器來(lái)理解回調.
報時(shí)器要具備的備件是
1) 要設定一個(gè)時(shí)間間隔,該時(shí)間以毫秒為單位。
2) 要設定一個(gè)觸發(fā)對象,即:當設定的時(shí)間到達時(shí)會(huì )觸發(fā)的對象。
3) 要讓報時(shí)器發(fā)揮它的作用,必須有一監聽(tīng)對象,而這個(gè)監聽(tīng)往往與接口相關(guān)。
ActionListener  aObj = new TimePrinter();
Timer  t1 = new Timer(5000, aObj); //創(chuàng )建一個(gè)定時(shí)器對象
t1.start();//啟動(dòng)定時(shí)器



內部類(lèi)
1、什么是內部類(lèi)?
定義在一個(gè)類(lèi)的類(lèi)體中的類(lèi)。
2、什么是外部類(lèi)?
包含內部類(lèi)的類(lèi)。
3、在內部類(lèi)的方法中是否可以直接訪(fǎng)問(wèn)外部類(lèi)的成員(屬性和方法)?
答案是: 肯定的。
4、在外部類(lèi)的方法中是否可以直接訪(fǎng)問(wèn)內部類(lèi)的成員(屬性和方法)?
答案是: 否定的。 若要訪(fǎng)問(wèn)必須通過(guò)內部類(lèi)的對象來(lái)實(shí)現。
5、在外部類(lèi)之外的類(lèi)的方法中如何訪(fǎng)問(wèn)內部類(lèi)的成員?
1) 先創(chuàng )建外部類(lèi)的對象;
如:  OutClass  a = new OutClass();
2) 再通過(guò)外部類(lèi)的對象去創(chuàng )建一個(gè)內部類(lèi)的對象;
如:  OutClass.InnerClass  b = a.new  InnerClass();
3) 最后通過(guò)內部類(lèi)的對象去訪(fǎng)問(wèn)內部類(lèi)的成員。
如:  b.innerPrintXY();
6、匿名的內部類(lèi)?
1) 沒(méi)有名字的內部類(lèi)。
2) 如何生成一個(gè)匿名的內部類(lèi)。
在構造某類(lèi)的對象時(shí),在構造器之后,分號之前加一對大括號;
然后,在大括號內重寫(xiě)該類(lèi)的某個(gè)方法。這樣生成的一段代碼、稱(chēng)之為匿名的內部類(lèi)。
容器:Collection接口
set接口:元素無(wú)序不重復;
SortedSet接口:可將元素自動(dòng)按大小排序;
List接口:元素在位置上有序,可以重復;
Map接口:構造的容器有鍵和值構成;鍵是唯一的,其內元素無(wú)序;
SortedMap接口:可自動(dòng)將案件排序;
1、記住本章中接口圖1
2、記住本章中接口及其實(shí)現類(lèi)的圖2
3、理解本章接口及其實(shí)現類(lèi)出現的原因。
4、掌握接口的特性。
5、掌握Collection接口提供的方法。
6、注意事項:
1) 容器中存放的元素均為對象。
2) 不同種類(lèi)的對象存放到容器中后,均變?yōu)镺bject類(lèi)型。
掌握Colleciton接口所提供方法的應用
Collection接口來(lái)源于 java.util.*;
應用舉例:
Collection con1 = new HashSet();
con1.add();//添加元素
con1.size();//統計con1容器中的元素個(gè)數
con1.remove();刪除某元素
flag = con1.contains();//判斷con1容器中包含了該元素?
con1.clea();//清空
flag = con1.isEmpty();//判斷con1是否為空
flag = con2.containsAll( con1 );//判斷con2是否包含con1的所有元素
con2.addAll ( con1);//con1中的元素都加到con2中去
con2.removeAll (con1);//從con2中刪除con1的所有元素
con2.retainAll (con1);//從con2中刪除不被con1包含的元素
Object [] obj = con1.toArry( ); //把容器所有元素構成一個(gè)數組。


(0623):Set接口(子接口SortedSet)、List接口及實(shí)現類(lèi)(Collections工具)
Set子類(lèi)接口的特性: 元素無(wú)序,且不重復(若添加重復元素時(shí)采用屏蔽技術(shù)不添加重復元素)
1、Set接口的實(shí)現類(lèi):  HashSet 。
2、HashSet實(shí)現類(lèi)的特性:
1) 元素無(wú)序;
2) 元素不重復,即:重復的元素添加不進(jìn)去。
3) 判斷元素相等不僅依賴(lài)equals(),同時(shí)依賴(lài)hashCode(),這兩個(gè)方法。(需重寫(xiě)兩方法)
應用舉例:
Set s1 = new HashSet();
S1.add();//添加元素;(不可添加重復元素自動(dòng)判斷)
S1.add(new Book(“JAVA”, 55 ));//添加自定義對象不可重復;
(不可以重復,需要重寫(xiě)equals()方法與hashCode()方法提供判斷標準)
public boolean equals (Object obj){
book bb = (book)obj;
(判斷語(yǔ)句??!)
}
public int hashCode(){
teturn 154;
或:
return this.name.hashCode() + String.valueOf(price).hashCode();
}
3、Set接口的子接口 SortedSet:  元素會(huì )自動(dòng)排序,且不重復。
4、SortedSet子接口的實(shí)現類(lèi):  TreeSet。它的特性:
1) 元素會(huì )自動(dòng)排序;
2) 元素不重復;
3) 判斷元素相等表面依賴(lài)equals(),實(shí)質(zhì)上依賴(lài)compareTo()。因此,當元素為自定義類(lèi)的對象時(shí),在該類(lèi)必須實(shí)現Comparable接口,重寫(xiě)compareTo()方法指定比較大小的規則。(只需重寫(xiě)compareTo)
應用舉例:
Set s2 = new TreeSet();
S2.add(“Welcome”);//添加新元素
S2.add(new Dog(“name”,555));//添加自定義對象
boolean flag = s2.add(new Dog( , , ));
//判斷是否可以添加重復自定義對象,需重寫(xiě)compareTo
Public int compareTo(Object o){};
1、List接口的特性:
1) 元素在位置上是有序的,即:每一個(gè)元素均有一個(gè)位置編號,從0至size()-1。
2) 元素可以重復。
3) 它比父接口多了一些與位置相關(guān)的操作方法,如:插入,刪除,修改,獲取指定位置上的元素等方法。
應用舉例:
List alist = new ArrayList();
alist.add(“Hello”);//添加新元素;
alist.set(0, “Beijing”);//將第0個(gè)位置上元素替換為北京
Object obj = alist.get(0);//獲取第0個(gè)位置上的元素;
alist.set(alist.size()-1, “AAA”);//將最后一個(gè)位置上的元素改為AAA;
alist.remove(alist.size()-1);//刪除最后一個(gè)元素;
int loc = alist.indexof(“Hello”);//在alist中查找“Hello”的位置并記錄;
2、List接口的常用實(shí)現類(lèi)有: ArrayList和LinkList.
A、ArrayList實(shí)現類(lèi)的特性:
1) 它采用隊列的原理來(lái)管理元素。
2) 元素在位置上是有序的,即:每個(gè)元素均有一個(gè)位置編號。
3) 元素可重復。
4) 判斷元素相等依賴(lài)equals()方法。
5) 它的查詢(xún)效率較高,而它的插入、刪除效率較低。這是由隊列的原理決定的。
應用舉例:
List alist2 = new ArrayList();
alist2.add(“Hello”);//添加新元素;
alist2.add(new Dog ( , ));//添加自定義對象;
boolean flag = alist.comtains(new Dog( , ));
//判斷容器中是否包含此自定義對象
public boolean equals(Object o){};//重寫(xiě)equals方法
B、LinkedList實(shí)現類(lèi)的特性:
1) 它采用鏈表的原理來(lái)管理元素。
2) 元素在位置上是有序的,即:每個(gè)元素均有一個(gè)位置編號。
3) 元素可重復。
4) 判斷元素相等依賴(lài)equals()方法。
5) 它的查詢(xún)效率較低,而它的插入、刪除效率較高。這是由鏈表的原理決定的。
應用舉例:
List alist3 = new LinkedList();
alist3.add(“  ”);//添加新元素;
long l1 = System.currentTimeMillis();
//獲取該語(yǔ)句開(kāi)始或結束時(shí)間;
C;如何對 List接口相關(guān)的容器中的元素進(jìn)行排序?
答案:它需要借助 工具類(lèi) Collections 。
該類(lèi)提供了相應的常用方法如下:
sort( alist ); 對alist進(jìn)行排序
List alist = new ArrayList();
alist.add(“ ”);
Object key = alist.get(n);//獲取容器第n個(gè)位置上的元素;
Collections.sort( alist );//將alist內的元素進(jìn)行排序;
Collections.shuffle(alist);//將alist內的元素隨機排序;
Colletions.reverse(alist);//將alist內的元素逆序;
int c = Collections.binarySearch(alist, “ ”);//利用二分法在容器中查找元素;




工具類(lèi) Collections 的應用
1、它只針對 與 List 接口相關(guān)的容器操作。
2、當容器存放的是自定義類(lèi)型的對象時(shí),應注意該類(lèi)必須實(shí)現Comparable接口,重寫(xiě)compareTo()方法,指定比較大小的規則。同時(shí),注意在重寫(xiě)compareTo()方法時(shí),要對對象的所有屬性一一比較大小。
3、注意1:Collections.binarySearch(alist5, key);采用二分查找法查找元素;它在查找時(shí),依賴(lài)compareTo()方法給定的標準。
注意2:List接口提供的 indexOf()方法也是用來(lái)查找,但它在查找前元素不需要排序,它判斷元素相等依賴(lài)equals()方法。
結論:在List接口相關(guān)的容器存儲自定義類(lèi)的對象時(shí),該類(lèi)必須做到:
1) 實(shí)現Comparable接口,重寫(xiě)compareTo()方法。
2) 在重寫(xiě)compareTo()方法時(shí),要對對象的屬性一一比較大小。
3) 在類(lèi)中要重寫(xiě)toString()方法便于反饋對象信息。
4) 在該類(lèi)中要重寫(xiě)equals()方法便于indexOf()方法實(shí)現查找。
應用舉例:
Collections.sort( list ); //對列表中的元素升序排序
Collections.sort( list, Collections.reverseOrder() );
//對列表中的元素降序排序(按其制定順序排序),Collections.reverseOrder()為反饋一個(gè)反自然的順序即逆序;
Collections.shuffle( list );//隨機排序列表中的元素
Comparator  comp=new   HeightComparator(); //創(chuàng )建比較器對象      
Collections.sort( list, comp); //根據比較器comp對列表對象排序(如下:)     
static class HeightComparator implements Comparator {
        int  heightCompare;//按高比較時(shí)返回負整數、零或正整數,以遍確定大小
        Person   p1, p2;//比較器要比較的兩個(gè)Person對象
      public int compare( Object object1, Object object2 ) {//實(shí)現接口中的方法
           p1 = ( Person ) object1; //強制轉換
           p2 = ( Person ) object2;
         //比較兩個(gè)對象的height大小,將他們包裝為Double對象后比較
         heightCompare = new Double(p1.height).compareTo(new Double(p2.height) );
         return heightCompare;//返回表示兩個(gè)對象大小的標志:正數表示前一個(gè)大
}
}
(0624):遍歷、Map接口(子接口SortedMap)、泛型

遍歷:
專(zhuān)門(mén)針對List接口相關(guān)的容器進(jìn)行遍歷的 ListIterator 該迭代器不僅可以正向遍歷所有元素,還可逆向遍歷所有元素。
//使用Iterator接口 對alist容器進(jìn)行遍歷
Iterator  it = alist.iterator(); //1
while( it.hasNext() ){ //2
Object obj = it.next();//3
System.out.println( obj );}
//使用ListIterator接口 對alist容器進(jìn)行遍歷(正向遍歷)
ListIterator  lit = alist.listIterator(); //1
while( lit.hasNext() ){ //2
Object obj = lit.next();//3
System.out.println( obj );//4}
泛型(java5.0及以上版本新增加的特性)
1、什么是泛型?
2、泛型產(chǎn)生的背景?
3、泛型的應用格式?
1、類(lèi)型名<元素的類(lèi)型>  變量名 = new  類(lèi)型名<元素的類(lèi)型>();
例如:  List<String>  alist = new ArrayList<String>();
2、class  類(lèi)名  implements  接口<類(lèi)名> {}
Class Dog implements comparTo<Dog>{};
4、應用泛型有何好處?
應用舉例:
//使用了泛型,明確了bb容器只能存放String類(lèi)型的元素。
List<String> bb = new ArrayList<String>();
bb.add("365");
ListIterator<String> lit = bb.listIterator();
while( lit.hasNext() ){
String str = lit.next();//遍歷時(shí)直接用該類(lèi)型接收
System.out.println( str );}

if ( iterator1.next() instanceof Integer )
    iterator1.remove();//遍歷過(guò)程中刪除某種類(lèi)型對象;
iterator1.set(((String)obj).toLowerCase());//將對象改為小寫(xiě),替換源對象;


1、Map接口的特性: 
1) 元素由鍵和值構成。
2) 元素的鍵是唯一,判斷元素相等依據元素的鍵。
3) 元素是不重復的(依據鍵來(lái)判斷)。若添加相等的元素時(shí),則采用覆蓋技術(shù),新元素的值覆蓋舊元素的值。
2、Map接口提供的常用方法有哪些?
put(key, value); 添加
3、Map接口相關(guān)的容器中的元素如何遍歷?
通過(guò)keySet()方法反饋一個(gè)Set接口的對象來(lái)實(shí)現。
應用舉例:
Map map1 = new hashMap();
map.put(  “西瓜”,  55);//添加元素
Double dou =(Double) map1.get(“西瓜”);//獲取指定鍵的元素值;
map1.remove(“西瓜”);//刪除該鍵的元素;
boolean flag = map1.containsKey(“”);
//判斷map1中是否有為該鍵的元素;
Boolean flag = map1.containsValue(12);
//判斷map1中是否含為該值的元素;
flag = map1.isEmpety();//判斷容器是否為空;
map1.putAll(map2);/將map2中的元素全添加到map1中;
Set  keys = map1.keySet(); //1 將map1中所有元素的鍵收集后構成一個(gè)集合。
Iterator it = keys.iterator();//2 通過(guò)Set接口的方法iterator()反饋一個(gè)迭代器
while( it.hasNext() ){ //3 判斷遍歷過(guò)嗎
Object obj = it.next(); //4
String key = (String)obj; //5
Double value1 = (Double)map1.get(key);//6
System.out.println("元素的鍵為: " + key + " 而元素的值為: " + value1 );}}
4、Map接口實(shí)現類(lèi): HashMap的特性
1) 元素是無(wú)序的(看:鍵是否有序)。
2) 元素不重復,在添加相同元素時(shí),采用覆蓋技術(shù)用新元素的值覆蓋舊元素的值。
3) 判斷元素相等(判斷鍵是否相等)依賴(lài)equals()和hashCode()兩個(gè)方法。
注意:當元素的鍵是自定義類(lèi)型時(shí),該類(lèi)中必須重寫(xiě)equals()和hashCode()方法。也要重寫(xiě)toString()便于反饋對象信息。
5、Map接口的子接口SortedMap,其實(shí)現類(lèi)為: TreeMap,它的特性:
1) 元素是有序的,元素會(huì )按鍵自動(dòng)排序。
2) 元素不重復,在添加相同元素時(shí),采用覆蓋技術(shù)用新元素的值覆蓋舊元素的值。
3) 判斷元素相等(判斷鍵是否相等)表面依賴(lài)equals(),但實(shí)質(zhì)上依賴(lài)compareTo()方法。
注意: 當元素的鍵是自定義類(lèi)型時(shí),該類(lèi)必須實(shí)現Comparable接口,重寫(xiě)compareTo()方法,并且盡量對對象的所有屬性一一比較大小。
思考: 如何產(chǎn)生十個(gè)不同的隨機整數?

(0627):異常處理、throws、throw、創(chuàng )建異常類(lèi)
一、常見(jiàn)異常:
java.lang.NullPointerException   空指針異常
java.lang.ArrayIndexOutOfBoundsException  數組下標越界
java.lang.ArithmeticException   算數異常;
java.lang.NumberFormatException  數據格式異常
java.lang.ParseException    轉換異常;
FileNotFoundException     文件找不到的異常
IoException         無(wú)法讀取文件,或損壞;
二、main方法中異常處理:
Try{
}catch (Exception e) {
e.toString();//獲取異常對象的名稱(chēng)和異常的原因
e.getMessage();//獲取異常的原因
e.printStackTrace();//將異常的所有信息(異常的名稱(chēng),原因,異常發(fā)生位置)打印到屏幕上。
}
一個(gè)try后面可以跟多個(gè)catch;
Arguments 命令行給定參數;
三、文件讀?。?
import java.io.FileInputStream;//文件的字節輸入流: 以字節方式讀取文件的內容。
或import java.io.FileReader;//文件的字符輸入流:以字符方式讀取文件的內容。
String path = "d:\\a1.java";
FileInputStream  fis = null;
try {
fis = new FileInputStream( path );
int n = fis.read();
while( n >= 0 ){
System.out.print( (char)n );
n = fis.read();
}


四、在重寫(xiě)方法時(shí)如何拋出異常,它必須遵循兩個(gè)原則。
1、在重寫(xiě)方法時(shí),不可拋出比原方法還要高級的異常。
2、在重寫(xiě)方法時(shí),不可拋出比原方法還要多的異常,但不一定指個(gè)數。
1) 當多出來(lái)的異常屬于原異常的子異常時(shí),則是合法的。
2) 當多出來(lái)的異常屬于未檢查的異常時(shí),則也是合法的。
3) 當多出來(lái)的異常屬于已檢查的異常且不屬于原異常的子異常時(shí),則是非法的。
五、finally語(yǔ)句:
1、一個(gè)try可以跟上一個(gè)catch或多個(gè)catch,而catch是有順序的,順序是:先子后父。
2、一個(gè)try后面要么跟catch,要么跟finally,要么同時(shí)跟catch和finally。
3、finally語(yǔ)句塊,其中的代碼一定會(huì )執行,不論是否有異常。
4、finally語(yǔ)句塊中的代碼通常用來(lái)關(guān)閉已打開(kāi)的文件或斷開(kāi)已連接的數據庫等操作。
六、Throw自定義異常(聲明):
不帶s的關(guān)鍵字 throw , 它一定是用在方法的內部。
1、它以語(yǔ)句的方式出現在方法體中,它通常后跟一個(gè)異常對象。
2、它表示在方法體產(chǎn)生了一個(gè)指定的異常。
3、在使用throw關(guān)鍵字時(shí),通常在該方法的頭部使用帶s的throws關(guān)鍵將異常拋到方法的外面去(即:方法調用處)。
舉例:
public void setAge(int age)  throws IOException {// 2 人為拋出異常
if( age > 0  && age <= 150 ){
this.age = age;
}else{
throw  new IOException(age + ", 這個(gè)給定的年齡是非法的。");//1 人為產(chǎn)生一個(gè)異常
}
}



七、關(guān)鍵字Throws:
1、它一定用在方法的頭部,將異常拋出(拋到該方法的調用處)。
2、建議:在編寫(xiě)方法時(shí),方法體中若有異常產(chǎn)生,則通常在該方法的頭部用throws關(guān)鍵字將產(chǎn)生的異常拋出去。
案例: 編寫(xiě)一個(gè)方法用來(lái)讀取指定文件的內容。
3、throws關(guān)鍵字一定是用在方法的首部,將異常拋出。
4、在非main方法中產(chǎn)生了異常,通常都在方法的頭部用throws將異常拋出去。(都拋到main方法中集中處理)

(0629):流與文件
輸入/出流
1、流的特征?
2、在java語(yǔ)言中,IO流有三種分類(lèi)?
3、在java語(yǔ)言中,所有的流均來(lái)源于java.io包。同時(shí),它們繼承自四個(gè)抽象的類(lèi)。
4、四個(gè)抽象的類(lèi): InputStream和OutputStream , Reader和Writer兩對。
5、InputStream 稱(chēng)以字節為單位的輸入流,它的常用方法如:
int read(); 以字節為單位讀取數據,反饋一個(gè)整數。當反饋是-1時(shí),表示讀完了。
void close(); 關(guān)閉輸入流,釋放所占資源。
6、OutputStream  稱(chēng)為以字節為單位的輸出流,它的常用方法如:
void write(int x); 以字節為單位存儲數據。
所以要注意給定的x應小于或等于255,若大于255,存儲數據會(huì )失真。
void flush(); 將緩沖區中的數據一次性寫(xiě)到存儲的目的地(文件)去. 確保存盤(pán)成功。void close(); 關(guān)閉輸出流,釋放所占資源。
7、Reader 稱(chēng)為以字符為單位的輸入流,它的常用方法如:
int read(); 以字符的方式讀取數據,反饋一個(gè)整數。當反饋-1時(shí),表示讀完了。
void close(); 關(guān)閉輸入流,釋放所占資源。
8、Writer 稱(chēng)為以字符為單位的輸出流,它的常用方法如: void wirte(int x); 以字符為單位存儲數據。
void close(); 關(guān)閉輸出流,釋放所占資源。
void flush(); 將緩沖區中的數據一次性寫(xiě)到存儲地(文件)中去。確保存盤(pán)成功。
9、File文件類(lèi),它的作用:用來(lái)管理(創(chuàng )建,刪除,修改,查看等)文件和目錄。
該類(lèi)的常用方法: 
案例1: 將指定位置下的所有文件名、目錄名及其相關(guān)屬性列出。
應用舉例:
//1 準備一個(gè)路徑
String path = System.getProperty("user.dir"); //獲取當前用戶(hù)的當前工作路徑
(System.getProperty(“l(fā)ine.separator”);文件中換行、換段)
//2 構建一個(gè)File類(lèi)的對象來(lái)管理此路徑
File  f1 = new  File( path );
//3 通過(guò)File類(lèi)對象的list()方法獲取指定路徑下的文件名和目錄,構成一個(gè)數組。
String[] fileDirNames = f1.list();
//4將路徑信息與文件名和目錄存放在File類(lèi)中,一一取出;
File  f2 = new File( path + "\\" + fileDirNames[i] );
long dt = f2.lastModified();//5獲取修改日期(毫秒數)
Date d1 = new Date(dt);//轉換成日期類(lèi)
long len = f2.length();//獲取文件大??;
1) 什么是路徑?
2) 絕對路徑和相對路徑?
3) ./ 當目錄 ;   ../ 表示當前目錄上一級,即:父目錄。
案例2: 在用戶(hù)當前的工作位置下創(chuàng )建一系列目錄和一個(gè)文件。
應用舉例:
String  path = System.getProperty("user.dir");
//獲取用戶(hù)當前的工作位置
//1 準備要創(chuàng )建的文件名和一系列目錄名。
String  fileName = "MyFileasdfasdf.java";
String  dirs = "目錄1" + File.separator + "目錄11";
//構造一個(gè)File類(lèi)的對象。注意:這里dirs, fileName在磁盤(pán)上是不存在的。
File  f1 = new File( dirs, fileName );
f1.getParentFile().mkdirs(); //創(chuàng )建一系列目錄,即:創(chuàng )建"目錄1\目錄11"
f1.createNewFile();//創(chuàng )建MyFile.java文件
File類(lèi)常用方法:
boolean canRead();boolean canWrite();可讀可寫(xiě)嗎?
boolean exists();存在嗎?
boolean isFile();是文件目錄嗎?
boolean isHidden();是隱藏的嗎?
long lastModified();獲取最后的修改時(shí)間;
long length();獲得文件長(cháng)度;
String getName();獲得文件目錄或名稱(chēng);
String getPath();獲得文件的路徑;
boolean createNewFile();創(chuàng )建一個(gè)文件或目錄;
boolean delete();刪除文件或目錄;
void boolean deleteOnExit();jvm退出時(shí)刪除;
boolean mkdir();創(chuàng )建單個(gè)目錄;
boolean mkdirs();創(chuàng )建在路徑中的一系列目錄;
String【】 list();列出該目錄下的所有文件名及目錄名放在字符串數組中;
System path = System.getproperty(“use.dir”);獲取當前用戶(hù)的工作路徑;
File f1 = new File();
f1.getAbsolutePat();獲取文件的絕對路徑;
二、以字節方式讀取文件或存盤(pán)文件的操作類(lèi): FileInputStream 和 FileOutputStream
1、FileInputStream : 文件的字節輸入流。
int read(); 以字節方式讀取文件的內容,當反饋-1時(shí)表示結束了。
void close(); 關(guān)閉輸入流,釋放所占資源。
案例1: 以字節的方式讀取文件的內容并顯示在屏幕上。
//1 準備要讀取的文件
String  path = "d:\\a1.txt";
//2 聲明FileInputStream類(lèi)的對象變量
FileInputStream  fis = null;
//3 創(chuàng )建該類(lèi)對象實(shí)現文件內容的讀取
fis = new  FileInputStream( path );//3
int x = fis.read();//4 讀取
while( x != -1 ){// 判斷讀完了嗎?

fis.close();//文件關(guān)閉
2、FileOutputStream : 文件的字節輸出流。
void write(int x);
void close();
void flush();
案例2 : 以字節方式將數據(26個(gè)字母)存儲到文件中。
//1準備要存儲的文件
String  path = "d:\\char26.txt";
//2聲明FileOutputStream類(lèi)的對象變量
FileOutputStream  fos = null;
//3創(chuàng )建該類(lèi)對象實(shí)現文件內容的存儲
fos = new FileOutputStream( path );//3
fos.write( “要寫(xiě)的內容” );
fos.flush(); //確保存盤(pán)成功。
if( fos != null )//文件關(guān)閉
將FileInputStream 和 FileOutputStream 兩者合起實(shí)現文件的復制。

(0630):文件字符輸入輸出流、緩沖流、處理流
一、文件字符輸入輸出流
FileReader : 文件的字符輸入流。
1、它以字符的方式讀取文件的內容。
2、它的常用方法:
int read(); 以讀取文件內容的一個(gè)字符,
反饋該字符的編碼值,若為-1則表示結束了。
void close();
3、案例:讀取指定文件的內容并顯示在屏幕上。
FileWriter : 文件的字符輸出流。
1、它以字符方式將數據存盤(pán)。
2、它的常用方法:
void write( int x );
void flush();
void close();
3、案例: 將26個(gè)大寫(xiě)字母或多個(gè)漢字存盤(pán)到指定的文件中。
將FileReader 和 FileWriter 兩者合起實(shí)現文件的復制。
思考2:  對于文本文件,能否從某個(gè)百分數(如:50%處)開(kāi)始復制。
對FileWriter類(lèi)提供特有方法:
void  writer(String str); 用來(lái)存儲一個(gè)字符串。
二、緩沖流
緩沖流有兩對:
1、緩沖的字節輸入/出流。
BufferedInputStream  : 緩沖的字節輸入流。
BufferedOutputStream : 緩沖的字節輸出流。
2、緩沖的字符輸入/出流。
BufferedReader  : 緩沖的字符輸入流。
BufferedWriter  : 緩沖的字符輸出流。
3、緩沖流必須套接在節點(diǎn)流上。
4、緩沖流出現的目的是: 提高輸入/出效率。
案例:提高復制文件的速度。
5、緩沖流的特性:
1、提高輸入或輸出的速度,即:效率。
2、緩沖流的特有方法:
1) mark(); 用來(lái)作標記,便于中途返回到該標記處。
2) reset(); 它與mark();方法配合使用,用來(lái)返回到標記處。
3) BufferedReader類(lèi)的 readLine()方法,用來(lái)讀取整行內容。
4) BufferedWriter類(lèi)的 newLine()方法,用來(lái)產(chǎn)生一個(gè)新行,即: 換行。
應用舉例:
bis.mark(365); //作標記(365作為標記可變)
bis.reset(); //返回到標記處。

str = br.readLine();//讀取一行, 當遇到\r或\n時(shí)表示一行結束了。
bw.write( str );//將讀取的一行內容存盤(pán)到bw對應的文件去。
bw.newLine(); //bw.write("\r\n"); //在文件中換行。
文件加速復制(利用緩存):
FileInputStream   fis = null;
FileOutputStream  fos = null;
////////////////////
BufferedInputStream   bis = null;
BufferedOutputStream  bos = null;
////////////////////
fis = new FileInputStream( path1 );
fos = new FileOutputStream( path2 );
//將節點(diǎn)流(文件字節輸入流)作為參數創(chuàng )建緩沖流。
bis = new BufferedInputStream( fis ); //提高讀取的速度
bos = new BufferedOutputStream( fos );//提高存盤(pán)的速度
int x = bis.read(); //fis.read();
bos.write( x ); //fos.write( x );
bos.flush();  //fos.flush();
bis.close();
fis.close();
bos.close();
fos.close();
三、處理流:
處理流:  LineNumberReader 類(lèi),它以行的方式讀取文件的內容。
以上類(lèi)還有具有:讀取行號的功能。
LineNumberReader  lnr = null;
fr = new FileReader( path );
lnr = new LineNumberReader( fr );//創(chuàng )建以行的方式處理文件內容
String str = lnr.readLine();
int row = lnr.getLineNumber(); //讀取行號






(0704):對象流、數據流、轉換流、打印流、鍵盤(pán)輸入
對象流:ObjectInputStream 和 ObjectOutputStream 一對。
1、它們以對象為單位,將對象實(shí)現存盤(pán)或讀取。
2、方法:writeObject(); 和 readObject(); 實(shí)現對象的存盤(pán)和讀取。
3、對象流的使用必須做到以下幾點(diǎn):
1) 自定義類(lèi)必須實(shí)現java.io.Serializable; 使對象串行化。
2) 在自定義類(lèi)往往需要重寫(xiě) toString();方法。
3) 在創(chuàng )建對象流時(shí),必須套接在FileOutputStream(path)和FileInputStream(path)對象上。
4) 通過(guò)writeObject(Object obj);方法將對象存盤(pán)。
5) 通過(guò)readObject();方法讀取對象。
應用舉例:
//準備一個(gè)文件用來(lái)存儲對象
String path = "d:/Objects.txt";
//準備對象輸出流的對象變量
ObjectOutputStream  oos = null;
//準備對象輸入流的對象變量
ObjectInputStream  ois = null;

//準備要存盤(pán)的對象
Person p1 = new Person("張三", true, 21);
Person p2 = new Person("李四", false, 19);
Person p3 = new Person("王二", true, 22);

try {
//創(chuàng )建對象輸出流的對象,實(shí)現將對象存盤(pán)到文件中。
oos = new ObjectOutputStream( new FileOutputStream(path) );
oos.writeObject( p1 ); //將對象存盤(pán)
oos.writeObject( p3 );
oos.writeObject( p2 );
oos.flush();//確保存盤(pán)成功。
//創(chuàng )建對象輸入流的對象,實(shí)現讀取指定文件中的對象
ois = new ObjectInputStream( newFileInputStream(path) );
//顯示這三個(gè)對象的內容。
Person pp = (Person)ois.readObject();
while( pp != null ){
System.out.println( pp );
pp = (Person)ois.readObject();
}
oos.close();
}

數據流: DataInputStream和DataOutputStream 一對。
1、DataInputStream 數據字節輸入流。專(zhuān)門(mén)用來(lái)處理八種基本類(lèi)型的數據及字符串的輸入。
2、DataOutputStream 數據字節輸出流。專(zhuān)門(mén)用來(lái)處理八種基本類(lèi)型的數據及字符串的輸出。
3、它們通常用來(lái)網(wǎng)絡(luò )中實(shí)現基本類(lèi)型數據的輸入輸出。
4、它們的方法是配對使用的。如:
readInt();  與 writeInt();  等。
readUTF();  與 writeUTF(); 用來(lái)處理字符串。
5、它們在使用時(shí),要注意輸出與輸入的順序及其配對方法的應用。
6、數據流屬于處理流,它在使用必須套接在節點(diǎn)流。
應用舉例:
案例:將八種基本類(lèi)型的數據及字符串存盤(pán)到某個(gè)文件中;之后,讀取它們并顯示在屏幕上。
//準備
String  path = "d:/datas.dat";
//準備一個(gè)數據輸出流的對象變量
DataOutputStream  dos = null;
//準備一個(gè)數據輸入流的對象變量
DataInputStream   dis = null;
try {
//構建一個(gè)數據輸出流的對象實(shí)現基本類(lèi)型數據的存盤(pán)
dos = new DataOutputStream( newFileOutputStream(path) );
//以下是將八種基本類(lèi)型的數據存盤(pán)。
dos.writeByte(127);


//將字符串存盤(pán)。
dos.writeUTF( "今天是個(gè)好天氣!" );
dos.flush();//確保存盤(pán)成功。
System.out.println("八種基本類(lèi)型的數據及字符串存盤(pán)成功。存在" + path + "文件中了。");
//創(chuàng )建一個(gè)數據的輸入流實(shí)現八種基本類(lèi)型數據及字符串讀取。
dis = new  DataInputStream( newFileInputStream(path) );

//以下是讀取八種基本類(lèi)型的數據。
byte b1 = dis.readByte();
///與存儲順序一一對應。
short s1 = dis.readShort();


//讀取字符串。
String str = dis.readUTF();
System.out.println( b1 );
System.out.println( s1 );

System.out.println( str );
System.out.println("讀取" + path + "文件內容結束了。");
dos.close();

dis.close();

轉換流:字節流轉換成字符流 或 字符流轉換成字節流。
1、InputStreamReader : 字節轉換成字符的一個(gè)以字符方式讀取內容的轉換流。
它通常套接在字節流上,如: new FileInputStream(path);
2、OutputStreamWriter : 字符轉換成字節的一個(gè)以字節的方式存盤(pán)的轉換流。
它通常套接在字節流上,如: new FileOutputStream( path );
3、在轉換流上,還可指定字符的編碼集,即:指定字符的編碼方案。
4、案例1: 以字符的方式讀取文件的內容,但給你的是文件的字節輸入流。 (輸入流: 由里到外。)
FileInputStream fis = null;
//創(chuàng )建一個(gè)緩沖的字符輸入流對象.注意:中間要有一個(gè)轉換流.
br=newBufferedReader( new InputStreamReader(fis) );
(以指定的字符編碼集讀?。海?
InputStreamReader  isr = null;
FileInputStream  fis = null;
//由isr轉換流需要套接在 fis上,所以先創(chuàng )建fis的對象。
fis = new FileInputStream( path );
//創(chuàng )建一個(gè)轉換流,指定以utf-8方式讀取文件的內容
isr = new InputStreamReader( fis , "utf-8");

5、 案例2: 以字節的方式存儲數據,但你給的是字符串(或多個(gè)字符)。 (輸出流: 由外到里。)
//創(chuàng )建一個(gè)緩沖的字符輸出流對象.注意:中間要有一個(gè)轉換流.
//bw = new BufferedWriter(new OutputStreamWriter(
new FileOutputStream(path)));
(已指定的編碼集輸出:)
OutputStreamWriter  osw = null; //2
FileOutputStream  fos = null; //3
//由osw轉換流必須套接在 fos文件流上。
fos = new FileOutputStream( path );//4
//創(chuàng )建轉換流同時(shí)指定字符編碼方案為utf-8
osw = new OutputStreamWriter( fos , "utf-8"); //5
//將給定的串以utf-8編碼方案存盤(pán)到osw所套接fos上,即存盤(pán)到path文件中。
打印流: 它一定是輸出流。它有: PrintStream 字節的打印流和PrintWriter字符的打印流。
1、打印流具有自動(dòng)刷新功能。
2、它還具有自動(dòng)的字符轉換成字節流的功能。
即:當使用PrintStream字節打印流打印漢字(字符)時(shí),中間不需要轉換流。
3、打印流的常用方法為:
* print();
* println();
而且以上兩個(gè)方法都是重載的方法。
4、在創(chuàng )建打印流對象,它需要套接節點(diǎn)流上。如:  FileOutputStream 或 FileWriter上。
當然,也可直接把 path 作為參數創(chuàng )建打印流對象。( <<<< 這是打印流的特點(diǎn)。)
(1: 將一些字符以字節打印流的方式打印輸出到文件中。)
String path = "printChars.txt";
//準備一個(gè)字節的打印流
PrintStream  ps = null;
//創(chuàng )建一個(gè)字節的打印流對象
ps = new PrintStream( path ); //new PrintStream( new FileOutputStream(path) );
(2使用字符打印流將多個(gè)字符打印到文件中。)
PrintWriter  pw = null;
pw = new PrintWriter( new FileWriter(path) ); for(int i = 0; i < chs.length;  i++){
pw.print( chs[i] );
}

(3改變默認輸出:System.out();)
ps = new PrintStream( path );
PrintStream old = System.out; //照像
System.setOut( ps );
// 改變。將系統默認的輸出設備改為 ps(即將內容寫(xiě)在path內)
System.setOut( old ); //還原 默認(即將內容顯示在屏幕上)
System.out.println("程序到此結束了!");




鍵盤(pán)輸入:
//在沒(méi)有Scanner類(lèi)時(shí)如何從鍵盤(pán)輸入數據
BufferedReader  br = null;//1創(chuàng )建緩存對象
br = new BufferedReader(newInputStreamReader(System.in));   
//2從鍵盤(pán)輸入,轉換成字符流
System.out.print("請從鍵盤(pán)上輸入一個(gè)字符串(exit退出)>>>>>");
try {
String str = br.readLine();//3讀取
while( !str.equals( "exit" ) ){
System.out.println("你輸入的是: " + str );
System.out.print("請繼續輸入>>>");
str = br.readLine();
}
System.out.println(" End. ");
}





(0705):Java 多線(xiàn)程機制
1、理解并掌握三個(gè)概念: 程序、進(jìn)程和線(xiàn)程?
程序+數據+文檔= 軟件;
程序是靜態(tài)的軟件的核心;
正在執行的程序就叫進(jìn)程;動(dòng)態(tài)的
線(xiàn)程是進(jìn)程的單一的連續的執行流,一個(gè)進(jìn)程可以有多個(gè)線(xiàn)程構成;
2、在java語(yǔ)言中,通過(guò)java.lang.Thread線(xiàn)程類(lèi)來(lái)管理線(xiàn)程。
3、每一個(gè)線(xiàn)程對象都有五個(gè)狀態(tài):
新生狀態(tài),就緒狀態(tài),執行狀態(tài),[阻塞狀態(tài)],死亡狀態(tài),
4、線(xiàn)程的新生狀態(tài)是通過(guò) new + 線(xiàn)程的構造器 來(lái)實(shí)現。
5、線(xiàn)程由新生狀態(tài) 通過(guò)Thread類(lèi)提供的 start() 方法使其進(jìn)行就緒狀態(tài)。
6、在java語(yǔ)言中,任何一個(gè)線(xiàn)程對象都有一個(gè)run()方法,即:線(xiàn)程體。
它用來(lái)完成線(xiàn)程的主要任務(wù),而且該方法是在線(xiàn)程進(jìn)入就緒狀態(tài)后由cpu自動(dòng)決定調用的,不是人為調用的。
7、在java語(yǔ)言中,創(chuàng )建線(xiàn)程類(lèi)有兩種方法:
(當所構建的類(lèi)已有一個(gè)普通類(lèi)作為他的父類(lèi)時(shí)要用實(shí)現Runnable接口創(chuàng )建線(xiàn)程類(lèi);(java語(yǔ)言支持單繼承))
1) 通過(guò)Thread類(lèi)擴展生成一個(gè)線(xiàn)程子類(lèi)。
public class Thread1 extends  Thread {
//重寫(xiě)線(xiàn)程體
@Override
public void run() {}
}
(測試類(lèi))
//創(chuàng )建兩個(gè)Thread1的線(xiàn)程對象。
Thread1  t1 = new Thread1("AAA");
Thread1  t2 = new Thread1("BBB");
//讓t1,t2線(xiàn)程對象進(jìn)行就緒狀態(tài)
t1.start();
t2.start();
}
2) 通過(guò)實(shí)現java.lang.Runnable接口來(lái)創(chuàng )建一個(gè)線(xiàn)程子類(lèi)。
注:為什么要出現第二種方法。(java支持單繼承,為了實(shí)現多繼承)
public class Thread2 extends Person  implements  Runnable {
//重寫(xiě)線(xiàn)程體
@Override
public void run() {}
}
(測試類(lèi):)
Thread2  t1 = new Thread2("ABC");
Thread2  t2 = new Thread2("CBA");
//在第二種創(chuàng )建子線(xiàn)程類(lèi)的方法中,無(wú)法讓線(xiàn)程對象進(jìn)入就緒狀態(tài)。
//將t1作參數目的是用t1的run()方法去覆蓋Thread類(lèi)對象的run()方法。
Thread  t11 = new Thread( t1 );
Thread  t22 = new Thread( t2 );
t11.start();
t22.start();
}



3) 人為干預線(xiàn)程對象的結束。
String name = Thread.currentThread().getName();
//獲取當前線(xiàn)程對象的名稱(chēng).

//重寫(xiě)線(xiàn)程體。
public void run() {

}
//控制線(xiàn)程對象的停止的方法。
public void isStop(){
this.isStop = true;
}
(測試類(lèi):)
public static void main(String[] args) {
//明白:主方法main也是一個(gè)主線(xiàn)程,其名稱(chēng)就是 main 。
String  na = Thread.currentThread().getName(); //獲取當前線(xiàn)程對象。
SubThread3  t1 = new SubThread3();
t1.setName( "AAA" );//通過(guò)Thread類(lèi)的setName()方法為t1線(xiàn)程取名稱(chēng)。
t1.start();//使程序進(jìn)入就緒狀態(tài);


* 這個(gè)循環(huán)的作用:拖延main線(xiàn)程的時(shí)間,從而讓t1.isStop()在一段時(shí)間后執行。* 即:使得t1線(xiàn)程有一定時(shí)間去工作。
for(int i = 1;  i <= 1000000;  i++){
System.out.print("");
}
t1.isStop(); //調用此方法的目的是什么?
讓程序停止,調用自定義類(lèi)中的停止方法;
}

常用方法:
t1.start();
t1.
線(xiàn)程同步:
Synchronized修飾方法時(shí)往往用wait()讓當前線(xiàn)程進(jìn)入等待狀態(tài);
notify()表示當前線(xiàn)程去喚醒等待者,配合他使用,兩個(gè)方法來(lái)自于Object類(lèi)
當方法對共享資源進(jìn)行操作時(shí),要用synchronized進(jìn)行限制,要求其達到同步。





(0706):網(wǎng)絡(luò )程序設計

一、計算機網(wǎng)絡(luò ):不同地理范圍有獨立功能,通過(guò)通信介質(zhì),在網(wǎng)絡(luò )操作系統控制下,通信雙方遵守共同的通訊規則,實(shí)現相互信息的傳遞,同時(shí)達到資源共享的計算機群
資源:硬件資源,軟件資源,信息資源
網(wǎng)絡(luò )協(xié)議:通信規則;
OSI:開(kāi)放的虛擬模型
Arpn網(wǎng)絡(luò )起源 阿帕網(wǎng)
傳輸層:遵守規則
路由:為數據傳輸選擇最佳路徑
路由器:實(shí)現路由的設備
Link:鏈路層,電氣設備匹配
相鄰層不認識,每經(jīng)過(guò)一層,加上每一次控制協(xié)議,最終統統轉換為2進(jìn)制數據,控制電流,然后相反拆包。
Ip:網(wǎng)絡(luò )地址,表示網(wǎng)絡(luò )的唯一編號。
Tcp:傳輸控制協(xié)議,需連接,像打電話(huà)
Udp:無(wú)需連接,不可靠的連接。
url:統一資源定位器,域名,(協(xié)議 主機名 端口 文件信息)
單機編程
c/s局域網(wǎng)編程(客戶(hù)端/服務(wù)器)
b/s遠程化編程(j2EE)(瀏覽器/服務(wù)器)
對等網(wǎng)
Ipconfig/all查看本機ip
WINDOWS\system32>ipconfig/all
Cooke:字符串 跟蹤服務(wù)器
127.0.0.1表示本機;



UDP通訊:
1、UDP是什么?
2、UDP的特點(diǎn)是什么?
3、UDP通訊的必要條件?
1) DatagramSocket(數據報套接字類(lèi)) 和DatagramPacket(數據報包類(lèi))
2) InetAddress (網(wǎng)絡(luò )地址類(lèi))
3) 需要一個(gè)字節類(lèi)型的數組用來(lái)接收來(lái)存儲信息。
4、如何在服務(wù)器上實(shí)現UDP通訊?
1) 構建一個(gè)DatagramSocekt類(lèi)的對象,并開(kāi)放一個(gè)端口。
2) 準備一個(gè)接收數據的接收數據報包(通過(guò)DatagramPacket類(lèi)創(chuàng )建)。
3) 調用receive()方法接收客戶(hù)端發(fā)來(lái)的信息。
4) 在接收數據報包上獲取客戶(hù)端的地址和端口號。
5) 將客戶(hù)端的地址和端口號及要發(fā)送的數據封裝成一個(gè)發(fā)送數據報包。
6) 調用send()方法將發(fā)送數據報包發(fā)送給客戶(hù)。
7) 重復 2)至6) 步驟可反復實(shí)現數據的接收與發(fā)送。
5、如何在客戶(hù)端上實(shí)現UDP通訊?
1) 構建一個(gè)DatagramSocekt類(lèi)的對象。
2) 將服務(wù)器公開(kāi)的地址和開(kāi)放的端口號以及要發(fā)送的數據封裝成一個(gè)發(fā)送數據報包。
3) 調用send()方法將發(fā)送數據報包發(fā)送給服務(wù)器。
4) 準備一個(gè)接收數據的接收數據報包。
5) 調用receive()方法接收服務(wù)器發(fā)來(lái)的信息。
6) 從接收數據報包上獲取信息并做相關(guān)的處理(如:顯示)。
7) 通訊完畢,要關(guān)閉DatagramSocket對象。
[/size][/size]
本站僅提供存儲服務(wù),所有內容均由用戶(hù)發(fā)布,如發(fā)現有害或侵權內容,請點(diǎn)擊舉報。
打開(kāi)APP,閱讀全文并永久保存 查看更多類(lèi)似文章
猜你喜歡
類(lèi)似文章
近5年133個(gè)Java面試問(wèn)題列表 – 碼農網(wǎng)
Java核心技術(shù) PDF 高清電子書(shū)
Java面試資源:百度“Java面試題”前200頁(yè)都在這里了
.Net 面試題整理(一)
100個(gè)你應該知道的java基礎知識
php學(xué)習筆記
更多類(lèi)似文章 >>
生活服務(wù)
分享 收藏 導長(cháng)圖 關(guān)注 下載文章
綁定賬號成功
后續可登錄賬號暢享VIP特權!
如果VIP功能使用有故障,
可點(diǎn)擊這里聯(lián)系客服!

聯(lián)系客服

欧美性猛交XXXX免费看蜜桃,成人网18免费韩国,亚洲国产成人精品区综合,欧美日韩一区二区三区高清不卡,亚洲综合一区二区精品久久