java從開始到放棄？

jdk:

軟件開發工具包（包含jre和軟件開發工具）（開發不同，jdk的大小不同，jdk的包也不同:javaee:企業版，javase:個人版，javame:袖珍版）

jre:

jvm和核心類庫(編寫簡單java程序)（jar容器）

jvm:

JAVA跨平臺的根本，（java虛擬機）

所以總結：只要安裝jdk即可。

java基本語法

常量：

固定不變的量 整數，小數，布爾，字符，字符串

變量：

在內存中開辟一塊空間，可以存儲數據，但是一個變量只能存儲一個值，這個值是可以改變的。

注釋：

單行注釋：//

多行注釋：/**/

文檔注釋：/** */在方法中顯示

關鍵字：

被java賦予了特殊含義的單詞，只能用，不能改，也不能重名

標識符：

程序中需要我們自己命名的

由26個英語字母，數字，_,$組成

不能和關鍵字同名

不能以數字開頭

區分大小寫

數據類型：

規范變量的內存大小，空間（取值）

基本數據類型（數值型，整數型，浮點型，字符型，布爾型）和引用數據類型（數組，類，接口）

有符號數最高為符號位。

float 4個字節（科學計算法，犧牲精度，最大值比long大的多）

double 8個字節（科學計算法，犧牲精度，最大值比long大的多）

long 8個字節 int 4個字節 short 2個字節 byte 1 個字節

ASCII值（國標碼）（中文字符碼GBK一個漢字對應倆個字節 GB-2312）一個漢字對應三個字節（UTF-8）uncode （內部編碼，倆個字節）lso8859-1(歐洲)（不支持中文）

大寫A 65（32）

小寫a 97

0 48

大整數類

確定數據類型的優先級，從低到高

char,byte-short-int-long-float-double

進制轉換：

1B = 8b 1kB=1024B 1MB=1024kB 1GB=1024MB 1TB=1024GB 1PB=1024TB System.out.println(14 + 'A' + 12);//字符轉換成整數運算

運算符

第一：根據類型分類

算數運算符：+ - * / % ++ --，賦值運算符 = += -= *= /= %= ^=，邏輯運算符 & && (短路與：當多個&&出現時，一旦發現一個flase，停止運算 返回false。) | || (短路或：當多個||出現時，一旦發現一個true，停止運算 返回 true。) !，關系運算符 == < <= > >= != ，位運算符& | ^ ~（不存在短路與，短路或），移位運算符：>> << >>>

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

（異或：相同為0，不同為1）

一元運算符

二元運算符

三元運算符 ？ (true)：(flase)

多個式子運算時：

1.排除法：先找優先級最低的，考慮結合性

2.結合計算：

流程控制語句

實現現實中的邏輯(順序，循環，分支（并列）三種結構)

分支

switch case final（多的話，用switch，少的用 if )

if else

循環：

for （起始 結束 自增）起始條件不成立，不影響結束條件的判斷（循環起別名（標識））

for循環的執行順序（注int i=1;可以寫函數調用）

while 起始 結束 自增量

do while

foreach

函數（方法）

擁有一段特殊功能的代碼。函數的作用：提高程序的安全性，復用性，健壯性，可讀性，節省內存。

函數的參數，返回值，類型

public static int mytest() {
return (float)0;
}（錯誤）

全局變量：相對的概念。比局部變量更大的范圍

成員變量：在堆區，創建有默認值。

局部變量：在棧區，沒有默認值。

函數：在棧區。

對象：在堆區。

在java中內存分為

堆：實體，整型默認為0，布爾型默認是false。（內存中的一塊區域，使用的底層隊列結構）

棧：函數，局部變量，先進后出，使用完立刻釋放（內存中的一塊區域，使用的底層棧結構）

方法區，本地方法區，寄存器

釋放機制：棧使用完立刻釋放，堆里面的東西（通過垃圾回收機制釋放）

遞歸：時間和空間的負責度（盡量避免遞歸）

重載：在同一類中，方法名相同，參數的個數，位置，類型不同，（與返回值無關）。作用：方便函數的編寫，程序的執行。（構造方法）

數組

數組：存儲多個數字；定義：可以同時存儲多個相同類型的數據，他是引用數據類型，數組是被放在堆區的，有默認值，

構成:new + 數據類型 + [元素的個數]
new :在堆內開辟空間,將數組的地址返回
int代表元素的數據類型
[3];代表數據的個數
我們可以通過一個變量保存數組的地址,這個變量的類型是int型的數組類型.
注意:int+[]是一個整體,代表一種數據類型,不能拆開.[]中也不能寫數.
int[] arr = new int[3];
解釋:先拿arr(引用類型)中保存的地址找到數組,然后在根據下標找到具體的元素,完成賦值或者取值
如果下標超出了數的范圍,會報下標越界異常

java.lang.ArrayIndexOutOfBoundsException

引用數據類型和基本數據類型：一個是值，一個是地址（16進制）new在堆區里動態開辟空間。存儲地址的類型（引用數據類型）

第一個元素的地址充當整個數組的地址（數組的內存是連續的，所以數組有下標。）

初始化賦值創建

int[] arr1=new int[]{4,5,7};int[] arr2= {5,7,8,9};//自動（new，分配空間）

數組作為參數的時候不能直接使用大括號的方式。

地址傳遞（參數數組）

在進行值傳遞的時候，函數里面無法影響的函數外

在進行址傳遞的時候，函數里面可以影響的函數外

二維數組

一維數組：首地址

二維數組：多個一維數組的地址。

[外鏈圖片轉存失敗(img-iwyAvUD9-1568960839567)(C:\Users\zhaoboshi\AppData\Roaming\Typora\typora-user-images\1563937957499.png)]

int[][] arr3 ={{4,5},{3,4,5,6}}; int[][] arr2=new int[2][4]; arr2[0] = new int[3]; arr2[1] = new int[] {3,4,5}; arr2[2] = new int[3];

排序

平均時間復雜度(犧牲空間，調高時間復雜度，提升用戶體驗)

?插入排序O(n^2)

冒泡排序

O(n^2)(循環首選最大值，倆個數比較)

選擇排序

快速排序O(n log n)
堆排序O(n log n)

? 歸并排序O(n log n)

? 基數排序O(n)

? 希爾排序O(n^1.25)

查找

二分查找 （有序）

這些算法的思想的在這不做詳細的介紹了：（但這些基礎的排序很重要也很基礎，可自己查詢）

面向對象

思想：封裝，繼承，多態

面向過程：強調的是功能行為：關注的是解決問題需要哪些步驟

面向對象：將功能封裝進對象，強調具備功能的對象。關注的是解決問題需要哪些對象

面向對象是基于面向過程的。面向對象是符合人們思想的思想，可以使開發者有執行者變為指揮者。

可以將復雜的事情簡單化

? 類是對象的抽象

對象<------------------------>類（萬物皆對象）

? 對象是類的實現

類

類：類名，大駝峰原則

屬性，成員變量

行為，成員方法 小駝峰原則

名詞提煉法

擁有相同（或者相似）屬性和行為的對象都可以抽象出一個類

在創建對象時（new），調用構造方法，構造方法會對成員變量初始化（空參構造方法 ，整型0 ，引用為null）。（創建對象時的保存對象地址的變量在棧里）（方法在棧里調用）。如果沒有引用的對象（可以被垃圾回收機制回收，匿名對象）

匿名對象的作用：節省代碼，節省內存。

應用場所：作為參數傳遞

數組就是特殊的對象。

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

屬性：權限

static修飾成員的功能 ：靜態成員變量，引用可以調用靜態（推薦使用類名調用）類名無法調用非靜態的屬性；非靜態的成員變量只能用引用調用。

總結成員變量的特點:

1.在創建對象的時候會賦默認值

2.可以在類中定義變量的時候,直接賦值

3.非靜態的成員變量可以在除了static修飾的方法外任何地方使用.

成員變量和局部變量的區別:

1.作用域:成員變量是整個對象.局部變量是從定義開始到所在的函數/if/for結束

2.默認值:成員變量會有默認值,局部變量沒有默認值,要想使用必須先賦值

3.釋放機制:成員變量跟對象保持一致,通過垃圾回收機制回收,局部變量使用完立即釋放

4.存放的位置:成員變量放在堆區中的對象中,局部變量放在棧區中的方法中.

static:這是一個關鍵字,被static修飾的成員就變成了靜態的.具有保值功能

一個類對應一個字節碼文件，

靜態方法區：類變成一個.class文件，當類中存在靜態屬性和方法時，靜態屬性和方法會被復制（從.class文件中）一份放在靜態方法區（通常認為靜態方法區在方法區的獨立空間）對象的堆空間里只存在非靜態的方法和屬性。

類調用靜態屬性時，是字節碼文件（.class）調用的靜態對象（字節碼文件是一個對象（特殊對象））。

靜態的成員方法和非靜態的成員方法優先使用靜態的成員方法。效率高，節省內存。除一種（當方法中使用非靜態的屬性（成員變量），只能是非靜態的方法）

工具類：類似工具經常使用的時候，可以用static封裝工具類

構造方法：

默認創建無參的構造方法。作用：在對象被創建的時候給屬性賦值。

this關鍵字：

構造方法局部變量和成員變量相同時（就近原則，沒有this時），this等于引用值（引用數據類型，等于當前的對象地址）。this（）可以當做構造方法 ；

this的注意點：

1.不能自己調用自己—死循環

2.不能相互調用,死循環

3.this充當構造方法時,必須放在第一行

4.this在作為方法的時候,只能充當構造方法,不能作為其他方法

5.this的使用范圍就是當前類的內部

構造代碼塊：

隨著對象的加載而加載，優先于構造方法之前，對象每創建一次執行一次。{}

靜態代碼塊：

父子類靜態代碼塊的加載，父類靜態代碼塊在前。

隨著類的加載而加載，優先于main，整個程序執行過程中只執行一次。static{}

封裝性：

通過對具體屬性的封裝實現的，把對成員變量私有話，通過范圍修飾詞：private，增加安全性，復用性和可讀性。

set get (約定規則，統一規范，方便使用)

臟數據：

臟數據:我們把程序中出現的不符合邏輯的數據稱為臟數據
原因:讓用戶直接將數據傳給了成員變量
解決:1.不讓他直接傳值----將成員變量私有化,寫一個公共的方法
2.對數據進行過濾,將過濾后的數據交給成員變量

繼承：

關鍵字：extend 繼承的源object

功能：減少代碼，多態的前提，方便操作，增加復用性，可讀性，安全類。

繼承當中方法的調用順序：

首先從自己的方法里找，如果沒有，就會從父類開始往上尋找。

重寫

（返回值為類型時，可以為父子關系）：從父類繼承中的方法中（增加了特殊功能），重寫方法的返回值可以與父類的相同，也可以是父類的子類

重載(Overload)

重載(overloading) 是在一個類里面，方法名字相同，而參數不同。返回類型可以相同也可以不同。

每個重載的方法（或者構造函數）都必須有一個獨一無二的參數類型列表。

最常用的地方就是構造器的重載。

重載規則:

被重載的方法必須改變參數列表(參數個數或類型不一樣)；

• 被重載的方法可以改變返回類型；
• 被重載的方法可以改變訪問修飾符；
• 被重載的方法可以聲明新的或更廣的檢查異常；
• 方法能夠在同一個類中或者在一個子類中被重載。
• 無法以返回值類型作為重載函數的區分標準。

super關鍵字：

代表的是當前對象的父類，可以調用父類的方法和屬性。但是它不是引用數據結構。在子類構造方法中，默認是有super();調用父類的空參構造方法。（new 子類的時候，也創建了父類對象）

final:關鍵字

可以修飾的內容：
1.類：final修飾的類不能有子類

2.成員變量：final修飾的變量是一個終值，不能再被改變，所以必須賦值。

3.局部變量：被final修飾的局部變量是一個終值，不能被再改變

4.方法：final修飾的方法不允許重寫

5.空白final ------（final在定義成員變量的時候，可以在構造方法中賦值（即在定義時可以不賦值，但是在構造方法中必須賦值））

public static void main(String args[]){}

object：

clone();克隆

（創建對象的四種方式：new ，克隆，反序列化，反射）

1.要想使用clone方法完成克隆,當前類必須實現了Cloneable這個接口

2.要想使用必須要重寫這個方法

3.不是所有系統類都實現了他.比如Object,Integer,String等.實現了他的有ArrayList,LinkedList

4.clone沒有調用new方法和構造方法.克隆不會調用構造方法，克隆時，根據源對象類型先分配和源對象相同的內存，然后將源對象中的各個域中數據拷貝過來，最后返回對象地址。new時，第1步也是先分配內存，然后調用構造方法初始化數據，最后將對象地址返回，

外界就可以通過這個對象地址(引用)操作此對象。

5.調用clone沒有辦法實現完全的深拷貝.對于調用clone的對象是深拷貝,但是對于他的成員默認還是淺拷貝,

如果想讓成員也深拷貝,就要在重寫的clone方法中調用成員的clone方法,依次類推.

equals(object obj);

比較地址。容錯處理。（重載，如果倆個重載方法，類型是父子關系，倆個方法都可以執行，存在優先級。）

finalize();

垃圾回收，

getclass();

返回此object的運行時類，字節碼文件對象 ,字節碼文件對應的類(Class)。字節碼文件對象對應字節碼文件（.class這個屬性也可以獲得字節碼文件對象）

jvm中類加載器生成字節碼文件對象

hashcode();

應用：對象的身份證。

toString():

默認調用（打印報名+@+hash碼）

abstract：抽象的

抽象類中可以沒有抽象方法；有抽象方法的類一定是抽象類。

繼承的子類要么也是抽象類，要么是實現父類的抽象方法。

抽象類不能直接創建對象，必須通過子類實現，所以抽象類一定有子類。

抽象類的作用：

1抽象方法是沒有實現的方法，抽象方法類似于規則聲明（制定規則），可以制定一批規則。

2.可以節省代碼

抽象類是介于接口和類之間。

比較:final,abstract,static,private

abstract（不能直接調方法，必須繼承）和final（不能繼承，不能重寫）和static（類，調用）和private不能共用。

不能與abstract同時存在的關鍵字

1.final:被final修飾的類不能有子類,方法不能重寫,但是abstract必須有子類,必須重寫

2.static:修飾的方法可以通過類名調用,abstract必須通過子類實現

3.private:修飾的方法不能重寫,abstract必須重寫

接口：interface

接口也是抽象的

類<—>類（繼承） extends

類<—>接口（實現）implements

成員變量：默認public,final,static（類型）符號常量。

成員方法：默認是public，abstract

單繼承，多實現。

接口與接口之間的繼承是繼承。（接口同名的方法在類中可以實現（接口倆個方法實現沒有區別））。

一般父類中放的是主要功能，接口中放的是額外的功能，接口作為父類的補充。

從jdk1.7 開始，以后的接口中可以有方法的實現，但是方法必須使用static或default修飾（接口同名的方法（實現不同方法（也可能是一個實現，一個是抽象的））在類中使用時必須重寫（即倆個接口的實現方法都不取，自己實現）

接口的子類重寫方法注意事項：

如果一個類實現兩個接口，這兩個接口同時有相同的抽象方法，在類中只需要重寫一次這個方法。
如果接口中有default修飾的方法不需要重寫。
如果兩個接口里的方法名相同都是default方法，里面的方法體不同，在類中需要重寫該方法。

如果兩個接口中方法名，參數都相同的方法，一個接口是抽象方法，另一個是default修飾有方法體。這時該類也必須重寫該方法。

面向接口編程：一個類聲明一個接口（接口暴露，類不暴露實現）

設計模式

設計模式:前人總結出來的對一些常見問題的解決方案,后人直接拿來使用.

常用的設計模式:單例,工廠,代理,適配器,裝飾,模板,觀察者等,一共有23種

單例模式

分析:

1.我們肯定要建立一個單例類來描述

2.只允許有一個對象

3.全局的訪問點:說的就是當前的s----通過static實現的

4.提供出去

5.給大家使用

作用:

1.傳值

2.作為全局的訪問點.

使用單例傳值的好處:

好處:可以讓兩個對象在完全沒有關系的前提下,實現值的傳遞,降低了耦合性,提高了內聚性

耦合性,內聚性在微觀上說:描述的是類與類之間的關系

好處:我們應該盡量提高內聚性,減少耦合性,可以提高程序的健壯性,增加代碼的可移植性,方便實現模塊兒化編程

如何做到低耦合高內聚?

在處理類與類關系的時候,讓類之間的關系越緊密耦合性越高,內聚性越低.反之,關系越松散耦合性越低,內聚性越高.

注意:在單例中一般只有向外提供s的方法是靜態的,其他的都是非靜態的.

通過static修飾對象名（當對象有被對象名指向時，垃圾回收機制不會清除）長期保存對象（垃圾回收機制）。

單例類的功能，可以將一個類的局部方法變成全局方法，可以傳值（減少類和類之間的關系，高內聚（模塊之間完成工作），低耦合（模塊與模塊之間的聯系）），建立全局訪問點。

餓漢式

final static *** ** = new **(); private 構造() public static get***Instance() {return **;}

懶漢式

static *** ; private 構造() public static get***Instance{ (if(**==null){** = new **()} return **;) }

典型單例類runtime()

package com.work.day4;//測試jvm的內存public class RunTimeTest {public static void main(String[] args) {Runtime time=Runtime.getRuntime();System.out.println(time.freeMemory()/1024./1024.);System.out.println(time.totalMemory()/1024./1024.);System.out.println(time.maxMemory()/1024./1024.);} }

模板設計模式

?

? 適配器設計模式<----httpservlet之前，三個類構成適配器模式，httpservlet,和myservlet使用模板模式

servlet->(實現，重寫5個方法)GenervalServlet->（繼承，重寫需要的方法）HttpServlet->(繼承，重寫需要的方法)myservlet

多態：

多態:一種事物的多種形態.

前提是：繼承。用法：用父類（不一定是直接的）的引用指向子類對象。

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

程序運行分成三個階段:預編譯,編譯,運行
預編譯:程序打開的時候,活兒已經干完了.(預處理命令 #define)
編譯:從打開程序開始到點擊左上角的三角之前—只能識別前面的引用類型,不會識別后面的對象
運行:從點擊三角開始—真正的識別對象,對象開始干活兒

多態：我們在編譯階段不能確定具體的對象類型，只有運行階段才知道干活的對象

object ：動態類型 動態綁定：（庫運行時，確定庫的內容）

總結:優點:可以提高代碼的擴展性,使用之前定義好的功能,后面直接拿來使用,不用再創建新的方法.
缺點:只能直接調用父類有的方法,不能直接調用子類特有的方法.

環境：：多態的環境下，說向上轉型，向下轉型。

注意:是在多態的前提下再說向上轉型,向下轉型.
向上轉型:相當于是自動類型轉換.多態本身就是向上轉型.
作用:實現多態
向下轉型:相當于強制類型轉換
作用:解決多態中無法調用子類特有屬性的缺點.

運算符：instanceof （使用前提：前后必須有關系）

原理說明：確定當前的對象是否后面的類和子類的對象，是返回true，不是返回false

作用：容錯處理，增加用戶體驗

多態下成員的使用： ！！！！！！方法相同編譯看父類，運行看子類

public static void main(String[] args) {/** 繼承*/Zi zi = new Zi();zi.show();zi.eat();System.out.println(zi.age);//10,繼承中子類與父類出現同名的屬性,父類的會被覆蓋掉//多態/** 當父類與子類有同名屬性或方法時* 成員變量:編譯的時候能不能訪問看父類,運行的時候也看父類* 成員方法:編譯的時候能不能訪問看父類,運行的時候看子類* 靜態成員方法:編譯運行都看父類*/Fu fu = new Zi();System.out.println(fu.age);fu.show();}

當父類與子類有同名的方法或屬性時：（多態）

成員變量：編譯的時候能不能訪問看父類，運行的時候也看父類

成員方法：編譯的時候能不能訪問看父類，運行的時候看子類

靜態成員方法：編譯的時候能不能訪問看父類，運行的時候也看父類

內部類：

內部類：定義在一個類的內部的類，內部類的地位與外部類的成員變量，成員方法平等。內部類也可以看做是外部類的成員。

public class Demo14 {public static void main(String[] args) {Outer outer = new Outer();outer.age = 10;//調用內部類成員的方式//兩種//第一種:借助于外部類的方法實現outer.show();//第二種:直接在這里調用//引用:外部類.內部類//構成:外部類對象的引用.new 內部類的構造方法Outer.Inner inner = outer.new Inner();inner.eat();} }class Outer{int age;//內部類class Inner{int height;public void eat() {System.out.println("eat");}}public void show() {System.out.println("show");Inner inner = new Inner();inner.eat();} }

內部類：間接使用多繼承

class A1{}class B1{} //說明功能 //我們可以通過內部類讓java間接實現多繼承 class X extends A1{class Y extends B1{} }

局部內部類：

定義：定義在一個類的方法里的類，

作用：功能私有化，增加代碼的可讀性和可操作性。

局部內部類:定義在一個類方法中的類

• 作用范圍:從定義開始到當前的方法結束
• 了解:局部內部類所在的方法中局部變量的使用.
• 局部變量的作用域:定義變量開始到函數結束

final:被final修飾的變量會被放在常量區,而常量區的值存在的時間要大于局部變量所在的方法,相當于從原來的基礎上擴大了作用域

• 原理:
• 當方法中同時存在局部內部類與成員變量時,成員變量的使用范圍就會從原來的基礎上進行擴大.
• 原因:在當前的情況下,程序會默認讓final去修飾height.所以當局部變量所在的方法結束的時候,變量沒有被釋放,保存的值還在.
• 關于變量前面的final:
• 前提:變量必須與局部內部類同時存在.并且在局部內部類中使用了當前的局部變量
• 在jdk1.7之前要想保住局部變量的值,要手動添加final
• 在jdk1.7之后,java的內部機制已經在變量的前面默認添加了final

靜態內部類：

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

public class Demo17 {public static void main(String[] args) { // Out out = new Out(); // Out.Inn inn = out.new Inn();//創建靜態內部類對象//構成: new + 外部類名字.內部類的構造方法Out.Inn inn = new Out.Inn();//調用方法inn.play();//調用靜態方法// inn.show();Out.Inn.show();} }

匿名內部類：

定義：定義在一個類方法中的

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

• 匿名子類對象:
• 匿名內部類對象:
• 創建匿名內部類對象注意點:1.匿名內部類對象必須有父類或者父接口
• 匿名內部類對象的作用:
• 1.當只用到當前子類的一個實例對象的時候,定義好馬上使用
• 2.當不好起名字的時候
• 3.可以更好的定義運行時的回調(知道即可)
• 內部類的作用:
• 1.間接實現了多繼承
• 2.方便定義
• 3.只有外部類可以訪問創建的內部類的屬性和方法,包括私有方法
• 4.同一個包中其他的類不可見,有了很好的封裝性

//匿名內部類作為參數public void canShuTest1() {System.out.println(new Animal() {public void eat() {// TODO Auto-generated method stubsuper.eat();}@Overridepublic String toString() {return "haha";}});

常用類

Math

package com.ali.test;import java.util.Random;/** Math:裝的是用于數學的計算方法*/ public class Demo13 {public static void main(String[] args) {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)//求[0,10)之間的整數System.out.println((int)java.lang.Math.floor(java.lang.Math.random()*10));//Random類//求[0,10)之間的整數Random random = new Random();System.out.println(java.lang.Math.abs(random.nextInt()%10));System.out.println(random.nextInt(10));//直接獲取的是[0,10)之間的數} }

BigInteger(嵌套了math，可以直接使用math的方法)

包裝類

包裝類：專門將簡單數據類型的數據類型，形成的對應的類

簡單數據類型 包裝類

byte Byte

short Short

int Integer

long Long

char Character

如果想字符串轉換數字，必須是數值型字符串。

簡單數據類型->包裝類（裝箱 Integer integer1=new Integer(5)）;

包裝類->簡單數據類型（拆箱 int value = integer1.tovlaue）

jdk1.5開始可以實現自動裝箱，拆箱。

/** 包裝類:專門將簡單數據類型的數據進行封裝,形成的對應的類. * 簡單數據類型 包裝類 * byte Byte * short Short * int Integer * long Long * float Float * double Double * boolean Boolean * char Character */ public class Demo10 {public static void main(String[] args) { // 基本類型轉成字符串類型 // static String Integer.toString(int i) // static String Double.toString(double d)String value1 = Integer.toString(12);System.out.println(value1+2); // 字符串類型轉基本類型 // int Integer.parseInt("23") // double Double.parseDouble("3.45")//注意:這里的字符串必須是數值型的字符串int a = Integer.parseInt("234");System.out.println(a+2); // // 把十進制轉成其它進制 // Integer.toHexString() 十六進制 // Integer.toOctalString() 八進制 // Integer.toBinaryString() 二進制System.out.println(Integer.toHexString(10));System.out.println(Integer.toOctalString(10));System.out.println(Integer.toBinaryString(10)); // 把其它進制轉十進制 // Integer.parseInt(數據,進制)System.out.println(Integer.parseInt("10",2));} } //注意點:在一個字節范圍內前面定義好的,后面再定義,直接使用前面的. // Integer integer4 = 100; // Integer integer5 = 100; // System.out.println(integer4 == integer5);//true//如果超過了一個字節的范圍,就認為是兩個數,要獨立占用兩塊兒內存空間.Integer integer4 = 1000;Integer integer5 = 1000;System.out.println(integer4 == integer5);//false

即在包裝類中，如果數據比較小（一個字節），認為是一個對象（值相同，即使new了倆個對象。）

枚舉

也是一個特殊的類(創建對象，調用方法)

package com.ali.test; /** 枚舉* 默認對應的是數字.數字從0開始計數* 枚舉是一個被命名的整型常數的集合，用于聲明一組帶標識符的常數。* 枚舉在曰常生活中很常見，例如一個人的性別只能是“男”或者“女”，一周的星期只能是 7 天中的一個等。* 類似這種當一個變量有幾種固定可能的取值時，就可以將它定義為枚舉類型。 在 JDK 1.5 之前沒有枚舉類型，那時候一般用接口常量來替代。而使用 Java 枚舉類型 enum 可以更貼近地表示這種常量。*/ enum EnumTest{First,Second,Third,Fourth,Fifth,Sixth } public class Demo12 {public static void main(String[] args) {EnumTest test = EnumTest.Fifth;System.out.println(test.compareTo(EnumTest.First));switch (test.compareTo(EnumTest.First)) {case -1:System.out.println("不相等");break;case 0:System.out.println("相等");break;case 4:System.out.println("不相等");break;default:System.out.println("hah");break;}System.out.println(EnumTest.First);System.out.println(test.getDeclaringClass().getName());//字節碼文件對象System.out.println(test.name());System.out.println(test.toString());System.out.println(test.ordinal());} }

異常

定義：程序當中出現的不正常的情況;

異常的由來：程序在運行時出現了不正常的情況，java提取了對應的屬性，名字，原因等，形成異常對象，進而形成了各種異常類

異常的分類：（throwable）

1.Error(錯誤)：運行中出現的嚴重錯誤，不需要我們進行更改

2.Exception：運行中出現的不嚴重的錯誤，我們可以嘗試去更改。

Exception:分類

第一種分類：系統異常，系統提前定義好的，我們直接使用

? 自定義異常：需要自己定義

第二種分類：編譯階段拋出的異常：

運行階段拋出的異常：大部分使用的異常。(在寫代碼的時候不需要的處理，手動避免)

運行階段出現的錯誤：會在此處產生一個異常對象，如果此處沒有處理異常的機制（能力），能繼續往上拋，一直的到jvm，jvm會報錯。

public class Demo1 {public static void main(String[] args) {//4.這里也沒有處理異常的能力,繼續往上拋,拋給JVM.//JVM會調用異常類的打印方法,將異常的信息打印到控制臺Math math = new Math();int value = math.div(3, 0);//3.這里也沒有處理異常的能力,繼續往上拋System.out.println(value);} }class Math{public int div(int a,int b) {//2.div方法也沒有處理異常的能力,繼續往上拋return a/b;//1.會自動生成一個異常類對象(new ArithmeticException()) ,這里沒有打印的能力,程序會將異常拋出,拋給//他所在的方法} }

異常的特點：程序出現異常的時候，會打印異常的信息并中斷程序的進行，所以當有多個異常同時出現的時候,默認只能執行第一個.

try catch

catch會對try里面的代碼進行監聽，如果try里面的代碼沒有異常，catch不會執行，會直接執行后面的代碼

如果try里面的代碼發生了異常，catch會立刻捕獲（效果：try里面的代碼會立刻中斷，直接執行catch）

try{

? 可能發生異常的代碼

? }catch(Exception e){ //捕獲異常 e就是要捕獲的異常

? 對當前異常的處理

}

try {int value = math.div(3, 0);//3.這里也沒有處理異常的能力,繼續往上拋//注意:只要try內部的代碼發生了異常,catch會立刻捕獲異常,馬上執行catch,所以發生異常后的代碼不會執行.//只有try里面的代碼沒有發生異常,這里的代碼才能執行System.out.println("haha:"+value);}catch (Exception e) {//e = new ArithmeticException() 多態//對異常進行處理//e.printStackTrace();//打印異常的位置,原因,名字//System.out.println(e.getMessage());//打印原因System.out.println(e.toString());//打印原因,名字}

多重處理（多個異常）：try catch catch finally//必須執行的操作（例如：關閉數據庫）：主要用于資源的釋放等。

catch會對try里面的代碼進行監聽,如果try里面的代碼沒有發生異常,catch不會執行,會直接執行后面的代碼.

如果try里面的代碼發生了異常,catch會立刻捕獲(效果:try里面的代碼會立刻終端,直接執行catch)

try{

可能發生異常的代碼

}catch(異常一 e){ //捕獲異常 e就是要捕獲的異常

對當前異常的處理

}catch(異常二 e){ //捕獲異常 e就是要捕獲的異常

對當前異常的處理

}catch(Exception e){ //捕獲異常 e就是要捕獲的異常

對當前異常的處理

}

（return 結束不了，finally還能執行）

System.exit(0)?/退出程序，

finally不能執行了

這個結構跟異常沒有關系

try{

獲取資源

}finally{

釋放資源

}

自定義異常：常見：訂單異常，用戶異常，素數異常

什么是自定義異常:自己定義的異常類,由于Exception已經有了異常的基本功能,所以一般寫的是他的子類

為什么要自定義異常?

系統沒有定義的異常需要我們自己來定義,我們要解決的是系統沒有解決的問題

分類:

編譯異常:發生在編譯階段.—對應的異常是除了RumtimeException之外的所有異常

特點:對異常進行處理的所有工作都要我們手動完成

運行時異常:發生在運行階段.—RumtimeException

特點:所有的工作我們都可以不管

常見的自定義異常:訂單異常 用戶異常 負數異常

以負數異常為例:

對于編譯異常需要我們進行處理的有:

異常類的創建----FuShuException

異常對象的創建—應該是在發生異常的位置

異常對象的拋出—throw

異常的聲明(我們要給可能發生異常的方法進行異常的聲明)----throws

作用:告訴別人我有可能發生異常

package com.ali.test; //為了解釋FuShuException構造方法中的參數如何在打印方法中顯示. public class Demo7 {public static void main(String[] args) {Teacher teacher = new Teacher("除數為負數了");teacher.printStackTrace();} }class Person{//相當于Exceptionprivate String message;public String getMessage() {return message;}public void setMessage(String message) {this.message = message;}public Person() {super();// TODO Auto-generated constructor stub}public Person(String message) {super();this.message = message;}public void printStackTrace() {System.out.println(this.getMessage());} }//相當于FuShuException class Teacher extends Person{public Teacher() {}public Teacher(String message) {super(message);} }

特點:所有的工作我們都可以不管

常見的自定義異常:訂單異常 用戶異常 負數異常

以負數異常為例:

對于編譯異常需要我們進行處理的有:

異常類的創建----FuShuException

異常對象的創建—應該是在發生異常的位置

異常對象的拋出—throw

異常的聲明(我們要給可能發生異常的方法進行異常的聲明)----throws

作用:告訴別人我有可能發生異常

package com.ali.test; //為了解釋FuShuException構造方法中的參數如何在打印方法中顯示. public class Demo7 {public static void main(String[] args) {Teacher teacher = new Teacher("除數為負數了");teacher.printStackTrace();} }class Person{//相當于Exceptionprivate String message;public String getMessage() {return message;}public void setMessage(String message) {this.message = message;}public Person() {super();// TODO Auto-generated constructor stub}public Person(String message) {super();this.message = message;}public void printStackTrace() {System.out.println(this.getMessage());} }//相當于FuShuException class Teacher extends Person{public Teacher() {}public Teacher(String message) {super(message);} }

總結

以上是生活随笔為你收集整理的java从入门到放弃（一）的全部內容，希望文章能夠幫你解決所遇到的問題。

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