JAVA基礎知識總結：一到二十二所有總結

時間 2019-11-16

標籤 java 基礎知識總結一到二十二所有欄目 Java 简体版

原文原文鏈接

》一：php

1、軟件開發的常識html

1.什麼是軟件？
一系列按照特定順序組織起來的計算機數據或者指令html5

常見的軟件：
系統軟件：Windows\Mac OS \Linux
應用軟件：QQ,一系列的播放器(愛奇藝，樂視，騰訊。。。。)，一系列的瀏覽器（谷歌，IE....）java

2.什麼是開發？
就是製做軟件的過程
軟件的出現實現了人與計算機之間的人機交互
交互方式：圖形化方式：操做簡單，用戶容易上手
命令行方式：在控制檯輸入輸入相應的指令，根據指令讓計算機完成相關的操做c++

3.命令行指令(Windows+r-----調起控制檯)
dir:列出當前目錄下全部的文件以及文件夾
cd:進入到指定目錄
cd..:退回到上一級目錄
rd:刪除目錄
cls:清空控制檯
exit:退出控制檯程序員

命令行讓計算機執行相應的操做，至關於人和計算機之間的交流，計算機能識別的「話」 -----計算機語言
計算機語言：c\c++\c#\html5\php\OC\Swift\Java.....算法

2、Java簡介
1.Java語言的由來
1995年，由Sun（Stanford University Network,斯坦福大學網絡公司）公司發佈的一門高級編程語言編程

2.Java語言的技術架構

J2SE:標準版，爲開發打基礎
J2EE:企業版---Web方向
J2ME:小型版，小型的電子消費產品c#

JDK1.5以後，改名爲JAVASE\JAVAEE\JAVAME設計模式

1996年，Sun發佈了JDK1.0
目前JDK最新版本是1.9（bate）,推薦使用JDK1.8

跟Java類似的語言：c#\Ruby\Python

3.Java語言的特色：跨平臺性

經過Java編寫的應用程序能夠在不一樣的系統平臺上運行，Java具備良好的可移植性，目前成爲Web應用程序開發的首選語言

工做原理：在須要運行Java程序的操做系統上安裝對應的Java虛擬機（JVM）

注意：Java語言具備跨平臺性，JVM是不跨平臺的

3、開發程序以前須要作的準備工做

JDK(Java Development Kit)；Java開發工具包
JRE(Java Runtime Environment):java運行環境
JVM(Java Virtual Machine):Java虛擬機

1.三者之間的關係
a。若是隻須要運行一個已經開發好的Java程序的話，只須要安裝JRE
b .做爲程序員，就須要安裝JDK,其中包含了Java的開發工具，同時也包含了JRE
c.JVM和JRE的關係：JRE包含了JVM，JVM是運行Java程序的核心虛擬機，同時也包含了Java程序所需的環境支持

總結:JDK>JRE>JVM(使用JDK開發的Java程序，交給JRE中JVM去運行)

2.安裝
a.下載地址
www.oracle.com/java.sun.com
b.瞭解JDK
bin:binary----二進制文件，裏面存放的是可執行的程序，好比javac.exe java.exe等

3.配置環境變量
用戶變量和系統變量的區別：本質上是沒有區別的，用戶變量配置的內容只對當前用戶有效，不會影響其餘的用戶，系統環境變量所作的修改會影響到這臺電腦上全部的用戶

%JAVA_HOME%\bin;C:\ProgramData\Oracle\Java\javapath;C:\Program Files (x86)\Parallels\Parallels Tools\Applications;%SystemRoot%\system32;%SystemRoot%;%SystemRoot%\System32\Wbem

配置環境變量的做用：能夠在任何目錄下直接訪問javac和java命令，主要是爲了方便開發

4、Java程序的運行機制

Java程序的運行須要通過先編譯，後運行的步驟

1.編譯階段：不會生成特定平臺的機器碼，而是生成一種和平臺無關的字節碼，這種字節碼不是可執行的

2.運行階段：起核心做用的是JVM，它是能夠運行字節碼文件的（編譯器生成虛擬機能理解的代碼，交給虛擬機來執行）

5、Java程序初體驗
demo:樣片，樣品

開發工具：文本文檔，EditPlus，Eclipse

1.建立一個擴展名爲.java的文件
2.在文件中定義一個類，類是Java程序的最小單元，格式爲：public class 類名（類名和文件名稱相同）

3.要讓程序有一個執行入口的話，須要在類中定義一個main函數（主函數），格式爲：public static void main(String[] args)

4.在main函數中寫相應的代碼，例如；System.out.print("hello world!");

5.編譯階段：使用javac命令，格式爲：javac Java文件名稱，例如：javac FirstDemo.java
6.運行階段：使用java命令，格式爲：java 類名，例如：java FirstDemo

注意事項：a.一個Java文件中能夠同時存在多個類，而且編譯以後會生成多個class文件
b。若是一個類被public修飾的話，則這個類的類名必須和Java文件的名稱保持一致，
c。被public修飾的類在一個Java文件中有且只能有一個

6、註釋
在編寫程序時，寫程序的人給代碼作的一些解釋和提示，能提升代碼的可讀性，爲了往後的更改和閱讀

註釋是解釋性文本，在運行程序的時候，註釋會被程序跳過，不過任何處理

1.//xxxxxx 單行註釋

2./*
xxxxxx 多行註釋
xxxxxxx
*/
3./**
xxxxxxx 文檔註釋
xxxxxx

七。API文檔
養成自學的好習慣，常常翻閱API文檔，（看成字典使用）
8、Java編碼規範
1.Java源程序文件名的後綴必須是,java
2.Java中的每句代碼必須以分號結尾
3.駝峯法則：在命名的時候，單詞之間經過首字母大寫來進行分隔，除包名和靜態常量，例如：FirstDemo,
4.英文和中文，通常狀況下，要求儘可能使用通俗易懂的英文進行命名，例如：download xiaZai（不推薦）

Java基礎語言包含：註釋、關鍵字、標識符、常量和變量、運算符、函數和數組

9、關鍵字和標識符
1.關鍵字
在Java語言中，被賦予了特殊含義的英文單詞，例如：class public import interface ....
特色：關鍵字中的字母所有小寫

2.標識符
在Java中自定義的一些英文單詞

定義合法的標識符須要知足的規則：
a.由數字、字母、下劃線（_）、美圓符號（$）組成
b.不能以數字開頭 abc 1abc(不合法)
c.不能使用關鍵字 class(不合法)
d。遵循駝峯命名法
e.不能夠包含空格 abc def(不合法)
f。不能包含除了$以外的特殊字符 abc&（不合法）

在Java中，嚴格區分大小寫
abc Abc

10、進制轉換
1.什麼是進制？
進制指的是進位制，例如：十進制是逢十進一，二進制是逢二進一

179
+ 11
----------------
常見的進制：十進制（0~9），二進制（0~1），八進制（0~7，以數字0開頭），十六進制（0~9，a~f或者A~F,以0x開頭）

在計算機底層，全部數字都是以二進制的形式存在的

爲何計算機採用二進制？
採用開頭原理，只有0和1兩個數值，至關於開關的打開和閉合狀態，計算機運算的速率會比較高，八進制和十六進制是經過二進制演變而來的

2.進制之間的相互轉化
a。計算機中存儲數據的單位
計算機中表示數據的最小單位是比特（bit）,又稱爲位
計算機中處理數據的單位是字節（Byte） 1B = 8b
KB MB GB TB PB EB ...DB

1KB = 1024B
1MB = 1024KB

b.十進制----》二進制
轉換原理：對十進制進行除2運算，直到商爲0爲止，而後將各個步驟中獲得的餘數倒着寫出來
對於小數而言，整數部分除2取餘數，小數部分乘以2取整
10.25

c.二進制 -----》十進制
轉換原理：將二進制數按權進行展開，將獲得的多項式相加（二進制的權是2）
110---》1*2^2 + 1*2^1 + 0 = 6
12345 ----》1*10^4 + 2 * 10^3....

d。二進制----》八進制
轉換原理：將二進制數進行分組，從右向左進行分組，三位爲一組，不夠時進行補0
010 010 110 ----》226
2 2 6

e二進制---》十六進制
轉換原理：將二進制從右向左進行分組，四位爲一組，不夠時補0
1001 01100------》96
9 6

f.十進制---》八進制或者十六進制
轉換原理：方法一：先將十進制轉換爲二進制，而後再將二進制進行分組，轉化爲對應的八進制或者十六進制

方法二：能夠將十進制進行除8或者16，直到商爲0，相似十進制轉二進制

g.八進制或者十六進制----》十進制
類比二進制轉換十進制

3.計算機是如何處理數據運算的

數值有正負之分

0000 0110----》6

原碼：就是這個數對應的二進制形式，高位表示符號位，0表示正數，1表示負數

注意：反嗎和補碼主要針對的是負數
反碼：就是將原碼除符號位以外的各位進行求反，
補碼：將原碼除符號位以外的各位進行求反，而後再加1 ，

正數的原碼，反碼以及補碼都是相同的，和源碼相同

10 + （-10） = 0

原碼
0000 1010
1000 1010
---------
1001 0100 -----》明顯不是0，說明計算機處理數據不是經過原碼進行的

反碼
0000 1010
1111 0101
---------
1111 1111----》-127，明顯不是0，說明計算機處理數據不是經過反碼進行的

補碼
-10的補碼
1111 0101
0000 0001
----------
1111 0110----》-10的補碼
0000 1010
---------
0000 0000----》結果爲0，

結論：計算機處理數據的計算是經過補碼進行的

》二：

1、數據類型
1.常量
在程序運行的過程當中，值不會發生改變的標識符
常量的分類：整數常量、小數常量、布爾值常量、字符常量、字符串常量、null常量

2.變量
表示的值能夠發生改變
定義一個變量，須要在內存【運算區域】中開闢一個空間，將不肯定的數據存儲到這個空間中
語法：數據類型標識符 = 數值

特色：a.變量的值是能夠變更的
b.須要在內存中開闢空間
c.命名規範：小駝峯命名。例如：gradeNum

3.數據類型
Java語言是強類型語言，每一種數據都定義了明確的數據類型，在內存中分配了不一樣大小的內存空間，來進行數據的存儲

分類：基本數據類型和引用數據類型

基本數據類型：數值型（byte\short\int\long）、字符型(char)、浮點型(float\double)、布爾型(boolean)
引用數據類型：類、數組、接口

基本數據類型和取值範圍
類型名關鍵字佔用的字節數取值範圍
字節整型 byte 1 -2^7~2^7-1(-128~127)
短整型 short 2 -2^15~2^15-1

整型 int 4 -2^31~2^31-1
長整型 long 8 -2^63~2^63-1

單精度 float 4 -2^128~2^127
雙精度 double 8 -2^1024~2^1023

字符型 char 2 0~65535

布爾型 boolean 1 true\false

特殊狀況:String(類)
浮點數在計算機底層是以科學計數法進行存儲的

4.類型轉換
不一樣數據類型之間是沒有辦法直接進行計算的，咱們須要將他們轉換爲同一類型才能夠參與運算

1>自動類型轉換
相兼容的數據類型，將取值範圍較小的數值或者變量賦值給取值範圍較大的類型對應的變量

注意：a.整型的默認類型爲int，浮點型的默認類型爲double
b.byte.short,char類型的變量在進行運算時，首先會將類型提高爲int型，而後參與運算

c.整型核浮點型進行計算時，會將整型提高爲浮點型，而後參與運算

2>強制類型轉換
相兼容的數據類型，將取值範圍較大的數值或者變量賦值給取值範圍較小的類型對應的變量

2、運算符
1.算術運算符
+ - * / %(求餘)，++（自增） --（自減）

2.賦值運算符
= += -= *= /= %=(複合賦值運算符)-----給變量進行賦值

3.關係運算符

< > <= >= ==(恆等於) != (不等於)
用於兩個變量之間比較大小，若是成立則結果爲true，若是不成立則結果爲false

4.邏輯運算符
用於連接布爾型的表達式
int x = 4;
數學中：3 < x < 5---->true
代碼中：

與（&，&&（短路與））、或（|、||）、異或（^）、非（！）

5.位運算符【0爲false，1爲true】

& | ^ ~(取反) <<(左移) >>(右移) >>>(無符號右移)

注意：除了無符號右移以外，其他的運算均包含符號

6.三目運算符

//格式：條件表達式？表達式1：表達式2；
//表示的意思是：判斷條件表達式是否成了，若是成立，則結果爲表達式1，若是不成立，則結果爲表達式2
//計算完成以後一定會返回一個結果

7.轉義運算符
經過\來改變後面字母或者符號的含義

》三：

1、Java語句的執行結構
1.順序語句
按照順序從上往下依次執行的語句，中間沒有任何的判斷和跳轉

2.分支語句
根據不一樣的條件來產生不一樣的分支
if語句、switch語句

3.循環語句
重複執行某句代碼
for語句、while語句、do-while語句

2、分支語句
1.什麼是分支？
判斷所給定的條件是否知足，根據不一樣的結果執行對應的不一樣的語句

2.if語句
使用布爾表達式或者布爾值做爲條件來進行分支控制

1>簡單if語句（單分支）
語法：if(條件表達式) {

//執行語句
}
這裏的條件表達式通常爲關係運算符
使用方式：首先判斷條件表達式是否成立，若是成立則執行語句，反之，不執行

2>if-else語句（雙分支）
語法：if(條件表達式) {
//執行語句1
}
else {
//執行語句2
}
使用方式：首先判斷條件表達式是否成立，若是成立則執行語句1，若是不成立，則執行語句2

3>多重if-else語句
語法：if(條件表達式1) {
//執行語句1
} else if(條件表達式2) {
//執行語句2
}else if(條件表達式3) {
//執行語句3
}
。。。。。。

else {
//執行語句
}
使用方式：根據不一樣表達式的成立與否執行對應的語句。只執行其中的一個分支，若是其中的一個分支條件知足，則中止繼續向下執行

4>擴展：嵌套if語句
語法：if(條件表達式1) {
//執行語句1
if(條件表達式2) {
//執行語句2
}
}
從語法的角度來講，嵌套的層數沒有限制，可是從代碼的可讀性來講，建議嵌套的層數不要多於3層

注意：使用if語句時容易出現的錯誤：
1.if(條件表達式);
{

}
2.忘記必要的括號

2.switch語句
語法：
switch(表達式或者變量) {

case 常量值1：
{
//執行語句1
}
break;
case 常量值2：
{
//執行語句2
}
break;
case 常量值3：
{
//執行語句3
}
break;
.。。。。。
default:
{
//執行語句
}

}
根據表達式或者變量的值進行匹配，若是case中有能匹配到的，則執行對應的語句，若是全部的case語句都不知足，則執行default中的語句

注意：a.表達式或者變量的取值類型：byte\short\int\char\String\枚舉，（不能使用long和boolean）
b.若表達式的值和case分支後的常量值匹配的話，則執行該case分支
c。break表示跳出switch-case語句
d.當全部的case分支都不匹配的狀況下，則執行default語句

擴展：Scanner類的使用

if語句和switch語句的區別：
a.若是對具體的數值進行判斷，而且數值很少的狀況下，並且符合byte\short\int\char這四種類型，推薦使用Switch完成，執行效率相對高一點
b。若是對區間進行判斷，結果爲布爾值的狀況下，推薦使用if，if的使用範圍更廣

3、循環語句
1.什麼是循環？
在知足條件的狀況下，反覆執行某一段代碼，這段被反覆執行的代碼就被稱爲循環體
當反覆執行這段循環體時，須要在合適的時候將循環條件改成假，從而結束循環，不然循環會一直執行下去，造成死循環
2.while循環
語法：while(條件表達式) {
//循環體
}
當條件表達式成立時，纔會執行循環體
循環體的執行次數取決於條件表達式

3.do-while語句
語法：do{
//循環體

}while(條件表達式);

4.for循環語句

語法：for(表達式1；表達式2；表達式3){

//循環體
}

表達式1：初始化表達式
表達式2：循環條件表達式
表達式3：循環後的操做表達式

執行順序：表達式1（int x = 0）--->表達式2----》循環體---》表達式3-----》表達式2----》循環體---》表達式3。。。。。。
其中，表達式1只執行一次

擴展：嵌套for循環

4、特殊流程控制語句
1.break

應用範圍：分支結構和循環結構
做用：跳出對應的結構

2.continue
應用範圍：循環結構
做用：表示結束當前循環，繼續下一次循環，並不會結束整個循環

3.return
return並非專門用於跳出循環的，做用是結束一個方法
return直接結束一個方法，無論這個return處於多少層循環之中

三者之間的區別：
a。break和continue的應用範圍不一樣
b.當程序中出現break和continue時，在他們的後面不能出現語句，由於執行不到
c。continue是結束當前循環，break是結束整個循環
d.return直接結束整個方法

》四：

1、方法
1.什麼是方法？
對於功能相同的代碼段，爲了簡化代碼，會把功能相同的代碼抽取出來，方便屢次使用，Java中，咱們使用【方法】，也被稱爲函數

2.函數的聲明
語法：
訪問權限修飾符其餘修飾符返回值類型函數名稱（參數列表）{

//函數體
}

public static void main(String[] args) {

}
a.訪問權限修飾符：目前所有要求使用public，和main函數保持一致
b.其餘的修飾符：只有static（要麼寫，要不不寫）
c.返回值類型：函數運行後所得結果對應的數據類型，void表示空
d。函數名稱：見名知意
e.參數列表：若是方法中有未知數參與運算，未知數對應的類型和變量名

3.函數的調用

4.static的使用
1》全局變量和局部變量
全局變量：在類中定義的變量，和main函數是並列的，在整個類中有效
局部變量：在方法內定義，而且只能在方法內部使用，當方法執行完成以後，這個變量就消失了
注意：局部變量在使用的時候必定要先進行初始化
局部變量局部有效，只在定義這個變量的方法內有效 {}

注意：在使用全局變量和局部變量的時候，儘可能避免命名相同

2》靜態方法：被static修飾的方法稱爲靜態方法，不加static則爲非靜態方法

5.方法中參數
分類：形式參數（形參）和實際參數（實參）
調用方法的時候，用實參給形參賦值，這個過程稱爲傳參
傳參時須要注意：實參的數量和類型要與形參的數量以及類型相匹配

6.方法壓棧
棧：是內存中的一塊空間（開口向上的容器）
入棧和出棧：先進後出，後進先出
局部變量在棧中開闢空間

注意：a。JVM首先執行main函數，main函數入棧
b.當執行到swap方法的時候，swap函數入棧
c.當全部的操做執行完成以後，方法須要出棧，swap先出棧，mian函數後出棧，所佔有的空間所有被釋放

7.方法的返回值
一個方法執行完成以後所獲得的結果
void表示沒有返回值

使用return獲得最終的結果，用於結束整個方法

8.提取一個方法注意事項
a。明確實現的功能，當調用函數的時候，是否須要返回結果----返回值類型
b,明確是否有未知項參與運算-------參數列表

8.函數的遞歸
遞歸：在一個方法中調用它自身，稱爲方法的遞歸
方法遞歸中包含了隱式的循環，他會重複執行某段代碼，可是在這裏不須要循環

》五：

1、初步認識數組
1.理解數組
數組是用來存儲相兼容數據類型的定長的容器
特色：

a.只能存放相兼容數據類型，不能存放多種數據類型
b.能夠存放基本數據類型和引用數據類型
c.數組是定長的，一旦被初始化，數組的長度就不能發生改變
d.將數組中存儲的數據稱爲元素
2.使用數組的好處：
能夠自動給數組中的數據從0開始編號，方便操做這些數據，咱們把這些編號叫作下標（索引）

3.定義數組
數組是一種引用數據類型
int x = 4;
int 是一種基本數據類型，int[]是一種引用數據類型，用來表示數組

int[] y = xxx;

方式一:數據類型[] 數組名稱，例如：int[] x,String[] s
方式二：數據類型數組名稱[]
推薦使用方式一

2、數組的初始化

Java中的數組必須先初始化，而後纔可使用，所謂初始化，就是爲數組中的每一個數組元素開闢內存空間，而且爲每一個元素賦初始值

1.靜態初始化
初始化的時候由程序員指定每一個數組元素的初始值，交給系統去計算數組的長度（大小）
語法：元素類型[] 數組名稱 = new 元素類型[]{元素0，元素1，元素2.。。。。。}；

2.動態初始化
初始化是程序員只須要指定數組的大小（長度），對應的初始值由系統自行進行分配
語法：元素類型[] 數組名稱 = new 元素類型[數組的長度];

系統對初始值的分配規則：
a.整型：0
b.浮點型：0.0
c.boolean:false
d.字符型：‘\u0000’(在不一樣的系統平臺上的展現結果是不同的，有的是方框（口），有的是空格)
e.引用數據類型：null

注意：在初始化數組時，靜態初始化和動態初始化必定不要同時使用（在指定數組長度的同時，不要給數組中每一個元素賦初始值）

數組初始化完成以後，就可使用數組了，包括數組元素的訪問，給數組元素賦值，獲取數組的長度等

3、數組的使用
見代碼

4、內存中的數組

數組是一種引用數據類型，數組元素和引用變量在內存中時分開存放的
數組引用變量存放在棧空間中，數組元素存放在堆空間中

擴展：
1>基本數據類型和引用數據類型在內存中的區別？
基本數據類型
int x = 4;
int y = x;
y = 20;
x = ?

引用數據類型
int[] a = {22,33};
int[] b = a;
b[0] = 18;
a[0] = ?

2>內存的分類：
a.寄存器：最快的存儲區，由編譯器根據需求進行分配，咱們在程序中沒法控制
b.棧：存放基本數據類型的變量和引用數據類型的引用
特色：被執行完成以後，函數或者變量所佔用的空間會被銷燬
c.堆：存放new出來的對象，例如：new出來的實際的數組元素
d.靜態域：存放靜態成員（static）
e.常量池：基本類型常量和字符串常量

舉例：內存結構------》一套房子
臥室----睡覺
廚房----作飯
客廳----招待客人

5、數組的應用

1.排序

1>冒泡排序
思路：比較相鄰兩個下標對應的元素值，若是符合條件就交換位置（最值出如今最右邊）

2>選擇排序
思路：固定一個下標，而後使用這個下標對應的值依次和他後面的值進行比較

2.查找
1>順序查找
思路：遍歷數組，依次把每一位元素和要比較的數值進行比較

2>二分法查找
思路：前提是一個數組是有序，經過折半來縮小查找範圍，提升效率

》六：

1、不定長參數
1.語法：數據類型... 變量名稱

使用注意事項：a.不定長參數就至關因而一個數組
b.不定長參數只能出如今參數列表的最後面
c.一個函數的參數列表中只能出現一次不定長參數
d.對於不定長參數的使用，調用函數的時候，能夠傳入不定長的數值，或者能夠直接傳入數組

2、Arrays工具類

3、二維數組
在一個一維數組中，數組的元素爲一個數組

1.定義二維數組
int[] arr
語法：元素類型[][] 數組名稱

》七：

1、面向對象編程
1.什麼是面向對象？
萬物皆對象

案例一：我想吃大盤雞
面向過程面向對象
1.我本身去買一隻雞 1.委託一個會砍價的人去幫忙買雞
2.我本身宰雞 2.委託一個膽大的人宰雞
3.我本身準備菜 3.委託一個廚師幫忙擇菜
4.我本身作菜 4.委託一個廚師幫忙作菜
5.我本身吃 5.我本身吃

案例二：小明是一個電腦小白，想要配一臺電腦，買完零件後須要搬到家裏，組裝起來開始玩遊戲
面向過程面向對象
1.小明補充電腦知識 1.委託一個懂電腦的朋友幫忙去買零件
2.小明去買零件 2,。委託一個快遞小哥將零件搬到家裏
3.小明將零件搬到家裏 3.委託一個會組裝電腦的人幫忙將電腦組裝起來
4.小明組裝電腦 4.小明開始玩遊戲
5.小明開始玩遊戲

面向過程和麪向對象的區別：
面向過程：一種看待問題的思惟方式，在解決問題的時候，着眼於問題是怎樣一步一步解決的，而後親力親爲的去解決每一個步驟中遇到的問題
面向對象：一種看待問題的思惟方式，着眼於找到一個具備特殊功能的具體的個體，而後委託這個個體去幫忙作某件事情，這個個體就被稱爲對象

區別總結：
a.都是一種看待問題的思惟方式
b.面向過程着眼於全部的問題親力親爲解決
c.面向對象着眼於找到一個具備特殊功能的對象，而後委託這個對象去幫忙作某件事情

Java語言是一門純粹的面向對象的程序設計語言，類和對象是面向對象編程的核心

2、類和對象

1.類和對象的概念
類：一個具備特殊功能的實體的集合（羣體）
對象：在一個類中，一個具備特殊功能的實體，可以幫忙解決特定的問題，對象也被稱爲實例

兩者之間的關係：類用於描述某一類對象的共同特徵，而對象則是類的具體存在（包含關係）

類對象
人張三，李四，楊陽，凌桃根。。。
快遞圓通、申通、順豐、匯通。。。
superHero 蝙蝠俠，奧特曼，蜘蛛俠，美國隊長。。。。。。。。

幫助理解：咱們能夠將類當作是一種自定義的數據類型，可使用類來進行定義變量，這種類型的變量統稱爲引用型變量，也就是說，類是引用數據類型

2.聲明一個類
語法：訪問權限修飾符 class 類名　｛
／／類體
｝

說明：ａ．訪問權限修飾符：只能是public(能夠被省略)
b.類名只要是一個合法的標識符便可，要求：類名首字母必須大寫，遵循駝峯命名法
c.類名儘可能使用單個或者多個有意義的單詞鏈接而成

注意：a.一個Java文件中能夠同時存在多個類，若是有多個類的話，編譯以後會生成多個class文件

b。一個Java文件中只能出現一個由public修飾的類，這個類的類名必須和Java源文件的名稱保持一致
c.若是一個Java文件中只有一個類的話，而且這個類不使用public修飾，這時類名和Java文件名能夠不同

3.類中成員變量和方法的定義
1>成員變量
a.成員變量也被稱爲屬性
b.成員變量其實就是全局變量
c.分爲靜態變量和非靜態變量
d.在靜態方法中只能訪問靜態變量，在非靜態方法中能夠訪問靜態變量和非靜態變量

2>類中方法的定義
a.分爲靜態方法和非靜態方法
b.在靜態方法中只能調用靜態方法，在非靜態方法中能夠調用靜態方法和非靜態方法

成員變量------類具備的特徵，舉例：人----身高，性別，三圍，姓名。。。。
成員方法------類具備的行爲，舉例：人----吃喝玩樂。。。。

4.對象的建立以及內存分析
對象的建立也稱爲實例化對象
語法：類名標識符 = new 類名();

Person xiaoming = new Person();
說明：xiaoming這個變量是一個引用型變量，存放於棧空間中，實際的Person對象存放於堆空間中
全部new出來的對象所有存放於堆空間中，對應的對象的引用存放於棧空間中

5.類中成員變量和方法的訪問
總結：a.靜態成員變量和靜態方法是屬於類的，使用類名. 的方式訪問
b.非靜態成員變量和非靜態方法是屬於對象的，使用對象. 的方式訪問
c.開闢空間的時機是不一樣的

6.方法重載
在同一個類中，若是知足如下的條件時，咱們就稱爲這幾個方法之間彼此重載
a.方法名相同
b.參數不一樣（數量不一樣，類型不一樣）
c.跟返回值類型沒有關係

7.構造方法
構造方法也叫做構造器，是當實例化一個對象（建立一個對象）的時候，第一個被調用的方法
語法：訪問權限修飾符類名（） {

}
普通方法：
訪問權限修飾符其餘的修飾符返回值類型函數名（參數列表） {

}

注意：a.構造方法是在實例化對象的過程當中自動調用的
b.系統會默認爲咱們提供一個無參的構造方法

構造方法和普通方法的區別
a.構造方法沒有返回值
b。構造方法的方法名必須和類名保持一致

使用構造方法的過程當中容易出現的問題;。
a.若是沒有寫有參的構造方法，系統會爲咱們提供一個默認的無參的構造方法
b。若是手動寫了有參的構造方法以後，系統將再也不提供無參的構造方法，若是須要使用，則須要手動加上（要求：通常狀況下，將無參的構造方法加上，哪怕方法裏面什麼都不寫）

》八：

面嚮對象語言的三大特性;封裝、繼承、多態

1、面嚮對象語言特性之封裝
1.什麼是封裝？
一個類中某些屬性，若是不但願外界直接訪問，咱們能夠將這個屬性做爲私有的，能夠給外界暴露出來一個訪問的方法
使用封裝解決私有化的問題

私有化使用private關鍵字

2.private的使用
1>修飾成員變量，表示這個成員變量只能在當前類中被訪問
2>修飾成員方法，表示這個方法只能在當前類中被調用

3.get/set方法
對於private修飾的成員變量，若是要在外界使用，則使用get和set方法進行取值和賦值

語法
get------獲取值
訪問權限修飾符返回值類型（成員變量的類型）getXxx() { 例如：public int getAge() {}
}

set-----賦值
訪問權限修飾符 void setXxx(成員變量類型變量名稱) { 例如：public void setAge(int a){}
}

4.this關鍵字

this表示的是對當前對象的引用

1>this.屬性：訪問本類中的成員變量
總結：通常狀況下，當私有變量的set方法中參數名稱和成員變量相同的時候，使用this進行區分，有參構造方法中也是一樣的道理（當局部變量名和成員變量名相同時，this表示的是成員變量名）

2>this.方法：訪問本類中的方法

3>this():訪問本類中的構造方法

注意：a.this()只能寫在構造方法中
b.this()只能出如今其餘構造方法中執行語句的第一行
c.this()具體調用的是哪一個構造方法，取決於所傳的參數

5.static關鍵字
1>靜態成員變量
由static修飾的成員變量被稱爲靜態成員變量
語法：訪問權限修飾符 static 數據類型變量名稱；

特色：
a.靜態成員變量是屬於類的，經過類名. 的方式和對象.的方式均可以進行訪問
b。靜態成員變量的聲明出如今實例以前（靜態成員變量隨着類的字節碼文件加載到JVM中，且只會加載一次）
c.使用類和不一樣對象訪問的靜態成員變量都屬於同一塊內存空間

2>靜態方法

特色：
a.靜態方法是屬於類的，經過類名.的方式訪問
b.靜態方法優先於實例被加載到JVM中，與靜態成員變量相似
c.在同一個類中，靜態方法只能訪問靜態方法

何時使用靜態？
當全部的對象須要共享數據的時候，就定義成靜態成員變量----靜態成員變量
對於一些廣泛或者須要屢次使用的功能，咱們將它抽取成方法的時候就聲明成靜態方法

3>靜態代碼塊
什麼是代碼塊？
在類中獨立存在的語句塊，能夠有多個，位置隨意{}
什麼是靜態代碼塊？
被static修飾，直接出如今類中的語句塊
語法：static {
//執行語句

}

用法：a.靜態代碼塊用於爲類的屬性進行初始化
b.靜態代碼塊是屬於類的，隨着類的加載而運行，每一個靜態代碼塊只會執行一次，靜態代碼塊的執行優先於main函數

擴展：
4>普通代碼塊：在方法或者語句中出現的{}
普通代碼塊和通常語句的執行順序由他們在代碼中出現的順序決定

5>構造代碼塊：直接在類中定義，且沒有加static關鍵字的代碼塊

6。單例
單例是一種設計模式，
什麼是設計模式？
前人總結的用來解決特定問題的方案
Java中有23中設計模式，經常使用的有單例設計模式，工廠設計模式

什麼是單例設計模式？

在程序運行過程當中，確保某一個類只有一個實例（對象），無論在哪一個模塊獲取這個類的對象，獲取到的都是同一個對象

實現方式：
a.懶漢式（飽漢式）

b.餓漢式

區別：a.懶漢式在必定程度上節約內存，可是數據是不安全的（線程不安全）
b.餓漢式，不節約內存，可是數據比較安全

7.包（package）
用來組織文件而存在的，和文件夾的功能相同
語法：package xx.yy.zz ---->class文件的存放位置

編譯命令：javac -d . Java源文件名稱（只要類中使用了package關鍵字）

注意：a.類編譯生成的class文件存在於對應的包下
b。通常狀況下，不一樣的類編譯生成的class文件必須存在於同一個包下才能相互訪問
c.當不一樣類的class文件存在於不一樣包下的時候，要相互訪問，則使用import，格式：import 包名.文件名稱

》九：

二。面向對象特性之繼承

1.什麼是繼承？
若是兩個或者兩個以上的類具備相同的屬性和方法，咱們能夠抽取一個類出來，在抽取出來的類中聲明各個類中公共的部分
被抽取出來的類-------父類，基類，超類
兩個或者兩個以上的類-----子類，派生類
兩者之間的關係：子類繼承自父類（基類）

2,語法
訪問權限修飾符 class 子類類名 extends 父類類名 {
}

a.當子類繼承自父類的時候，子類對象能夠訪問父類中的成員變量
b.子類一樣能夠調用父類中的方法
c.一個父類，能夠有多個對應的子類
d.一個子類，只能有一個父類（單繼承）

3.super
this是對當前對象的引用
super是對父類對象的引用

1》super.屬性：訪問父類中的成員變量
2》super.方法：訪問的是父類中的方法
3》super():訪問的是父類的構造方法
注意：a.super()必須出如今子類構造方法的第一行語句
b.super()具體調用的是父類中的哪一個構造方法，取決於所傳的參數

2、訪問權限修飾符
1.訪問權限修飾符：public\private\protected\default
2.default:若是沒有添加訪問權限修飾符的話，其實就是default權限（注意：default必定不能寫出來）
3.修飾類：類的訪問權限修飾符只有兩個：public和default

訪問權限修飾符同包不一樣包
public 能夠能夠
default 能夠不能夠

說明：
public修飾的類在不一樣包下能夠訪問，可是須要注意：
a.進行導包（須要使用類的全限定名，例如：包名.包名.類名；import com.b.Student;）
b.若是在不一樣包中有相同名字的類，在使用的時候必定要注意使用類的全限定名

4.修飾屬性:四個訪問權限修飾符都能用
權限大小：public>protected>default>private

訪問權限修飾符本類同包不一樣類子類（不一樣包）不一樣包
private 能夠不能夠不能夠不能夠
default 能夠能夠不能夠不能夠
protected 能夠能夠能夠不能夠
public 能夠能夠能夠能夠

3、方法重寫
1.重寫規則
在具備繼承關係的兩個類中，子類中的方法若是知足瞭如下條件，就說子類重寫了父類的方法
a.方法名相同
b.參數相同
c.子類方法的返回值類型必須和父類方法的返回值類型相同，或者是父類方法返回值類型的子類型
d.子類方法的訪問權限必須大於等於父類方法的訪問權限

2.final關鍵字
1》final修飾類：這個類不能被繼承
2》final修飾方法：這個方法不能被重寫
3》final修飾變量

當final修飾一個成員變量的時候，系統不會再給這個成員變量賦初始值，因此在使用以前須要咱們手動進行初始化
靜態成員變量:在聲明變量的時候或者在靜態代碼塊中進行初始化
非靜態成員變量：在聲明變量的時候或者構造代碼塊中或者構造方法中直接初始化
局部變量：
注意：final修飾基本數據類型和引用數據類型的區別？
當final修飾基本數據類型的時候，不能再對基本數據類型變量進行賦值
當final修飾引用數據類型的時候，引用類型變量不能再被從新賦值，可是能夠改變引用變量所指向的內容

總結：a.final和訪問權限修飾符沒有關係，是相互獨立的
b.對於基本數據類型變量，命名字母所有大寫，不一樣單詞之間使用下劃線進行分隔
c.對於引用數據類型變量，命名不須要遵循常量命名規範

4、Object類

是Java中全部類的父類，在其中定義了一些經常使用的方法
1》toString()
2>getClass()
3>hashCode()
4>equals()

》十：

1、抽象類
一、定義
當多個類中出現相同功能，可是功能主體是不一樣的，這是能夠進行向上抽取的，只抽取功能的定義部分，使用抽象類實現

抽象類的存在就是爲了被繼承

2.使用
abstract

3.抽象類的特色
a.使用關鍵字abstract修飾的類
b.抽象類不可使用new關鍵字進行建立對象
c.抽象類中既能夠寫抽象方法，也能夠寫普通方法
d.若是子類只實現了抽象類中的部分抽象方法，那麼這個時候子類仍然是一個抽象類

4.抽象方法的特色：
a.抽象方法必須存在於抽象類中
b.使用abstract修飾的方法
c.只有聲明，沒有實現

5.抽象類和通常類的區別
a.抽象類是在通常類的基礎上，使用abstract修飾的類
b.抽象類中既能夠有抽象方法，也能夠有普通方法，普通類中只能有普通方法
c.抽象類不能用於實例化對象

2、接口
1.概念
初期理解：能夠認爲接口是一種特殊的抽象類，當抽象類中的方法所有是抽象方法的時候，咱們就可使用接口來表示

接口是抽象方法的集合，

2.使用
interface

語法：訪問權限修飾符 interface 接口名稱
{
}

3.接口的特色
a.接口不能實例化對象
b.接口中不能寫成員變量
接口中成員變量的修飾符是固定的，public static final,在接口中出現的變量通通認爲是常量
c.接口中默認全部的方法都是抽象方法
接口中方法的修飾符也是固定的，public abstract,接口中默認全部的方法都是抽象方法

4.接口的實現和類之間的關係
一個類若是要實現另一個類中的方法的話，使用繼承實現
一個類若是要實現一個接口中的方法的話，則須要實現這個接口

語法：
訪問權限修飾符 class 子類類名 implements 接口名 {

}
其中，把實現了這個接口的類稱爲接口的實現類

注意：
a.子類必須實現接口中的所有的抽象方法，子類才能夠實例化，不然，子類仍然是一個抽象類
b.一個類是能夠實現多個接口，須要把實現的接口中的方法所有實現了
c.實現接口和類的繼承之間沒有關係，一個類在實現接口的同時也能夠繼承
d.接口之間是能夠進行繼承的，而且是多繼承

總結
接口實際上是對外暴露的規則
接口能夠實現程序功能的擴展
接口能夠用來多實現
接口之間是能夠繼承的，而且是多繼承的關係
一個類在繼承的同時能夠實現接口

3、多態

一種事物的多種體現形式
Java中的體現形式：
1>父類的引用指向子類的對象
2>接口的引用指向實現類的對象

4、對象轉型

1.對象的向上轉型
由子類類型轉換爲父類類型
由實現類類型轉換爲接口類型

對象向上轉型以後就不能再訪問子類中特有的方法和屬性
對象向上轉型以後就不能再訪問實現類中特有的方法，

2.對象的向下轉型
由父類類型轉換爲子類類型:強制類型轉換

3.instanceof
語法：對象 instanceof 對象匹配的類型
做用：判斷這個對象是否是指定的類型

五。工廠設計模式

多態的應用

當須要一個對象的時候，並非直接經過new的方式實例化對象，而是經過工廠類的工廠方法直接去獲取

》十一：

1、內部類
一個類中包含着另一個類，裏面的類被稱爲內部類，外面的稱爲外部類

1.成員內部類
和成員變量或者成員方法平級的內部類
語法：
訪問權限修飾符 class 外部類類名{

//成員變量
//成員方法
訪問權限修飾符 class 內部類類名 {

//內部類的類體
}
}

特色；
a.實例化對象的語法
Out out = new Out();
Out.In in = out.new In();
b。成員內部類四種訪問權限修飾符均可以使用（通常類只能使用public和default）
c.成員內部類編譯生成的class文件的格式：外部類類名$內部類類名，例如：Out$In.class

2.局部內部類
是和局部變量平級，存在於方法中的內部類
語法：
訪問權限修飾符 class 外部類類名{

//成員變量
//成員方法
訪問權限修飾符返回值類型方法名（參數列表） {

訪問權限修飾符 class 內部類類名 {

//內部類的類體
}
}
}

特色：
a.局部內部類具備和局部變量相同的做用域
b.和局部變量相似，不能使用訪問權限修飾符進行修飾
c.編譯生成的class文件的格式：外部類類名$編號內部類類名，例如：Out$1In.class,Out$2In.class,
d。局部內部類若是要訪問和他平級的局部變量，這個局部變量必須是一個常量
e.若是須要往外部類的方法中傳入參數，外部類的方法形參必須使用final修飾

3.靜態內部類
使用static修飾的成員內部類被稱爲靜態內部類
語法：
訪問權限修飾符 class 外部類類名{

//成員變量
//成員方法
訪問權限修飾符 static class 內部類類名 {

//內部類的類體
}
}

特色：
a.實例化內部類對象的格式：Out.In in = new Out.In();
b.靜態內部類相似於靜態成員變量，可使用訪問權限修飾符進行訪問
c.靜態內部類編譯生成的class文件的格式：外部類類名$內部類類名，例如：Out$In.class
d.在靜態內部類中只能訪問外部類中的靜態成員變量
e.在靜態內部類中也能夠寫靜態成員變量

4.私有內部類
被private修飾的成員內部類

語法：
訪問權限修飾符 class 外部類類名{

//成員變量
//成員方法
private class 內部類類名 {

//內部類的類體
}
}

5.匿名內部類（重要）
沒有名字的內部類
正由於沒有名字，因此匿名內部類只能使用一次，一般用來簡化代碼，匿名內部類使用的前提條件：必須繼承一個父類或者實現一個接口

特色：
a.匿名內部類沒有名字
b.匿名內部類實際上是指定類的子類或者指定接口的實現類
c.編譯生成class文件的格式：測試類類名$編號，例如：InnerClassDemo05$1.class

》十二：

1、String類
字符串是一種特殊的對象，一旦被初始化就不能被改變了

字符串常量存儲於常量池中

2、StringBuffer類
是一個字符串緩衝區，至關於一個容器

特色
a.能夠對字符串進行增長和刪除的操做
b.長度是可變的
c.能夠進行操做多種數據類型
d.最終能夠經過toString()轉換爲字符串

3、StringBuilder類
JDK1.5以後出現的
StringBuffer是線程同步的，StringBuilder是線程不一樣步的

建議：多線程使用StringBuffer，單線程使用StringBuilder
實際開發中，建議使用StringBuilder

4、經常使用類
1.對象包裝類
int ----->Integer
byte-----Byte
short----Short
long------Long
boolean---Boolean
float-----Float
double----Double
char------Character

2.數據的裝箱和拆箱
裝箱：將基本數據類型轉化爲對應的對象包裝類
拆箱：將對象包裝類轉化爲對應的基本數據類型

3.String類和基本數據類型之間的轉換

a.對象包裝類的常見做用：用於基本數據類型和字符串類型之間的轉換

4.Date類
用來表示日期的

5.SimpleDateFormat

6.Calendar

7.Random
獲取隨機數

8.Math
是一個工具類

Math類的構造器被私有化了，因此Math類中的方法所有是靜態方法，能夠直接經過類名進行調用，並且還提供了兩個靜態屬性，PI和E,他倆的值其實就是π和e

》十三：

測試
用一個字符串常量建立一個字符串對象
1.獲取這個字符串的長度
2.獲取任意長度的子串
3.判斷這個字符串是否爲空
4.將這個字符串中的小寫字母轉化爲大寫字母
5.獲取某個字符在字符串中第一次出現的位置
6.判斷這個字符串是不是以某個前綴開始的

7.用這個字符串建立一個StringBuffer對象
修改索引爲1處的字符爲‘a’
將字符串反轉
在索引爲3的位置插入一個字符串「hello」

1、枚舉
JDK1.5以後引入的一個新的特性，存在於java.lang

表示取值範圍限定的變量（四季，星期，月份）

枚舉類和普通類的區別：
a.枚舉類的父類java.lang.Enum，而不是Object
b。使用enum關鍵字（enumeration）
c.枚舉類的構造器只能使用private訪問權限修飾符
d.枚舉類的的全部實例必須在枚舉類中顯式列出，系統會自動給這些實例添加修飾符public static final
e。全部的枚舉類都提供了一個values方法，能夠用來遍歷枚舉中全部的枚舉值

語法
訪問權限修飾符 enum 枚舉名稱 {
//枚舉值
可能取得值1，可能取得值2，可能取得值3，....,可能取得值n;
}

注意：枚舉值的命名須要所有大寫，不一樣單詞之間使用下劃線分隔

2、異常
1.概念：
程序在編譯運行過程當中遇到的種種不正常的現象
Java經過Throwable類來描述各類不一樣的異常，Java中的異常都是面向對象的，全部的異常都是Throwable
的子類
2.分類
Throwable的子類：Exception Error
Error:大多數與代碼編寫者沒有關係，表示當代碼運行時，JVM出現的問題，例如：StackOverFlow（棧溢出）
Exception:程序可以捕獲而且處理的異常
CheckedException:編譯時異常,這種異常必需要處理，不然編譯都沒法經過
RuntimeException：運行時異常，編譯能夠經過，可是在程序運行的時候被發現

3.處理異常
處理機制：拋出異常，捕捉異常

a.捕捉異常：try catch
語法：
try{
//可能會有異常的代碼
}
catch(Exception e){

//捕捉並處理try代碼塊中出現的異常
}
說明：關鍵詞try後面的代碼塊中寫可能會有異常的代碼，這塊區域被稱爲監控區域，
若是在try中檢測到了異常，程序在運行的時候系統會試圖匹配對應的catch代碼塊
若是匹配到了對應catch代碼塊，則運行並處理異常，結束以後整個try-catch語句結束

b.拋出異常throw throws
throw ：拋出一個異常的對象，調用這個對象所在的方法的時候就會出現這種異常
throws：聲明在方法定義的時候，用來表示這個方法可能會拋出的異常

補充問題：
1.多個catch
2.e1.printStackTrace();

//返回異常的消息信息
System.out.println(e1.getMessage());//String

3.若是在try中出現多個異常的時候，只處理位於最前面的異常，可是後面的異常不會對程序產生影響

四、自定義異常
在實際項目開發中，若是系統提供的異常不可以知足實際的需求的話，就須要自定義異常

實現方式：
編譯時異常：繼承自Exception類，
運行時異常：繼承自RuntimeException

3、集合
1.概念
數組：用來存儲相兼容數據類型的定長的容器（基本數據類型和引用數據類型）
集合：存儲引用數據類型的變長的容器（引用數據類型）

》十四：

1、泛型
1.概念
泛型指的是泛指的類型。主要用於子類和父類，接口和實現類之間的數據傳遞

JDK1.5以後新增的特性，主要用於解決安全問題，是一個安全機制

好處：
a.能夠提升代碼的複用性
b.避免了強制類型轉換的麻煩
c.提升了代碼的安全性
d.能夠把運行時的異常提早到編譯時

泛型：經過<>來定義要操做的引用數據類型

何時使用泛型？
一般使用在集合框架中，當遇到<>的時候，通常須要定義泛型

2.泛型的應用場景
a.泛型應用在類中

訪問權限修飾符 class 類名<類型1，類型2。。。>
{
}

b.泛型應用在接口中
interface 接口名稱<類型1，類型2。。。> {

}

c。泛型應用在方法中
訪問權限修飾符 <類型1，類型2.。。。> 返回值類型方法名（參數列表） {

}

d.應用在集合中

e.通配符-------- ？
能夠匹配任意類型
1><? super 類名>：能夠是指定類或者指定類的父類

2><? extends 類名>:能夠是指定類或者執行類的子類

2、List接口
List是Collection接口的一個子接口，可使用Collection中的全部的方法
List在Java中表明一個有序的集合，集合中的每一個元素都有對應的索引，List容許添加劇復元素，能夠經過索引來訪問集合中的元素

1.ArrayList-----List接口的一個實現類
特色：
a.不排重（同一個元素，能夠被添加屢次）
b.有序的（元素的添加順序和底層的存儲順序是相同的）
c.底層存儲採用相似「數組」的數據結構，查詢和修改的效率比較高，新增和刪除的效率比較低

2.LinkedList
特色：
a.不排重（同一個元素，能夠被添加屢次）
b。有序的（元素的添加順序和底層的存儲順序是相同的）
c.底層存儲採用鏈表的數據結構，查詢和修改的效率比較低，新增和刪除的效率比較高

鏈表的存儲：當添加第一個元素的時候，會自動的添加進去第二個元素的地址

3.Vector
特色：
a.在用法上和ArrayList幾乎徹底相同
b.Vetor是一個古老的集合。（JDK1.0開始）
c。Vector是線程安全的，ArrayList是線程不安全的（推薦使用ArrayList，Collections工具類能夠將一個ArrayList變成線程安全的）
d.在性能上比ArrayList低

4.Satck

是Vector的子類，用於模擬棧這種數據結構，棧一般是先進後出
最後push進棧的元素，將最早被pop出棧，進棧出棧都是Object，從棧中取出元素後必需要作強制類型轉換

3、遍歷集合

1.加強for循環
2.迭代器Iterator（接口）
3.ListIterator迭代器

》十五：

1、Set接口
Set集合不容許包含相同的元素，若是試圖將兩個相同的元素添加到一個集合中，使用add方法，添加失敗，返回false
一、HashSet
HashSet是Set集合的一個實現類，大多數狀況使用它

特色：
a,排重（相同的元素不能被重複添加）
原理：若是兩個對象的hashCode相同，而且經過equals方法比較返回的結果也是相同的，HashSet集合會認爲這兩個元素是同一個，集合中只會被添加一次
b。無序的（元素的添加的順序和底層存儲的順序不一樣，是隨機的，是由一套算法決定的，每次的順序極可能不同）
c.集合元素值能夠是null
d.底層存儲採用的數據結構是哈希算法，具備很好的存取和查找功能
原理：hashCode值決定了元素在內存中的存儲地址，能夠經過hashCode值就能夠訪問到集合的元素

2.LinkedHashSet
是hashSet的一個子類，使用和HashSet基本相同

特色：
a.排重的
b。有序的（元素的添加順序和底層的存儲順序相同）
c。底層存儲採用的數據結構是鏈表

3.TreeSet
是Set接口的一個實現類，同時也是SortedSet接口的惟一實現類，能夠確保集合元素處於排序狀態

特色：
a.排重的
b.有序的
c.底層存儲採用的數據結構是二叉樹（紅黑樹）（數據結構）

排序方式：
a。天然排序
TreeSet會調用集合元素的compareTo()方法比較元素之間的大小關係，而後按照升序進行排序

Java提供了一個Comparable接口，這個接口裏有compareTo()方法，該方法返回一個整數。實現該接口的類必須重寫compareTo()方法
規則是：
obj1 compareTo(obj2):
0:相等
正整數：obj1 > obj2
負整數：obj1 < obj2

Java中的一些經常使用類已經實現了Comparable接口，並重寫了compareTo()方法，提供了比較大小的一套標準，Integer、Character（unicode編碼）、Boolean(true > false),String(unicode編碼),Date（後面的日期比前面的日期大）

b.定製排序
若是要實現降序排序，能夠採用定製排序，主要須要實現一個Comparator接口，其中包含了一個compare（）方法

規則：
int compare(obj1，obj2)
0:相等
正整數：obj1 > obj2
負整數：obj1 < obj2

2、Map接口
Map一樣是一個集合的接口，一樣用來存儲引用數據類型，變長的容器，主要用於保存具備映射關係的數據，Map中的元素是以鍵值對的形式存在的
key:鍵
value:值
userName:zhangsan
password:1243134

key和value之間是單向的一對一的關係，能夠經過指定的key就能夠找到對應的value

特色：
a.Map中的元素是以鍵值對的形式存在的，一個鍵對應一個值，不容許只有鍵沒有值，也不容許一個鍵對應多個值
b.Map中的元素是按照鍵進行排重的，Map中的鍵不容許重複，若是添加相同的鍵，這時後添加的會覆蓋原來的
c。鍵和值都是引用數據類型
d.鍵和值能夠爲null（針對部分）

1.HashMap
特色：
a.無序的，
b.底層存儲採用的數據結構是哈希算法

2.LinkedHashMap

特色：
a.有序的，
b.底層存儲採用的數據結構是鏈表

3.Hashtable
Hashtable和HashMap之間的關係就至關因而Vector和ArrayList之間的關係

區別：
a.在用法上和HashMap基本相同
b.Hashtable是一個古老的Map實現類（JDK1.0開始就存在了）
c。Hashtable是線程安全的，HashMap是不安全的，推薦使用HashMap、
d.Hashtable的性能比HashMap的低
e.Hashtable是不容許將null做爲鍵和值的。若是試圖將null添加到Hashtable中時，將引起NullPointerException，

4.TreeMap
TreeMap是Map集合的一個實現類，同時也是SortedMap的實現類

特色：
a.有序的
b.底層存儲採用的數據結構是二叉樹（紅黑樹）

TreeMap中的排序主要針對的是Key
排序方式：天然排序和定製排序

5.Map的遍歷、

a.加強for循環
b迭代器Iterator
c。entrySet

3、Collections工具類（Arrays工具類）

四。集合的總結

1.是否排重
XxxxxxList：不排重
XxxxxxSet：排重
XxxxxMap:按照鍵排重

2.底層存儲的數據結構
ArrayList:數組結構
HashXxxxx:哈希算法
LinkedXxxx:鏈表
TreeXxxx:二叉樹（紅黑樹）

3.是否有序
HashXxxx:無序的
LinkedHashXxxx:有序的

》十六：

1、File類
主要用於文件操做
對存儲在磁盤上的文件和目錄的抽取和封裝

2、IO流
1.概念
File類只能建立或者修改文件或者文件夾的層級結構，若是要訪問文件中的內容的話，就須要用到IO流（Input Output，輸入輸出流）

操做磁盤上的文件內容，實現數據的輸入輸出操做，磁盤上的文件和內存之間進行交互須要有一個媒介或者管道，這個媒介或者管道就稱爲IO流

2.流的分類
a.按流的流向分：
輸入流：數據從磁盤到內存，只能從中讀取數據，不能寫入數據，例如：InputStream(字節輸入流)，Reader(字符輸入流)
輸出流：數據從內存到磁盤，只能向其寫入數據，不能讀取數據，例如:OutputStream（字節輸出流），Writer(字符輸出流)

b。按數據單位分：
區別：所操做的數據單元不一樣，字節流操做的最小數據單元是8位的字節，而字符流操做的最小數據單元是16位的字符
字符流：主要使用Reader和Writer做爲基類
字節流：主要使用InputStream和OutStream做爲基類

c.按層次分
節點流：能夠從/向一個磁盤讀/寫數據的流，
處理流：用於對一個已經存在的流進行鏈接或者封裝，高級流

3.實現
1>InputStream和Reader
抽象類，是不能用來實例化對象的
FileInputStream FileReader

2>OutputStream和Writer
FileOutputStream FileWriter

注意：流在使用完畢以後須要關閉，釋放和此流有關的系統資源

》十七：

1、轉換流
做用：實現將字節流轉換爲字符流

a.InputStreamReader:字節字符轉換輸入流：字節輸入流-----》字符輸入流
b.OutputStreamWriter:字節字符轉換輸出流：字節輸出流-----》字符輸出流

問題一：爲何沒有將字符流轉換爲字節流的轉換流？？
字節流比字符流的使用範圍更廣，字符流比字節流操做方便

問題：使用字符輸入流讀取一個文件中的內容，默認處理文件的編碼格式爲GBK，當文件的內容是GBK之外的格式時，讀取出來的內容是亂碼的，因此須要轉換流去處理這個問題

問題二：何時使用轉換流？
若是須要處理其餘編碼格式的文本（默認爲GBK），這個時候使用轉換流

2、緩衝流

1.概念
當須要操做數據的時候，爲了提升工做效率，並非直接去操做流中的數據，而是在流中有一種緩衝區（數組），咱們要操做的實際上是緩衝區的中數據

2.分類
緩衝字節輸入流：BufferedInputStream
緩衝字節輸出流：BufferedOutputStream
緩衝字符輸入流：BufferedReader
緩衝字符輸出流：BufferedWriter

3、Properties類-----擴展

是Map接口的一個實現類，而且是Hashtable的子類

4、對象流-----本地化
操做的數據是對象
經常使用：將一個對象固化到本地磁盤上，能夠用做存儲和加載
ObjectInputStream
OBjectOutputStream

》十八：

1、進程和線程
1.進程
是一個程序的運行狀態和資源佔用的描述

進程的特色：
a.獨立性：不一樣的進程之間是獨立的，相互之間資源不共享
b.動態性：進程在系統中不是靜止不動的，而是一直活動的
c.併發性：多個進程能夠在同一個處理器上同時進行，互不影響

多進程：一個操做系統能夠運行多個應用程序

2.線程
線程是進程的組成部分，一個進程能夠有多個線程，每一個線程用來處理一個指定的子任務

舉例：打開酷狗軟件-------》這是一個進程
播放歌曲/刷新歌詞------》兩個線程（併發的）

線程的執行是搶佔式的，多個線程能夠在一個進程中併發執行，其實質是CPU在不一樣的線程之間進行快速的切換，也就是說，當前運行的線程在任什麼時候候都有可能被掛起，以便於別的線程去執行對應的任務，一樣的，被掛起的線程隨時有可能爭搶到時間片，繼續執行

多線程：在一個進程中，多個線程同時進行
應用：一個瀏覽器能夠同時下載多張圖片
一個服務器能夠同時響應多個用戶請求

3.進程和線程之間的關係
a.一個程序運行後至少有一個進程
b.一個進程能夠包含多個線程，但至少須要有一個線程，不然進程是沒有意義的

爲何要選用多線程編程而不選用多進程呢？/線程相對於進程的優勢？
a.進程間資源不能進行共享，可是線程之間能夠共享資源
b.系統若是要建立進程的話，須要爲這個進程從新分配系統資源，而建立線程的話則相對容易的多，所以使用線程處理併發任務比進程的效率高
c.Java中內置了多線程的功能支持，簡化了多線程編程

2、線程的實現
1.繼承自Thread類
Thread類是全部線程類的父類，實現了對線程的抽取和封裝
1>使用Thread類建立並開啓線程的步驟：
a.定義一個類，繼承自Thread類，重寫該類的run方法，該run方法的方法體就表明了線程須要完成的任務，所以，run方法體也被稱爲線程執行體
b.建立子類的對象，即至關於建立了一個線程
c.須要使用start方法手動開啓線程

關於線程的執行，須要注意的問題：
a.若是一個線程中的全部的任務都處理完了，那麼這個線程會自動中止（正常狀況）
b.若是在一個線程a中開闢了子線程a0,a1,a2.....那麼線程a中止後，在這個線程中開闢的子線程會所有中止
c.多個線程併發執行，其實就是在爭搶CPU時間片

2.實現接口Runnable
使用實現Runnable接口的方式建立並開啓線程的步驟：
a.定義一個類，這個類實現Runnable接口，須要重寫對應的run方法，run方法的方法體一樣是線程的執行體
b.建立實現了Runnable接口對應類的對象，並以此實例做爲Thread類的target對象
c.手動調用start方法開啓線程

兩種方式實現線程的比較：
1.實現Runnabel接口
a.自定義的類只是實現了Runnable接口，同時還能夠去繼承其餘的類
b.多個線程能夠共享同一個target對象，因此很是適合多個相同的線程來處理同一份資源的狀況
弊端：不直觀，若是要獲取當前正在運行的線程，只能經過Thread.currentThread()
2.繼承Thread類
直觀，若是要訪問正在運行的線程，除了能夠經過Thread.currentThread()方式以外，還可使用super關鍵字

弊端：由於線程類已經繼承了Thread類，因此不能再去繼承其餘的類（單繼承）

實際上，大多數的多線程應用都採用實現Runnable接口的方式實現(推薦使用匿名內部類)

3、線程的生命週期
對象的生命週期：從一個對象被實例化到這個對象被銷燬的過程當中，這個對象經歷的種種狀態

舉例：人的生命週期：出生---嬰兒---兒童---少年---青年----中年---老年---死亡

對於線程，當一個線程被建立並啓動以後，它既不是一啓動就進入了執行狀態，也不是一直處於執行狀態，在線程的生命週期中，一樣的也會經歷各類過程（在一個進程中，多個線程能夠併發，爭搶CPU時間片）

New(新生):線程被實例化，可是尚未開始執行
Runnable(就緒)：沒有爭搶到時間片
Running（運行）：爭搶到了時間片，開始執行線程中的任務
Blocked(阻塞)：線程再執行的過程當中遇到突發情況，使得其餘的線程爭搶去了時間片，被阻塞的線程會等待合適的時機從新進入就緒狀態
Dead(死亡)：線程終止
a.run方法執行完畢，線程正常結束
b.直接調用該線程的stop方法強制終止這個線程（這種作法比較危險，死鎖）

4、線程的經常使用方法
1.設置線程的優先級
能夠經過設置優先級來改變線程搶到時間片的機率，優先級高的線程搶到時間片的機率比較高，能夠得到更多的執行機會

默認狀況下，每一個線程的優先級都與建立它的的父線程具備相同的優先級
setPriority（），所傳的參數範圍1~10，默認爲5，對應的數值越大，說明優先級越高，這個方法的設置必定要在start以前

2.使得線程休眠
使得當前正在執行的線程休眠一段時間，釋放時間片，致使線程進入阻塞狀態
sleep(5000);5000表明的是毫秒
設置了sleep就至關於將當前線程掛起5s,這個操做跟線程的優先級無關，當對應的時間到了以後，還會再執行，
若是隻設置了優先級的話，等於給設置了優先級的線程設置衝突，那麼被掛起的是優先級比較低的那個線程

3.中斷線程
interrupt（）
interrupt只是改變一個線程的狀態，並非真正的中止一個線程
若是線程處於阻塞狀態（sleep,join），則中斷狀態被清除
若是一個線程沒有處於阻塞狀態，這時調用interrupt將不起做用，不然，會引發InterruptedException異常（該線程預先準備好處理此情況）

實際看到的效果：中止了線程

在線程的執行體中，能夠經過 boolean isInterrupted() 來測試線程是否已經中斷。

4.線程合併
join()
優先執行被合併進來的線程，執行完合併進來的線程以後，再執行原來的線程

5.後臺線程
setDeamon（）
又被稱爲守護線程或者精靈線程
特徵：若是全部的前臺線程都死亡，後臺線程會自動死亡

這個方法的調用須要在start以前

6.線程讓步
yield（）
yield方法是一個和sleep方法類似的方法
它可讓當前正在執行的線程暫停，但他不會阻塞該線程，它只是將該線程轉入就緒狀態，徹底會出現的一個狀況是：當某個線程調用了yield方法暫停以後，線程調度器可能會將該線程立馬調起來進入執行狀態
實際上，只有優先級相同或者優先級更高的線程纔有可能獲取執行的機會

yield方法和sleep方法的區別：
a.sleep方法暫停當前線程以後，會給其餘線程執行的機會的，可是跟線程的優先級沒有關係，yield只有優先級相同或者優先級更高的線程纔有可能獲取執行的機會
b.sleep會將一個線程轉入阻塞狀態，可是yield不會，只是作出了讓步
c.sleep會有InterruptedException的異常，可是yield沒有
d.sleep能夠有更好的可移植性，一般不要依靠yield來控制併發的線程

》十九：

1、多線程使用過程當中的臨界資源問題

1.臨界資源：被多個線程同時訪問的資源

臨界資源產生的緣由：有多個線程同時訪問一個資源的時候，若是一個線程在取值的過程當中，時間片又被其餘的線程搶走了，臨界資源問題就產生了

如何解決臨界資源問題？
一個線程在訪問臨界資源的時候，若是給這個資源上一把鎖，這個時候若是其餘線程也要訪問這個資源的話，就須要在鎖外面等待

2.鎖：

對象鎖：在Java中，任意的對象均可以被當作鎖來使用
類鎖：把一個類當作鎖，語法：類名.class

2、使用鎖來解決臨界資源問題

1.同步代碼塊
語法：
synchronized(鎖) {

}

說明：
a.程序執行到了同步代碼塊中，就使用鎖鎖住了臨界資源，這個時候，其餘的線程是不能執行代碼段中的代碼的，只能在鎖外面進行等待
b.執行完代碼段中的代碼，會進行自動解鎖，那麼這個時候其餘的線程開始爭搶時間片
c.必定要保證不一樣的線程看到的是同一把鎖，不然同步代碼塊沒有意義

2.同步方法
synchronized 訪問權限修飾符返回值類型函數名（參數列表） {
//被多個線程能夠同時訪問的臨界資源
}

3.同步鎖（JDK1.5以後新增的）
能夠經過定義同步鎖對象來實現同步，和同步代碼塊以及同步方法具備相同的效果

1>使用ReentrantLock類來進行鎖的操做，實現了Lock接口
lock（）：加鎖
unlock（）：解鎖

3、單例在多線程中的應用

4、生產者與消費者設計模式
1.對臨界資源問題的應用
它描述的是有一塊緩衝區做爲倉庫，生產者能夠將產品放入倉庫，消費者能夠從倉庫中取走產品，解決生產者消費者問題，咱們須要作的就是保證生產者和消費者之間的同步

同步問題的核心：經常使用的方式就是加鎖，目的是爲了保證在任意時刻資源只能被一個線程訪問

2.實現
wait():當緩衝區已滿或者爲空的狀況下，生產者/消費者中止本身的執行，放棄鎖，使本身處於等待狀態，讓其餘線程執行
Object的方法
調用方法：對象.wait()
釋放對象這個鎖標記，而後再鎖外面進行等待(sleep是持有鎖進行休眠)
必須放到同步代碼段中執行

notify():當生產者/消費者向緩衝區中放入/取走一個產品時，向其餘等待的線程發出通知，同時使本身放棄鎖，處於等待狀態
Object的方法
調用方法：對象.notify()
表示喚醒對象鎖標記外面正在等待的一個線程

notifyAll():所有喚醒
調用方法：對象.notify()
表示喚醒對象鎖標記外面正在等待的全部線程

》二十：

1、網絡編程基礎
1.概念
所謂計算機網絡，就是把分佈在不一樣區域的計算機與專門的外部設備使用通訊線路鏈接成一個規模大，功能比較強的網絡系統，從而使得計算機之間能夠相互通訊，共享資源
所謂的網絡編程，在同一個網絡中不一樣的機器之間進行通訊

2.計算機之間進行通訊的必要條件
ip地址，端口，網絡協議

1>ip地址
ip地址其實就是計算機在網絡中的地址，是一個32位的二進制數，一般被分爲4個8位二進制
一臺計算機在網絡中的地址，在同一個網段內，ip地址是惟一的
ipv4:由4個字節組成，分爲四段
ipv6：由6個字節組成，分爲六段
ip地址的分類（5類）
A：保留給政府機構，1.0.0.1~126.255.255.254
B:分配給中型企業,128.0.0.1~191.255.255.254
C:分配給任何須要的我的，192.0.0.1~223.255.255.254
D：用於組播，224 ~ 239
E：用於實驗，240~255
127.通常指的是本機的ip，localhost

2>端口
數據的發送和接受都是須要經過端口出入機器的，在同一臺機器上，兩個不一樣的程序不能佔用同一個端口，端口號的範圍：0~65535

a.公認端口：0~1023
b.註冊端口：1025~49151
c.動態或私有端口：1024~65535

3>網絡協議
須要通訊的設備之間要實現相同的通訊協議，才能進行相互通訊
網絡分層：物理層，數據鏈路層，網絡層，傳輸層，會話層，表示層，應用層
傳輸層協議：TCP\UDP
應用層協議：HTTP(是一個被動的協議，只有客戶端主動給服務端發送請求的時候，服務端纔會給客戶端響應)

環信融雲

3.InetAddress類
在java中，使用InetAddress類來表明ip地址，是對ip地址的抽取和封裝，有兩個子類：Inet4Address,Inet6Address.,分別是ipv4和ipv6的抽象
Java中涉及到網絡的類基本都存在於java.net包下

4.使用UDP實現數據的接受和發送
UDP:是一個面向無鏈接的，效率高的，可是相對不安全的通訊協議

UDP傳輸的數據是封裝到數據報包中進行的，該協議並不能保證數據可以正確的到達目的地

涉及的類：
Socket：實現數據的接受和發送，又被稱爲套接字，是兩臺機器之間進行通訊的端口
DatagramSocket：用來表示發送和接收數據報包的套接字，在這個類上老是啓用UDP進行數據發送

DatagramPacket:數據報包，用來將指定長度的包接收或者發送到指定主機上的指定端口號上

5.使用TCP實現數據的接受和發送
TCP：面向鏈接的，安全的，基於字節流的傳輸層通訊協議，可是效率沒有UDP高

面向鏈接：須要在通訊的兩個機器之間創建通訊

使用經典的三次握手創建鏈接
a.客戶端向服務端發送一個請求
b.服務端收到請求以後，回客戶端一個響應
c.當客戶端收到服務端的響應以後，回服務端一個確認信息

總結：使用TCP實現數據的發送和接收須要有發送方和接收方

涉及到的類
Socket：此類實現客戶端套接字
ServerSocket：此類實現服務器套接字

a.客戶端發送消息，服務端接收消息
b.客戶端發送消息，服務端回覆消息
c.客戶端上傳文件到服務端（圖片）
d.客戶端從服務端下載文件（圖片）

》二十一：

1、URL和URLConnection

1.HTTP
超文本傳輸協議
是一個應用層的協議
是一個被動的協議
只有客戶端主動給服務端發送消息，服務端纔會給客戶端一個響應

2.URL
統一的資源定位符（網址）
指向一個網絡上的資源

格式：網絡通訊協議：//主機：端口/要訪問的文件路徑？參數鍵1=參數值1&參數鍵2=參數值2.。。。。
若是沒有寫端口號的話，默認爲80
舉例：http://image.baidu.com/search/index?tn=baiduimage&ct=201326592&lm=-1&cl=2&ie=gbk&word=%CD%BC%C6%AC&fr=ala&ala=1&alatpl=others&pos=0

經常使用構造方法：
URL(String spec)
根據 String 表示形式建立 URL 對象。
URLConnection openConnection()
返回一個 URLConnection 對象，它表示到 URL 所引用的遠程對象的鏈接。

URL：爲了創建一個本機到網絡指定資源的通道，就能夠直接訪問網絡資源

3.URLConnection
是一個抽象類，沒法實例化對象
若是要訪問指定的網絡資源，則須要用到URLConnection，表示應用程序和URL之間的鏈接，

經常使用方法：
getInputStream:獲取一個網絡到本機的輸入流
getOutputStream：獲取本機到網絡的輸出流

4.HttpURLConnection
也是一個抽象類，是URLConnection的子類
定義了一些經常使用的字段
HTTP_OK 200 請求成功
HTTP_NOT_FOUND 404 要請求的資源不存在
HTTP_FORBIDDEN 403 訪問被拒絕
HTTP_UNAVAILABLE 503 服務沒法訪問

經常使用的方法
int getResponseCode()
從 HTTP 響應消息獲取狀態碼。

String getResponseMessage()
獲取與來自服務器的響應代碼一塊兒返回的 HTTP 響應消息（若是有）。

setReadTimeout
設置一個請求的超時時間
一個請求在發出去以後，若是在指定的時間以內未收到響應，則認爲請求超時
區分sleep，sleep會阻塞線程，在設置的時間以內是靜態的，setReadTimeout在設置的時間以內是動態的，一直在向服務器請求數據
若是在指定的時間以內服務器沒有響應的話，則會拋出SocketTimeoutException

應用：
a.使用URLconnection將一張網絡圖片下載到本地
b.使用URLConnection請求網絡數據到本地

》二十二：

1、反射機制
1.概念
反射機制指的是程序在運行的過程當中，對於任意一個類，都可以知道這個類對應的全部的屬性和方法；對於任意一個對象，都可以調用其中的任意的方法和屬性，在Java中，把這種動態獲取信息以及動態調用對象的方法的功能稱爲Java語言的反射機制
一個類編譯以後會生成對應的class字節碼文件，能夠經過這個字節碼文件動態的去獲取全部的類，對類中的屬性和方法進行訪問

在Java中，對類、構造方法、屬性、普通方法分別抽象除了對應的類：Class、Constructor、Field、Method

class Animal {
String name;
int age;

public Animal() {
}

public void show() {
}
}

class Cat extends Animal{

public Cat() {
}

}

class Dog extends Animal{

public Dog() {
}
}

class Desk {
String color;
float weight;

}

class Text {
//屬性
Field field;