java基礎知識點總結 1

>標示符： 全部的名字 和同類區分 方便調用
       命名規則：由數字字母_$組成 不能以數字開頭 區分大小寫 不能是java關鍵字
命名規範：儘可能增長可讀性
類名：全部單詞首字母大寫
變量名/方法名:除了第一個單詞 其餘單詞首字母大寫
final常量： 全部字母大寫
>關鍵字：java中被賦予特殊含義的單詞或者字符
static void
byte short int long float double boolean char
protected private public
static final abstract synchronized
class interface
instanceof
try catch throws throw finally
if else for while do break continue return
switch case default
{} () <> [] ; : ? ,
**** >數據類型：
先數據性質分類 再按空間大小分類
整數類型：沒有小數點的數字
---byte 字節型 [-128,127] 是java描述數據的最小單位
---short 短整型 佔2個字節
---int 整型 佔4個字節 一個整數常量默認是int類型
---long 長整型 佔8個字節 一個整數常量後面有l/L 是long類型
浮點類型：有小數點的數字
---float 單精度 佔4個字節 浮點常量後面加f/F 是float類型
---double 雙精度 佔8個字節 浮點類型常量默認是double
字符類型：全部的符號
---char 字符型 佔2個字節 char類型的常量必須有'' 單引號中有且只有一個字符
布爾類型：只有兩種選擇 而且是相反的
---boolean 布爾型 佔1個字節 true、false
*****>數類型轉換
自動類型轉換狀況一： 高精度變量=低精度數據;
float f1=12;
自動把int類型4個字節的12 轉換爲float類型4個字節的12.0f
自動類型轉換狀況二： byte、short,char類型的變量=int常量值;
byte b1=13;
先檢測b1是否能裝下13 會把4個字節int類型的13 自動轉換爲1個字節byte類型的13
short s1=999999;
檢測s1不能裝下999999 再也不轉換 直接報錯
強制類型轉換： 低精度變量=(低精度變量類型)高精度數據;
int i1=(int)12.3;
>運算後結果的數據類型
1 byte short char 不能直接參加運算 必須轉換爲int參加運算
2 運算後結果的數據類型取決於精度最高的數據 '1'+(byte)12+12+12.5
>運算符
1 算術運算符：+ - *／
　　　　　　　　％　求餘　取模　　　n%m=n除以m獲得一個整數 除不盡的那部分
4.5%1.1=0.1
++ --自增自減
a++;++a;徹底等價於 a=(a的類型)(a+1);
b=a++;徹底等價於 b=a;a++
b=++a;徹底等價於a++;b=a;
int i=2;//3
int j=(i++)+(i/++i)+(--i)+(i--)+(++i*2)+i/3;
// 2 + 3/4 + 3+ 3 + 3*2+3/3
//++在前 就先自增 後參加本次運算
//++在後 先參加本次運算 後自增
+ 字符串鏈接符
而後數據與字符串鏈接 都造成一個新的字符串
2 比較運算符： > >= < <=
!= 不等號 判斷兩邊的數據是否是不相等
== 恆等號 判斷兩邊的數據是否是相等
3 賦值運算符：= 把等號右邊的值賦值給左邊的變量
a+=b;徹底等價於 a=(a的類型)(a+b);
a-=b;徹底等價於 a=(a的類型)(a-b);
a*=b;徹底等價於 a=(a的類型)(a*b);
a/=b;徹底等價於 a=(a的類型)(a/b);
a%=b;徹底等價於 a=(a的類型)(a%b);

short s=12; s=s+1;
short s=12; s+=1;
4 邏輯運算符:
& && and 兩個只要有一個false 結果就是false
| || or 兩個只要有一個true 結果就是true
^ 異或 兩邊相同則爲false 兩邊不一樣才爲true
!
單與雙的區別：
相同之處： 做爲邏輯運算符時 &和&& |和||結果都是同樣
不一樣之處：(1)雙的時候 有邏輯短路 當第一個表達式就知道結果時 第二個表達式就再也不執行 直接給出結果
(2)單還能夠做爲位運算符 操做的數字的二進制
5 位運算符：（ 操做的數字的二進制）
>>
<<
&
|
^
6 三元運算符：boolean類型的數據?值1:值2

>流程控制：
順序結構：從左到右 從上到下
選擇結構：代碼書寫規範 對齊縮進
if(){}
if(){}else{}
if(){}else if(){}else{}
swicth(表達式){
case 值1:
語句塊1;
break;
case 值2:
語句塊2;
break;
case 值3:
語句塊3;
break;
case 值4:
語句塊4;
//break;
default:
語句塊n;
break;
}
注意：(1) case後面的值不能重複
(2)switch後面表達式值的數據類型 僅限於 byte short char int
(3)只有當全部的case的值都不予switch表達式的值相等時 才運行default
與其位置無關
(4) break做用是結束整個switch結構

循環結構:
while(){}
do{}while();
for(;;){}

for(int a=1;a<=10;a++){
for(int b=1;b<=10;b++){

}
}
跳轉:
continue:結束本次循環 繼續i++進行下次循環
break: 結束整個循環
數組：裝相同類型 指定個數個數據的容器
建立時必須明確：裝什麼(元素類型) 裝多少 (元素個數)
關鍵字:[]
建立數組格式： (1) 元素類型[] 數組名=new 元素類型[元素個數];
(2) 元素類型[] 數組名=new 元素類型[]{值1,值2,值3....};
(3) 元素類型[] 數組名={值1,值2,值3....};
求最大值：
//定義變量記錄最大值 賦初始值爲第一個元素的值
int max=arr[0];
//拿max與數組的其餘元素作比較
for(int i=1;i<arr.length;i++){
max=arr[i]>max?arr[i]:max;
}
數組排序：
順序排序：依次拿當前元素和其後面的全部元素做比較
for(int i=0;i<arr.length-1;i++){
for(int j=i+1;j<arr.length;j++){
if(arr[i]<arr[j]){
int k=arr[i];
arr[i]=arr[j];
arr[j]=k;
}
}
}
冒泡排序：依次拿相鄰的元素做比較
for(int i=0;i<arr.length-1;i++){
for(int j=0;j<arr.length-1-i;j++){
if(arr[j+1]<arr[j]){
int k=arr[i];
arr[i]=arr[j+1];
arr[j+1]=k;
}
}
}
插入排序： 假設前面的元素時有序的 依次拿當前元素倒着和其前面的元素作比較
for(int i=1;i<arr.length;i++){
//定義變量記錄當前元素
int k=arr[i];
//定義變量記錄前面的元素的下標
int j;
for(j=i-1;j>=0;j--){
if(k>arr[j]){
arr[j+1]=arr[j];
}else{
break;
}
}
//把k放在j+1位置處
arr[j+1]=k;
}

面向對象 567
面向對象：找具備幫助我解決問題功能的對象 指揮對象解決問題
eg:找飯店吃飯
面向過程：把解決問題的過程按動做分紅多個步驟 逐個步驟去完成
eg:本身作飯吃
優勢： >把複雜問題簡單化
>程序員的角色由執行者轉換爲指揮者
>更符合如今人的思惟方式
使用面向對象寫程序步驟：
(1)建立類描述一類事物
提取表面的數據作成員變量
提取動態的功能作成員方法
(2)根據類建立對象：類名 對象名=new 構造方法;
類中定義了那些成員變量 直接決定了對象擁有那些屬性
類中定義了那些成員方法 直接決定了對象擁有那些功能
(3) 給對象的屬性賦值
(4) 調用對象的方法 解決問題

類：對一類事物的描述 是建立對象的設計圖紙 模板
對象：現實事物在電腦中的模型 類的實例

成員：成員變量 成員方法(構造方法 普通方法) 內部類 靜態代碼塊 構造代碼塊

成員變量和局部變量：
(1)定義的位置不一樣
(2)做用域不一樣
(3)是否有默認初始值
(4)修飾符不一樣

重載：一個類中幾個方法 方法名相同 參數列表不一樣的現象
要求：同一個類 方法名相同 參數列表必須不一樣(參數個數不一樣 參數類型不一樣 參數順序不一樣)
重寫：父類的方法沒法知足子類的需求 子類根據本身的需求從新定義父類的已有的方法
要求：除了範圍修飾符能夠擴大 拋出少的小的異常 其餘方法聲明必須和父類徹底同樣
區別：>位置不一樣：重載是在一個類中 重寫發生在子類中
>要求不一樣： 重載要求：同一個類 方法名相同 參數列表必須不一樣
重寫要求： 除了範圍修飾符能夠擴大 拋出少的小的異常 其餘方法聲明必須和父類徹底同樣
>影響不一樣：
重載的方法之間相互無響應 ：只是經過方法參數列表來區分
子類重寫父類的方法 父類的方法會被隱藏

構造方法：建立對象時調用的方法
構造方法和普通方法的區別：
>格式不一樣：構造方法沒有返回值 不用void標示
>做用不一樣：構造方法做用是建立對象
普通方法 表明此類的對象具備的某一指定功能
>調用不一樣：構造被關鍵字new調用 調用一次建立一個新的對象
普通方法被對象調用 一個對象能夠調用屢次普通方法
>命名不一樣：構造方法名字必須和類名相同
普通方法名字能夠是類名(按規範不能是類名)
>是否有默認： 一個類沒有構造方法 默認添加一個無參數的構造方法

建立對象內存圖：
>類加載 若是類有靜態成員 還要建立靜態區域
>建立引用
>建立對象：
>>經過super(12,11)把父類中定義的成員加載進子類對象內存中
並給屬性賦默認初始值
>>經過super(12,11) 運行父類構造方法中的其餘語句
>>經過子類構造方法 把子類中定義的成員加載進子類對象內存中
並給屬性賦默認初始值
>>隱藏父類被從新定義的成員
>>運行子類構造方法中的其餘語句
>然引用指向建立的對象

static:靜態 修飾符
static修飾的成員：靜態成員 類成員
無static修飾的成員：實例成員
static修飾變量：類變量 共享數據
> static修飾變量不但能夠被對象調用 還能夠被類直接調用
> static修飾變量 一個對象更改此屬性的值 其餘對象的此屬性值都被更改
static修飾方法
> static修飾方法不但能夠被對象調用 還能夠被類直接調用
> static修飾方法只能調用靜態成員

this:
使用場景一：當成員變量和局部變量重名時 變量名默認指向局部變量
經過this.變量名來指向成員變量
注意:全部成員前面默認有this. （當前對象）
使用場景二：一個構造方法調用另一個構造方法(複用其方法體)
經過this(參數列表)調用指定的構造方法
注意：this(參數列表)必須是第一個語句

繼承：extends
當一個新類擁有一個現有的類的全部成員時 可讓此新類從現有的類派生 衍生
格式：class Zi extends Fu{}
特色：
>子類能夠繼承父類全部的成員
>子類能夠繼承父類的私有成員 但不能直接使用 只能經過父類的其餘方法間接使用
>子類不能繼承父類的構造方法
>子類能夠擁有子類特有的成員
>子類能夠從新定義父類的成員
從新定義父類的成員變量：要求變量名相同便可
從新定義父類的成員方法：重寫 除了範圍修飾符能夠擴大 拋出少的小的異常 其餘方法聲明必須和父類徹底同樣
>全部子類構造方法的第一個語句 默認調用父類無參數的構造方法
經過super(參數列表)來調用父類有參數的構造方法
>java只支持類的單繼承

多態：
什麼是多態：給一個子類對象起個父類名字
多態的對象有什麼特色：除了重寫的方法其餘和父類對象徹底同樣
怎麼使用多態：
定義方法參數列表時 定義方法返回值類型時 定義類的成員變量時 定義數組時 都定義爲父類類型
這樣就能夠 傳遞 返回 賦值 裝任意子類類型的對象

1 提升代碼複用性
2 提升程序的擴展性

抽象：abstract 模糊 不具體 信息不完整
特色：
>抽象方法 不能寫方法體
>有抽象方法的類必須是抽象類
>抽象類不能建立對象 只能定義引用(指向子類對象)
>子類繼承抽象類 除非重寫全部的重寫方法 不然仍然是抽象類
>抽象類有構造方法 經過構造方法把非抽象方法和成員變量加載進子類對象內存中

接口：interface 全部的方法都是抽象方法時 能夠把此抽象類定義爲接口
特色： > 接口中的變量 默認修飾符 public static final
> 接口中的方法 默認修飾符 public abstract
> 接口不能建立對象 只能定義引用 (指向的是實現類對象)
> 類經過關鍵字implements實現接口 一個類能夠實現多個接口
> java支持接口之間的多繼承

接口使用 當成抽象類使用便可
接口是規範 雙方達成的協議
1 提升代碼複用性
2 提升程序的擴展性
3 下降模塊之間的耦合度

向上轉向
向下轉型
instanceof 對象 instanceof 類名
import
package



基礎類庫：經常使用類庫 異常 集合 線程 io流 socket xml
經常使用類庫：
Object: String toString() 獲取當前對象的字符串表示形式
boolean equals(Object obj) 判斷當前引用和參數引用是否是指向同一個對象
*重寫equals方法
>方法聲明不能更改
>經過instanceof判斷參數對象是否是當前類的類型
>向下轉型
>根據要求返回
String:字符串是常量：字符串對象一旦建立 字符序列不能更改