day01

java基礎

1.關鍵字:是被java賦予了特殊含義的單詞,咱們只能用不能改,也不能跟這些關鍵字重名

2標識符:程序中需要我們自己命令的
//不能跟關鍵字重名
//標識符中只能包含字母,數字,_和$
//區分大小寫 A a
//不能以數字開頭
//注意:可以使用中文作為標識符,但是一般不使用.

3.常量:固定不變的量

變量:存儲程序中用到的數據,它存儲的數是可以改變的,只能存儲一個數

4.數據類型
分類:第一種分法是根據數據類型分.

? 第一:基本數據類型
數值型 范圍
>byte型 1個字節 [-2^7,27-1]
>short型 2個字節 [-2^15,215-1]
>int 4個 [-2^31,231-1]
>long 8個 [-2^63,263-1]
布爾型
>boolean 1個
浮點型(小數)
>float 4個
>double 8個
字符型
>char 1個

5.類型轉換
類型的高低是根據數據類型表示的數范圍的大小確定的.
自動類型轉換 :數據類型從低類型轉成高類型,沒有數據的損失
強制類型轉換:數據類型從高類型轉成低類型,有可能會出現數據的損失.

6.char相關的內容
char 1個字節,默認對應的語言是英文,字符集是ASCII 0-48 A-65 a-97
針對中文: 對應的字符集是GBK/GB2312 一個漢字2個字節
常用的字符集: GBK(中國標準) UTF-8(國際通用標準) ASCII(國標) uncode(內部編碼) ISO8859-(歐洲標準)
對于中文: 2個字節 3個字節 不支持中文 2個字節 不支持中文

? 我們通常把字符串轉成二進制的過程稱為編碼
將二進制轉成字符串的過程稱為解碼

運算符: 分類: 第一:根據類型分類 算數運算符:+ - * / % ++(自增) --(自減)

賦值運算符:= += -= *= /= %= ^=

邏輯運算符:&& || !

關系運算符:== < <= > >= !=

位運算符:操作位的. & | ^ ~

移位運算符:操作位的. >> << >>>

第二:根據操作元素個數分類

? 算數運算符:+ - * / % ++(自增) --(自減)

短路與:當一個式子中有多個連續的&&,我們只需要找出第一個false,即可停止運算.因為只要有一個false,整體結果就是false

短路或:當一個式子中有多個連續的||,我們只需要找出第一個true,即可停止運算.因為只要有一個true,整體結果就是true

8.移位運算符 >> 有符號右移 << 有符號左移 >>> 無符號右移
>>1 右移一位:代表除以2
<<1 左移一位:代表乘以2

9.dowhile 與while的區別:就是dowhile不管條件成立與否,語句都會先執行一次

10.循環可以嵌套,可以給for循環添加標識,我們可以認為是給他起了一個別名.

11.函數的構成:
修飾詞 返回值類型 函數名(參數列表){
函數的功能代碼;
return 返回值;
}
修飾詞:限定當前函數的可見范圍的,暫時先忽略
*返回值類型:可以有,也可以沒有,如果沒有需要些void
函數名:必須有,命名規則:遵循小駝峰原則(當有多個單詞組成名字的時候,除第一個單詞外,所有單詞的首字母大寫)
函數名:要做到見名知意
參數列表:1.可以有,可以沒有 2.如果有,可以有一個或多個,多個參數之間以,隔開
return 返回值; 這里是一個動作,后面放的是要返回的數據,要求:返回值類型要與return后面的類型一致
注意點:return后面只能放一個數據
特點:有結束的意思

? 注意:函數之間可以調用,但是不能嵌套

?

//函數的調用:通過函數的名字發生的調用

12函數

if,for等可以嵌套.但是函數的定義不能嵌套,調用可以.

• 函數的功能必須通過調用實現
• 函數有功能單一性原則.即一個函數中最好只有一個功能.
• 函數的作用:可以提高程序的安全性,復用性,健壯性,可讀性,節省內存.

13.函數功能

1)直接定義在函數,for,if等中的變量稱為局部變量.
局部變量只在他所在的函數,for,if中可見可用.出了這個范圍就會從內存中消失.

2)我們把函數定義處的變量稱為形參:形式上的參數
把函數調用處的變量稱為實參:實際的參數
形參必須通過接受實參的值才能起作用.

我們在定義形參和實參時注意:
參數的個數要一致
參數的位置要一致
參數的類型要一致
3)return注意點:
返回數據,將數據往外拋
結束的意思,在表示結束時,函數不一定有返回值.

14.java將內存分成了5塊兒,分別是堆區,棧區,方法區,本地方法區,寄存器
棧區:里面存放數據的特點是:先進后出,我們主要將局部變量和函數放在棧區,數據的特點是使用完立刻釋放
堆區:存放的是實體(對象和數組),實體可以同時存放多個值,實體里面的變量如果不賦值,會有默認值.整型數據默認值是0,boolean—false

15.函數的重載:在同一個類中,方法名相同,參數不相同的方法的關系

• 注意點:
• 1.參數的個數不同是重載
• 2.參數的類型不同是重載
• 3.參數的位置不同是重載
• 4.重載與返回值無關
• 5.重載與參數的名字無關
  • 6.重載的方法本質上還是不同的方法.

day02

數組

? 1.數組可以存儲多個相同數據，本身是引用數據類型 放在堆區 有默認值。
2.引用數據類型里面存儲地址（16進制數），簡單數據類型存值（10進制數）。
3.new 動態開辟內存空間（需要的時候），然后當前地址返回給變量（變量存地址），所以存地址的叫引用數據類型。
4.數組第一個元素的地址就是（充當）整個數組的地址，數組內存連續，計算機單位默認是字節。1234 1238 123C 然后就能用下標了。
5.引用的本質 變量只告訴地址 ，具體操作是對象本身（數組）。
6.int[] arr = {1,2,3,4} 數組作為參數時。不能直接寫大括號這種創建數組方式。
7.main方法入棧 方法里有變量。
8.ArrayIndexOutOfBoundsException。
9.值傳遞：傳基本數據類型。址傳遞：傳遞地址。根本是兩個引用指向同一地址進行操作。

二維數組

? 1.二維數組：第二個是一個建議值， 一維數組位置放的二維數組地址，創建時數組里放數組并且分開寫是可以的。

int[][] arr=new int[1][1]; arr[0]=new int[]{1,2,4,5};//全存儲了

排序

重點掌握:冒泡,選擇,希爾**,快速排序,歸并排序**,插入排序。

各算法的時間復雜度
平均時間復雜度
插入排序 O(n2)
冒泡排序 O(n2)
選擇排序 O(n2)
快速排序 O(n log n)
堆排序 O(n log n)
歸并排序 O(n log n)
基數排序 O(n)
希爾排序 O(n1.25)

//冒泡排序:先確定最大值public static void bubbleSort(int[] arr) {for (int i = 0; i < arr.length-1; i++) {//確定的是整體的次數,比元素的個數少一for (int j = 0; j < arr.length-1-i; j++) {//確定一個元素需要比較的次數if (arr[j] > arr[j+1]) {//交換---改結束值arr[j] = arr[j] ^ arr[j+1];arr[j+1] = arr[j] ^ arr[j+1];arr[j] = arr[j] ^ arr[j+1];}}}} //選擇排序:先確定最小值public static void SelectedSort(int[] arr) {for (int i = 0; i < arr.length-1; i++) {//確定的是整體的次數,比元素的個數少一for (int j = i; j < arr.length-1; j++) {//確定一個元素需要比較的次數if (arr[i] > arr[j+1]) {//交換---改起始值arr[i] = arr[i] ^ arr[j+1];arr[j+1] = arr[i] ^ arr[j+1];arr[i] = arr[i] ^ arr[j+1];}}}}

查找

? 1.二分查找是重點 數組必須有序

? m=(l+r)/2; 或 m=(l+r)>>1;

? r=m-1; l=m+1;

? 結束條件：l>r while循環

//二分查找public static int binarySearch(int[] arr,int key) {int l = 0;int r = arr.length-1;int m ;while (l<=r) {m = (l+r)>>1;//這里使用移位運算符做除法if (key == arr[m]) {return m;//查到后返回下標}else if (key > arr[m]) {l = m+1;}else if (key < arr[m]) {r = m-1;}} return -1;}

面向對象

1.面向過程：

• 強調的是功能行為 。

• 關注的是解決問題需要哪些步驟。

2.面向對象：

• 將功能封裝進對象 強調具有功能的對象 。

• 關注的是解決問題需要哪些對象。

3.面向對象是基于面向過程的 ，HTML是面向對象的。

4.怎么理解面向對象？

• 二者都是都是編程思想。

• 面向對象是基于面向過程的。

• 面向對象是比面向過程更高級的編程思想。

• 面向對象是更符合人們思考習慣的思想。

• 讓編程人員從執行者變成指揮者。

• 將復雜事情簡單化。

5.類是對象的抽象。

6.類：描述事物就是描述事物的名稱、屬性、行為。擁有相同（相似）屬性和行為的對象都可以抽象出一個類。

7.構造方法對對象進行初始化（賦值）。

8.單引號只能寫一個字符。數組就是特殊的對象。

9.沒有引用指向的對象（匿名對象）會被垃圾回收機制回收。

匿名對象：節省代碼 節省內存。作為參數傳遞。test（new Dag（））；方法里接受的是new返回的地址。匿名內部類。

10.人有孩子，人有人的屬性 。

11.一個類型一旦創建出來,就是一個獨立的數據類型,在他可見的范圍內都是可以使用的,包括自己的內部

static 關鍵字

1.static 修飾成員變量，就是靜態成員變量。應該由類調用，如果對象調用會有警告。非靜態只能由對象調用。

2.靜態方法放到方法區還會放到靜態方法區一份，放入后方法生命周期跟類一致（.class文件一致）。

3.靜態成員變量放在靜態方法區的靜態方法里而不是在堆的對象里。

4.類調用靜態成員變量是字節碼文件在干活。字節碼文件本身是對象。

5.優先使用靜態成員方法。非靜態至少兩次 ，靜態字節碼直接一次查找。效率高。沒有對象也可以調用。但是生命周期長占用極少 框架。

注意：靜態方法中要使用非靜態屬性必須使用非靜態成員變量。否則靜態方法使用的時候非成員變量還不一定在。

6.靜態工具類：類里方法都是靜態 一些工具方法（查找啊、排序呀）。重點啊，自己多封裝。

構造方法

1.構造方法形參隨便起名。但是創建時就不知道每個參數就不知道如何賦值。所以形參要和實參一致。this.name = name;否則就近原則變成，局部變量=局部變量。默認引用數據類型，保存當前對象引用可以點類中的成員變量和方法。 點出來的一定是成員變量。this可以充當構造方法。 dameo13 70 80

this：注意

• 不能出現自己調用自己—死循環
• 相互調用不行–死循環
• 必須放在第一行

構造代碼塊和靜態代碼塊

• 靜態代碼塊:隨著類的加載而加載,在整個程序執行過程中只執行一次,執行順序優先于main

• 構成:static+{}

• 作用:對類進行初始化

• 構造代碼塊:隨著對象的加載而加載,每次創建對象的時候都會執行一次,執行順序優先于構造方法.

• 構成:{}

• 作用:對對象進行初始化

  靜態代碼塊優先級（只執行一次）> 構造代碼塊 > 構造函數

封裝性

1.對屬性的封裝增加安全性、復用性、可讀性。

2.get set 方法 規范。開發框架時會用到。

繼承

1.繼承 是多態的基礎。Object類沒有父類。

2.父類當中的private 子類得不到。

3.繼承中方法調用過程：首先找自己 ，然后找父類，一直到Object，找到為止。

4.super 專門調用父類的方法 在子類中重寫方法時調用super（如果父類里還有有用的）

5.重寫時 返回值類型可以是父子關系 子類返回值是父類返回值的子類。

6.構造方法：子類構造方法要先調用父類構造方法，因為不對父類屬性進行初始化，子類就調用不到父類的屬性（屬性不初始化不能調用），所以在第一行就得調用父類的構造方法（同 this）。

day03

final關鍵字

在定義時必須初始化，否則后期沒法寫值了。修飾類，變量，方法。π

空白 final 成員變量 中 final的變量值賦值 可以推遲到People構造方法技結束之前。

String類被final修飾 。

abstract關鍵字

不能直接創建對象，對象里方法都沒方法體。

抽象類介于類和接口之間。制定規則。

abstract關鍵字 和 final static private等不能并用。

可以實現類里的抽象方法，也可以把自己變成抽象的。

接口

成員變量 默認修飾 public final static。成員方法默認修飾public abstract。

接口默認就是抽象的。

接口底層就是個類。

接口多實現 實現多個接口 “，”分開。補充類的單繼承

類如果多繼承那么父類里有同名方法 子類不知道選哪個 。而接口的方法沒有方法體，實現時直接實現兩個接口的。

接口作為父類的補充。

jdk1.7開始 接口里有方法的實現 但是必須用static和default修飾。

為什么：接口里的方法子類必須都得實現 接口更常用 接口更強大更靈活，但是現在還使用第一功能 。多繼承。

要是都實現了呢，子類選什么：同名方法有實現（哪怕一個）了就重寫，除非方法名只存在一個。

面向接口編程：每個類都有接口 類封起來 只調用接口用。

設計模式

前人解決常見問題的解決方案，后人直接拿來用。

單例：

• 一個類只允許有一個對象。供全局訪問。用戶拿到唯一一個

• 構造方法私有化 private

• 類里頭創建（new）一個對象 pfs 必須private 否則類名就點到了。不想變所以final ，在這里創建兩個對象違背單例的思想。

• 通過公共靜態方法 必須靜態 此時還創建不了對象 只能通過類名。

• 同時對象也得靜態 靜態方法里必須靜態成員變量。

  餓漢：直接實例化。

  懶漢 ：用的時候實例化。不能final final完只能null了 注意要有if 否則誰用誰來new 注意：有線程安全問題。

  把地址存起來 間接把唯一對象長久保存下來 不讓垃圾回收，靜態方法區老有一個指向地址，否則用戶用完就沒了

  對象全局化 方法也全局了 非靜態屬性也全局了。

  高內聚低耦合：通過單例起到連接各類 兩個類卻不互相關聯影響。

  應用：Runtime類 通過getRuntime（）獲取當前運行時，應用不能創建自己的Runtime實例。

  嚴謹的單例會把clone方法重寫 。保證單一

  package com.qf.singleInstance; /** 第一種方法:* 讓董事局主席類即充當單例類又作為董事局主席這個人*/ class ChairMan{//作為單例的功能private static ChairMan chairMan = null;private ChairMan() {}public static ChairMan getChariMan() {if (chairMan == null) {chairMan = new ChairMan();}return chairMan;}//作為董事局主席這個人的功能String name;String sex;int height;int weight;public String getName() {return name;}public void setName(String name) {this.name = name;}public String getSex() {return sex;}public void setSex(String sex) {this.sex = sex;}public int getHeight() {return height;}public void setHeight(int height) {this.height = height;}public int getWeight() {return weight;}public void setWeight(int weight) {this.weight = weight;}public void show(){System.out.println("馬云的信息");} }class Demo2 //深圳 {public static void shenzhen() {ChairMan chairman=ChairMan.getChariMan();//第二次使用單例類--直接調取值出來使用chairman.show();}}class Demo3 //哈爾濱 {public static void shanghai() {ChairMan chairman=ChairMan.getChariMan();//第三次使用單例類--直接調取值出來使用chairman.show();}} public class Demo1 //公司總部 {public static void main(String[] args) {ChairMan chairman=ChairMan.getChariMan();//第一次使用單例類--首先完成賦值chairman.setName("馬云");chairman.show();//這里是為了實現程序的模擬跳轉Demo2.shenzhen();Demo3.shanghai();}}

  ?

多態

繼承是多態的前提。

繼承要使用子類 使用父類創建對象就出問題了。

父（間接父類也行）類的引用指向子類的對象。

編譯 點擊三角之后是運行階段

編譯階段只識別等號前面的引用 運行才識別后面的對象？？？？？8

• 缺點：不能直接調用子類的獨有方法。
• 優點：提高代碼的擴展性 ？？？？？？？？？？？？？？？？？？

public static void feedAnimal（Animal animal）{animal.eat（）；//每個類都有eat方法 ？？？？？？？9 }

• object 里頭方法參數也是最高級的object 不能被限制到 ？？？？？？8

向上轉型 student-> persion

向下轉型 persion->student 調用子類的方法

二者都要在多態的環境里來講。

錯誤案例：Student persion =new persion；

persion person = new person（）；

Student Student =（Student） person（）；

動態的實現手段：動態類型 動態綁定 動態加載

動態加載：person person = new student（）；

動態類型：object var

動態綁定：加載動態庫 靜態庫

instance of ：確定當前對象是否是后面對象的子類

Demo 11？？？？？？？？？？？？？？？？？？

前后沒有繼承關系 直接報錯

成員變量 繼承下子類會把父類的重寫 。多態下調用父類和子類同名的成員變量 編譯能能通過看父類的 運行也看父類 demo12？？？？？

Object類

**clone（）**創建并返回次對象的一個副本

想要使用本方法完成克隆，必須實現Cloneable接口

？？？？？？？？？？？？？？？？？？？？？？？？？？？

person里有dog 想屬性深拷貝 必須把dog也給深拷貝 因為太多了所以不能完全深拷貝。

equals（） 默認比較地址Demo13 54 方法重寫 參數不能夠變，重寫嘛

finalize（）

**getClass（）**得到當前字節碼對象 Class 所有字節碼文件對象

基本的java類型（boolean、byte、int、float等）和關鍵字void也表示為Class對象。 car.class 、int.class 等得到的也是Class 的對象 等同于getClass（）；

**hashCode（）**hash碼值是對象的唯一身份證 值是10進制 后integer包裝成16進制

notify（）

notifyAll（）

**toString()**默認是“包名+類名@hash碼值” 一般都要重寫這個方法

wait()

wait()

wait()

內部類

1.定義在一個類的內部 成員變量、成員方法和內部類平級 把他當成成員變量

在成員方法里創建內部類的對象

拿到外部類點一個new 內部類

Outer.Inner inner = outer.new Inner();

導包 先執行包里的代碼 一般不用 如下。

import com.qf.test.Outer.Inner; Inner inner = outer.new Inner();

作用：用內部類間接實現多繼承實現 Demo14？？？？？？？

2.局部內部類 定義在一個方法里的類 demo15

四個方法 要求1可以調用34 2不可以調用 解決方法吧34放到1里頭 但是方法不能嵌套 所以用類把方法包起來 就是局部內部類

作用：我們通過局部內部類實現了功能的私有化,并對方法內部的代碼進行了整理,增強了代碼的可讀性和可操作性.

//因為函數的定義不能嵌套,所以這里要通過局部內部類實現

注意：跟局部內部類平級的成員變量會默認加final關鍵字，因為局部內部類可能用到成員變量 類可以創建對象 對象在堆區可能比方法生命周期更長（指向要一直存在的話） 所以成員變量得一直存在 防止出錯。

Demo16？？？？？？？？？？？？？？？？？？？？？？？？？

3.靜態內部類

靜態內部類不一定有靜態方法，有靜態方法的一定是靜態內部類

Out.Inn inn = new Out.Inn()；

4.匿名內部類day03 demo18

定義在一個類方法中的匿名子類對象,屬于局部內部類

匿名子類對象

兩種方式 使用已有的

匿名內部類對象

Day04

異常

1.異常的問題 throwable

• Error（）：嚴重錯誤。不讓解決 解決不了。
• Exception（）：可捕獲處理的問題。

2.Exception分類：

• 運行時異常：運行階段拋出。數組越界 空指針異常
• 編譯異常：在編譯階段拋出。

或

• 系統異常：系統提前定義好的,我們直接使用
• 自定義異常：需要我們自己定義

3.異常層層向上拋 直到遇到能處理的接收。最后會拋給JVM。

發現有多個異常時，第一個異常會把后面的中斷，程序結束。

4.try里出現異常catch會立刻捕獲，try后面的代碼會中斷。catch里會處理異常，一般寫解決方案，而不是打印一下。引用e指向具體子類異常對象。可以調用e.toString。

5.異常一般 從小往大寫。Exception放最下面。

6.finally必須執行的代碼。catch有return 后面代碼無法執行 但是finally里還能執行。

7.System.exit(0)；此時全結束 finally也不行了。

8.自定義異常：一般寫編譯異常。

9.throw 是告訴別人 可能發生異常

模板設計模式

可以在地址欄看到 參數 是get。

post 看不到 參數在方法體里。

包裝類

字符串轉數字 ：字符串必須是數值型字符串。

拆箱：value integer1.intValue（）；

裝箱：一個字節范圍內 兩個對象用一塊內存空間。

Integer in1 =100； Integer in2 =100； Integer in1 =1000； Integer in2 =1000； sout（in1==in2）；//true sout（in3==in4）；//false

枚舉

jdk1.5前沒有枚舉類型。用接口常量代替。

enum

enum EnumTest{//當做類 他已經默認繼承類了 可以實現First，//0Second，//1third,//2Fourth//3 }

常用類

類加載器classloder 配合虛擬機生成字節碼文件對象。

1.BigInteger 和BigDecimel

2.Math

? System.out.println(java.lang.Math.abs(-10));//絕對值
System.out.println(java.lang.Math.cos(3.14159));//三角余弦
System.out.println(java.lang.Math.ceil(3.4));//向上取整
System.out.println(java.lang.Math.floor(3.4));//向下取整
System.out.println(java.lang.Math.random());//隨機數 [0,1.0)

3.Date

枚舉

默認對應的是數字.數字從0開始計數

• 枚舉是一個被命名的整型常數的集合，用于聲明一組帶標識符的常數。
• 枚舉在曰常生活中很常見，例如一個人的性別只能是“男”或者“女”，一周的星期只能是 7 天中的一個等。
• 類似這種當一個變量有幾種固定可能的取值時，就可以將它定義為枚舉類型

String

正則表達式

總結

以上是生活随笔為你收集整理的Java基础第一周的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。