JavaSE_kuang
JavaSE——kuang——個人版
個人歸納，基于狂神筆記，視頻
多寫點
前言—預(yù)科—入門
Java：一個帝國的誕生
C語言帝國的統(tǒng)治
反抗
一鳴驚人
開拓疆土
帝國的誕生
Java的特征和優(yōu)勢（重要）
Java三大版本
JDK，JRE，JVM
JDK
Java Development KIt 包括：JRE的超集，包含編譯器和調(diào)試器等用于程序開發(fā)的文件
JRE
Java Runtime Environment（JRE）包含：Java虛擬機、庫函數(shù)、運行Java應(yīng)用程序和Applet所必須文件
JVM
Java VIrtual Machine 是一種規(guī)范，可以使用軟件來實現(xiàn)，也可以使用硬件來實現(xiàn)，就是一個虛擬的用于執(zhí)行bytecodes字節(jié)碼的計算機。它也定義了指針集、寄存器集、結(jié)構(gòu)棧、垃圾收集堆、內(nèi)存區(qū)域。
Java的跨平臺實現(xiàn)的核心是不同平臺使用不同的虛擬機
Java開發(fā)環(huán)境搭建（新手來看）
百度搜索JDK，找到下載地址，瀏覽Oracle的網(wǎng)站。JDK下載地址
HelloWorld
環(huán)境安裝好了，測試代碼一定要寫一個HelloWorld！儀式感！！！
找個文件夾，存放即將要寫的代碼！！
新建文件 Hello.java
編寫我們的helloWorld程序！
public class Hello{public static void main(String[] args){System.out.println("Hello,world!!!");} }保存文件，打開命令行，利用javac編輯！
javac Hello.java // 如果沒有報錯，查看文件夾下是否有一個新的文件 // Hello。class // 如果沒有出現(xiàn)，恭喜！說明你遇到了你在學(xué)Java當(dāng)中的第一個Bugjava 執(zhí)行！
java Hello//成功輸出Hello，world！！！如果出現(xiàn)錯誤，檢查字母大小是否有錯誤，或者是否標(biāo)點符號錯誤，文件名錯誤等等，一定要確定成功輸出，我們之后再來研究，它是怎么輸出的！
編寫Java程序時，應(yīng)該注意一下幾點：
- 大小寫敏感：Java是大小寫敏感的，這就意味著標(biāo)識符Hello與hello是不同的。
- 類名（大駝峰式）：對于所有的類來說，類名的首字母應(yīng)該大寫。如果類名由若干單詞組成，那么每個單詞的首字母都應(yīng)該大寫，例如：MySwaggerConfig。
- 方法名（小駝峰式）：所有的方法名都應(yīng)該以小寫字母開頭。如果方法包含有若干單詞，則后面的每一個單詞首字母大寫。例如：getUserInfo。
- 源文件名：源文件名必須和類名相同。當(dāng)保存文件的時候，你應(yīng)該使用類名作為文件名保存（切記Java是大小寫敏感的），文件名的后綴為.java。（如果文件名和類名不相同則會導(dǎo)致編譯錯誤）。
- 主方法入口：所有Java程序由public static void main(String[] args){ }方法開始執(zhí)行。
Java 程序運行機制
計算機的高級編譯語言類型：編譯型，解釋型。Java語言是兩種類型的結(jié)合；（以后在拓展，我自己都不是很理解；）
第一步：編譯
利用編譯器（javac）將源程序編譯成字節(jié)碼文件。字節(jié)碼文件名：源文件名.class
第二步：運行
利用虛擬機（解釋器，java）解釋執(zhí)行 .class 字節(jié)碼文件
總結(jié)
- 暫時不想寫
源程序編譯成字節(jié)碼文件。字節(jié)碼文件名：源文件名.class
總結(jié)
- 暫時不想寫
安裝IDEA
IDEA 目前最好用的Java 智能開發(fā)工具，高效，簡單，好用。
網(wǎng)站官網(wǎng)：https://www.jetbrains.com/
目前IntelliJ IDEA有免費的社區(qū)版（功能相對較少），和收費的旗艦版（功能比較全面）；
安裝步驟，網(wǎng)上太多了，大同小異，多卸載，多安裝幾次，自然熟練；
? 其他事項：
2-JavaSE：基礎(chǔ)語法
注釋
記筆記，沒啥好說的，用它（Ctrl + /）。
項目結(jié)構(gòu)復(fù)雜時，看到亂七八糟的的全英文，頭疼，為了你的頭發(fā)多寫注釋吧，當(dāng)你寫一個類時，注釋他是什么實體，一個屬性，什么屬性，一個方法，什么方法；以后你的代碼便是一目了然，好不痛快！
注釋不會別執(zhí)行，是給我們寫代碼的人看的，書寫注釋是一個非常好的習(xí)慣，在很多大公司都是強制要求各位去進行編寫注釋！比如，我們的BAT三大巨頭等等。。。。
Java中的注釋有三種：
單行注釋：只能注釋當(dāng)前行，以//開始，直到行結(jié)束
//輸出Hello，World！多行注釋：注釋一段文字，以 /* 開始，*/ 結(jié)束；
/*這是我們Java程序的主入口，main方法也是程序的主線程。 */文檔注釋：用于生產(chǎn)API文檔，配合JavaDoc。
// 注：文檔注釋現(xiàn)在只做了解，在學(xué)習(xí)JavaDoc時候我們會詳細(xì)給大家說，目前知道有這樣的注釋就好。
/*** 個人碼詳情* @param param* @return */【狂神建議】平時寫代碼，要注意注釋的規(guī)范性，一個好的程序員，一定是有非常良好的編程習(xí)慣的，希望大家能夠從小事開始鍛煉自己的行為習(xí)慣！
標(biāo)識碼
每個人從出生開始就有一個名字，咱們生活中的所有事物也都有名字，這名字時誰規(guī)定的呢？回答是：造物主，誰生產(chǎn)出來的誰規(guī)定名字，在我們程序中也不例外。
我們作為造物主，需要給所有的東西給上一個名字，比如我們的HelloWorld程序：
Hello是類名，也是我們的文件名。他前面的public class是關(guān)鍵字，不過是搞Java那群人已經(jīng)定義好的有特殊作用的， 下面的每一個代碼都有自己的意思和名字對吧，就是用來區(qū)分！和我們的名字一樣，拿來被叫或稱呼的，程序一切都源自于生活，一定要把學(xué)程序和生活中的一切聯(lián)系起來，你會發(fā)現(xiàn)這一切都是息息相關(guān)的。
我們來看看有哪些是Java自己定義好的關(guān)鍵字呢？（不能拿來作標(biāo)識符）
Java 所有的組成部分都需要名字、類名、變量名以及方法名都被稱為標(biāo)識符。
關(guān)于 Java 標(biāo)識符，有以下幾點需要注意：
- 所有的標(biāo)識符都應(yīng)該以字母（A-Z 或者 a-z），美元符（$）、或者下劃線（_）開始
- 首字母之后可以是字母（A-Z 或者 a-z），美元符（$）、或者下劃線（_）或者數(shù)字的任何字符組合
- 不能使用關(guān)鍵字作為變量名或方法名
- 標(biāo)識符是大小寫敏感的
- 合法標(biāo)識符舉例：age、$salary、_value、 _1_value
- 非法標(biāo)識符舉例：123abc、-salary、#abc
【可以使用中文命名，但是一般不建議這樣去用，也不建議使用拼音。。?！?/p>
數(shù)據(jù)類型
Java是一種強類型語言，每個變量都必須聲明其類型。
1 強弱類型語言
強類型語言也稱為強類型定義語言。要求變量的使用嚴(yán)格符合規(guī)定，所有變量都必須先定義后才能使用。
弱類型語言也稱為弱類型定義語言。與強類型定義相反。想VB，PHP等就屬于弱類型語言。
２數(shù)據(jù)類型
Java的數(shù)據(jù)類型分為兩大類：基本數(shù)據(jù)和引用數(shù)據(jù)類型【記住了，就這兩個類型，但他可以兜得你頭暈】
如果你頭暈的話，以下代碼能幫你快速上手，所有要敲代碼，記筆記，搜整歸納。
電腦32位和64位的區(qū)別？
32位操作系統(tǒng)只可以使用32位的cpu，而64位的CPU既可以安裝32位操作系統(tǒng)也可以安裝64位操作系統(tǒng)。尋址能力簡單點說就是支持的內(nèi)存大小能力，64位系統(tǒng)最多可以支達128 GB的內(nèi)存，而32位系統(tǒng)最 多只可以支持4G內(nèi)存。 32位操作系統(tǒng)只可以安裝使用32位架構(gòu)設(shè)計的軟件，而64位的CPU既可以安裝使用32位軟件也可以安裝使用64位軟件?，F(xiàn)在的電腦都是64位了！回歸正題，自己定義一些變量試試！！！
//八大基本類型//整數(shù) int num1 = 1000000; //最常用 4字節(jié) byte num2 = 111; //-128--127 1字節(jié) short num3 = 11111; //2字節(jié) long num4 = 1111111L; //long類型要在數(shù)字后加L 8字節(jié)//小數(shù)：浮點數(shù) float num5 = 1.111F; //float類型要在數(shù)字后加F 4字節(jié) double num6 = 3.14159265358979; //8字節(jié)//字符 char aaa = 'a'; //注意單引號不是雙引號，2個字節(jié) //String name = "李四"; //字符串String是類不是關(guān)鍵字//布爾型：是非 boolean flag = true; //1位System.out.println(flag);【Java語言的整型常數(shù)默認(rèn)為int型，浮點數(shù)默認(rèn)是Double】
3、整數(shù)拓展
在我們計算機中存在很多進制問題，十進制，八進制等等的問題，他們怎么表示呢？
十進制整數(shù)， 如 ——————99，-200.0； 八進制整數(shù)，要求以0開頭 如 ——————015； 十六進制整數(shù)，要求 0x 或 0X 開頭 如 ——————0X15演示代碼
//整數(shù)拓展 進制 二進制（0b開頭） 十進制 八進制（0開頭） 十六進制（0x開頭） int i1 = 0b10; int i2 = 010; int i3 = 0x10;System.out.println(i1); System.out.println(i2); System.out.println(i3);4、浮點型拓展
【金融面試問：銀行金融業(yè)務(wù)用什么類型表示？】
浮點類型flout，double的數(shù)據(jù)不適合在不容出錯的金融計算領(lǐng)域。
如果需要進行不產(chǎn)生舍入誤差的精確數(shù)字計算，需要使用BigDecimal類。
大數(shù)值：
- BigInteger實現(xiàn)了任意精度的整數(shù)運算
- BigDecimal實現(xiàn)了任意精度的浮點運算
浮點數(shù)使用總結(jié)：
5、字符型拓展
當(dāng)引號用來表示字符常量。例如’A’是一個字符，"A"是一個字符串。
char類型用來表示在Unicode編碼表中的字符。
// 字符擴展 char c1='a'; char c2='中'; //我們通過單引號來表示字符常量 System.out.println(c1); System.out.println((int)c1); System.out.println(c2); System.out.println((int)c2); //強制轉(zhuǎn)換可以把字符轉(zhuǎn)換成數(shù)字，所有的字符本質(zhì)還是數(shù)字 // Unicode 編碼表：97=a 65=A （本質(zhì)上還是數(shù)字） // 2字節(jié) 65536字符 Excel最長有2的16次方=65536 //U0000 UFFFF char c3='\u0061'; System.out.println(c3);//a //轉(zhuǎn)義字符（轉(zhuǎn)義字符它有特殊的意思） // \t 制表符 // \n 換行 // 轉(zhuǎn)義字符有非常的多，可以自己去查詢一下System.out.println("Hello\tWorld"); System.out.println("Hello\nWorld"); System.out.println("===============================");【思考題】
String sa = new String("Hello World"); String sb=new String("Hello World"); System.out.println(sa==sb); //false 兩個對象是不同的 String sc = "Hello World"; String sd="Hello World"; System.out.println(sc==sd); //true 對象那可以了解 從內(nèi)存分析內(nèi)存級別分析
6、布爾型拓展
boolean類型（一位，不是一個字節(jié)）。就是0|1
//布爾值擴展 boolean flag=true; if (flag==true){} if (flag){} //老手 Less is More！類型轉(zhuǎn)換
由于Java是強類型語言，所以要進行有些運算的時候，需要用到類型轉(zhuǎn)換。
低-------------------------->高byte,short,char,int,long,float,Double數(shù)據(jù)類型轉(zhuǎn)換必須滿足如下規(guī)則：
-
不能對boolean類型進行類型轉(zhuǎn)換
-
不能把對象類型轉(zhuǎn)換成不相干類的對象
-
在把容量大的類型轉(zhuǎn)換為容量小的類型時必須使用強制類型轉(zhuǎn)換
-
轉(zhuǎn)換過程中可能導(dǎo)致溢出或損耗精度，例如：
int i = 128; byte b = (byte) i;//內(nèi)存溢出 -128 -
浮點數(shù)到整數(shù)的轉(zhuǎn)換是通過舍棄小數(shù)得到的，而不是四舍五入。
1、自動類型轉(zhuǎn)換
自動類型轉(zhuǎn)換：容量小的數(shù)據(jù)類型可以自動轉(zhuǎn)換為容量大的數(shù)據(jù)類型。
2、強類型轉(zhuǎn)換
強制類型轉(zhuǎn)換，又被稱為造型，用于顯式的轉(zhuǎn)換一個數(shù)值的類型
(type)var，條件是轉(zhuǎn)換的數(shù)據(jù)類型必須是兼容的。
char c = 'a'; int i1 = c + 1; System.out.println(i1); System.out.println((char) i1);3、常見錯誤和問題+JDK7拓展
操作比較大的數(shù)時，需要留意是否溢出，尤其是整數(shù)操作時；
//操作比較大的數(shù)，注意溢出 //JDK7新特性，數(shù)字之間可以用下劃線分割 ——二進制整數(shù)以0b開頭即可 int money = 10_0000_0000; System.out.println(money); //1000000000(10 億） 不會輸出下劃線 int years = 20; int total = money*years; System.out.println(total); //-1474836480 ,計算時內(nèi)存溢出 System.out.println("============================"); long total2 = money*years; //-1474836480 默認(rèn)是int，轉(zhuǎn)換之前已經(jīng)存在問題 long total3 = money*((long)years);//先將一個數(shù)轉(zhuǎn)換為long System.out.println(total2); //-1474836480 System.out.println(total3); //20000000000L和l的問題
- 不要命名名字為l的變量
- long類型使用大寫L而不是小寫。
變量，常量
1、變量（variable）
變量是什么，是可以變化的量！
Java是一種強類型語言，每一個變量都必須聲明其類型
Java變量是程序中最基本的存儲單元，其要素包括變量名，變量類型和作用域
變量聲明后，才能為其分配相應(yīng)長度的存儲單元。格式為
注意事項
- 每個變量都有類型，類型可以是基本類型，也可以是引用類型。
- 變量名必須是合法的標(biāo)識符。
- 變量聲明是一條完整的語句，因此沒一個聲明都必須以分號結(jié)束
2、變量作用域
變量根據(jù)作用域可劃分為三種：
- 類變量（靜態(tài)變量：static variable）：獨立于方法之外的變量，用static修飾。
- 實例變量（成員變量：member variable）：獨立于方法之外的變量，不過沒有static修飾。
- 局部變量（lacal variable）：類的方法中的變量。
3、常量
常量（Constant）：初始化（initializa）后不能再改變值！不會變動的值。finally
final 常量名 = 值； final double PI = 3.14；final String LOVE = "hello";常量名一般使用大寫字符。
4、變量的命名規(guī)范（規(guī)范需要遵守）
運算符（operator）
Java 語言支持如下運算符：
- 算術(shù)運算符：+，-，*，/，%，++，–，
- 賦值運算符：=
- 關(guān)系運算符：>，<，>=，<=，==，!=，instanceof
- 邏輯運算符：&&，||，！
- 位運算符：&，|，^，~，>>，<<，>>>（了解！！！）
- 條件運算符：？ ：
- 拓展賦值運算符：+=，-=，*=，/=
1、二元運算符
2、取模運算
3、一元運算符
**自增（++）自減（–）**運算符是一種特殊的算術(shù)運算符。
//++ -- 自增，自減 一元運算符 int a = 3; System.out.println(a); //先賦值后自增 3 int b = a++; System.out.println(a); //先自增后賦值 4 int c = ++a; System.out.println(a); //5 System.out.println(b); //3 System.out.println(c); //5 System.out.println("======================="); //冪運算 2^3 借助工具類Math，來操作 double pow = Math.pow(2, 3); System.out.println(pow);4、邏輯運算符（注意其中的短路方式）
5、位運算符
6、拓展運算符
7、字符串連接符
“+” 運算符兩側(cè)的操作數(shù)中**只要有一個是字符串（String）**類型，系統(tǒng)會自動把另外一個操作數(shù)轉(zhuǎn)換為字符串然后在進行連接。（字符串的拼接）
8、三目條件運算符
9、運算符優(yōu)先級
public static void main(String[] args) {boolean flag = 1<4*5&&122>3||'q'+3<5;System.out.println(flag); //true }包機制
在Java中采用包機制處理開發(fā)者定義的類名沖突問題。、
包的作用：為了更好地組織類，Java提供了包機制，用于區(qū)別類名的命名空間。
1、包的作用
2、創(chuàng)建包
包聲明應(yīng)該在源文件的第一行，每一個源文件只能有一個包聲明，這個文件的每個類型都應(yīng)用于它。
一般利用公司域名倒置作為包名；com.baidu.www
3、import
為了能夠使用某一個包的成員，我們需要在Java 程序中明確導(dǎo)入該包。使用”import“語句可完成此功能。其語法格式為：
import package1[.package2...].(classname|*); import java.lang.System;JavaDoc
1、簡介
JavaDoc是一種將注解生成HTML文檔的技術(shù)，生成的HTML文檔類似于Java的API，易讀且清晰明了。
javadoc命令是用來生成自己API文檔的，使用方式：使用命令行在目標(biāo)文件所在目錄輸入javadoc + 文件名.java.
先看一段樣例代碼
/*** @author Hua* @version 1.0* @since 1.8*/public class Doc {String name;/** 這是一個JavaDoc測試程序* @param name* @return* @throws Exception*/public String test(String name) throws Exception{return name;} }簡單介紹
- 以/* 開始，以/結(jié)束。
- @author —— 作者名
- @version —— 版本號
- @since —— 指明需要最早使用的jdk版本
- @param —— 參數(shù)名
- @return —— 返回值情況
- @throws —— 異常拋出情況
2、命令行生成Doc
javadoc -encoding UTF-8 -charset UTF-8 Doc.java回顧及總結(jié)
這一章，學(xué)習(xí)Java基礎(chǔ)。
- 安裝使用了IDEA
- 使用注釋
- 了解Java的關(guān)鍵字
- 數(shù)據(jù)類型
- 怎么定義一個變量
- 怎么操作這些變量
- 如何生成一篇完整的JavaDoc文檔
- 。。。
- 補充：規(guī)范書：阿里巴巴開發(fā)手冊
不積跬步，無以至千里；不積小流，無以成江海！
簡單的東西，更不能忽視，平日多學(xué)多練，高手和普通人的差距就是平日花的時間多。
3-JavaSE：流程控制
用戶交互Scanner
1、Scanner對象（需要記住）
java.util.Scanner是Java5 的新特征，我們可以通過Scanner 類來獲取用戶的輸入?；菊Z法：
Scanner s = new Scanner(System.in);2、 next & nextLine
//創(chuàng)建一個掃描器對象用于接收鍵盤輸入的數(shù)據(jù) Scanner scanner = new Scanner(System.in); //Hello World! System.out.println("用next方法接收");//判斷用戶有沒有輸入字符串 if (scanner.hasNext()){//用next方式接收String str = scanner.next();//程序會等待用戶輸入完畢System.out.println("輸出內(nèi)容："+ str); } //String str = scanner.nextLine(); //System.out.println("輸入的數(shù)據(jù)為："+str); //Hello World!//凡是I/O類使用完畢記得關(guān)閉以節(jié)約資源 scanner.close(); //創(chuàng)建一個掃描器對象用于接收鍵盤輸入的數(shù)據(jù) Scanner scanner = new Scanner(System.in); //Hello World! System.out.println("用nextLine方法接收");//判斷用戶有沒有輸入字符串 if (scanner.hasNextLine()){//用next方式接收String str = scanner.nextLine();//程序會等待用戶輸入完畢System.out.println("輸出內(nèi)容："+ str); } //String str = scanner.nextLine(); //System.out.println("輸入的數(shù)據(jù)為："+str); //Hello World!//凡是I/O類使用完畢記得關(guān)閉以節(jié)約資源 scanner.close();兩者區(qū)別
- next():
- 一定要讀取到有效字符后可以結(jié)束輸入
- 對輸入有效字符之前遇到的空白，next() 方法會自動將其去掉。
- 只有輸入有效字符后才將其后面輸入的空白作為分隔符或者結(jié)束符。
- next() 不能得到帶有空格的空字符串。
- nextLine():
- 以Enter為結(jié)束符，也就是說 nextLine() 方法返回的是輸入回車之前的所有字符。
- 可以獲得空白
3、其他方法
如果要輸入 int 或 float 類型的數(shù)據(jù)，在 Scanner 類中也有支持，但是在輸入之前最好先使用hasNextXxx() 方法進行驗證，在使用 nextXxx() 來讀取。
順序結(jié)構(gòu)
JAVA的基本結(jié)構(gòu)就是順序結(jié)構(gòu)，除非特別指明，否則就按照順序一句一句執(zhí)行。
順序結(jié)構(gòu)是最簡單的算法結(jié)構(gòu)。
選擇結(jié)構(gòu)
1、if但選擇結(jié)構(gòu)
if(布爾表達式){//如果布爾表達式為true將執(zhí)行的語句 }2、if雙選擇結(jié)構(gòu)
if(布爾表達式){//如果布爾表達式為true }else {//如果布爾表達式為false }3、if多選擇結(jié)構(gòu)
if(布爾表達式 1){//如果布爾表達式 1為true }else if(布爾表達式 2){//如果布爾表達式 2為true }else if(布爾表達式 3){//如果布爾表達式 3為true }else {//如果以上布爾表達式都被為false }案例：（一個就夠了）
//考試分?jǐn)?shù)大于60就是及格，小于60就不及格 Scanner scanner = new Scanner(System.in); System.out.println("請輸入成績："); int score = scanner.nextInt();//equals:判斷字符串是否相等 if(score == 100) {System.out.println("恭喜滿分"); }else if (score < 100 && score >= 90){System.out.println("A級"); }else if (score < 90 && score >= 80){System.out.println("B級"); }else if (score < 80 && score >= 70){System.out.println("C級"); }else if (score < 70 && score >= 60){System.out.println("D級"); }else if (score < 60 && score >= 0){System.out.println("不及格！"); }else {System.out.println("成績輸入不合法！"); } System.out.println("End"); scanner.close();4、嵌套的if結(jié)構(gòu)
使用嵌套的if…else 語句是合法的，（但要注意效率問題）
if(布爾表達式 1){//如果布爾表達式 1位true，if(布爾表達式 2){//如果布爾表達式 2位true，} }5、switch多選擇結(jié)構(gòu)
多選擇結(jié)構(gòu)還有一個實現(xiàn)方式就是switch case 語句。
switch(expression){case value://語句break; //可選case value://語句break; //可選default://可選//語句 }- default 在沒有case語句的值和變量值相等的時候執(zhí)行，default分支不需要 break 語句。
- switch case 執(zhí)行時，一定會先進行匹配，匹配成功返回當(dāng)前 case 的值，再根據(jù)是否有break，判斷是否持續(xù)輸出，或是跳出判斷。
- 【case 穿透】
- 【JDK7增加了字符串表達式】
循環(huán)結(jié)構(gòu)
三種循環(huán)結(jié)構(gòu)
- while 循環(huán)
- do…while 循環(huán)
- for 循環(huán)
1、while 循環(huán)
while(布爾表達式){//循環(huán)體 }我們需要一個讓表達式失效的方式來結(jié)束循環(huán)。
- 循環(huán)內(nèi)部控制
- 外部設(shè)立標(biāo)志位
- …(待補充)
2、do…while 循環(huán)
do…while 循環(huán)和 while 循環(huán)相似，不同的是，do…while 循環(huán)至少會執(zhí)行一次。
do {//循環(huán)體 }while(布爾表達式);3、For循環(huán)(用的最多了)(簡化代碼提高可讀性)
for循環(huán)語句是支持迭代的一種通用結(jié)構(gòu)，是最有效、最靈活的循環(huán)結(jié)構(gòu)。
for循環(huán)執(zhí)行的次數(shù)是在執(zhí)行前就確定的。語法格式：
for(初始化; 布爾表達式; 更新){//循環(huán)體 }關(guān)于for 循環(huán)有以下幾點說明：
- 最先執(zhí)行初始化步驟?？梢月暶饕环N類型，但可初始化一個或多個循環(huán)控制變量，也可以是空語句。
- 然后，檢測布爾表達式的值。如果為 true，循環(huán)體被執(zhí)行。如果為false，循環(huán)終止，開始執(zhí)行循環(huán)體后面的語句。
- 執(zhí)行一次循環(huán)后，更新循環(huán)控制變量（迭代因子控制循環(huán)變量的增減）。
- 再次檢測布爾表達式。循環(huán)執(zhí)行上面的過程。
4、練習(xí)（重中之重）（理解第一步，其他都是練習(xí)）
【練習(xí)一：計算0—100之間的奇數(shù)和偶數(shù)的和】
//練習(xí)1：計算1到100之間的奇數(shù)和偶數(shù)的和 int oddSum = 0; int evenSum = 0;for (int i = 0; i <= 100; i++) {if (i%2!=0) {//奇數(shù)oddSum+=i;}else {//偶數(shù)evenSum+=i;} } System.out.println("奇數(shù)的和："+ oddSum); System.out.println("偶數(shù)的和："+ evenSum);【練習(xí)2：用while或for循環(huán)輸出1-1000之間能被5整除的數(shù)，并且每行輸出3個】
//練習(xí)2：用while或for循環(huán)輸出1-1000之間能被5整除的數(shù)，并且每行輸出3個 //練習(xí)3：打印九九乘法表 for (int i = 1; i <= 1000; i++) {if (i%5==0){System.out.print(i +"\t"); //水平制表轉(zhuǎn)義字符}if (i%(5*3)==0){ //注意if (i%5*3==0)錯誤, % 優(yōu)先級與 * 同級，從左向右依次運算//System.out.println(); //與print區(qū)別輸出后換行，print輸出后不換行System.out.print("\n"); //換行轉(zhuǎn)義字符} }【練習(xí)3：打印九九乘法表】
//練習(xí)3：打印九九乘法表 //9*9乘法表 //1.我們先打印第一列，這個大家應(yīng)該都會 //2.我們把固定1再用一個循環(huán)包起米 //3.去掉重復(fù)項，i<=j //4.調(diào)整樣式 for (int i = 1; i <= 9; i++) {for (int j = 1; j <= i; j++) {System.out.print(i+"*"+j+"="+i*j+"\t");}System.out.println(); }【練習(xí)，題目要多少有多少，牛客網(wǎng)，藍橋，多著呢，可以練習(xí)】
5、增強for循環(huán)
for(聲明語句 : 表達式){//循環(huán)體 }聲明語句： 聲明新的局部變量，該變量的類型必須和數(shù)組元素的類型匹配。其作用域限定在循環(huán)語句塊，其值與此時數(shù)組元素的值相等。
表達式： 表達式是要訪問的數(shù)組名，或者是返回值為數(shù)組的方法。
int[] numbers = {1,0,2,4}; for (int i = 0; i < 4; i++) {System.out.println(numbers[i]); } System.out.println("==================="); //遍歷數(shù)組或集合 for (int x:numbers){System.out.println(x); }break & continue
1、break 關(guān)鍵字
break 主要用在循環(huán)語句或者 switch 語句中，用來跳出整個語句塊。
break 跳出最里層的循環(huán)，并且繼續(xù)執(zhí)行該循環(huán)下面的語句。
2、continue 關(guān)鍵字
continue 適用于任何循環(huán)控制結(jié)構(gòu)中。作用是讓程序立刻跳轉(zhuǎn)到下一次循環(huán)的迭代。
3、兩者區(qū)別
break在任何訊循環(huán)語句的主體部分，均可用break控制循環(huán)的流程。break用于強行退出循環(huán)，不執(zhí)行循環(huán)中剩余的語句。（break語句也在switch語句中使用）
continue語句在循環(huán)語句體中，用于終止某次循環(huán)過程，即跳過循環(huán)體中尚未執(zhí)行的語句，接著進行下一次是否執(zhí)行循環(huán)的判斷。
4、帶標(biāo)簽的contimue
4-JavaSE：方法
方法
1、何謂方法
引言：System.out.printIn()，那么它是什么呢？
- printIn() 是一個方法。
- System 是系統(tǒng)類
- out 是標(biāo)準(zhǔn)輸出對象
什么是方法？
Java方法是語句的集合，它們在一起執(zhí)行一個功能。
- 方法是解決一類問題的步驟的有序組合
- 方法包含于類或?qū)ο笾?/li>
- 方法在程序中被創(chuàng)建，在其他地方被引用
設(shè)計方法的原則：方法的本意是功能塊，就是實現(xiàn)某個功能的語句塊的集合。我們設(shè)計方法的時候，最好保持方法的原子性，就是一個方法只能完成1個功能，這樣利于我們后期的拓展。
方法的優(yōu)點
- 使程序變得更簡短而清晰
- 有利于程序維護
- 可以提高程序開發(fā)的效率
- 提高了代碼的重用性
回顧：方法的命名規(guī)則？
2、方法的定義
Java的方法類似于其他語言的函數(shù)，是一段用來完成特定功能的代碼片段，一般情況下，定義一個方法包含以下語法：
修飾符 返回值類型 方法名(參數(shù)類型 參數(shù)名){...方法體...return 返回值； }方法包含一個方法頭和一個方法體。下面是一個方法的所有部分：
- **修飾符：**修飾符，這是可選的，告訴編譯器如何調(diào)用該方法。定義了該方法的訪問類型。
- **返回值類型：**方法可能會返回值。return ValueType是方法返回值的數(shù)據(jù)類型。有些方法執(zhí)行所需要的操作，但沒有返回值。在這種情況下，return ValueType是關(guān)鍵字void。
- **方法名：**是方法的實際名稱。方法名和參數(shù)表共同構(gòu)成方法簽名。
- **參數(shù)類型：**參數(shù)像是一個占位符。當(dāng)方法被調(diào)用時，傳遞值給參數(shù)。這個值被稱為實參或變量。參數(shù)列表是指方法的參數(shù)類型、順序和參數(shù)的個數(shù)。參數(shù)是可選的，方法可以不包含任何參數(shù)。
- 形式參數(shù)：在方法被調(diào)用時用于接收外界輸入的數(shù)據(jù)。
- 實參：調(diào)用方法時實際傳給方法的數(shù)據(jù)，
- **方法體：**方法體包含具體的語句，定義該方法的功能。
3、方法調(diào)用
Java支持兩種調(diào)用方法的方式，根據(jù)方法是否返回值來選擇。
當(dāng)程序調(diào)用一個方法時，程序的控制權(quán)交給了被調(diào)用的方法。當(dāng)被調(diào)用方法的返回語句執(zhí)行或者到達方法體閉括號時候交還控制權(quán)給程序。
當(dāng)方法返回一個值的時候，方法調(diào)用通常被當(dāng)做一個值。例如：
int larger = max(30, 40)Java 支持兩種調(diào)用方法的方式，根據(jù)方法是否返回值來選擇。
當(dāng)程序調(diào)用一個方法時，程序的控制權(quán)交給了被調(diào)用的方法。當(dāng)被調(diào)用方法的返回語句執(zhí)行或者到達方法體閉括號時候交還控制權(quán)給程序。
示例代碼：
public static void main(String[] args) {int max = max(10,20);System.out.println(max); }public static double max(int num1, int num2) {int result = 0;if (num1 == num2) {System.out.println("num1 == num2");return 0;}if (num1 > num2){return num1;}else {return num2;} }JAVA中只有值傳遞！
4、方法的重載（重寫，別混）
一個類的兩個方法擁有相同的名字，但是有不同的參數(shù)列表叫做方法的重載。
- Java編譯器根據(jù)方法簽名判斷哪個方法應(yīng)該被調(diào)用。
- 方法重載可以讓程序更清晰易讀。執(zhí)行密切相關(guān)任務(wù)的方法應(yīng)該使用相同的名字。
- 重載的方法必須擁有不同的參數(shù)列表。你不能僅僅依據(jù)修飾符或者返回類型不同來重載方法。
5、拓展命令行傳參
6、可變參數(shù)
Jdk1.5開始，Java支持傳遞同類型的可變參數(shù)給一個方法。
聲明格式：
typeName...parameterName一個方法中只能指定一個可變參數(shù)，它必須是方法的最后一個參數(shù)。任何普通的參數(shù)必須在它之前聲明。
public static void main(String[] args) {//調(diào)用可變參數(shù)的方法printMax(34,2,5,64,98);printMax(new double[]{45,56,2}); }public static void printMax(double... numbers) {if (numbers.length == 0) {System.out.println("No argument passed");return;}double result = numbers[0];//排序for (int i = 1; i < numbers.length; i++) {if (numbers[i] > result){result = numbers[i];}}System.out.println("The max value is "+ result); }7、遞歸（小重點吧）
遞歸就是A方法調(diào)用A方法！自己調(diào)用自己。
利用遞歸可以用簡單的程序來解決一些復(fù)雜的問題。它通常把一個大型復(fù)雜的問題層層轉(zhuǎn)化為一個與原
問題相似的規(guī)模較小的問題來求解，遞歸策略只需少量的程序就可描述出解題過程所需要的多次重復(fù)計
算，大大地減少了程序的代碼量。遞歸的能力在于用有限的語句來定義對象的無限集合。
遞歸結(jié)構(gòu)包括兩個部分：
遞歸頭。解答：什么時候不調(diào)用自身方法。如果沒有頭，將陷入死循環(huán)。
遞歸體。解答：什么時候需要調(diào)用自身方法。
【演示：利用代碼計算5的乘階！】
public static void main(String[] args) {System.out.println(f(5)); }public static int f(int n) {if (n == 1){return 1;}else {return n*f(n-1);} }能不用遞歸就不用遞歸，遞歸都可以用迭代來代替。 ?我不理解
總結(jié)和作業(yè)（流程與方法）
- 用戶交互Scanner
- 順序結(jié)構(gòu)
- 選擇結(jié)構(gòu)
- 循環(huán)結(jié)構(gòu)
- break & continue
- 方法
作業(yè)：
- 寫一個計算器，要求實現(xiàn)加減乘除功能，并且能夠循環(huán)接收新的數(shù)據(jù)，通過用戶交互實現(xiàn)。思路推薦：
- 寫4個方法：加減乘除
- 利用循環(huán)+switch進行用戶交互
- 傳遞需要操作的兩個數(shù)
- 輸出結(jié)果
5-JavaSE：數(shù)組
數(shù)組概述
關(guān)于數(shù)組我們可以把他看作是一個類型的所有數(shù)據(jù)的一個集合，并用一個數(shù)組下標(biāo)來區(qū)分或指定每一個數(shù)，（注意：數(shù)組的下標(biāo)是從0開始的，所以10個數(shù)的話，下標(biāo)就是0-9，a(0)=1）。使用數(shù)組會讓程序變得簡單，而且避免了定義多個變量的麻煩。
數(shù)組的定義：
- 數(shù)組是相同類型數(shù)據(jù)的有序集合。
- 數(shù)組描述的是相同類型的若干個數(shù)據(jù)，按照一定的先后次序排列組合而成。
- 其中，每一個數(shù)據(jù)稱作一個數(shù)組元素，每個數(shù)組元素可以通過一個下標(biāo)來訪問它們。、
數(shù)組的四個基本特點：
數(shù)組聲明創(chuàng)建
1、聲明數(shù)組
首先必須聲明數(shù)組變量，才能在程序中使用數(shù)組。下面是聲明數(shù)組變量的語法：
dataType[] arrayRefvar; // 首選的方法 或 dataType arrayRefvar[]; // 效果相同，但不是首選方法2、創(chuàng)建數(shù)組
Java語言使用new操作符來創(chuàng)建數(shù)組，語法如下：
arrayRefvar = new dataType[arraySize];上面的語法語句做了兩件事：
- 一、使用 dataType[arraySize] 創(chuàng)建了一個數(shù)組。
- 二、把新創(chuàng)建的數(shù)組的引用賦值給變量 arrayRefVar
數(shù)組變量的聲明，和創(chuàng)建數(shù)組可以用一條語句來完成，如下所示：
dataType[] arrayRefVar = new dataType[arraySize];數(shù)組的元素是通過索引訪問的。數(shù)組索引從0開始，所以索引值從0到 arrayRefVar.length-1.
獲取數(shù)組長度：
arrays.length【演示聲明，創(chuàng)建，一個數(shù)組，并賦值，進行訪問】
int[] nums;//1. 聲明一個數(shù)組 nums = new int[10];//2. 創(chuàng)建一個數(shù)組//3. 給數(shù)組元素賦值 nums[0] = 1; nums[1] = 2; nums[2] = 3; nums[3] = 4; nums[4] = 5; nums[5] = 6; nums[6] = 7; nums[7] = 8; nums[8] = 9; nums[9] = 10;System.out.println("nums[9] == "+nums[9]);//計算所有元素的和 int sum = 0; //獲取數(shù)組長度：array.lenth for (int i = 0; i < nums.length; i++) {sum+=nums[i]; } System.out.println("總和為 "+ sum);3、內(nèi)存分析
Java內(nèi)存分析：
4、三種初始化
靜態(tài)初始化
除了用new 關(guān)鍵字來產(chǎn)生數(shù)組以來，還可以直接在定義數(shù)組的同時就為數(shù)組元素分配空間并賦值。
int[] a = {1,2,3}; Man[] mans = {new Man(1,1), new Man(2,2)};動態(tài)初始化
數(shù)組定義，為數(shù)組元素分配空間、賦值的操作、分開進行。
int[] a = new int[2]; a[0] = 1; a[1] = 2;數(shù)組的默認(rèn)初始化
數(shù)組是引用類型，它的元素相當(dāng)于類的實例變量，因此數(shù)組一經(jīng)分配空間，其中的每個元素也被按照實例變量同樣的方式被隱式初始化。
int[] a = new int[2]; //0,0 boolean[] b = new boolean[2]; // false,false String[] s = new String[2]; //null,null5、數(shù)組邊界
下標(biāo)的合法區(qū)間：[0, lenth-1]，如果越界就會報錯；
int[] a = new int[2]; System.out.printf(a[2]);**ArrayIndexOutBoundsException：**數(shù)組下標(biāo)越界異常！
6、小結(jié)
- 數(shù)組是相同數(shù)據(jù)類型（數(shù)據(jù)類型可以為任意類型）的有序集合
- 數(shù)組也是對象。數(shù)組元素相當(dāng)于對象的成員變量（詳情請見內(nèi)存圖、以后整個此類筆記）
- 數(shù)組長度是確定的，不可變的。如果越界，則報：ArrayIndexOutBoundsException
數(shù)組使用
數(shù)組的元素類型和數(shù)組的大小都是確定的，所以當(dāng)處理數(shù)組元素時候，我們通常使用基本循環(huán)或者 For-Each 循環(huán)。
【以下實例完整地展示了如何創(chuàng)建、初始化和操作數(shù)組】
int[] arrays = {1,2,3,4,5}; //靜態(tài)初始化//打印全部數(shù)組元素 for (int i = 0; i <arrays.length; i++) {System.out.println(arrays[i]); } System.out.println("============"); //計算所有數(shù)組之和 int sum = 0; for (int i = 0; i <arrays.length; i++) {sum +=arrays[i]; } System.out.println(sum); System.out.println("============"); //查找最大元素 int max = arrays[0]; for (int i = 1; i <arrays.length; i++) {if (max < arrays[i]) {max = arrays[i];} } System.out.println(max); System.out.println("============");1、 For-Each 循環(huán)
JDK 1.5 引進了一種新的循環(huán)類型，被稱為 For-Each 循環(huán)或者加強型循環(huán)，它能在不使用下標(biāo)的情況下遍歷數(shù)組。語法格式如下：
for(type element : array){System.out.prinfIn(element); } //示例 //打印全部數(shù)組元素JDK1.5,沒有下標(biāo) for (int array: arrays) {System.out.print(array+ " "); }2、數(shù)組作方法入?yún)?/h5>
數(shù)組可以作為參數(shù)傳遞給方法。
//打印數(shù)組元素方法 public static void printArray(int[] arrays) {for (int i = 0; i <arrays.length; i++) {System.out.print(arrays[i] + " ");}System.out.println("============"); }3、數(shù)組作返回值
//反轉(zhuǎn)數(shù)組 public static int[] reverse (int[] arrays) {int[] result = new int[arrays.length];for (int i = 0; i <arrays.length; i++) {result[i] = arrays[arrays.length-i-1];}return result; }result 數(shù)組作為函數(shù)的返回值。
多維數(shù)組
多維數(shù)組可以看成是數(shù)組的數(shù)組，比如二維數(shù)組就是一個特殊的一維數(shù)組，其中的每一個元素都是一個一維數(shù)組。
多維數(shù)組的動態(tài)初始化（以二維數(shù)組為例）
// 為每一維分配空間，格式如下 typeLength1為行，typeLength2為列 type[][] typeName = new type[typeLength1][typeLength2]; int[][] a = new int[2][5]多維數(shù)組的引用（以二維數(shù)組為例）
int[][] arrays = {{1,2},{2,3},{3,4,6},{4,5}}; for (int i = 0; i < arrays.length; i++) {for (int j = 0; j < arrays[i].length; j++) {System.out.print(arrays[i][j] +" ");}System.out.println(); }arrays.length 和 arrays[i].length
Array 類
數(shù)組的工具類 java.util.Arrays
由于數(shù)組對象本身并沒有什么方法可以供我們調(diào)用，但API中提供了一個工具類Arrays供我們使用，從而可以對數(shù)據(jù)對象進行一些基本的操作。
Arrays類中的方法都是static修飾的靜態(tài)方法，在使用的時候可以直接使用類名進行調(diào)用，而”不用“使用對象來調(diào)用（注意，是”不用“，而不是”不能“）
java.util.Arrays 類能方便地操作數(shù)組，使用之前需要導(dǎo)包！
具有以下常用功能：
- 給數(shù)組賦值：通過 fill 方法。
- 對數(shù)組排序：通過 sort 方法，按升序。
- 比較數(shù)組：通過 equals 方法比較數(shù)組中元素值是否相同
- 查找數(shù)組元素：通過 binarySearch 方法能對排序好的數(shù)組進行二分查找法操作
1、打印數(shù)組
2、數(shù)組排序
3、二分法查找
4、元素填充
5、數(shù)組轉(zhuǎn)換為List集合
int[] a = {1,5,565,15,6546,464,564,6546,46,46,46,4}; System.out.println(a);//哈希碼 [I@1b6d3586 //打印數(shù)組元素 Arrays.sort(a); System.out.println(Arrays.binarySearch(a, 12));// 二分法查找 ，必須先對數(shù)組進行排序 Arrays.fill(a,2,4,0);// 元素填充 System.out.println(Arrays.toString(a)); List<int[]> list = Arrays.asList(a);常見排序算法（有興趣的話，下次補個額外的基礎(chǔ)算法筆記）
1、 冒泡排序（Bubble Sort）
冒泡排序，是一種計算機科學(xué)領(lǐng)域的比較簡單的排序算法。
冒泡排序算法的原理如下：
2、選擇排序（Selection sort）
選擇排序是一種簡單直觀的排序算法。它的工作原理是每一次從待排序的數(shù)據(jù)元素中選出最小（或最大）的一個元素，存放在序列的起始位置，然后，再從剩余未排序元素中繼續(xù)尋找最小（大）元素，然后放到排序序列的末尾。以此類推，直到全部待排序的數(shù)據(jù)元素排完。選擇排序是不穩(wěn)定的排序方法。
累了，休息了3、有空全部補上
稀疏數(shù)組
(69條消息) Java實現(xiàn)稀疏數(shù)組_Marvellous丶的博客-CSDN博客
用作棋盤很是合適。
6-JavaSE：面向?qū)ο?/h3>
面向過程&面向?qū)ο?/h4>
面向過程的思維模式
面向?qū)ο蟮乃季S模式
面向過程的思維模式
面向?qū)ο蟮乃季S模式
對于描述復(fù)雜的事物，為了從宏觀上把握、從整體上合理分析，我們需要使用面向?qū)ο蟮乃悸穪矸治稣麄€系統(tǒng)。但是，具體到微觀操作，仍然需要面向過程的思路去處理。
OOP詳解
1、什么是面向?qū)ο?/h5>
Java 的編程語言是面向?qū)ο蟮?#xff0c;采用這種語言進行編程稱為面向?qū)ο缶幊?#xff08;Object-Oriented Programming，OOP）。
面向?qū)ο缶幊痰谋举|(zhì)就是：以類的方式組織代碼，以對象的組織（封裝）數(shù)據(jù)。
抽象（abstract）
忽略。。。有待考量
封裝（Encapsulation）
封裝是面向?qū)ο蟮奶卣髦?#xff0c;是對象和類概念的主要特性。封裝是把過程和數(shù)據(jù)包圍起來，對數(shù)據(jù)的訪問只能通過指定的方式。
在定義一個對象的特性的時候，有必要決定這些特性的可見性，即哪些特性對外部是可見的，哪些特性用于表示內(nèi)部狀態(tài)。
通常，應(yīng)禁止直接訪問一個對象中的數(shù)據(jù)的實際表示，而應(yīng)通過操作接口來訪問，這稱為信息隱藏。
信息隱藏是用戶對封裝性的認(rèn)識，封裝則為信息隱藏提供支持。
封裝保證了模塊具有較好的獨立性，使得程序維護較為容易。對應(yīng)用程序的修改僅限于類的內(nèi)部，因而可以將程序修改帶來的影響減少到最低限度。（懂一點的，看完應(yīng)該頗有收獲）
繼承（inheritance）
繼承是一種聯(lián)結(jié)類的層次模型，并且允許和支持類的重用，它提供了一種明確表述共性的方法。
? 新類繼承了原始類后，新類就繼承了原始類的特性，新類稱為原始類的派生類（子類），而原始類稱為新類的基類（父類）。
? 派生類（子類）可以從它的基類（父類）那里繼承方法和實例變量，并且派生類（子類）中可以修改或增加新的方法使之更適合特殊的需要繼承性很好的解決了軟件的可重用性問題。比如說，所有的Windows應(yīng)用程序都有一個窗口，它們可以看作都是從一個窗口類派生出來的。但是有的應(yīng)用程序用于文字處理，有的應(yīng)用程序用于繪圖，這是由于派生出了不同的子類，各個子類添加了不同的特性。
多態(tài)（polymor phism）
多態(tài)性是指允許不同類的對象對同一信息作出相應(yīng)。
? 多態(tài)性語言具有靈活、抽象、行為共享、代碼共享的優(yōu)勢，很好的解決了應(yīng)用程序函數(shù)同名問題。
相同類域的不同對象，調(diào)用相同方法，表現(xiàn)出不同的結(jié)果。（吃飯-飽了-沒飽）
從認(rèn)知論角度考慮是先有對象后有類。對象，是具體的事物。類，是對對象的抽象。
從代碼運行角度考慮是先有類后有對象，類是對象的模板。
2、類與對象的關(guān)系
類是一種抽象的數(shù)據(jù)類型，它是對某一類事物整體描述/定義，但是并不能代表某一具體的事物。
例如：我們生活中所說的詞語：動物、植物、手機、電腦等等。這些也都是抽象的概念，而不是指某一個具體的東西。
例如：Person類、Pet類、Car類等，這些類都是用來描述/定義某一具體的事物應(yīng)該具備的特點和行為，對象是抽象概念的具體實例
Student s = new Student("tom", 20); s.study(); Car c = new Car("BYD",8,30); c.run();==在java中，沒有類就沒有對象，而類又是根據(jù)具體的功能需求，進行實際的分析，最終抽象出來的。
3、對象和引用的關(guān)系
引用“指向”對象
使用類類型、數(shù)組類型、接口類型聲明出的變量，都可以指向?qū)ο?#xff0c;這種變量就是引用類型變量，簡稱引用。
在程序中，創(chuàng)建出對象后（new），直接使用并不方便，所以一般會用一個引用類型的變量去接收這個對象，這個就是所說的引用指向?qū)ο蟆?/p>
總結(jié)：對象和引用的關(guān)系，就如同電視機和遙控器，風(fēng)箏和線的關(guān)系一樣。
方法回顧及加深
方法一定是定義在類中的，屬于類的成員。
1、方法的定義
格式： 修飾符 返回類型 方法名(參數(shù)列表) throws 異常{... }1. 修飾符
public、static、abstract、final等等都是修飾符，一個方法可以有多個修飾符。例如程序入口main方法，就使用了public static這兩個修飾符 注：如果一個方法或者屬性有多個修飾符，這多個修飾符是沒有先后順序的2. 返回類型
方法執(zhí)行完，如果又要返回的數(shù)據(jù)，那么就要聲明返回數(shù)據(jù)類型，如果沒有返回類型就必須寫void只有構(gòu)造方法（構(gòu)造器）不寫任何返回類型也不寫void //return 結(jié)束方法，返回一個結(jié)果 public String satHello(){return "hello,World!"; } public void print(){return; } public int max(int a,int b){return a>b?a:b; }【思考】：聲明返回類型的方法中一定要出現(xiàn)return語句,那么沒有返回類型(void)的方法中,能不能出現(xiàn)return語句?
注：break 和 return 的區(qū)別
return 語句的作用：
break 語句的作用
3.方法名
遵循java中標(biāo)識符的命名規(guī)則即可。4.參數(shù)列表
根據(jù)需求定義，方法可以是無參的，也可以是有一個參數(shù)，也可以有多個參數(shù)5.異常拋出類型
如果方法中的代碼在執(zhí)行過程中，可能會出現(xiàn)一些異常情況，那么就可以在方法上把這些異常聲明并拋出，也可以同時聲明拋出多個異常，使用逗號隔開即可。 public void readFile(String file) throws IOException{} public void readFile(String file) throws IOException,ClassNotFoundException{}2、方法調(diào)用
在類中定義了方法，這個方法中的代碼并不會執(zhí)行，當(dāng)這個方法被調(diào)用的時候，方法中的代碼才會被一行一行順序執(zhí)行。（）
1.非靜態(tài)方法
沒有使用 static 修飾符修飾的方法，就是非靜態(tài)方法。
調(diào)用這種方法的時候，是一定要使用對象的。因為非靜態(tài)方法是屬于對象的。（非靜態(tài)屬性也是一樣的）
【例子】
//學(xué)生類 public class Student {//方法 非靜態(tài)方法public void say(){System.out.println("學(xué)生說話了！");} } -------------------------------------------- //實例化這個類new //對象類型對象名=對象值 Student student = new Student();//非靜態(tài)方法 student.say();2.靜態(tài)方法
使用 static 修飾符修飾的方法，就是靜態(tài)方法。
調(diào)用這種方法德時候，可以使用對象調(diào)用，也可以使用類來調(diào)用，但是推薦使用類進行調(diào)用，因為靜態(tài)方法時屬于類的。（靜態(tài)屬性也是一樣的）
【例子】
public class Student {public static void say(){System.out.println("學(xué)生說話了！");} } -------------------------------------------- Student.say();//靜態(tài)方法 static3. 類中方法之間的調(diào)用
假設(shè)同一個類中有兩個方法，a方法和b方法，a和b都是非靜態(tài)方法，相互之間可以直接調(diào)用。
//靜態(tài)方法和類一起加載 public void a(){b(); }//非靜態(tài)方法：類實例化后 才存在 public void b(){a(); }- 都是非靜態(tài)，或都是靜態(tài)，a，b方法可以相互直接調(diào)用
- 一個靜態(tài)，一個非靜態(tài)，非靜態(tài)可以調(diào)用靜態(tài)，但靜態(tài)方法不能調(diào)用非靜態(tài)方法（先后產(chǎn)生的關(guān)系）
- 另外：在同一個類中,靜態(tài)方法內(nèi)不能直接訪問到類中的非靜態(tài)屬性.
3、調(diào)用方法時的傳參
1.形參和實參
public void test(int a){ //a是方法test的形參//... } ----------------------- int x = 3; t.test(x);// x是方法test的實參 //不關(guān)心參數(shù)的名字，關(guān)注于變量的類型以及變量接收的值2.值傳遞和引用傳遞（好好理解，挺重要的）
調(diào)用方法進行傳參時,分為值傳遞和引用傳遞兩種。
如果參數(shù)的類型是基本數(shù)據(jù)類型,那么就是值傳遞。
如果參數(shù)的類型是引用數(shù)據(jù)類型,那么就是引用傳遞。
值傳遞是實參把自己變量本身存的簡單數(shù)值賦值給形參.
引用傳遞是實參把自己變量本身存的對象內(nèi)存地址值賦值給形參.
所以值傳遞和引用傳遞本質(zhì)上是一回事,只不過傳遞的東西的意義不同而已.
4、this關(guān)鍵字
在類中，可以使用this 關(guān)鍵字表示一些特殊的作用。
1.this在類中的使用
- 【區(qū)別成員變量和局部變量】
- 【調(diào)用類中的其他方法】
- 【調(diào)用類中的其他構(gòu)造器】注 ：this的這種用法，只能在構(gòu)造器中使用，普通方法是不能使用的，且該代碼只能在第一句。
2.this關(guān)鍵字在類中的意義
this 在類中表示當(dāng)前類將來創(chuàng)建出的對象。
創(chuàng)建與初始化對象
使用new關(guān)鍵字創(chuàng)建對象
使用new關(guān)鍵字創(chuàng)建的時候，除了分配內(nèi)存空間之外，還會給創(chuàng)建好的對象進行默認(rèn)的初始化以及對類中構(gòu)造器的調(diào)用。
那么對main方法中的以下代碼: Student s = new Student(); 1)為對象分配內(nèi)存空間,將對象的實例變量自動初始化默認(rèn)值為0/false/null。(實例變量的隱式賦 值) 2)如果代碼中實例變量有顯式賦值,那么就將之前的默認(rèn)值覆蓋掉。(之后可以通過例子看到這個現(xiàn)象) 例如:顯式賦值 private String name = "tom"; 3)調(diào)用構(gòu)造器 4)把對象內(nèi)存地址值賦值給變量。(=號賦值操作)構(gòu)造器
類中的構(gòu)造器也稱為構(gòu)造方法，是在進行創(chuàng)建對象的時候必須要調(diào)用的。并且構(gòu)造器有以下兩個特點：
構(gòu)造器的作用
構(gòu)造器重載
除了無參構(gòu)造器之外,很多時候我們還會使用有參構(gòu)造器,在創(chuàng)建對象時候可以給屬性賦值.
構(gòu)造器之間的調(diào)用
使用this關(guān)鍵字,在一個構(gòu)造器中可以調(diào)用另一個構(gòu)造器的代碼。
注意:this的這種用法不會產(chǎn)生新的對象,只是調(diào)用了構(gòu)造器中的代碼而已.一般情況下只有使用new關(guān)鍵字才會創(chuàng)建新對象。
默認(rèn)構(gòu)造器
在java中,即使我們在編寫類的時候沒有寫構(gòu)造器,那么在編譯之后也會自動的添加一個無參構(gòu)造器,這個無參構(gòu)造器也被稱為默認(rèn)的構(gòu)造器
內(nèi)存分析
JAVA程序運行的內(nèi)存分析
棧 stack：
堆 heap：
放置new出來的對象！
堆是一個不連續(xù)的內(nèi)存空間，分配靈活，速度慢！
方法區(qū)(也是堆)：
被所有線程共享！
用來存放程序中永遠(yuǎn)是不變或唯一的內(nèi)容。（類代碼信息、靜態(tài)變量、字符串常量）
引用類型的概念
屬性（field，或者叫成員變量）
類的方法
方法是類和對象動態(tài)行為特征的抽象。方法很類似于面向過程中的函數(shù)。面向過程中，函數(shù)是最基本單位，整個程序有一個個函數(shù)調(diào)用組成；面向?qū)ο笾?#xff0c;整個程序的基本單位是類，方法是從屬于類或?qū)ο蟮摹?/p>
封裝
白話：該露的露，該藏的藏
專業(yè)：我們程序設(shè)計要追求“高內(nèi)聚，低耦合”。
高內(nèi)聚是類的內(nèi)部數(shù)據(jù)操作細(xì)節(jié)自己完成，不允許外部干涉；低耦合：僅暴露少量的方法給外部使用。
封裝（數(shù)據(jù)的隱藏）
在定義一個對象的特性的時候，有必要決定這些特性的可見性，即哪些特性對外部是可見的，那些特性用于表示內(nèi)部狀態(tài)。
通常，應(yīng)禁止直接訪問一個對象中數(shù)據(jù)的實際表示，而應(yīng)通過操作接口來訪問，這稱為信息隱藏。
1、封裝的步驟
設(shè)置 通過set方法，命名格式：set屬性名()；屬性的首字母要大寫
設(shè)置 通過get方法，命名格式：get屬性名()；屬性的首字母要大寫
2、作用和意義
良好的封裝，便于修改內(nèi)部代碼，提高可維護性。
良好的封裝，可進行數(shù)據(jù)完整性檢測，保證數(shù)據(jù)的有效性。
3、方法重載
類中有很多方法，有著相同的方法名，但是方法的參數(shù)各不相同，這種情況被稱為方法的重載。方法的重載可以提供方法調(diào)用的靈活性。
【思考：HelloWorld中的System.out.printIn()方法，為什么可以把不同類型的參數(shù)傳給這個方法？方法的重載】
public class Test{ public void test(String str){ }public void test(int a){ } }方法重載必須滿足以下條件
在java中，判斷一個類中的兩個方法是否相同，主要參考兩個方面：方法名字和參數(shù)列表
繼承
現(xiàn)實世界中的繼承無處不在。比如
繼承的本質(zhì)是對某一批類的抽象，從而實現(xiàn)對現(xiàn)實世界更好的建模。
為什么需要繼承？繼承的作用？
【注】Java中類只有單繼承，沒有多繼承！接口可以多繼承！
1、繼承
子類中繼承了父類中的屬性和方法后，在子類中能不能直接使用這些屬性和方法，適合這些屬性和方法原有的修飾符（public、
protected、default、private）相關(guān)的。
父類中的構(gòu)造器是不能被子類繼承的，但是子類的構(gòu)造器中，會隱式的調(diào)用父類中的無參構(gòu)造器（默認(rèn)使用super 關(guān)鍵字）
2、Object類
java中的每一個類都是“直接”或“間接”的繼承Object類。所以每一個對象都和Object類有“is a”的關(guān)系。從API文檔中，可以看到任何一個類最上層的父類都是Object。（Object類本身除外）AnyClass is a Object。
System.out.println(任何對象 instanceof Object);在Object類中，提供了一些方法被子類繼承，那么就意味著，在java中，任何一個對象都可以調(diào)用這些被繼承過來的方法。（因為Object 是所有類的父類）
例如：toString方法、equals方法、getClass方法等
注：Object類中的每一個方法之后都會使用到
3、Super關(guān)鍵字
子類繼承父類之后，在子類中可以使用this 來表示訪問或調(diào)用子類中的屬性或方法，使用super 就表示訪問或調(diào)用父類中的屬性和方法。
1-super的使用
【訪問父類中的屬性】
public class Person{protected String name = "zs"; } ------------------------------------- public class Student extends Person{private String name = "lisi";public void test(String name){System.out.printfIn(name);System.out.printfIn(this.name);System.out.printfIn(super.name);} }【調(diào)用父類中的方法】
public class Person{public void print(){System.out.println("Person");} } ------------------------------------- public class Student extends Person{public void print(){System.out.println("Student");}public void test(){print();this.print();super.print();} }【調(diào)用父類中的構(gòu)造器】
public class Person{} ------------------------------------- public class Student extends Person{//編譯通過，子類構(gòu)造器中會隱式的調(diào)用父類的無參構(gòu)造器// superpublic Student(){} }- 當(dāng)父類沒有無參構(gòu)造時，子類會編譯報錯
【顯式的調(diào)用父類的有參構(gòu)造器】
public class Person{protected String name;public Person(String name){this.name = name;} } public class Student extends Person { //編譯通過,子類構(gòu)造器中顯式的調(diào)用父類的有參構(gòu)造器public Student(){super("tom");} }- 注：不管是顯式還是隱式的父類的構(gòu)造器,super語句一定要出現(xiàn)在子類構(gòu)造器中第一行代碼。所以this和super不可能同時使用它們調(diào)用構(gòu)造器的功能,因為它們都要出現(xiàn)在第一行代碼位置。
【super使用的注意的地方】
【super 和 this 的區(qū)別】
代表的事物不一樣：
【super 和 this 的區(qū)別】
- this：代表所屬方法的調(diào)用者對象。
- super：代表父類對象的引用空間。
- this：在非繼承的條件下也可以使用。
- super：只能在繼承的條件下才能使用。
- this：調(diào)用本類的構(gòu)造方法。
- super：調(diào)用的父類的構(gòu)造方法。
4、方法重寫（override）
【例子】
A類繼承B類 A和B中都一個相同的靜態(tài)方法test B a = new A(); a.test();//調(diào)用到的是B類中的靜態(tài)方法test A a = new A(); a.test();//調(diào)用到的是A類中的靜態(tài)方法test //可以看出靜態(tài)方法的調(diào)用只和變量聲明的類型相關(guān) //這個和非靜態(tài)方法的重寫之后的效果完全不同重寫的語法
ClassNotFoundException --> Exception
總結(jié)：
多態(tài)
多態(tài)性是OOP中的一個重要特性，主要是用來實現(xiàn)動態(tài)聯(lián)編的
多態(tài)可以讓我們不用關(guān)心某個對象到底是什么具體類型，就可以使用該對象的某些方法，從而實現(xiàn)更加靈活的編程，提高系統(tǒng)的可擴展性。
1、認(rèn)識多態(tài)
允許不同類的對象對同一消息做出響應(yīng)。即同一消息可以根據(jù)發(fā)送對象的不同而采用多種不同的行為方式。
相同類域的不同對象,調(diào)用相同的方法,執(zhí)行結(jié)果是不同的
2、重寫、重載和多態(tài)的關(guān)系
重載是編譯時的多態(tài)
- 調(diào)用重載的方法，在編譯期間就要確定調(diào)用的方法時誰，如果不能確定則編譯報錯
重寫是運行時多態(tài)
- 調(diào)用重寫的方法，在運行期間才能確定這個方法到底是哪個對象中的。這個取決于調(diào)用方法的引用，在運行期間所指向的對象是誰，這個引用指向哪個對象那么調(diào)用的就是哪個對象中的方法。（java中的方法調(diào)用，是運行時動態(tài)和對象綁定的）
3、多態(tài)的注意事項
4、多態(tài)存在的條件
以下三種類型的方法是沒有辦法表現(xiàn)出多態(tài)特性的（因為不能被重寫）：
5、方法綁定（method binding）
執(zhí)行調(diào)用方法時，系統(tǒng)根據(jù)相關(guān)信息，能夠執(zhí)行內(nèi)存地址中代表該方法的代碼。分為靜態(tài)綁定和動態(tài)綁定。
靜態(tài)綁定：
? 在編譯期完成，可以提高代碼執(zhí)行速度。
動態(tài)綁定：
通過對象調(diào)用的方法，采用動態(tài)綁定機制。這雖然讓我們編程靈活，但是降低了代碼的執(zhí)行速度。這也是Java比C、C++速度慢的主要因素之一。Java中除了final類、final方法、static方法。所有方法都是JVM在運行期才進行動態(tài)綁定的。
多態(tài)：如果編譯時類型和運行類型不一致，就會造成多態(tài)。
6、instanceof 和 類型轉(zhuǎn)換
1、instanceof
System.out.println(x instanceof Y); //該代碼能否編譯通過,主要是看聲明變量x的類型和Y是否存在子父類的關(guān)系.有"子父類關(guān)"系就編譯通過, 沒有子父類關(guān)系就是編譯報錯. //之后學(xué)習(xí)到的接口類型和這個是有點區(qū)別的。 //輸出結(jié)果是true還是false,主要是看變量x所指向的對象實際類型是不是Y類型的"子類型".2、類型轉(zhuǎn)換
【總結(jié)】
如Father father=new Son0；
如father就是一個指向子類對象的父類引用，把father賦給子類引用son 即Son son=（Son）
father；其中father前面的（Son）必須添加，進行強制轉(zhuǎn)換。
修飾符
1、static修飾符
static變量
- 在類中，使用static修飾的成員變量，就是靜態(tài)變量，反之為非靜態(tài)變量。
- 靜態(tài)變量屬于類的,"可以"使用類名來訪問,非靜態(tài)變量是屬于對象的,"必須"使用對象來訪問。
- 靜態(tài)變量對于類而言在內(nèi)存中只有一個,能被類的所有實例所共享。實例變量對于類的每個實例都有一份，它們之間互不影響。
- 在加載類的過程中為靜態(tài)變量分配內(nèi)存,實例變量在創(chuàng)建對象時分配內(nèi)存，所以靜態(tài)變量可以使用類名來直接訪問，而不需要使用對象來訪問.。
static方法
- 在類中,使用static修飾的成員方法,就是靜態(tài)方法,反之為非靜態(tài)方法。
- 靜態(tài)方法"不可以"直接訪問類中的非靜態(tài)變量和非靜態(tài)方法,但是"可以"直接訪問類中的靜態(tài)變量和靜態(tài)方法。注意:this和super在類中屬于非靜態(tài)的變量.(靜態(tài)方法中不能使用)
- 非靜態(tài)方法"可以"直接訪問類中的非靜態(tài)變量和非靜態(tài)方法,也"可以"直接訪問類中的靜態(tài)變量和靜態(tài)方法
- 父類的靜態(tài)方法可以被子類繼承,但是不能被子類重寫。父類的非靜態(tài)方法不能被子類重寫為靜態(tài)方法 ；
代碼塊和靜態(tài)代碼塊
- 【類中可以編寫代碼塊和靜態(tài)代碼塊】
- 匿名代碼塊是在創(chuàng)建對象的時候自動執(zhí)行的,并且在構(gòu)造器執(zhí)行之前。同時匿名代碼塊在每次創(chuàng)建對象的時候都會自動執(zhí)行.
靜態(tài)代碼塊是在類加載完成之后就自動執(zhí)行,并且只執(zhí)行一次. - 匿名代碼塊的作用是給對象的成員變量初始化賦值,但是因為構(gòu)造器也能完成這項工作,所以匿名代碼塊使用的并不多。
靜態(tài)代碼塊的作用是給類中的靜態(tài)成員變量初始化賦值。 - 注：在構(gòu)造器中給靜態(tài)變量賦值,并不能保證能賦值成功,因為構(gòu)造器是在創(chuàng)建對象的時候才指向,但是靜態(tài)變量可以不創(chuàng)建對象而直接使用類名來訪問.
創(chuàng)建和初始化對象的過程
注:子類中非靜態(tài)屬性的顯示賦值是在父類構(gòu)造器執(zhí)行完之后和子類中的匿名代碼塊執(zhí)行之前的時候
靜態(tài)導(dǎo)入
2、final修飾符
修飾類
用final修飾的類不能被繼承,沒有子類。
修飾方法
用final修飾的方法可以被繼承,但是不能被子類的重寫。
修飾變量
用fifinal修飾的變量表示常量,只能被賦一次值.其實使用fifinal修飾的變量也就成了常量了,因為值不會再變了。
3、abstract 修飾符
abstract修飾符可以用來修飾方法也可以修飾類,如果修飾方法,那么該方法就是抽象方法;如果修飾類,那么該類就是抽象類。
1、抽象類和抽象方法的關(guān)系
抽象類中可以沒有抽象方法,但是有抽象方法的類一定要聲明為抽象類。
注:子類繼承抽象類,那么就必須要實現(xiàn)抽象類沒有實現(xiàn)的抽象方法,否則該子類也要聲明為抽象類。
思考1 : 抽象類不能new對象,那么抽象類中有沒有構(gòu)造器?
抽象類是不能被實例化,抽象類的目的就是為實現(xiàn)多態(tài)中的共同點,抽象類的構(gòu)造器會在子類實例化時調(diào) 用,因此它也是用來實現(xiàn)多態(tài)中的共同點構(gòu)造，不建議這樣使用！思考2 : 抽象類和抽象方法意義(為什么要編寫抽象類、抽象方法)
打個比方，要做一個游戲。如果要創(chuàng)建一個角色，如果反復(fù)創(chuàng)建類和方法會很繁瑣和麻煩。建一個抽象類 后。若要創(chuàng)建角色可直接繼承抽象類中的字段和方法，而抽象類中又有抽象方法。如果一個角色有很多種 職業(yè)，每個職業(yè)又有很多技能，要是依次實例這些技能方法會顯得想當(dāng)笨拙。定義抽象方法，在需要時繼 承后重寫調(diào)用，可以省去很多代碼。 總之抽象類和抽象方法起到一個框架作用。很方便后期的調(diào)用和重寫 抽象方法是為了程序的可擴展性。重寫抽象方法時即可實現(xiàn)同名方法但又非同目的的要求。接口
1、接口的本質(zhì)
普通類：只有具體實現(xiàn)
抽象類：具體實現(xiàn)和規(guī)范（抽象方法）都有！
接口：只有規(guī)范！
【為什么需要接口？接口和抽象類的區(qū)別？】
- 接口就是比“抽象類”還“抽象”的“抽象類”，可以更加規(guī)范的對子類進行約束。全面地專業(yè)地實現(xiàn)了：規(guī)范和具體實現(xiàn)的分離。
- 抽象類還提供某些具體實現(xiàn)，接口不提供任何實現(xiàn)，接口中所有方法都是抽象方法。接口是完全面向規(guī)范的，規(guī)定了一批類具有的公共方法規(guī)范。
- 從接口的實現(xiàn)者角度看，接口定義了可以向外部提供的服務(wù)。
- 從接口的調(diào)用者角度看，接口定義了實現(xiàn)者能提供哪些服務(wù)。
- 接口是兩個模塊之間通信的標(biāo)準(zhǔn)，通信的規(guī)范。如果能把你要設(shè)計的系統(tǒng)之間模塊之間的接口定義好，就相當(dāng)于完成了系統(tǒng)的設(shè)計大綱，剩下的就是添磚加瓦的具體實現(xiàn)了。大家在工作以后，做系統(tǒng)時往往就是使用“面向接口”的思想來設(shè)計系統(tǒng)。
【接口的本質(zhì)探討】
- 借口就是規(guī)范，定義的是一組規(guī)則，體現(xiàn)了現(xiàn)實世界中“如果你是。。。則必須能。。?！钡乃枷搿Ｈ绻闶翘焓?#xff0c;則必須能飛。如果你是汽車，則必須能跑。如果你好人，則必須干掉壞人；如果你是壞人，則必須欺負(fù)好人。
- 接口的本質(zhì)是契約，就像我們?nèi)碎g的法律一樣。制定好后大家都遵守。
- OOP的精髓，是對對象的抽象，最能體現(xiàn)這一點的就是接口。為什么我們討論設(shè)計模式都只針對具備了抽象能力的語言（比如C++、java、C#等），就是因為設(shè)計模式所研究的，實際上就是如何合理的去理解抽象。
2、接口與抽象類的區(qū)別
抽象也是類，除了可以寫抽象方法以及不能直接new對象之外，其他的和普通類沒有什么不一樣的。接口已經(jīng)是另一種類型了，和類是有本質(zhì)的區(qū)別的，所以不能用類的標(biāo)準(zhǔn)去衡量接口。
聲明類的關(guān)鍵字是class，聲明接口的關(guān)鍵字是interface
- 抽象類是用來繼承的，java中的類是單繼承。
- 類A繼承了抽象類B，那么類A的對象就屬于B類型了，可以使用多態(tài)。
一個父類的引用可以指向這個父類的任意子類對象。
注：繼承的關(guān)鍵字是extends - 接口是用來被類實現(xiàn)的，java中的接口可以被多實現(xiàn)。
類A實現(xiàn)接口B、C、D、E…那么類A的對象就屬于B、C、D、E等類型了，可以使用多態(tài)。
一個接口的引用，可以指向這個接口的任意實現(xiàn)類對象。
注：實現(xiàn)的關(guān)鍵字是implements
3、接口中的方法都是抽象方法
接口中可以不寫任何方法，但是如果寫方法了，該方法必須是抽象方法
public interface TimeService {//默認(rèn)就是public abstract修飾的void timer(); }4、接口中的變量都是靜態(tài)常量（public static final修飾）
接口中可以不寫任何屬性，但如果寫屬性了，該屬性必須是public static final修飾的靜態(tài)常量。
注：可以直接使用接口名訪問其屬性。因為是public static修飾的
注：聲明的同時就必須賦值（因為接口中不能編寫靜態(tài)代碼塊）
5、一個類可以實現(xiàn)多個接口
public class Student implements A,B,C,D{ //Student需要實現(xiàn)接口A B C D中所有的抽象方法 //否則Student類就要聲明為抽象類,因為有抽象方法沒實現(xiàn) } main: A s1 = new Student(); B s2 = new Student(); C s3 = new Student(); D s4 = new Student();注:
s1只能調(diào)用接口A中聲明的方法以及Object中的方法
s2只能調(diào)用接口B中聲明的方法以及Object中的方法
s3只能調(diào)用接口C中聲明的方法以及Object中的方法
s4只能調(diào)用接口D中聲明的方法以及Object中的方法
注:必要時可以類型強制轉(zhuǎn)換
例如 : 接口A 中有test() ， 接口B 中有run()
A s1 = new Student(); s1.test(); B s2 = new Student(); s2.run(); if(s1 instanceof B){ ((B)s1).run(); }6、一個接口可以繼承多個父接口
注:一個引用所指向的對象,是有可能實現(xiàn)任何一個接口的。(java中的多實現(xiàn))
7、接口的作用
接口的最主要的作用是達到統(tǒng)一訪問，就是在創(chuàng)建對象的時候用接口創(chuàng)建
【接口名】 【對象名】 = new 【實現(xiàn)接口的類】
作用：1. 約束2. 定義一些方法，讓不同人實現(xiàn)-- 10 ----》 13. public abstract4. public static final5. 接口不能被實例化~，接口中沒有構(gòu)造方法～6. implements可以實現(xiàn)多個接口7. 必須要重寫接口中的方法-內(nèi)部類
接口完了，就是內(nèi)部類了。
很多時候，我們創(chuàng)建類的對象的時候并不需要使用很多次，每次只使用一次，這個時候我們就可以使用內(nèi)部類了。
1、內(nèi)部類概述
內(nèi)部類就是在一個類的內(nèi)部在定義一個類，比如，A類中定義一個B類，那么B類相對A類來說就稱為內(nèi)部類，而A類相對于B類來說就是外部類了。
內(nèi)部類不是在一個Java源文件中編寫兩個平行的兩個類，而是在一個類的內(nèi)部再定義另外一個類。我們可以把外邊的類稱為外部類，在其內(nèi)部編寫的類稱為內(nèi)部類。
內(nèi)部類分為四種：
2、成員內(nèi)部類（實例內(nèi)部類、非靜態(tài)內(nèi)部類）
注：成員內(nèi)部類中不能寫靜態(tài)屬性和方法
【定義一個內(nèi)部類】
//在A類中申明了一個B類，此B類就在A的內(nèi)部，并且在成員變量的位置上，所以就稱為成員內(nèi)部類 public class Outer {private int id = 10 ;public void out(){System.out.println("這是外部類的方法");}//內(nèi)部類 加個Static 就是靜態(tài)內(nèi)部類class Inner{public void in() {System.out.println("這是內(nèi)部類的方法");}//獲得外部類的私有屬性--public void getId() {System.out.println(id);}} }【實例化內(nèi)部類】
實例化內(nèi)部類，首先需要實例化外部類，通過外部類去調(diào)用內(nèi)部類
public class Application {public static void main(String[] args) {//newOuter o1 = new Outer();//通過這個外部類來實例化內(nèi)部。Outer.Inner i1 = o1.new Inner();i1.in();i1.getId();} }【成員內(nèi)部類能干什么？】
3、靜態(tài)內(nèi)部類
使用static關(guān)鍵字修飾的內(nèi)部類就叫靜態(tài)內(nèi)部類。
static一般只修飾變量和方法，平常不可以修飾類，但是內(nèi)部類卻可以被static修飾。
注意：
偶們上面說的內(nèi)部類能夠使用外部類的方法和屬性，在靜態(tài)內(nèi)部類中就行了，因為靜態(tài)內(nèi)部類沒有了指向外部類對象的引用。除非外部類中的方法或?qū)傩砸彩庆o態(tài)的。這就回歸到了static關(guān)鍵字的用法。
靜態(tài)內(nèi)部類能夠直接被外部類給實例化，不需要使用外部類對象
OUter.Inner inner = new Outer.Inner();靜態(tài)內(nèi)部類中可以聲明靜態(tài)方法和靜態(tài)變量，但是非靜態(tài)內(nèi)部類中就不可以聲明靜態(tài)方法和靜態(tài)變量
4、局部內(nèi)部類
局部內(nèi)部類是在一個方法內(nèi)部聲明的一個類
局部內(nèi)部類中可以訪問外部類的成員變量及方法
局部內(nèi)部咧中如果要訪問該內(nèi)部類所在方法中的局部變量，那么這個局部變量就必須是final修飾的
//局部內(nèi)部類 public void method(){class Inner{public void in(){}} }5、匿名內(nèi)部類
在這四種內(nèi)部類中，以后的工作可能遇到最多的是匿名內(nèi)部類，所以說匿名內(nèi)部類是最常見的一種內(nèi)部類。
什么是匿名對象？如果一個對象只要使用一次，那么我們就需要new Object().method()。就可以了，而不需要給這個實例保存到該類型變量中去。這就是匿名對象。
【匿名對象】
public class Test {public static void main(String[] args) {//沒有名字初始化類，不用講實例保存到變量中---new Apple().eat();} }class Apple{public void eat(){System.out.println("eat");} }匿名內(nèi)部類跟匿名對象是一個道理：
匿名對象：我只需要使用一次，那么我就不用聲明一個該類型類型變量來保存對象了，
匿名內(nèi)部類：我也只需要使用一次，那么我就不需要在類中先定義一個內(nèi)部類，而是等待需要用的時候，我就在臨時實現(xiàn)這個內(nèi)部類，因為用次數(shù)少，可能就這一次，那么這樣寫內(nèi)部類，更方便。不然先寫出一個內(nèi)部類的全部實現(xiàn)來，然后就調(diào)用它一次，豈不是用完之后就一直將其放在那，那就沒必要那樣。
- 如果依托的是類，那么創(chuàng)建出來的匿名內(nèi)部類就默認(rèn)是這個類的子類
- 如果依托的是接口，那么創(chuàng)建出來的匿名內(nèi)部類就默認(rèn)是這個接口的實現(xiàn)類。
- 匿名內(nèi)部類的聲明及創(chuàng)建對象必須一氣呵成。并且之后能反復(fù)使用，因為沒有名字。
總結(jié)
以上是生活随笔為你收集整理的JavaSE_kuang的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 空间数据与空间分析不确定性原理——学习笔
- 下一篇： java 区位码转中文_Java根据汉字