JavaSE基础知识
程序注釋
? 任何一套程序代碼里面實際上都會由大量的程序邏輯所組成，但是如果要想對一套代碼進行長期的維護，就需要編寫大量的注釋，對一些程序的代碼功能要進行詳細(xì)的解釋，這樣不僅為自己鋪平道路，實際上也為后來接手的工程師鋪平道路。
關(guān)于注釋的笑話：有一位程序員到一家新的公司進行項目開發(fā)，突然有一天老板說，某一個功能執(zhí)行的速度實在是太慢了，讓這位程序員修改一下，后來這個程序員找到了相關(guān)源代碼，里面寫上了一個注釋“后面的兄弟，悠著點，我在這里嗎讓代碼延遲了3秒，別一下子改的太快了，給后面的兄弟留點發(fā)揮空間”，于是這位工程師根據(jù)前輩的注釋進行了修改，將原始的延遲3秒，修改為了延遲2.5秒，速度變快了，老板給了獎金。
? 在Java程序里面針對于代碼的注釋一共提供了三種注釋形式：
-
? 單行注釋：“// 注釋內(nèi)容";（考慮到開發(fā)工具的代碼格式化問題）
-
? 多行注釋：“/*… 注釋內(nèi)容 … */";
-
? 文檔注釋：“/** … 文檔注釋的特定語法標(biāo)記進行注釋的編寫 …… */”，這種注釋往往可以結(jié)合開發(fā)工具使用
? 既然所有的注釋文字不會自己進行代碼的編譯處理，所以在實際項目開發(fā)之中可以將一些暫時不需要的代碼通過注釋的形式讓其失效，這種形式要比直接刪除代碼更高效。
public class YootkDemo{ // 【單行注釋】定義程序的執(zhí)行主類public static void main(String args[]){// 【單行注釋】程序的執(zhí)行起點，主方法/*【多行注釋】以下的程序代碼是在屏幕上進行一些提示信息的輸出，如果有需要則可以再里面進行多行的定義 */System.out.println("Hello world!"); // 【代碼失效】 System.out.println("江湖上稱我為"); } }在以后進行項目開發(fā)的時候，一些暫時不需要的代碼就可以利用注釋進行關(guān)閉。
標(biāo)識符
在任何一個程序里面都一定會有大量的名稱進行一些特定結(jié)構(gòu)的聲明，例如：在Java程序里面一直強調(diào)，每一個程序都是一個類，那么所有的類就一定要有類的名稱，這就是屬于一個標(biāo)識符，所有的程序編譯器都是依據(jù)這個名稱來進行代碼結(jié)構(gòu)管理的，既然要進行管理，對于名稱就有它的命名要求。
在java之中所有的標(biāo)識符由字母、數(shù)字、下劃線（_）以及“$”所組成的，其中不能使用數(shù)字開頭，不能夠使用java關(guān)鍵字（保留字）進行標(biāo)識符定義。 順便說一下：正常的標(biāo)識符里面一般都要求有具體的嚴(yán)格意義，例如：你在程序里面定義了a、b、c一系列的標(biāo)識符，那么這些意義不明確，所以代碼 閱讀起來是非常困難的。另外對于標(biāo)識符定義中的“$”也不要去直接使用，因為其有特殊的含義，所以一般來講標(biāo)識符的組成就是字母、下劃線、數(shù)字 所組成的，建議使用字母開頭。yootk_name,YootkDemo,teacherLee,num_110(正確形式)
110_No.1(使用數(shù)字開頭、并且使用了“.”作為了標(biāo)識符的組成)
abc#hello(使用了非法的“#”符號作為了標(biāo)識符)
class(使用了程序中的關(guān)鍵字（保留字），那么這種標(biāo)識符也是錯誤的。)
任何的編程語言里面都會提供有大量的關(guān)鍵字，這些關(guān)鍵字往往都具有特殊的含義，java中的關(guān)鍵字會隨著每次版本的更新而有所擴充。
很多的語言里面都有許多相同的關(guān)鍵字（java、C、++是一個系列的）：for,if,else,swich,while、……；
java有兩個未使用到的關(guān)鍵字：goto（代碼調(diào)試的萬惡之手）、const(定義常量，被final所取代)；
有三個特殊含義的標(biāo)記（嚴(yán)格來講不屬于關(guān)鍵字）：null、true、false；
JDK1.4之后更新了assert關(guān)鍵字，用于斷言操作；
JDK1.5之后擴充了enum關(guān)鍵字，用于進行枚舉定義；
JDK1.10之后擴充var關(guān)鍵字，用于進行匹配類型變量的定義；
JDK1.13之后擴充yield關(guān)鍵字，進行局部返回。
除了以上的標(biāo)識符定義要求之外，實際上java也考慮到中國的地位，也推出了一些比較神奇的做法，可以直接使用中文進行標(biāo)識符的定義。
范例：使用中文標(biāo)識符
public class 優(yōu)拓公開課{ // 【單行注釋】定義程序的執(zhí)行主類public static void main(String args[]){// 【單行注釋】程序的執(zhí)行起點，主方法/*【多行注釋】以下的程序代碼是在屏幕上進行一些提示信息的輸出，如果有需要則可以再里面進行多行的定義 */int 年齡 = 18;//中文定義System.out.println("Hello world!"); // 【代碼失效】 System.out.println("江湖上稱我為"); } }? 這種定義的形式可以作為娛樂，但是正常的開發(fā)者一般都不會采用這樣的形式來進行標(biāo)識符的定義，還應(yīng)該使用傳統(tǒng)的字母、數(shù)字之類的進行定義，除了標(biāo)識符的組成要求之外，在Java里面或者是在實際的工作之中還會有一些命名規(guī)范的出現(xiàn)，命名規(guī)范都要求遵循標(biāo)識符的組成原則，但是對于大小寫的定義是有描述的，例如：類名稱每個單詞的首字母大寫（例如：YootkDemo）,這些具體的描述可以根據(jù)不同的公司來動態(tài)調(diào)整。
數(shù)據(jù)類型
具體內(nèi)容
任何的程序設(shè)計語言本身就屬于一場數(shù)字的游戲，如果說我們的人生就是一部自我完善的堅史，那么編程語言既然是一種現(xiàn)實物理和數(shù)學(xué)的抽象，其背后就是數(shù)字的一場游戲（計算機的組成的核心本質(zhì)只有數(shù)字：“0”、“1”），那么既然要進行數(shù)字的操作，則需要進行數(shù)據(jù)的存儲，所以任何的編程語言里面都會設(shè)計有一系列的數(shù)據(jù)類型，利用不同的數(shù)據(jù)類型保存相應(yīng)的類型
例如：如果要是描述年齡，那么肯定要使用整數(shù)。如果要進行折扣處理的話，往往就希望這個小數(shù)點越小越好，所以就需要浮點型。所以任何一門完善的編程語言其數(shù)據(jù)類型的支持程序都是異常豐富的。
在java程序的內(nèi)部對于數(shù)據(jù)類型實際上分為兩大類型：
【分類】基本數(shù)據(jù)類型：所有的數(shù)據(jù)操作都是采用值傳遞，相當(dāng)于把數(shù)據(jù)給了對方一個副本信息，副本信息的修改不影響原始的數(shù)據(jù)內(nèi)容，這些基本數(shù)據(jù)類型也是構(gòu)成程序開發(fā)的基本環(huán)節(jié)；
|-【子分類】整型：byte、short、int、long; -->默認(rèn)值：0 |-【子分類】浮點型（有小數(shù)點=小數(shù)）：float、double; -->默認(rèn)值:0.0 |-【子分類】字符型：char; -->默認(rèn)值:'\u0000'(十六進制) |-【子分類】布爾型：boolean. -->默認(rèn)值:false(特殊意義的關(guān)鍵字)?
【分類】引用數(shù)據(jù)類型：是進行內(nèi)存的數(shù)據(jù)操作，給的內(nèi)存使用權(quán)。是所有初學(xué)者最難理解的部分；
|-有三種引用數(shù)據(jù)類型：數(shù)組、類、接口。 -->默認(rèn)值:null(特殊意義的關(guān)鍵字)提示：整個的Java編程語言之中由于對C、C++進行了結(jié)構(gòu)上的優(yōu)化(Java是基于C++開發(fā)出來的),在整個的C、C++里面最讓人頭疼的部分就是指針，而java為了解決這個問題，取消了指針的定義，而使用了更加簡單的引用數(shù)據(jù)類型來進行代替，在后面進行面向?qū)ο笾v解開始的時候?qū)σ脭?shù)據(jù)類型做出全面的分析在java開發(fā)過程之中，對于基本數(shù)據(jù)類型（最為核心的數(shù)據(jù)類型）默認(rèn)一共提供有八種類型，其中有7種類型是由明確的數(shù)據(jù)存儲范圍（計算機里面所有的數(shù)據(jù)內(nèi)容都是通過二進制的形式保存的，所有的數(shù)據(jù)都有一個保存的上限&下限）
-byte: 描述的是字節(jié)，在進行網(wǎng)絡(luò)數(shù)據(jù)傳輸一定是字節(jié)數(shù)據(jù)處理，也會用在編碼轉(zhuǎn)換上；（1字節(jié)） -int：描述的是整型，例如：定義年齡；（4字節(jié)） -long：描述的是長整型（范圍比int廣），用在進行文件大小描述、日期時間的描述上；（8個字節(jié)） -double：描述小數(shù)，例如：要進行工資的定義，則肯定是小數(shù)；（8個字節(jié)） -char：主要是進行中文處理；（2個字節(jié)） -*boolean*：進行邏輯表述。變量與常量
變量與常量是在整個程序計算過程之中主要使用的兩個數(shù)據(jù)的存儲形式，其中所有給定的不可能修改的內(nèi)容我們將其稱為常量，而所有可以修改的內(nèi)容就將其稱為變量。
范例：觀察變量
public class DongJun{ public static void main(String DongJun[]){//10是一個數(shù)字，既然已經(jīng)定義好了10，那么就意味著這個內(nèi)容無法修改了System.out.println(10); //常量 } }程序執(zhí)行結(jié)果:10
在上學(xué)的時候?qū)W校經(jīng)常會用一種方式去懲戒哪些所謂的“調(diào)皮的學(xué)生”，就是將你的行為和處分決定記錄在你的檔案里面，這些內(nèi)容將持續(xù)陪伴你，并且不會變更，那么就可以將這些記錄定義為你個人的常量
變量顧名思義就是內(nèi)容可以改變的標(biāo)記，所有的變量都一定要有其對應(yīng)的數(shù)據(jù)類型，例如:int,double都屬于數(shù)據(jù)類型，每一種變量可以根據(jù)其定義的數(shù)據(jù)類型進行內(nèi)容的修改。
如果要想使用變量則必須進行定義，而變量的定義語法形式為：“數(shù)據(jù)類型 變量名稱 = 默認(rèn)值”，而這個變量名稱實際上就是之前講解的標(biāo)識符的組成，相當(dāng)于你自己定義的有意義的名稱。
范例：定義變量
public class DongJun{ public static void main(String DongJun[]){//所有程序語言最后一定要使用;作為結(jié)尾int age = 10;//定義一個整型變量，并且設(shè)置了默認(rèn)值System.out.println(age); //輸出變量內(nèi)容age = 19; //賦值System.out.println(age); //輸出變量內(nèi)容 } }程序執(zhí)行結(jié)果： 18
19
按照正常的設(shè)計來講每一種數(shù)據(jù)類型即便不設(shè)置默認(rèn)值，那么也應(yīng)該使用其對應(yīng)數(shù)據(jù)類型的默認(rèn)值進行定義，但是如果你的代碼寫成如下的形式，則執(zhí)行的時候一定是錯誤的
public class DongJun{ public static void main(String DongJun[]){int age ;//如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示System.out.println(age);}}D:\yootk>javac DongJun.java
DongJun.java:4: 錯誤: 可能尚未初始化變量age
System.out.println(age);
本次主要是觀察變量聲明和賦值在不同的JDk版本里面所帶來的流程上的區(qū)別。
范例：在JDK1.4及以前的版本
要求在主方法中定義變量的同事一定要為其設(shè)置默認(rèn)值，如果不設(shè)置就出錯；
范例：在JDK1.5及以及以后
在主方法中定義變量的時候可以不設(shè)置默認(rèn)值，但是在其使用之前一定要進行默認(rèn)值設(shè)置，否則會出現(xiàn)編譯錯誤
如果把常量比喻為不同的咖啡：美式、拿鐵、卡布奇諾，這些調(diào)制好了的東西一般是不會發(fā)生改變的，而如果是變量那么就好比是你的咖啡杯，咖啡杯可以裝不同咖啡，但是當(dāng)你需要更換咖啡的時候，那么就意味著你原始的咖啡就沒了，而盛的咖啡就是新的。
整型
在現(xiàn)實的生活里面數(shù)學(xué)上一般都會存在有整數(shù)的概念，整數(shù)實際上描述就是沒有小數(shù)點的內(nèi)容，是一個完整的十進制的數(shù)值。
例如：如果要想表示一個人的年齡肯定要使用整數(shù)，如果要想去描述住房樓層肯定也使用整數(shù)，在Java程序里面，對于整數(shù)的數(shù)據(jù)類型一共有四種支持：Byte、short、int、long。
在給定的這四種整型數(shù)據(jù)類型里面，最為常用的數(shù)據(jù)類型就是Int型，在java程序之中任何的一個整型數(shù)字的常量默認(rèn)對應(yīng)的類型全部都是整型。
定義int變量
程序執(zhí)行結(jié)果：30
雖然int 可以解決大部分的整型的數(shù)據(jù)操作問題，但是從另外的角度來講，對于當(dāng)前程序開發(fā)來說，int本身是由其長度范圍(-2147483648-2147483647),那么如果說超過了這個計算范圍，則就有可能出錯。
public class DongJun{ static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示 public static void main(String DongJun[]){//數(shù)據(jù)類型 變量名稱 = 常量、整數(shù)常量的默認(rèn)類型為 intint max = 2147483647; //定義一個整型變量// int變量-= int變量數(shù)值 + 20 常量（int類型）max = max + 1; // 進行變量的加法計算System.out.println(max); } }程序執(zhí)行結(jié)果-2147483648
這里面就存在了計算機之中的基本概念：二進制的數(shù)據(jù)計算問題了。在程序之中所有的數(shù)據(jù)都是被二進制的操作進行管理的，但是由于Java編程語言屬于高級編程語言，所以對于一些底層的細(xì)節(jié)就由編程語言自己來處理。
專業(yè)描述：Java之中int數(shù)據(jù)類型一共有32位，第一位屬于符號位，其余的位數(shù)屬于數(shù)據(jù)位。每一次進行所謂的加或減的時候?qū)嶋H上都是在底層進行了二進制數(shù)據(jù)計算，當(dāng)已經(jīng)最大值的似乎還“011111”，如果再進行加1的處理，符號位就會發(fā)生改變，所以就變?yōu)榱俗钚≈怠?對于以上的問題在程序開發(fā)之中可以理解為數(shù)據(jù)的溢出，數(shù)據(jù)溢出采用的是一種循環(huán)的模式進行處理的。
如果要想解決這種數(shù)據(jù)溢出的問題，那么最佳的做法就是擴大使用的數(shù)據(jù)范圍，比int范圍更大的數(shù)據(jù)范圍就是long，所有的編程語言里面對于數(shù)據(jù)范圍的擴大都使用自動的擴大的形式，例如：如果現(xiàn)在是一個int型變量和一個long型變量進行加法操作，那么必定要先進行數(shù)據(jù)類型的統(tǒng)一，而這種統(tǒng)一的操作過程就是將int類型自動轉(zhuǎn)為long的類型。從而形成最終的兩個long型變量的計算操作。
范例：通過long數(shù)據(jù)類型解決int的溢出問題
程序執(zhí)行結(jié)果2147483648
由于默認(rèn)的整數(shù)對應(yīng)的類型為int,所以如果要想將其變?yōu)閘ong的常量則可以使用“整數(shù)L”、“整數(shù)l”（“小寫L”比較坑）因為其長的和1很相似（如果你沒有受過一定的訓(xùn)練是看不出的）
結(jié)論：如果要想解決數(shù)據(jù)溢出問題，肯定要使用更大的數(shù)據(jù)類型來進行處理。
這個時候就會出現(xiàn)一個新的概念：數(shù)據(jù)類型的轉(zhuǎn)換，不同的數(shù)據(jù)類型之間是可以進行轉(zhuǎn)換的，但是在進行轉(zhuǎn)換的處理過程之中一般都會使用如下的兩個轉(zhuǎn)換原則。
自動類型轉(zhuǎn)換：保存數(shù)據(jù)范圍小的數(shù)據(jù)類型如果遇見了保存范圍數(shù)據(jù)大的數(shù)據(jù)類型，則范圍小的數(shù)據(jù)類型自動轉(zhuǎn)換為范圍大的數(shù)據(jù)類型后再進行計算，之前的程序就屬于這種自動轉(zhuǎn)換。
范例：數(shù)據(jù)類型的自動轉(zhuǎn)換
public class DongJun{ static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示public static void main(String DongJun[]){//數(shù)據(jù)類型 變量名稱 = 常量、整數(shù)常量的默認(rèn)類型為 intint num_a = 10 ;long num_b = 20;//num_a這個int變量由于其數(shù)據(jù)類型的位數(shù)不足，所以將自己轉(zhuǎn)換為long類型后在于num_b進行加法計算lonmg result = num_a + num_b;System.out.println(result);}}?
強制類型轉(zhuǎn)換:將保存數(shù)據(jù)范圍大的數(shù)據(jù)類型強制的變?yōu)楸４鏀?shù)據(jù)范圍小的數(shù)據(jù)類型，這種轉(zhuǎn)換由于需要縮小數(shù)據(jù)類型的保存位數(shù)，所以就有可能產(chǎn)生數(shù)據(jù)溢出問（數(shù)據(jù)出錯）
范例：數(shù)據(jù)類型的強制轉(zhuǎn)換
public class DongJun{ static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示public static void main(String DongJun[]){//數(shù)據(jù)類型 變量名稱 = 常量、整數(shù)常量的默認(rèn)類型為 int//此時必須強制性的將整型常量轉(zhuǎn)為long類型才可以正常保存在long變量之中l(wèi)ong num = 2147483677L; //該類型已經(jīng)超過了int的最大內(nèi)容System.out.println(num);System.out.println((int)num);}}2147483677
-2147483619
*所以這種數(shù)據(jù)范圍的強制轉(zhuǎn)型所帶來的最為嚴(yán)重的問題就是有可能會有數(shù)據(jù)的溢出情況出現(xiàn)，所以如果你非要進行強制性類型轉(zhuǎn)型，那么一定要注意其最終的目標(biāo)數(shù)據(jù)類型是否可以包含下當(dāng)前的數(shù)據(jù)內(nèi)容。
通過以上的分析實際上就可以得到一個最為重要的結(jié)論：在進行不同數(shù)據(jù)類型操作的過程之中，一定會首發(fā)發(fā)送自動的擴大類型的轉(zhuǎn)型操作，而后再進行計算，但是一般不建議使用強制的類型轉(zhuǎn)換，因為有可能會有數(shù)據(jù)溢出的問題。
既然有了整型的概念，就必須重點分析一下byte數(shù)據(jù)類型問題
回顧：針對于不同數(shù)據(jù)類型的使用byte：主要用于網(wǎng)絡(luò)傳輸、二進制數(shù)據(jù)處理、編碼轉(zhuǎn)換（在講解IO和網(wǎng)絡(luò)編程會使用到）int：描述大部分的整型數(shù)值，以后見到整型的需求首先考慮就是int型變量或常量；long：主要描述文件大小或者是日期時間的數(shù)字（以后講解到類庫的時候會進行說明）byte描述的是一個字節(jié)，java程序開發(fā)之中的每一個字節(jié)所能描述的數(shù)據(jù)范圍:"-128-127"，就需要注意其不能夠存儲更大的數(shù)據(jù)信息。
范例：定義byte變量
public class DongJun{ static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示 public static void main(String DongJun[]){byte data = 10 ; //定義一個byte變量System.out.println(data); } }10
以上的程序?qū)崿F(xiàn)了最為基礎(chǔ)的byte變量的定義以及內(nèi)容的輸出，但是在整個的程序執(zhí)行過程之中會有一個小小的問題出現(xiàn)了：按照之前的概念來講，此時的數(shù)字10應(yīng)該是一個int型的常量，那么按照以上操作來講應(yīng)該是int型的常量賦值給了byte型的變量，出現(xiàn)了一個與之前概念不匹配的應(yīng)用環(huán)境，之所以沒有這種強制的轉(zhuǎn)換需求，主要的原因在于：Java針對于符合byte范圍內(nèi)，那么就必須進行強制轉(zhuǎn)換處理。
范例：超過byte范圍強制處理
public class DongJun{
static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示
public static void main(String DongJun[]){
byte data = (byte)250 ; //定義一個byte變量
System.out.println(data);
}
}
-6
此時由于設(shè)置的整型內(nèi)容超過了byte范圍，所以一旦強制性轉(zhuǎn)換之后就產(chǎn)生了數(shù)據(jù)的溢出問題；
浮點型
浮點型最大的特點就是在數(shù)字里面包含有小數(shù)點，在Java程序里面針對于浮點型數(shù)據(jù)類型提供了兩個關(guān)鍵字：
- 單精度浮點數(shù)據(jù)類型：float,包含32位的數(shù)據(jù)長度 - 雙精度浮點數(shù)據(jù)類型：double,包含64位的數(shù)據(jù)長度 在Java里面，任何的一個小數(shù)其默認(rèn)的數(shù)據(jù)類型均為double(double可以保存全宇宙里面最大的一個數(shù)值)，double是整個是所有數(shù)據(jù)類型之中可以保存數(shù)據(jù)內(nèi)容最大的一種類型。范例：定義double變量
public class DongJun{ static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示public static void main(String DongJun[]){//double 變量 = 常量 (double變量)double num_a = 99.89 ; //定義double變量int num_b = 199; //double變量（num_a） + double變量(num_b，int自動轉(zhuǎn)為double) = double結(jié)果double result = num_a + num_b ; System.out.println(result);}}>298.89java之所以沒有使用float作為小數(shù)的默認(rèn)類型，主要是考慮到float計算本身存在的二進制位的操作問題（會產(chǎn)生精度問題），這個問題是整個計算機編程語言行業(yè)之中最大的問題（娘胎帶的問題了）,所以在java里面如果要想定義float變量，就必須將小數(shù)的常量進行強制的類型轉(zhuǎn)換才可以正常進行。
范例：定義float型變量
public class DongJun{ static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示public static void main(String DongJun[]){float num_a = 10.0F ; //將double常量強制轉(zhuǎn)換為float變量float num_b = (float) 0.4; //將double常量強制轉(zhuǎn)換為float變量System.out.println(num_a/num_b);?
?
范例：觀察float可能存在的問題
public class DongJun{ static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示public static void main(String DongJun[]){float num_a = 9.9F ; //將double常量強制轉(zhuǎn)換為float變量float num_b = (float) 0.3; //將double常量強制轉(zhuǎn)換為float變量System.out.println(num_a/num_b);?
?
32.999996(會出現(xiàn)許多小數(shù))
float數(shù)據(jù)類型本身是有問題的，而正因為這些問題的存在，所以不建議使用float這種數(shù)據(jù)類型進行浮點數(shù)定義，最好使用double。
范例：通過double可以解決float的問題
public class DongJun{ static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示public static void main(String DongJun[]){double num_a = 9.9 ; //將double常量強制轉(zhuǎn)換為float變量double num_b = 0.3; //將double常量強制轉(zhuǎn)換為float變量System.out.println(num_a/num_b);?
?
33.0
在以后的項目開發(fā)過程之中肯定要首選double作為小數(shù)的數(shù)據(jù)類型。
在項目的開發(fā)之中整型和浮點型之間最大的區(qū)別就是小數(shù)點，也就是所有的整型數(shù)據(jù)內(nèi)容是不會保留小數(shù)位的，那么如果說現(xiàn)在計算的數(shù)據(jù)本身會產(chǎn)生小數(shù)位，則如果沒有使用浮點型而使用整型，對應(yīng)的小數(shù)位會全部丟棄。(如果要想準(zhǔn)確，那么就必須采用小數(shù)來進行計算，需要將其中的一個計算的內(nèi)容變成double)
范例：解決小數(shù)點的保留問題
public class DongJun{ static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示public static void main(String DongJun[]){int num_a = 9 ;int num_b = 2 ; System.out.println(num_a/(double)num_b);} }4.5
如果在計算之中某一個類型變?yōu)榱薲ouble，則其他的類型都要變?yōu)閐ouble（double范圍是最廣的），這個時候當(dāng)前的計算結(jié)果一定是double類型。
通過以上的分析，應(yīng)該就已經(jīng)非常清楚了這些數(shù)值型的數(shù)據(jù)類型的自動轉(zhuǎn)換操作過程：byte>short>int>long>float>double(保存范圍小的自動進行轉(zhuǎn)換),而在進行強制類型轉(zhuǎn)換的時候，如果浮點型強制變?yōu)榱苏?#xff0c;那么就會丟掉小數(shù)點。在未來選擇數(shù)值型數(shù)字類型的時候，整型就使用int,浮點型（小數(shù)）就使用double
字符型
在java程序里面，依然提供有傳統(tǒng)編程語言使用的字符的概念，字符是使用“’”聲明的一個內(nèi)容，字符提供有char關(guān)鍵字來進行類型的定義。
范例：字符的定義
public class DongJun{ static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示public static void main(String DongJun[]){char c= 'y';//字符需要使用單引號進行聲明System.out.println(c);} }y
在使用字符進行初始化內(nèi)容賦值的時候后，一定只能夠設(shè)置一位內(nèi)容，如果設(shè)置了多位，語法一定會出錯。
在程序之中字符（char）可以和整型（int）直接進行轉(zhuǎn)化處理，而字符轉(zhuǎn)換為整型之后得到的數(shù)值就屬于字符的編碼。
那么既然所有的字符在JVM里面都有相應(yīng)的編碼存在，這樣一來就必須非常清楚幾個常見的字符范圍的定義：
小寫字符范圍（'a'~'z'）:97~122; 大寫字符范圍（'A'~'Z'）:65~90; 數(shù)字字符范圍（'0'~'9'）:48~57于是這個時候有人發(fā)現(xiàn)一個問題：大寫字符和小寫字母之間的編碼的數(shù)值內(nèi)容差32個，所以理論上修改數(shù)值就可以進行大小寫的控制，下面市縣一個小寫字母轉(zhuǎn)大寫字母的操作。
范例：小寫字母轉(zhuǎn)為大寫字母
public class DongJun{ static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示public static void main(String DongJun[]){char c= 'a'-32;//字符需要使用單引號進行聲明System.out.println(c);}}A
通過以上的分析實際上是許多的讀者就應(yīng)該發(fā)現(xiàn)一個比較熟悉的昌吉了，這個場景的內(nèi)容就是常規(guī)的編程語言里面所出現(xiàn)ASCII碼的內(nèi)容（在整個計算機內(nèi)部核心的組成就是"0",“1”），但是需要描述的內(nèi)容太多了，所以就需要對這些數(shù)值進行合理的安排，就可以基于不同的內(nèi)容實現(xiàn)相應(yīng)字符的顯示
需要提醒讀者的是，在使用java開發(fā)的時候后，所采用的并不是這種ASCII碼，JAVA在其設(shè)計的時候已經(jīng)充分的考慮了當(dāng)前的開發(fā)市場（C、C++為主時代）所有的開發(fā)者都已經(jīng)習(xí)慣于這樣的編碼順序，那么在進行java編碼的設(shè)計的時候就將傳統(tǒng)的ASCII碼包含在當(dāng)前語言設(shè)計的編碼當(dāng)中，開發(fā)了屬于JAVA自己的十六進制編碼，該編碼的名稱為“UNICODE”。UNICODE是一個非常強大的編碼，可以描述出世界上任意的文字，包括中文、日文等。范例：通過char保存中文
public class DongJun{ static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示public static void main(String DongJun[]){char c= '俊';//傳統(tǒng)的ASCII碼是不包含中文定義的int num = c;System.out.println(num);} }20426（這個數(shù)值已經(jīng)遠(yuǎn)遠(yuǎn)超過了byte可能描述的數(shù)據(jù)范圍）
UNICODE描述了一個更廣闊的編碼范圍，其中也很好的支持有傳統(tǒng)的AsCII編碼，讓所有的開發(fā)者在使用上不會產(chǎn)生任何的不適應(yīng)感。由于字符可以保存中文，所以在日后進行網(wǎng)絡(luò)數(shù)據(jù)傳輸?shù)臅r候，如果要進行中文數(shù)據(jù)的處理，建議使用的就是char來進行操作。
布爾型
布爾型是一種描述處理結(jié)果的邏輯內(nèi)容，對于計算機的世界來講除了真就是假，沒有中間的過渡環(huán)節(jié)，布爾在java編程語言里面使用boolean關(guān)鍵字來進行定義，而布爾的取值只有兩個內(nèi)容：True、False（這兩個在java中都屬于有特殊含義的關(guān)鍵字）
如果要想使用布爾類型進行程序的開發(fā)，往往都需要結(jié)合一些分支語句的結(jié)果進行使用
范例：使用布爾型
public class DongJun{ static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示public static void main(String DongJun[]){boolean flag = true;if(flag){System.out.println("1");}} }** 如果此時設(shè)置flag的內(nèi)容為false，那么對于當(dāng)前的if判斷就不會成立。既然已經(jīng)談到布爾數(shù)據(jù)類型就必須對一個語言的區(qū)別進行一些描述。**
如果你使用的是C、C++編程開發(fā)，在這樣的編程語言里面基本上強調(diào)都是通過數(shù)字0來描述FALSE，而通過一個非0的數(shù)字來描述TRUE，通過這樣的數(shù)值來描述布爾值，但是在JAVA之中并不存在于這樣的概念。
String 字符串
在任何一門語言里面實際上字符串都屬于一種比較特殊的類型，而JAVA之中字符串也屬于非常特殊的一種數(shù)據(jù)形式，它不是基本數(shù)據(jù)類型，而它屬于一種引用數(shù)據(jù)類型，因為字符串的類型要使用“String”聲明，而在JAVA編寫程序代碼的過程之中已經(jīng)明確強調(diào)了：首字母大寫的一定是類，所以String是一個系統(tǒng)類（這個系統(tǒng)類的設(shè)計是非常繁瑣的，后面會有專門的內(nèi)容進行全面分析），本次先來觀察一下String的基本使用
在程序里面如果要想描述單個字符肯定要使用char類型（通過“’”聲明），但是如果要想描述一組的字符，就可以通過字符串的形式來處理。
范例：定義字符串
public class DongJun{ static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示public static void main(String DongJun[]){String message = "董俊";System.out.println(message);} }董俊
** 需要注意的是，每一個字符串實際上都可以進行內(nèi)容的連接，而內(nèi)容的連接，可以通過“+”來實現(xiàn)（不是數(shù)字的加法而表述的是一個連接操作）**
范例：字符串連接操作
public class DongJun{
static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示
public static void main(String DongJun[]){
String message = “姓名：”;
message = “我的” + message ;
System.out.println(message+“董俊”);
既然在字符串之中“+”屬于連接的操作形式，所以這個時候就會存在有另外一個問題：如果現(xiàn)在直接與其他基本數(shù)據(jù)類型進行連接又會如何呢？
范例：觀察基本數(shù)據(jù)類型與字符串的連接
public class DongJun{ static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示public static void main(String DongJun[]){String prompt = "數(shù)據(jù)輸出";System.out.println(prompt + 1);System.out.println(prompt + 1.1);System.out.println(prompt + 'Y');System.out.println(prompt + true);} }數(shù)據(jù)輸出1
數(shù)據(jù)輸出1.1
數(shù)據(jù)輸出Y（字符并沒有變?yōu)閿?shù)字，而是直接使用了原始的字符內(nèi)容）
數(shù)據(jù)輸出true
以上僅僅是連接了一些基本數(shù)據(jù)型常量，那么如果說現(xiàn)在連接的是一些基本的計算表達(dá)式，那么請繼續(xù)觀察程序問題。
范例：觀察計算表達(dá)式問題
public class DongJun{ static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示public static void main(String DongJun[]){double num_a = 9.5 ;int num_b = 3 ;System.out.println("數(shù)學(xué)計算:"+num_a + num_b);} }數(shù)學(xué)計算：9.53（字符串連接）
public class DongJun{ static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示public static void main(String DongJun[]){double num_a = 9.5 ;int num_b = 3 ;System.out.println("數(shù)學(xué)計算:"+(num_a + num_b));} }數(shù)學(xué)計算:12.5（先數(shù)學(xué)計算再連接）
** 之所以此時要強調(diào)這種問題的關(guān)鍵在于，在進行字符串處理的時候“+”和數(shù)學(xué)計算的“+”會有那么一些麻煩的表述，當(dāng)java任何的數(shù)據(jù)類型與字符串進行連接的似乎還，所有的數(shù)據(jù)類型會首先變?yōu)樽址?#xff0c;按照此時的代碼，首先執(zhí)行的是“字符串+double變量”，自動轉(zhuǎn)為String的字符串，而后這個字符串再通過“+”連接一個整型，這個時候的整型也會自動轉(zhuǎn)為字符串，所以最終的計算就稱為了一個字符串的連接操作，而加上了括號之后表示要先計算括號內(nèi)部的數(shù)據(jù)加法（double類型），最后再與字符串進行連接操作（double自動轉(zhuǎn)為了String）但是這些操作僅僅是發(fā)生在包含有“+”的概念上，如果使用的是其他的運算，例如使用的是“-”，那么該程序在編譯的時候就會出錯**
另外需要提醒大家的是，在進行字符串定義的時候本身如果包含有一些特殊的內(nèi)容肯定是無法直接定義的，所以在這樣的情況下要想描述一些特殊標(biāo)記的符號就要使用轉(zhuǎn)義字符，常見的轉(zhuǎn)義字符為：雙引號（"、“\"”）、單引號（'、“\'”）、換行符(“\n”)、制表符（“\t”）。范例：觀察轉(zhuǎn)義字符
public class DongJun{ static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示public static void main(String DongJun[]){String message = "董俊\"\n\\\t我的填";System.out.println(message);} }這些轉(zhuǎn)義字符也就在基礎(chǔ)學(xué)習(xí)的過程之中有些作用，主要可以讓內(nèi)容的輸出更加好看一些，但是如果在實際上的開發(fā)里面用處不是特別大
var關(guān)鍵字
Java 本身屬于一門靜態(tài)變成語言，在進行各個變量定義的時候就必須明確的聲明變量的類型以及變量的具體內(nèi)容（JDK1.5之后的版本要求是在使用之前復(fù)制），但是隨著當(dāng)今時代編程語言的技術(shù)發(fā)展，對于編程語言的要求也開始變得更多，所以這個時候很多的語言就退出了一個所謂的推斷式變量定義，后來java在JDK1.10版本之中正式引入了此機制，所以提供了一個新的var關(guān)鍵字，這個關(guān)鍵字主要用于進行變量的定義，并且會根據(jù)所賦予的內(nèi)容進行自動類型的配置。范例：觀察var關(guān)鍵字的使用
public class DongJun{ static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示public static void main(String DongJun[]){var num_a = 10.2 ;//將自動推斷num_a類型為doublevar num_b = 3 ;//將自動推斷num_b類型為intSystem.out.println(num_a - num_b);} }7.199999999999999(這種精度問題可以忽略)
public class DongJun{ static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示 public static void main(String DongJun[]){var num_a = 10.2 ;//將自動推斷num_a類型為doublevar num_b = 3 ;//將自動推斷num_b類型為intSystem.out.println(((Object)num_b).getClass());//class java.lang.IntegerSystem.out.println(((Object)num_a).getClass());//class java.lang.Double} }** 在使用var關(guān)鍵字的時候除了可以為其賦值為基本數(shù)據(jù)類型之外，也可以設(shè)置字符串變量。**
范例：定義字符串變量
public class DongJun{ static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示public static void main(String DongJun[]){var message = "董俊";System.out.println(message);} }董俊
** 于是這個時候就有人提出疑問了，按照現(xiàn)在的做法，感覺所有的變量都使用var定義實際上減少了我們對于關(guān)鍵字的記憶需求，為什么你又在這邊強調(diào)不要去使用它呢？**
個人總結(jié)兩個缺點：缺點一：像傳統(tǒng)C、C++、Java這樣編程語言對于數(shù)據(jù)類型都是有非常嚴(yán)格的要求，所以其對應(yīng)的數(shù)據(jù)類型如果寫的非常明確，那么就適合于程序的編寫與調(diào)試，而如果使用var直接定義，那么類型不明確，于是世界上有一種變量的聲明格式采用的是加入數(shù)據(jù)類型的模式完成例如：“var double_num_a = 10.2;”缺點二：其他語言的var是真正的動態(tài)類型（隨時可以改變變量所保存的數(shù)類型的），而Java之中只是提供了一個var樣子而已（一旦定義了變量，并且已經(jīng)推斷出了類型之后，那么該變量所保存的類型不允許改變）。范例：錯誤的var操作
public class DongJun{ static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示public static void main(String DongJun[]){var num = 10.2;num = "www.yootk.com";?
? }
? }
DongJun.java:5: 錯誤: 不兼容的類型: String無法轉(zhuǎn)換為double
num = “www.yootk.com”;
^
1 個錯誤
錯誤: 編譯失敗
綜合以上的結(jié)論來講，var關(guān)鍵字這種所謂的數(shù)據(jù)類型推斷于實際的開發(fā)意義確實不是很大，這種操作盡量慎用
運算符
編程語言的本質(zhì)是在于數(shù)學(xué)的計算（包括整個計算機的組成都是依據(jù)數(shù)學(xué)公式“馮諾依曼”），如果我們現(xiàn)在的程序開發(fā)使用的還是低級語言（匯編語言），那么所有的開發(fā)者就必須進行大量的細(xì)節(jié)處理，計算機的基本組成為二進制的數(shù)據(jù)，所以對于正數(shù)、負(fù)數(shù)、小數(shù)都需要進行各種二進制的計算轉(zhuǎn)換，才可以通過計算機進行處理，但是如果所有的開發(fā)代碼都還保持著這些低級語言的開發(fā)環(huán)境，那么對于技術(shù)的發(fā)展是非常不利的。放低思維：在國內(nèi)的互聯(lián)網(wǎng)的歷史上，百度肯定是作為一家搜索引擎的公司出現(xiàn)的，他自己有自己的開發(fā)技術(shù)，但是在早期的互聯(lián)網(wǎng)時代之中，實際上為了便于上網(wǎng)出現(xiàn)了所謂的導(dǎo)航網(wǎng)站（早期的Yahoo）。
在國內(nèi)的“hao123.com”，本身沒有任何的技術(shù)難度，所以在這樣的情況下，許多的初級網(wǎng)民就覺得非常好用，于是最終2000W賣給了百度.
-
如果所有的程序中的數(shù)學(xué)計算都要求每一位開發(fā)者進行所有底層的處理轉(zhuǎn)換，那么計算機的發(fā)展肯定無法前進，那么作為高級編程語言（C、C++、JAVA、Python等），就必須讀這些數(shù)學(xué)計算進行一系列的簡化處理，所以才提出了所謂的運算符的概念，通過各種運算符以及編譯操作過程就可以簡化所有的計算處理。*
通過之前的學(xué)習(xí)實際上以及接觸了兩類運算符：
|-賦值運算符：變量 = 內(nèi)容（數(shù)據(jù)）、 變量 = 其他變量；
|-數(shù)學(xué)運算符：+、-、*、/;
而除了以上可以見到的運算符之外，在Java程序之中依然還包括有許多的運算符，那么這些運算符基本的使用過程實際上和正常生活的數(shù)學(xué)邏輯是非常貼近的。
** 重要的運算符：四則運算、邏輯運算（大小關(guān)系）、三目運算、自增或自減運算，除了這些基本的運算符之外，實際上所有的運算符都有其運算優(yōu)先級（先乘除后加減）**
高手的編程
public class DongJun{ static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示public static void main(String DongJun[]){int a = 10;int b = 20;int result = a++ - b++ * a - b-- / ++b * ++a;System.out.println(result);} }-222(不要問為什么)
在你以后的開發(fā)生涯之中，如果你真的寫出了這樣代碼，接手你代碼的后續(xù)的開發(fā)者一定會跑路。隨著開發(fā)產(chǎn)業(yè)的不斷發(fā)展，那么所謂的優(yōu)秀的代碼大部分都會有一種固定的特征：“全部編寫簡單按程序”，所有的代碼可以像“1+1= 2”那樣簡單。數(shù)學(xué)運算符
數(shù)學(xué)運算符是整個運算符之中最接近于原生生活的一種運算符，利用數(shù)學(xué)運算符可以方便的實現(xiàn)四則運算（加、減、乘、除、模），除了標(biāo)配的運算符之外還提供有簡化運算符。模（MOD）：在實際的項目開發(fā)過程里面，求模的意義可以實現(xiàn)數(shù)的批量控制，例如：每20個人站為一組范例：通過求模的方式進行批量處理
public class DongJun{ static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示public static void main(String DongJun[]){// 此時的變量的定義規(guī)則為：第一個單詞的字母全部小寫，隨后每一個單子的首字母大寫//Java中類的定義規(guī)則：每一個單詞的首字母必須大寫int currentNumber = 20 ; //定義變量int result = currentNumber % 20; // 如果先currentNuumber不是20，則模的結(jié)果一定不是0System.out.println("運算結(jié)果："+result);} }運算結(jié)果： 0
對于求模的操作可能比較接近于當(dāng)前基礎(chǔ)環(huán)境的就只有一個常用的功能了：判斷奇偶數(shù)（奇數(shù)模2為1，偶數(shù)模2為0）實現(xiàn)奇偶數(shù)判斷
public class DongJun{
static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示
public static void main(String DongJun[]){
// 此時的變量的定義規(guī)則為：第一個單詞的字母全部小寫，隨后每一個單子的首字母大寫
//Java中類的定義規(guī)則：每一個單詞的首字母必須大寫
int number = 3; // 定義變量
int result = number % 2 ;
System.out.println(“運算結(jié)果：”+result);
}
}
運算結(jié)果：1（現(xiàn)在判斷的數(shù)字是一個奇數(shù)）
范例：簡化運算符
public class DongJun{ static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示public static void main(String DongJun[]){// 此時的變量的定義規(guī)則為：第一個單詞的字母全部小寫，隨后每一個單子的首字母大寫//Java中類的定義規(guī)則：每一個單詞的首字母必須大寫int numberA = 33; // 定義變量int numberB = 33; // 定義變量int numberC = 33; // 定義變量int numberD = 33; // 定義變量int numberE = 33; // 定義變量numberA += 5;numberB -= 5;numberC *= 5;numberD /= 5;numberE %= 5;System.out.println("運算結(jié)果A："+numberA);System.out.println("運算結(jié)果B："+numberB);System.out.println("運算結(jié)果C："+numberC);System.out.println("運算結(jié)果D："+numberD);System.out.println("運算結(jié)果E："+numberE);} }運算結(jié)果A：38
運算結(jié)果B：28
運算結(jié)果C：165
運算結(jié)果D：6
運算結(jié)果E：3
自增與自減運算符
在Java運算符里面針對于數(shù)學(xué)運算提供有“++”（自增運算，每一次調(diào)用內(nèi)容都會“+1”處理）、“--”（自減運算，每一次調(diào)用內(nèi)容都會“-1”處理），那么首先先來觀察一下這兩個運算符的基本使用。范例：使用自增
public class DongJun{ static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示public static void main(String DongJun[]){// 此時的變量的定義規(guī)則為：第一個單詞的字母全部小寫，隨后每一個單子的首字母大寫//Java中類的定義規(guī)則：每一個單詞的首字母必須大寫int num = 10 ; System.out.println("原始num變量內(nèi)容:" + num);num++;//num+ = 1，但是性能要更高System.out.println("自增后num變量內(nèi)容:" + num);}}原始num變量內(nèi)容:10
自增后num變量內(nèi)容:11
** 當(dāng)執(zhí)行了自增操作之后，原始內(nèi)容會增加1**
以上見到的自增是我們在實際開發(fā)中最為推薦的操作方法，但是對于當(dāng)前自增或者是自減運算又會根據(jù)位置的不同而有所不同，主要是發(fā)生在執(zhí)行順序上。
public class DongJun{
static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示
public static void main(String DongJun[]){
// 此時的變量的定義規(guī)則為：第一個單詞的字母全部小寫，隨后每一個單子的首字母大寫
//Java中類的定義規(guī)則：每一個單詞的首字母必須大寫
int numA = 10;
int numB = 5;
int result = numA + numB++;
System.out.println(“計算結(jié)果:” + result);
System.out.println(“numA=” + numA + “、numB=”+ numB);
}
}
計算結(jié)果:15
numA=10、numB=6
以上就實現(xiàn)了自增和自減
關(guān)系運算符
在程序設(shè)計之中對于數(shù)據(jù)的關(guān)系基本上就是：>, <, >=, <=, （不等于）!=, （等于）== 這些關(guān)系運算符可以直接應(yīng)用在數(shù)值的描述上（字符本身也是可以與整數(shù)進行自動轉(zhuǎn)換，所以字符上也可以使用。）范例：比較兩個數(shù)字的大小關(guān)系
public class DongJun{ static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示public static void main(String DongJun[]){// 此時的變量的定義規(guī)則為：第一個單詞的字母全部小寫，隨后每一個單子的首字母大寫//Java中類的定義規(guī)則：每一個單詞的首字母必須大寫int zsAge = 10 ;int lsAge = 20 ;boolean result = zsAge > lsAge;System.out.println(result);} }False
所有的關(guān)系運算符計算完成之后的數(shù)據(jù)類型是布爾類型（它的取值范圍（True、False））
范例：實現(xiàn)浮點型數(shù)據(jù)比較
public class DongJun{ static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示public static void main(String DongJun[]){// 此時的變量的定義規(guī)則為：第一個單詞的字母全部小寫，隨后每一個單子的首字母大寫//Java中類的定義規(guī)則：每一個單詞的首字母必須大寫int zsAge = 10 ;int lsAge = 20 ;boolean result = zsAge > lsAge;System.out.println(result);} }true
** 直接利用數(shù)值的比較是在進行關(guān)系運算符處理過程之中最為常見的數(shù)據(jù)類型，但是千萬不要忘記了，由于java程序本身使用了十六進制的UNICODE編碼，所以所有的字符內(nèi)容都可以轉(zhuǎn)為十進制數(shù)字。**
范例：字符和整數(shù)進行比較
public class DongJun{ static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示public static void main(String DongJun[]){// 此時的變量的定義規(guī)則為：第一個單詞的字母全部小寫，隨后每一個單子的首字母大寫//Java中類的定義規(guī)則：每一個單詞的首字母必須大寫char name = '董';//中文都是有編碼System.out.println(name == 33891);} }true
不同的數(shù)據(jù)類型彼此發(fā)生數(shù)據(jù)大小比較之后一定要發(fā)生轉(zhuǎn)型問題，如果轉(zhuǎn)型失敗（這種明面上的數(shù)據(jù)類型，如果真有轉(zhuǎn)型失敗的問題，那么編譯器會直接告訴使用者可能出現(xiàn)的語法錯誤）那么一定無法進行比較，所以本次字符一定是首先自動的轉(zhuǎn)為整型，而后利用整型數(shù)值進行相等的判斷。范例：布爾型的相等和不等判斷
public class DongJun{ static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示public static void main(String DongJun[]){// 此時的變量的定義規(guī)則為：第一個單詞的字母全部小寫，隨后每一個單子的首字母大寫//Java中類的定義規(guī)則：每一個單詞的首字母必須大寫boolean flagA = true;boolean flagB = false;System.out.println(flagA == flagB);System.out.println(flagA != flagB);} }false
true
三目運算符
如果同學(xué)們僅僅是在基礎(chǔ)課程的學(xué)習(xí)過程之中實際上是很難感受到三木運算符的優(yōu)勢（在日后進行代碼開發(fā)的過程里面，三目運算符相當(dāng)?shù)暮糜?#xff0c;同時可以幫助所有的人解決許多的代碼冗余的問題）。 |- 三目運算符的本質(zhì)相當(dāng)于是一個帶有判斷的賦值運算符， 傳統(tǒng)的賦值運算符能夠設(shè)置的內(nèi)容基本上就是變量或者常量，它采用都是比較直白的模式** 如果某些值需要有條件的進行賦予則就必須進行一些關(guān)系運算符的判斷處理了，當(dāng)符合于某些判斷條件的時候賦值，如果不符合賦予另外一個數(shù)值，而這個過程就屬于三目運算符的操作，該操作的基本語法形式如下。**
語法形式：[數(shù)據(jù)類型] 變量 = 判斷條件 ? 條件滿足時復(fù)制內(nèi)容：條件不滿足時賦值內(nèi)容;范例：觀察三目運算符的使用
public class DongJun{ static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示public static void main(String DongJun[]){// 此時的變量的定義規(guī)則為：第一個單詞的字母全部小寫，隨后每一個單子的首字母大寫//Java中類的定義規(guī)則：每一個單詞的首字母必須大寫int ageA = 10;int ageB = 15;int maxAge = ageA > ageB ? ageA : ageB;System.out.println(maxAge);} }15
對于此時的三目運算符相當(dāng)于使用了一個if分支語句進行判斷處理操作。
范例：三目等價于if、else判斷
public class DongJun{ static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示public static void main(String DongJun[]){// 此時的變量的定義規(guī)則為：第一個單詞的字母全部小寫，隨后每一個單子的首字母大寫//Java中類的定義規(guī)則：每一個單詞的首字母必須大寫int ageA = 10;int ageB = 15;int maxAge = 0;if (ageA > ageB){maxAge = ageA;}else {maxAge = ageB;}System.out.println(maxAge);} }最終輸出結(jié)果同上
實際上在所有的運算符使用的過程之中都是可能存在有嵌套關(guān)系的，下面實現(xiàn)一個三目運算的嵌套處理。范例：實現(xiàn)三目運算的嵌套
public class DongJun{ static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示public static void main(String DongJun[]){// 此時的變量的定義規(guī)則為：第一個單詞的字母全部小寫，隨后每一個單子的首字母大寫//Java中類的定義規(guī)則：每一個單詞的首字母必須大寫int ageA = 10;int ageB = 15;int ageC = 18;int maxAge = ageA > ageB ? ageA : ageB > ageC ? ageB : ageC ;System.out.println(maxAge);} }18
** 對于此時的程序的操作結(jié)構(gòu)實際上是不便于閱讀的，提倡編寫簡單代碼。**
邏輯運算符
邏輯運算主要描述的是與或非這樣的基本關(guān)系，使用邏輯運算符最終的特點在于可以同時連接多個判斷條件。 例如：在之前使用的關(guān)系運算符，每一次只能夠進行一個條件的判斷，這樣的操作一定不適合于更加復(fù)雜的程序邏輯。邏輯運算符 ---------------------------------------------------------- |-與（&普通與和&&短路與）：若干個判斷條件同時為true，最終程序結(jié)果才是true; |-或：(|普通或||短路或)若干個判斷條件有一個為true，最終程序運算的結(jié)果就是true; |-非：（！）true變?yōu)閒alse、false變true。 ---------------------------------------------------------------------------------** 在給出的邏輯運算符之中非運算的理解可以說是最簡單的了，因為僅僅是進行了布爾求反而已**
范例：觀察與邏輯
public class DongJun{ static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示public static void main(String DongJun[]){// 此時的變量的定義規(guī)則為：第一個單詞的字母全部小寫，隨后每一個單子的首字母大寫//Java中類的定義規(guī)則：每一個單詞的首字母必須大寫int x = 1;int y = 1;System.out.println(x == y & 2 > 1);System.out.println(x == y & 2 < 1);} }true
false
** 與的概念雖然很好理解，但是在java里面卻針對于邏輯操作提供有兩種不同的運算“&”、“&&”，那么這兩種運算有什么區(qū)別呢。**
范例：觀察普通與存在的問題
public class DongJun{ static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示public static void main(String DongJun[]){// 此時的變量的定義規(guī)則為：第一個單詞的字母全部小寫，隨后每一個單子的首字母大寫//Java中類的定義規(guī)則：每一個單詞的首字母必須大寫// 按照高等數(shù)學(xué)的邏輯來理解“數(shù)字/0 = 無求大（計算機的設(shè)計來講無求大意味著內(nèi)存占滿）”System.out.println((1 > 2) & 10 / 0 ==0);} }Exception in thread “main” java.lang.ArithmeticException: / by zero
at DongJun.main(DongJun.java:7)
*這個時候的程序出錯實際上意味著所有的判斷條件都執(zhí)行了，但是現(xiàn)在來分析一個問題：對于與操作的邏輯來講，最大的特點是若干個判斷條件如果有一個條件為False，那么最終的與邏輯的結(jié)果全部為false（中間出現(xiàn)多少個true都沒有意義了）。 *
如果現(xiàn)在使用的是“&”操作意味要全部判斷 想要解決程序邏輯判斷的性能問題，最佳做法就是使用短路與進行操作。范例：短路與進行操作
public class DongJun{ static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示public static void main(String DongJun[]){// 此時的變量的定義規(guī)則為：第一個單詞的字母全部小寫，隨后每一個單子的首字母大寫//Java中類的定義規(guī)則：每一個單詞的首字母必須大寫// 按照高等數(shù)學(xué)的邏輯來理解“數(shù)字/0 = 無求大（計算機的設(shè)計來講無求大意味著內(nèi)存占滿）”System.out.println((1 > 2) && 10 / 0 ==0);//第一個判斷條件（1>2）結(jié)果為false，后面的判斷沒有意義了直接停止判斷，返回false} }false
范例：觀察普通或
public class DongJun{ static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示public static void main(String DongJun[]){// 此時的變量的定義規(guī)則為：第一個單詞的字母全部小寫，隨后每一個單子的首字母大寫//Java中類的定義規(guī)則：每一個單詞的首字母必須大寫// 按照高等數(shù)學(xué)的邏輯來理解“數(shù)字/0 = 無求大（計算機的設(shè)計來講無求大意味著內(nèi)存占滿）”System.out.println((1 == 2) | (10 / 0 ==0));//第一個判斷條件（1>2）結(jié)果為false，后面的判斷沒有意義了直接停止判斷，返回false} }Exception in thread “main” java.lang.ArithmeticException: / by zero
at DongJun.main(DongJun.java:7)
范例：使用短路或
public class DongJun{ static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示public static void main(String DongJun[]){// 此時的變量的定義規(guī)則為：第一個單詞的字母全部小寫，隨后每一個單子的首字母大寫//Java中類的定義規(guī)則：每一個單詞的首字母必須大寫// 按照高等數(shù)學(xué)的邏輯來理解“數(shù)字/0 = 無求大（計算機的設(shè)計來講無求大意味著內(nèi)存占滿）”System.out.println((1 == 1) || (10 / 0 ==0));//第一個判斷條件（1>2）結(jié)果為false，后面的判斷沒有意義了直接停止判斷，返回false} }true
經(jīng)過以上分析可以得到一個結(jié)論，考慮到執(zhí)行性能的問題，一定要使用短路與、短路或進行若干操作。位運算符
為了提升程序的數(shù)據(jù)處理性能，在任何的語言里面都提供有位運算符，在很多的項目開發(fā)之中一般的開發(fā)人員很難見到位運算具體的操作（大部分的位運算都出現(xiàn)在一些比較底層的開發(fā)過程之中），java中支持的位運算的類型有：&（位與）、|（位或）、^（異或）、~（反碼）、<<（左移）、>>（右移）、>>>（無符號右移）。如果要想使用位運算，處理的邏輯為：數(shù)字除2取余，一直除0為止，最后將所有的余數(shù)倒敘取出，下面來分析一下如何將十進制的13數(shù)字轉(zhuǎn)為二進制。面試題：請解釋“&”和“&&”的區(qū)別？- 對于“&&”主要應(yīng)用在邏輯運算中，表示短路與操作，在進行若干個條件判斷的時候，如果有條件返回了false，那么后續(xù)的條件都不判斷，最終的判斷的結(jié)果就是false；- 對于“&”有兩種使用環(huán)境：|- 邏輯運算：表示所有的判斷條件都會執(zhí)行，不管是否遇見有返回false的判斷條件；|- 位運算：表示進行位與的計算，如果兩位的內(nèi)容都是1結(jié)果才是1，如果有一位是0，那么位與的結(jié)果就是0；程序的邏輯結(jié)構(gòu)
|- 實際上程序本身是有自己完善的邏輯性，而且從程序設(shè)計角度來講，程序的邏輯一共分為三種邏輯：順序結(jié)構(gòu)、分支結(jié)構(gòu)、循環(huán)結(jié)構(gòu)。 |- 在面對程序的時候后我們就相當(dāng)于“程序的上帝”，你規(guī)定了某一個程序的功能，某一個程序的處理的邏輯，所謂的程序邏輯就相當(dāng)于通過自己的想法，為程序規(guī)劃路線。分支結(jié)構(gòu)
所有的程序都有可能根據(jù)一些內(nèi)容動態(tài)的判斷是否要執(zhí)行某些代碼，這樣的處理邏輯就稱為分支邏輯，在程序的開發(fā)之中分支邏輯分為兩種類型：if分支（邏輯條件判斷）、switch開關(guān)語句（數(shù)值判斷）。if 分支結(jié)構(gòu)
if如果直接翻譯為中文的話為“如果”的含義，在使用if語句進行判斷的會說話必須判斷是布爾型的處理結(jié)構(gòu)，針對if語句有如下是那種操作結(jié)構(gòu)： |- if (布爾表達(dá)式) { 當(dāng)布爾表達(dá)式成立時執(zhí)行語句 }|- if (布爾表達(dá)式) { 當(dāng)布爾表達(dá)式成立時執(zhí)行語句 } else {條件不滿足時執(zhí)行語句 }|- if (布爾表達(dá)式) { 當(dāng)布爾表達(dá)式成立時執(zhí)行語句 } else if (布爾表達(dá)式){當(dāng)布爾表達(dá)式成立時執(zhí)行語句 }……else{條件不滿足執(zhí)行 }范例：學(xué)生成績分支
public class DongJun{ static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示public static void main(String DongJun[]){double score = 190.00 ;if (score >= 90.00 && score <= 100){ System.out.println("優(yōu)等生");} else if (score >= 60 && score < 90){System.out.println("良等生");} else {System.out.println("差等生");}} }Switch 開關(guān)語句
Switch是一個開關(guān)語句，在switch之中它能夠判斷的數(shù)據(jù)類型僅僅是：整數(shù)、字符、JDK1.5之后追加了枚舉，JDK1.7之后追加了String的判斷支持，如果要想使用switch必須結(jié)合case、default（不是必須）來一起使用，其基本的語法結(jié)構(gòu)如下 |- switch (整數(shù)|字符|枚舉|String){case 匹配內(nèi)容：內(nèi)容滿足時執(zhí)行的語句;[break ;]}case 匹配內(nèi)容:{內(nèi)容滿足時執(zhí)行的語句;[break ;]},……[default:{內(nèi)容都不滿足時執(zhí)行;[break ;]}]}對于switch來講，它無法像if語句那樣使用邏輯表達(dá)式進行判斷，僅僅支持?jǐn)?shù)值操作
范例：觀察switch語句
public class DongJun{
static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示
public static void main(String DongJun[]){
int ch = 3;
switch(ch) {
case 1:
System.out.println("【1】匹配的數(shù)字1");
break ;
case 2:
System.out.println("【2】匹配的數(shù)字2");
break;
default:
System.out.println("【NO】無法匹配內(nèi)容");
break;
}
【NO】無法匹配內(nèi)容
** 以上的程序的處理結(jié)構(gòu)是在實際的開發(fā)之中使用switch最為常見的結(jié)構(gòu)形式，但是在使用的過程之中，也有可能出現(xiàn)一些認(rèn)識上的問題，導(dǎo)致最終程序的執(zhí)行結(jié)果與預(yù)期有所差別，下面針對于switch中出現(xiàn)一些情況進行說明。**
|- 在編寫switch語句的過程之中每一次case語句中都會包含一個“break”，這個語句的含義是阻止其他功能執(zhí)行
|- 不一定按照順序來寫case
|- 在早期的switch語句結(jié)構(gòu)之外，除了數(shù)字之外最主要的支持就是字符了，（因為字符可以和整型自動互相轉(zhuǎn)換）
范例：在switch語句中使用String
public class DongJun{ static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示public static void main(String DongJun[]){String message = "我";switch(message){case "Dong":System.out.println(message+"Jun");break;case "董":System.out.println(message+"俊");break;default:System.out.println("請輸入正確的姓名");break;}} }這種字符串與switch結(jié)合匹配主要使用的形式是全匹配。
yield 關(guān)鍵字
yield是在JDK13之后正式加入到j(luò)ava中的新關(guān)鍵字，這個關(guān)鍵字的主要作用是進行內(nèi)容的局部返回，現(xiàn)階段其主要的設(shè)計是結(jié)合switch語句來使用，下面在正式的講解yield之前首先觀察一個程序范例：觀察switch分支
public class DongJun{ static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示public static void main(String DongJun[]){String data = "one";int result = 0 ;switch (data){case "one":result = 1;break;case "two":result = 2;break;default:result = -1;break;}System.out.println(result);} }1
* 本程序的核心含義是通過switch的判斷來最終決定result變量內(nèi)容是什么，以上的程序開發(fā)是屬于傳統(tǒng)的做法，而傳統(tǒng)的做法現(xiàn)在就覺得有些啰嗦，如果可以直接在switch里面返回數(shù)據(jù)該多好呢？*
范例：觀察JDK13之后的新結(jié)構(gòu)
public class DongJun{ static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示public static void main(String DongJun[]){String data = "one";int result = switch (data){case "one" : yield 1 ;case "two" : yield 2 ;default :{yield -1;} };System.out.println(result);} }1
* 以上的做法實際上是局部的switch返回的簡化的處理形式，如果現(xiàn)在不想使用“->”標(biāo)記符號組合，就可以通過yield關(guān)鍵字來處理了*
該程序的機制實際上并沒有完全的加入到j(luò)ava的正規(guī)使用的環(huán)境之中，還只是一種當(dāng)前現(xiàn)階段的測試應(yīng)用環(huán)境，如果要想使用這樣的功能就必須在編譯和執(zhí)行的時候追加“–enable-preview”參數(shù)
知識結(jié)構(gòu)擴展：python語言里面有yield關(guān)鍵字|-在python中的yield也是實現(xiàn)了局部返回，但是它在進行局部返回的時候可以結(jié)合生成器和多協(xié)程開發(fā)進行操作。循環(huán)結(jié)構(gòu)
在java里面循環(huán)的結(jié)構(gòu)分為兩類：while循環(huán)、for循環(huán)，這兩種循環(huán)在實際的項目開發(fā)過程之中基本上都要使用到，而且循環(huán)的結(jié)構(gòu)幾乎所有的項目中全部都存在。while循環(huán)
while 是一種條件判斷的循環(huán)處理，它主要是針對于給定的條件，當(dāng)條件滿足之后才會執(zhí)行。范例：實現(xiàn)"1-100"數(shù)字累加
public class DongJun{ static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示public static void main(String DongJun[]){int sum = 0 ;int num = 1 ;while (num <= 100) {sum +=num;num ++ ;}System.out.println("sum="+sum);} }sum=5050
public class DongJun{
static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示
public static void main(String DongJun[]){
int sum = 0 ;
int num = 1 ;
do
{
sum +=num;
num++ ;
}
while(num<=100);
System.out.println(“sum=”+sum);
}
}
sum = 5050
如果真的在實際的項目開發(fā)過程之中，很難見到“do……while”循環(huán)結(jié)構(gòu)，在代碼里面基本上只要條件的循環(huán)都以while循環(huán)結(jié)構(gòu)為主。for循環(huán)結(jié)構(gòu)
如果說你已經(jīng)明確知道了循環(huán)次數(shù)的時候，就可以通過for循環(huán)結(jié)構(gòu)更加簡單的進行循環(huán)處理，首先來觀察一下for循環(huán)的語法結(jié)構(gòu) |-for(循環(huán)初始化條件 ; 循環(huán)判斷 ; 循環(huán)條件變更){循環(huán)體;}可以發(fā)現(xiàn)在for語句結(jié)構(gòu)里，將所有的循環(huán)有關(guān)的操作全部放在了一行語句完成。范例：使用for循環(huán)
public class DongJun{ static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示public static void main(String DongJun[]){int sum = 0;for (int num = 1; num <= 100 ; num ++ ){sum += num;}System.out.println("sum="+sum);} }sum = 5050
** 需要特別引起注意的一件事情在于：對于for循環(huán)結(jié)構(gòu)實際上可以拆開編寫，但是在實際的開發(fā)過程中不建議如此定義**
范例：不便方式
public class DongJun{
static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示
public static void main(String DongJun[]){
int sum = 0;
int num = 1;
for (; num <= 100 ; )
{
sum += num;
num ++ ;
}
System.out.println(“sum=”+sum);
}
}
以上的程序代碼在實際上開發(fā)中不建議使用
while循環(huán)：當(dāng)不知道明確的循環(huán)次數(shù)，但是卻明確知道循環(huán)的結(jié)束條件的情況下可以使用while循環(huán)； for循環(huán)：明確的知道循環(huán)次數(shù)的時候使用。循環(huán)控制語句
在正常的情況下，所有的循環(huán)一旦開啟了，那么肯定會按照既定的原則持續(xù)的執(zhí)行下去（一直到不滿足循環(huán)條件為止，循環(huán)才會自動的退出），但是在某些情況下，有可能會阻塞循環(huán)的執(zhí)行。 針對于中斷執(zhí)行提供有兩個關(guān)鍵字：continue、break;結(jié)論：continue結(jié)束一次循環(huán)調(diào)用，而break是退出整個循環(huán)結(jié)構(gòu)
循環(huán)嵌套
大部分的結(jié)構(gòu)都是可以嵌套的，例如：在switch里面可以繼續(xù)嵌套循環(huán)或者是if語句，在循環(huán)結(jié)構(gòu)里面也可以嵌套if結(jié)構(gòu)，那么同期，一個循環(huán)內(nèi)部也一定可以嵌套另外一個循環(huán)。** 關(guān)于循環(huán)嵌套的提醒：只要你能夠編寫循環(huán)，就可以正常的向后學(xué)習(xí)課程內(nèi)容。**
范例：打印乘法口訣表
public class DongJun{ static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示public static void main(String DongJun[]){for (int x = 1; x <= 9 ; x ++ ){for (int y = 1; y <= x ; y ++){System.out.print(y+"*"+x+"="+(x*y)+"\t");}System.out.println();}} }11=1
12=2 22=4
13=3 23=6 33=9
14=4 24=8 34=12 44=16
15=5 25=10 35=15 45=20 55=25
16=6 26=12 36=18 46=24 56=30 66=36
17=7 27=14 37=21 47=28 57=35 67=42 77=49
18=8 28=16 38=24 48=32 58=40 68=48 78=56 88=64
19=9 29=18 39=27 49=36 59=45 69=54 79=63 89=72 9*9=81
此時的程序利用循環(huán)嵌套實現(xiàn)
范例：打印正三角形
public class DongJun{ static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示public static void main(String DongJun[]){int line = 5 ;//總共輸出5行for (int x=0 ; x <5 ; x ++){for (int y=0 ;y < line - x; y++ ){System.out.print(" ");//輸出空格}for (int y=0; y <= x ; y++ ){System.out.print("* ");}System.out.println();}} }實現(xiàn)了三角形的打印
|- 在現(xiàn)在的項目開發(fā)過程里面，如果不是必須的情況下，這種循環(huán)的嵌套代碼會出現(xiàn)，但是不會出現(xiàn)的很多，而且隨著你自己開發(fā)經(jīng)驗的累計，那么最終也一定可以熟練掌握。 |- 既然已經(jīng)存在循環(huán)嵌套結(jié)構(gòu)，那么就必須去討論一下關(guān)于continue語句的問題了，在程序的開發(fā)語言里面可以發(fā)現(xiàn)“C”、“C++”、“Java”語法的結(jié)構(gòu)都是非常類似，在C語言里面提供有了一個“goto”關(guān)鍵字，這種關(guān)鍵字在所有項目開發(fā)中都被命令禁止使用的開發(fā)關(guān)鍵字，因為會造成程序邏輯結(jié)構(gòu)的混亂，在Java里面將“goto”關(guān)鍵字定義為了未使用到的關(guān)鍵字，如果此時在循環(huán)嵌套結(jié)構(gòu)里面你非要進行一種代碼跳轉(zhuǎn)的實現(xiàn)，就可以通過continue來完成。范例：在循環(huán)嵌套結(jié)構(gòu)里面使用continue進行跳轉(zhuǎn)
public class DongJun{ static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示public static void main(String DongJun[]){point: for (int x = 0; x <3 ; x ++ ){for (int y=0; y< 3 ; y++){if (x == y){continue point;//代碼跳轉(zhuǎn)}System.out.print(x + "、");}System.out.println();}} }1、2、2、
在內(nèi)部的for循環(huán)嵌套結(jié)構(gòu)里面使用了continue實現(xiàn)了無條件的跳轉(zhuǎn)處理操作，所以最終的執(zhí)行結(jié)果就出現(xiàn)了偏差，但是這樣的程序邏輯是非常不適合閱讀，所以以上的代碼形式在開發(fā)中盡量不要出現(xiàn)方法作用概述
方法（英文單詞“method”）指的是一種可以被重復(fù)調(diào)用的代碼段，如果完全沒有學(xué)習(xí)過編程的概念你就把方法想象為一個功能。例如：只要你會開車，那么給你汽車你就可以直接開走（在你的開車的過程之中可能完全不知道汽車的工作原理）。方法定義
在java里面由于方法是整個程序之中最為重要的結(jié)構(gòu)，所以對于方法的定義本身也是非常繁瑣的，為了方便大家理解本次講解的方法結(jié)構(gòu)，所以將采用如下的定義方式： -------------------------------------------------------------- public static 方法返回值類型 方法名稱（參數(shù)類型 變量， 參數(shù)類型 變量, ……） { 方法體（本方法所需要實現(xiàn)的功能）;[return 返回值;] }特別注意：public static本次講解的方法指的是主類中定義，并且由主方法直接調(diào)用的處理形式
方法的定義格式：
方法的返回值類型：主要使用的是java數(shù)據(jù)類型（基本類型、引用類型）、如果沒有返回值就使用void定義；
方法名稱在java之中有明確的命名要求：第一個單詞的字母小寫，而后每一個單詞的首字母大寫；
如果方法定義了非Void返回值類型，則可以通過return返回處理結(jié)果，如果使用了void，也可以使用return，就不需要返回具體的數(shù)據(jù)內(nèi)容了
定義一個無參且無返回值的方法
public class DongJun{ static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示public static void main(String DongJun[]){printMessage();printMessage();}public static void printMessage(){//第一個單詞字母小寫，后續(xù)單詞首字母大寫System.out.println("******************") ;System.out.println("****** DJ ******") ;System.out.println("******************") ;} }****** DJ ******
****** DJ ******
程序之中存在有方法之后，程序代碼依舊要通過主方法執(zhí)行
范例：定義一個有參數(shù)有返回值的方法
public class DongJun{
static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示
public static void main(String DongJun[]){
String result = payAndGet(20.0);
System.out.println(result);
//如果方法本身就存在返回值聲明，那么也可以直接進行輸出
System.out.println(payAndGet(9.9));
}
購買一份快餐，找零：10.0
對不起，你的余額不足。
需要注意的一個問題：如果你現(xiàn)在定義的方法使用了void聲明了返回值類型（方法不會返回數(shù)據(jù)），那么這個時候也可以利用return語句結(jié)束當(dāng)前方法調(diào)用（此時的return不應(yīng)該繼續(xù)返回任何內(nèi)容了）
范例：使用return結(jié)束方法調(diào)用
public class DongJun{ static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示public static void main(String DongJun[]){sale(3);sale(-3);}public static void sale(int amount){if (amount <= 0)//設(shè)置一個判斷條件{return ;//后續(xù)的語句都不在執(zhí)行了（相當(dāng)于break、continue概念）}System.out.println("銷售出了"+amount+"李興華");}}銷售出了3李興華
return相當(dāng)于結(jié)束當(dāng)前方法
方法重載
方法重載從嚴(yán)格意義上來講指的是一種方法名稱的重用功能，利用特定的處理機制，可以讓一個方法實現(xiàn)不同的功能。** 在Java程序里面方法的名稱實際上和變量的名稱一樣，都是不能夠重復(fù)的，所以如果要進行方法重載的話，那么首先要做的事情就是必須將方法名稱設(shè)置為相同，但是需要針對于方法的參數(shù)進行不同的定義，方法的參數(shù)及類型要有所不同。**
范例：觀察方法重載
public class DongJun{
static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示
public static void main(String DongJun[]){
System.out.println(sum(10, 20));
System.out.println(sum(10, 20, 30));
System.out.println(sum(10.2, 20.3));
}
public static int sum(int x, int y) {
return x + y;
}
public static int sum(int x, int y, int z)//此時定義的sum()方法的名稱重復(fù)，但是參數(shù)的個數(shù)不重復(fù)
{
return x + y + z;
}
public static double sum(double x, double y) {
return x + y;
}
}
30
60
30.5
對于以上的程序代碼，本身也存在有一些設(shè)計問題
** 在java中進行方法重載的時候只是針對于方法名稱和參數(shù)的類型及個數(shù)有所要求，但是并沒有對方法的返回值有所要求，也就是說一個方法被重載之后可以由不同的返回值類型定義，但是這也成為了一個設(shè)計上的問題。**
為什么需要有方法重載的機制呢？
之所以提供有方法的重載，主要的目的是為了保留方法名稱（有些方法名稱是擁有公共特征，不應(yīng)該將其隸屬于某一種數(shù)據(jù)類型）
實際上在整個的java里面最具有代表性的一種重載的就屬于輸出的操作。
范例：觀察屏幕輸出
public class DongJun{ static int age; //如果現(xiàn)在沒有定義具體的內(nèi)容，則應(yīng)該使用默認(rèn)值“0”來表示public static void main(String DongJun[]){System.out.println(1);System.out.println(1.1);System.out.println("www");System.out.println('Y');System.out.println(true);} }1
1.1
www
Y
true
此時可以發(fā)現(xiàn)“System.out.println()”(后面有括號全部表示方法調(diào)用)可以輸出不同的數(shù)據(jù)類型，所以該方法本身也屬于一種重載的方法。
方法遞歸調(diào)用
方法的遞歸調(diào)用屬于一種方法調(diào)用的特殊形式，這種方法調(diào)用指的是就是一個方法調(diào)用自身的情況，但是在進行遞歸調(diào)用過程之中一定要設(shè)置好結(jié)束條件，否則依然會出現(xiàn)循環(huán)的問題。范例：通過遞歸實現(xiàn)一個數(shù)字的累加
|- “1100”累加，或者是由"11000"累加，所以這種情況下可以考慮利用遞歸的模式完成.
500500
為了便于理解，下面針對于當(dāng)前給定的sum()遞歸調(diào)用進行一個簡單的操作說明：
【第一次調(diào)用】由“main（）”方法發(fā)出：return 10000+sum(9999);【第二次調(diào)用】由“main（）”方法發(fā)出：return 9999+sum(9998);【倒數(shù)第二次調(diào)用】由“main（）”方法發(fā)出：return 1+sum(0);【倒數(shù)第二次調(diào)用】由“main（）”方法發(fā)出：return 0; 由于遞歸操作較為繁瑣，而且一旦處理不當(dāng)那么就有可能在代碼的執(zhí)行過程之中出現(xiàn)內(nèi)存溢出的問題（需要一些棧內(nèi)存支持），所以如果不是必須的情況下盡量不要去編寫遞歸調(diào)用（在java開發(fā)過程里面實際上你也不會使用遞歸。）面向?qū)ο蟾攀?/h1> 在整個的java（連同C++一樣）最為復(fù)雜繁瑣的部分就是面向?qū)ο蟮木幊塘?#xff0c;但是如果說現(xiàn)在我們都不知道面向?qū)ο蟮某绦蚪Y(jié)構(gòu)是什么，而僅僅是進行一些概念上的細(xì)分，實際上就屬于極為不厚道的講法。在編程語言項目的發(fā)展歷史過程之中，早期的項目設(shè)計結(jié)構(gòu)使用的是“面向過程”，面向過程最大的特點是解決當(dāng)前的問題。而面向?qū)ο笫窃诿嫦蜻^程之上的進一步的技術(shù)發(fā)展，面向?qū)ο笞畲蟮囊粋€特點在于進行標(biāo)準(zhǔn)化的設(shè)計，也就是說它在進行項目開發(fā)之前一定要對不同層次的功能的整合進行詳細(xì)的說明。
** 面向?qū)ο蟮脑O(shè)計之中，除了擁有模塊化的設(shè)計結(jié)構(gòu)之外，實際上還有三個重要的特點：**
|- 封裝性：程序內(nèi)部的處理結(jié)構(gòu)對外不可見（結(jié)構(gòu)內(nèi)部不可見、實現(xiàn)結(jié)構(gòu)不可見）;
- 實現(xiàn)結(jié)構(gòu)不可見：不同的層之間進行處理的時候可以完全不知道具體的實現(xiàn)細(xì)節(jié)；
- 內(nèi)部結(jié)構(gòu)不可見：內(nèi)部的相關(guān)的核心定義外部無法直接訪問，這就與訪問權(quán)限相關(guān)了；
|- 繼承性：在先人的基礎(chǔ)上繼續(xù)發(fā)展，就好比如果參考進化論，每一位人祖先都是猿人，肯定每一代都要比上一代要強，利用繼承的結(jié)構(gòu)劃分出不同的類關(guān)系，同時保證一些公共的特征存留下來。
|- 多態(tài)性：多態(tài)是一種不確定的執(zhí)行模式，同樣的一個功能不同的人干會有不同的方法，但是最終的目的都是在解決核心的問題。
類與對象
如果要想研究面向?qū)ο蟮木幊碳夹g(shù)，那么首先一定要明確的就是類與對象的關(guān)系，因為這個關(guān)系是整個面向?qū)ο缶幊讨谢窘M成單元，類描述的是一類事物的共同特征的集合（概念是不能夠直接使用的），而對象描述的是一個體化擁有鮮明特點的實物。** 在每一個類之中都會有相關(guān)的屬性和行為（方法)，所謂的行為描述的就是類的功能，所有的對象都可以去調(diào)用類中定義的功能。**
在進行面向?qū)ο笤O(shè)計之中一定要先進行類結(jié)構(gòu)的定義，而后才可以擁有具體的對象，對象是可以直接使用的操作；
一個類可以產(chǎn)生多個對象，不同的對象擁有各自不同的特點（屬性），但是所有的對象都擁有相同的功能（方法）。
|- 專業(yè)描述：類是對象共性的集合，而對象是類的實例，類必須依靠對象實例才可以使用。
類與對象的定義
在之前所編寫的所有的程序代碼都是在一個類中進行程序的定義，在之前分析過了“public class”、"class"定義類的基本區(qū)別，實際上在java中程序類主要就是通過class關(guān)鍵字進行定義的，所以定義的基礎(chǔ)語法結(jié)構(gòu)如下）： ------------------------------------------------ class 類名稱 { //遵守命名規(guī)則，每個單詞的首字母大寫[訪問修飾符] 數(shù)據(jù)類型 成員屬性（變量）;[訪問修飾符] 數(shù)據(jù)類型 成員屬性（變量）;... ... ...[訪問修飾符] 返回值類型 方法名稱 （參數(shù)類型 參數(shù)1 ...）{本方法處理語句;[return [];]} } ------------------------------------------------ 一個類中可以同時定義多個成員屬性（FIeld）、也可以定義多個方法（Method)，在進行屬性定義前出現(xiàn)的“訪問修飾符”最終的作用就是實現(xiàn)類的封裝性的特點，本次針對于修飾符采用不定義（默認(rèn)的形式），而方法中出現(xiàn)的訪問修飾符統(tǒng)一使用“public”來進行描述。范例：定義一個描述圖書信息的類
|- 聲明并實例化對象： 類名稱 對象名稱（變量） = new 類名稱(); |- 進行分步定義，整個的操作分為兩個處理階段：- 聲明對象：類名稱 對象名稱 = null（引用數(shù)據(jù)類型的默認(rèn)值）；- 實例化對象： 對象名稱 = new 類名稱（）;當(dāng)一個類已經(jīng)產(chǎn)生了實例化對象之后肯定要對類結(jié)構(gòu)進行操作，在java程序里面，對象可以通過兩類語法形式使用類：
|- 調(diào)用類中的成員屬性（Field）：實例化對象.屬性= 值；
|- 調(diào)用類中的方法（Method）：實例化對象.方法名稱();
范例：聲明并實例化對象
class Book {//圖書的名稱肯定是多位字符String title;String author;//價格一定是一個小數(shù)，double的準(zhǔn)確性高于floatdouble price;public void getInfo() { //本次定義getInfo()方法過程之中可以發(fā)現(xiàn)沒有使用最初講解方法時的“static”關(guān)鍵字，在之前講解方法時在主類中定義的，而現(xiàn)在在類中定義的方法主要通過對象來進行調(diào)用，所以此時暫時不加static，具體語法后續(xù)會有詳細(xì)解釋。System.out.println("圖書名稱："+ title + "、圖書作者：" + author + "、圖書價格:" + price);} }public class DongJun //主類 {public static void main(String avgs[]){Book book = new Book();book.title = "我的";book.author = "天啊";book.price = 89.6 ; book.getInfo();} }圖書名稱：我的、圖書作者：天啊、圖書價格:89.6
** 此時的程序代碼已經(jīng)可以通過類產(chǎn)生的實例化對象進行類中結(jié)構(gòu)的調(diào)用了，實例化對象一旦出現(xiàn)，類的結(jié)構(gòu)就可以進行各種操作的，而本次的操作僅僅是進行了一些屬性的設(shè)置以及方法的調(diào)用**
觀察屬性默認(rèn)值
圖書名稱：null、圖書作者：null、圖書價格:0.0
** 現(xiàn)在程序僅僅是進行了book類對象的實例化處理，隨后在沒有進行屬性設(shè)置的情況下立即調(diào)用getInfo()方法獲取對象內(nèi)容，通過結(jié)果可以發(fā)現(xiàn)title、author內(nèi)容全部為null（String 是一個類，類是引用數(shù)據(jù)類型，默認(rèn)值就是null）而price的默認(rèn)值為“0.0”。**
一個類與對象的基本概念已經(jīng)講述完畢，同時以上給出的語法結(jié)構(gòu)實際上也屬于實際開發(fā)過程之中的常規(guī)的操作形式了，但是為了幫助大家更好理解面向?qū)ο笤O(shè)計與之前概念的聯(lián)系，下面利用面向?qū)ο蟮脑O(shè)計形式來實現(xiàn)一個正三角形的打印，而這個打印過程里面，將通過屬性來保存打印的行數(shù)。范例：面向?qū)ο笤O(shè)計的應(yīng)用
class Triangle {int line = 5 ;public void paint() {for (int x = 0; x< line ; x++){for (int y = 0; y< line - x; y++ ){System.out.print(" ");}for (int y = 0 ;y <= x ; y++ ){System.out.print("* ");}System.out.println();}} } public class DongJun //主類 {public static void main(String avgs[]){Triangle tri = new Triangle();tri.line = 3;tri.paint();} }** 在之前實現(xiàn)此功能的時候要么就直接在主方法里面進行定義，要么就直接定義有一個方法進行調(diào)用，但是現(xiàn)在將與這個圖形有關(guān)的成員屬性（變量）和操作方法混合定義在了一個“Triangle”類里面，從代碼管理來講，結(jié)構(gòu)是非常清晰的。**
對象內(nèi)存分析
在之前已經(jīng)為大家講解過了整個java之中的數(shù)據(jù)類型劃分，而對于數(shù)據(jù)類型的劃分，在Java里面分為兩類：基本數(shù)據(jù)類型（數(shù)值的傳遞操作）、引用數(shù)據(jù)類型（內(nèi)存地址的傳遞，這種引用傳遞就類似于C、C++之中的指針的概念）** 所有的數(shù)據(jù)都要保存在內(nèi)存之中，但是如何可以準(zhǔn)確的獲取數(shù)據(jù)，就稱為了計算機操作系統(tǒng)本身需要解決的問題，那么經(jīng)過了長期的發(fā)展之后，人們發(fā)現(xiàn)應(yīng)該將內(nèi)存的功能分為兩個部分：**
|- 【heap】 堆內(nèi)存：是保存對象的真實信息；
|- 【stack】棧內(nèi)存：保存的是對象的堆內(nèi)存的地址；
對于所有的內(nèi)存的操作實際上每一位開發(fā)者是完全不知情的，所有與內(nèi)存分配有關(guān)的任何操作全部都是由JVM負(fù)責(zé)完成的，不同的操作系統(tǒng)之中內(nèi)存分配機制肯定也是不同的，那么最終全部由JVM進行分配
如果要想進行對象屬性或方法的操作，一定要保證存在有實例化對象（開辟了堆內(nèi)存的對象、或者有堆指向的實例）引用傳遞分析
Java之中引用數(shù)據(jù)類型需要內(nèi)存的支持，所以在進行程序開發(fā)的過程之中，內(nèi)存是可以有多個指向，內(nèi)存的多個指向指的是不同的棧內(nèi)存可以指向同一個堆內(nèi)存。垃圾產(chǎn)生分析
在Java語言里面有一個最為重要的技術(shù)特點：垃圾回收（Garbage Collector），所有的數(shù)據(jù)都要保存在內(nèi)存之中，但是內(nèi)存里面也是需要進行順序式的空間分配，如果要想非常深入的去理解垃圾回收的相關(guān)操作，那么就需要先明白垃圾是什么？如何產(chǎn)生的，隨后才可以進一步的優(yōu)化 Java提供有自動的GC回收機制，但是如果你的程序之中產(chǎn)生的垃圾過多，那么也會造成硬件性能的損耗，從而導(dǎo)致程序的執(zhí)行性能下降，所以最佳的做法是避免垃圾的產(chǎn)生。成員屬性的私有化
|- 在面向?qū)ο蟮脑O(shè)計之中有三大主要特征（封裝、繼承、多態(tài)），封裝是在面向?qū)ο笤O(shè)計之中最為常見的一種概念，但是如果要思想把封裝的所有概念都弄明白，則還需要充分的理解繼承與多態(tài)，本次所講解的成員屬性私有化就是封裝的一種基礎(chǔ)實現(xiàn)。 |- 按照一般程序的設(shè)計思路來講，如果要想使用類肯定要通過對象，類中一般會提供有屬性和方法，那么不同的對象可以進行屬性的操作，傳統(tǒng)的做法是直接在類的外部由實例化對象直接進行屬性的操作。范例：使用private關(guān)鍵字定義類中屬性
class Book {private String title;private String author;private double price;public void getInfo(){System.out.println("圖書標(biāo)題："+ title + "\n圖書作者："+ author +"\n圖書價格："+ price);} } public class DongJun //主類 {public static void main(String avgs[]){Book book = new Book();book.title = "成長日記";book.author = "董俊";book.price = 99.9; book.getInfo();} }DongJun.java:14: 錯誤: title 在 Book 中是 private 訪問控制
book.title = “成長日記”;
^
DongJun.java:15: 錯誤: author 在 Book 中是 private 訪問控制
book.author = “董俊”;
^
DongJun.java:16: 錯誤: price 在 Book 中是 private 訪問控制
book.price = 99.9;
使用private關(guān)鍵字定義類中屬性所以無法訪問
使用了private外部的對象無法直接訪問了，但是類的內(nèi)部是可以進行訪問的，于是如果要想進行private私有屬性的訪問操作，按照J(rèn)ava本身定義規(guī)則來講，就需要編寫setter、getter方法來完成 |- stter：進行屬性內(nèi)容的設(shè)置，基本形式: ------------------------------------------- public void set 屬性名稱(屬性類型 變量){ 屬性名稱 = 變量} private String title; public void setTitle(String t){title = t; } |- getter：獲取屬性內(nèi)容：基本的形式： -------------------------------------- public 屬性類型 get屬性名稱(){return 屬性名稱; } public String getTitle(){return title; }你的類中不管有多少屬性都需要編寫與之匹配的setter、getter的方法的個數(shù)，而且這種編寫的設(shè)計結(jié)構(gòu)是所有的Java后續(xù)開發(fā)之中都一定會使用的模式。
范例：觀察private屬性訪問
class Book
{
private String title;
private String author;
private double price;
public void setTitle(String t){
title = t;
}
public void setAuthor(String a){
author = a;
}
public void setPrice(double p)
{
price = p;
}
public String getTitle(){
return title;
}
public String getAuthor(){
return author;
}
public double getPrice()
{
return price;
}
}
public class DongJun //主類
{
public static void main(String avgs[]){
Book book = new Book();
book.setTitle(“我行得正”);
book.setAuthor(“做的好”);
book.setPrice(88);
System.out.println(“圖書名：”+book.getTitle()+book.getAuthor()+book.getPrice());
}
}
圖書名：我行得正做的好88.0
在日后整個程序的開發(fā)過程之中，只要編寫類中的屬性一定要使用private進行聲明，而private聲明的屬性必須要與之匹配的setter、getter方法才可以被外部所訪問，即便當(dāng)前的代碼里面沒有調(diào)用全部方法，但是作為一個標(biāo)準(zhǔn)類的功能這些方法都是必須提供出來的。構(gòu)造方法
構(gòu)造方法是Java類之中的一種特殊形式的操作方法，其調(diào)用的時機是在對象實例化的時候（堆內(nèi)存開辟的時候進行調(diào)用），下面首先來觀察一下構(gòu)造方法的基本形式；范例：觀察構(gòu)造方法
class Book {public Book(){//構(gòu)造方法System.out.println("******董俊來*******");} } public class DongJun {public static void main(String args[]){System.out.println("【1】聲明book類對象：“Book book = null; ”");Book book = null; System.out.println("【2】實例化book類對象:“book = new Book();”");book = new Book();//實例化對象} }【1】聲明book類對象：“Book book = null; ”
【2】實例化book類對象:“book = new Book();”
在整個程序執(zhí)行過程之中，真正進行構(gòu)造方法調(diào)用的位置處就是使用關(guān)鍵字“new”實例化對象的時候，實際上對于此時的操作，Book類中就定義了構(gòu)造方法，但是對于構(gòu)造方法本身是有其非常嚴(yán)格的定義要求的：
|- 構(gòu)造方法的方法名稱不能夠任意編寫，必須與類名稱保持一致；- 此時定義的類是類名稱是Book,而構(gòu)造方法的名稱使用的是“public Book(){}”; |- 構(gòu)造方法沒有返回值聲明，并且不能夠返回任何的數(shù)據(jù)內(nèi)容; |- 一個類之中如果沒有定義任何的構(gòu)造方法，則會在程序編譯的時候自動由JDK生成一個無參的構(gòu)造方法。構(gòu)造方法在現(xiàn)實中的應(yīng)用；
|- 構(gòu)造方法是在使用關(guān)鍵字new的時候才會被調(diào)用，而且一個對象只會執(zhí)行一次構(gòu)造操作，就好比一個人只能出生一次; |- 如果現(xiàn)在類中沒有通過構(gòu)造方法進行屬性內(nèi)容的設(shè)置，那么就意味著整個的程序在對象實例化之后所有的成員屬性都是默認(rèn)值，那么就需要一步一步的進行屬性的配置，就好比書先封裝好了，隨后再往里面填充內(nèi)容，最終形成成品。如果現(xiàn)在一個類種即要求有參構(gòu)造也要求提供無參構(gòu)造的時候后，唯一可以使用的方法就是通過方法的重載形式來完成，但是需要注意的是，此時只需要考慮方法的參數(shù)類型及個數(shù)即可（因為構(gòu)造方法的名稱和類名稱是完全相同的）
觀察方法的重載
class Book {private String title;private String author;private double price;public Book(){}public Book(String t){this.setTitle(t);this.setAuthor("沐言優(yōu)拓");this.setPrice(90.1);}public Book(String t, String a, double p){setTitle(t);this.setAuthor(a);setPrice(p);}public void getInfo(){System.out.println("圖書標(biāo)題："+ title + "\n圖書作者："+ author +"\n圖書價格："+ price);}public void setTitle(String t){title = t;}public void setAuthor(String a){author = a;}public void setPrice(double p){price = p;}} public class DongJun //主類 {public static void main(String avgs[]){Book book = new Book("董俊","2",89.0);book.getInfo();} }本程序在Book類中定義有三個構(gòu)造方法：無參構(gòu)造、單參構(gòu)造以及三參構(gòu)造，需要注意的是構(gòu)造方法本身沒有明確的順序要求，但是考慮到代碼的結(jié)構(gòu)性的特點，按照采用參數(shù)的降序排列或者升序排列
類中構(gòu)造方法和類中的普通方法的定義有什么區(qū)?
* 類的構(gòu)造方法只在使用關(guān)鍵字new實例化新對象的時候調(diào)用一次，而有了實例化對象之后，就可以利用該對象重復(fù)的調(diào)用類中定義的普通方法。*
* 如果現(xiàn)在構(gòu)造方法不返回任何數(shù)據(jù)，那么為什么不能夠使用void定義呢？
構(gòu)造方法的名稱是由大小寫要求的，但是如果僅僅是憑借名稱實際上編譯器是無法區(qū)別構(gòu)造方法還是普通方法。
匿名對象
匿名本質(zhì)上的含義指的就是沒有名字，而匿名對象本質(zhì)上的核心思想就是沒有名字的對象。范例：觀察匿名對象的使用
class Book {private String title;private String author;private double price;public Book(){}; //無參構(gòu)造方法public Book(String t){ //單參構(gòu)造方法this.setTitle(t);this.setAuthor("沐言優(yōu)拓");this.setPrice(-1.0);}public Book(String t, String a, double p){setTitle(t);this.setAuthor(a);setPrice(p);}public void getInfo() {System.out.println("圖書名稱："+title+"、圖書作者："+ author + "、圖書價格："+ price);}public void setTitle(String t){title = t;}public void setAuthor(String a){author = a;}public void setPrice(double p) {if (p > 0){price = p;}}public String getTitle(){return title;}public String getAuthor(){return author;}public double getPrice(){return price;} } public class YootkDemo{public static void main(String args[]){new Book("從入門到時間","董俊",99).getInfo(); // 聲明并實例化new Book("從入門到時間").getInfo();new Book().getInfo();} }此時通過關(guān)鍵字new創(chuàng)建的book類的實例化對象，那么就屬于一個匿名對象，因為沒有對象名稱對其進行引用（之前分析了：通過對象名稱可以讓對象調(diào)用多次的操作，如果沒有對象名稱了，那么該對象就沒有引用了，這個對象在使用一次之后就會成為垃圾對象了，那么這個時候有同學(xué)可能就不理解了，為什么要有匿名對象呢？）
現(xiàn)在假設(shè)有這樣一種生活場景：我是一個賣視頻的商鋪，因為我的生意非常的火爆，所以我沒有時間為我制作的每一件商品命名
范例：使用匿名對象
class Food {private String name;private double price;public Food(String n, double p){name = n;price = p;}//setter、getter略public String getInfo(){return "名稱："+name + "、價格：" +price; } } public class DongJun //主類 {public static void main(String avgs[]){for (int x= 0;x <100 ; x ++ ){sale(new Food("西紅柿烤燒餅",7.9);}}public static void sale(Food temp){System.out.println("【賣出商品】"+ temp.getInfo());} }當(dāng)然，以上的代碼也可以使用有名對象，例如：先為food實例化對象命名，隨后在通過對象名稱進行操作
?
this 關(guān)鍵字
如果要是以java中的關(guān)鍵字使用為例，個人覺得this關(guān)鍵字是比較繁瑣的一個關(guān)鍵字，因為this在程序開發(fā)之中使用較為靈活，它可以根據(jù)不同的環(huán)境而有所改變，而且使用this關(guān)鍵字進行處理操作的過程之中，可以描述是那種處理含義：成員屬性、方法（普通方法、構(gòu)造方法）、表示當(dāng)前對象。this 調(diào)用本類成員屬性
在一個類中定義的許多的成員屬性都可以互相進行調(diào)用，例如：某一個屬性可能在構(gòu)造方法中被調(diào)用，那么也可能在普通方法中進行調(diào)用，只要是在一個類中那么就都可以實現(xiàn)這樣的處理。范例：觀察之前編寫過的一個代碼
class Book {private String title;private String author;private double price;public Book(String t, String a, double p ){title = t;author = a ;price = p ;}public String getInfo(){return "【圖書信息】書名："+this.title + "、作者："+ this.author + "、價格："+ this.price;} } public class DongJun //主類 {public static void main(String avgs[]){Book book = new Book("入門到實戰(zhàn)","董俊",90);System.out.println(book.getInfo());} }【圖書信息】書名：入門到實戰(zhàn)、作者：董俊、價格：90.0
以上的程序代碼是在之前經(jīng)常編寫過的程序邏輯，但是對于當(dāng)前的程序代碼里面有一處的設(shè)計是非常不合理的，這一處指的就是類中定義的構(gòu)造方法，來觀察一下構(gòu)造方法的定義： |- public Book(String t, String a, double p ){title = t;author = a ;price = p ;} 這個時候的構(gòu)造方法里面需要傳遞有三個參數(shù)，并且這三個參數(shù)名稱使用了單個字母描述，那么請問，如果按照正常的標(biāo)識符的定義要求來講，這樣的標(biāo)識符雖然符合語法意義，但是不符合于實際的“明確要求”，因為字母t、a、p可能描述的單詞范圍太多了，那么這個時候最佳的做法肯定是希望可以寫上全部的名稱范例：修改程序?qū)崿F(xiàn)正確的賦值
class Book {private String title;private String author;private double price;public Book(String title, String author, double price ){//一旦使用了“this.屬性”，那么就永恒描述的是類中的成員耐屬性。this.title = title;this.author = author ;this.price = price ;}public String getInfo(){return "【圖書信息】書名："+this.title + "、作者："+ this.author + "、價格："+ this.price;} } public class DongJun //主類 {public static void main(String avgs[]){Book book = new Book("入門到實戰(zhàn)","董俊",90);System.out.println(book.getInfo());} }【圖書信息】書名：入門到實戰(zhàn)、作者：董俊、價格：90.0
在以后編寫代碼的過程之中，只要是訪問本類中的成員屬性的操作里面一定要采用“this.屬性”的形式進行明確的指派，我曾經(jīng)個人在編寫代碼的時候就因為有一個地方少寫了 this，最終發(fā)現(xiàn)執(zhí)行的結(jié)果缺少內(nèi)容 ，我排查了好久之后才發(fā)現(xiàn)的問題。調(diào)用本類的普通方法
在一個類之中往往會存在有大量的普通方法，這些普通方法每當(dāng)獲取了該類的實例化對象之后，那么都可以直接進行調(diào)用，而如果要在本類中進行方法調(diào)用的時候，理論上直接使用方法名稱即可，但是也可以使用"this.方法()"的形式進行更加明確的調(diào)用（兩者效果相同，但是后者的編寫形式更好）。范例：觀察本類的方法調(diào)用
class Book {private String title;private String author;private double price;public Book() {}public Book(String title, String author, double price ){setTitle(title);setAuthor(author);setPrice(price); //調(diào)用本類方法}public void set(String title, String author, double price) {setTitle(title);setAuthor(author);setPrice(price); //調(diào)用本類方法}public void setTitle(String title) {this.title = title;}public void setAuthor(String author){this.author = author;}public void setPrice(double price){this.price = price ;}public String getTitle() {return this.title;}public String getAuthor() {return this.author;}public double getPrice() {return this.price;}public String getInfo(){return "【圖書信息】書名："+this.title + "、作者："+ this.author + "、價格："+ this.price;} } public class DongJun //主類 {public static void main(String avgs[]){Book bookA = new Book("入門到實戰(zhàn)","董俊",90);System.out.println(bookA.getInfo());Book bookB = new Book();bookB.set("Python從入門到實戰(zhàn)","李興華",98.8);System.out.println(bookB.getInfo());} }【圖書信息】書名：入門到實戰(zhàn)、作者：董俊、價格：90.0
【圖書信息】書名：Python從入門到實戰(zhàn)、作者：李興華、價格：98.8
構(gòu)造方法互調(diào)用
|- 一個類之中構(gòu)造方法是允許進行重載的，在進行構(gòu)造方法重載的過程之中只需要考慮方法的參數(shù)類型及個數(shù)的不同即可，所以一個類里面構(gòu)造方法可能有很多，那么在這樣的環(huán)境下就可以考慮利用"this()"的形式實現(xiàn)構(gòu)造方法的互相調(diào)用，這種互相調(diào)用的機制也僅僅是使用一次(構(gòu)造方法只能夠調(diào)用一次，是在新對象開辟堆內(nèi)存空間的時候使用)。 |- 既然所有的對象進行實例化的時候都一定會進行構(gòu)造方法的調(diào)用，那么假設(shè)說現(xiàn)在類中存在有三個構(gòu)造方法，分別描述的是無參構(gòu)造、單參構(gòu)造、三參構(gòu)造，那么這個時候不管是調(diào)用了那一個構(gòu)造方法，都可能執(zhí)行某些操作（輸出一些重要的信息），那么按照原始的做法代碼有可能定義為如下的形式：范例：采用原始的形式實現(xiàn)固定操作的執(zhí)行
class Book {public Book() { System.out.println("【對象創(chuàng)建提示】");//想象為30行代碼}public Book(String title) {//單參System.out.println("【對象創(chuàng)建提示】");//想象為30行代碼}public Book(String title, String author, double price ){//多參System.out.println("【對象創(chuàng)建提示】");//想象為30行代碼} } public class DongJun //主類 {public static void main(String avgs[]){new Book("java實戰(zhàn)","董俊",89);new Book("java實戰(zhàn)");new Book();} }【對象創(chuàng)建提示】
【對象創(chuàng)建提示】
【對象創(chuàng)建提示】
范例：利用方法的形式解決代碼重復(fù)
class Book {public Book() { this.initObject();}public Book(String title) {//單參this.initObject();}public Book(String title, String author, double price ){//多參this.initObject();}public void initObject() { // 信息提示System.out.println("【對象創(chuàng)建提示】");//想象為30行代碼} } public class DongJun //主類 {public static void main(String avgs[]){new Book("java實戰(zhàn)","董俊",89);new Book("java實戰(zhàn)");new Book();} }【對象創(chuàng)建提示】
【對象創(chuàng)建提示】
【對象創(chuàng)建提示】
范例：利用this實現(xiàn)構(gòu)造方法的互調(diào)用
class Book {private String title;private String author; private double price;public Book() { System.out.println("【對象創(chuàng)建提示】");//想象為30行代碼}public Book(String title) {//單參this();this.title = title;}public Book(String title, String author, double price ){//多參this(title);//調(diào)用無參構(gòu)造this.title = title;this.author = author;this.price = price;} } public class DongJun //主類 {public static void main(String avgs[]){new Book("java實戰(zhàn)","董俊",89);new Book("java實戰(zhàn)");new Book();} }【對象創(chuàng)建提示】
【對象創(chuàng)建提示】
【對象創(chuàng)建提示】
先不去考慮重用性設(shè)計直接編寫原始代碼
class Book {private String title;private String author; private double price;public Book() { this.title = "木言優(yōu)拓";this.author = "李興華";this.price = 9988.66;}public Book(String title) {//單參this.title = title;this.author = "小李老師";this.price = 5566.88;}public Book(String title, String author, double price ){//多參this.title = title;this.author = author;this.price = price;}public String getInfo(){return "圖書名稱:" + this.title + "、圖書作者："+ this.author + "、圖書價格:" +this.price;} } public class DongJun //主類 {public static void main(String avgs[]){Book bookA = new Book();Book bookB = new Book("從java到入門");Book bookC = new Book("從python到入門","李興華",99.8);System.out.println(bookA.getInfo());System.out.println(bookB.getInfo());System.out.println(bookC.getInfo());} }圖書名稱:木言優(yōu)拓、圖書作者：李興華、圖書價格:9988.66
圖書名稱:從java到入門、圖書作者：小李老師、圖書價格:5566.88
圖書名稱:從python到入門、圖書作者：李興華、圖書價格:99.8
解決構(gòu)造方法中的重復(fù)代碼
class Book {private String title;private String author; private double price;public Book() { this("木言優(yōu)拓","李興華",9988.66);}public Book(String title) {//單參this(title,"小李老師",5566.88);}public Book(String title, String author, double price ){//多參this.title = title;this.author = author;this.price = price;}public String getInfo(){return "圖書名稱:" + this.title + "、圖書作者："+ this.author + "、圖書價格:" +this.price;} } public class DongJun //主類 {public static void main(String avgs[]){Book bookA = new Book();Book bookB = new Book("從java到入門");Book bookC = new Book("從python到入門","李興華",99.8);System.out.println(bookA.getInfo());System.out.println(bookB.getInfo());System.out.println(bookC.getInfo());} }圖書名稱:木言優(yōu)拓、圖書作者：李興華、圖書價格:9988.66
圖書名稱:從java到入門、圖書作者：小李老師、圖書價格:5566.88
圖書名稱:從python到入門、圖書作者：李興華、圖書價格:99.8
this 表示當(dāng)前對象
經(jīng)過了之前一系列分析可以發(fā)現(xiàn)，對于this有一個最為常見的調(diào)用類結(jié)構(gòu)的操作形式：“this.成員屬性”、“this.方法()”，那么根據(jù)在之前所學(xué)習(xí)的概念來講，類中的屬性或方法可以調(diào)用的只能夠是實例化對象（如果使用了沒有實例化的對象，則一定會出現(xiàn)“NullPointerException”），所以之前的語法之中的this本質(zhì)上描述的就是一個對象，但是這個對象不是一個固定的對象，而是描述的當(dāng)前對象概念。一般的擁有浪漫氣息的節(jié)日里面，酒店或者一些客房的預(yù)訂最為繁華的，例如：紅色情人節(jié)需要準(zhǔn)備，如果是白色情人節(jié)也可以準(zhǔn)備，如果是浪漫的圣誕結(jié)更需要準(zhǔn)備。如果要想觀察出程序里面的當(dāng)前對象，最簡單的做法就是直接進行this關(guān)鍵字的輸出，默認(rèn)情況下每一個實例化對象的輸出應(yīng)該得到的就是一個對象的編碼
觀察實例化對象的直接輸出
class Book{} public class DongJun //主類 {public static void main(String avgs[]){Book bookA = new Book();System.out.println("【main()方法】 = " + bookA);Book bookB = new Book();System.out.println("【main()方法】 = " + bookB);} }【main()方法】 = Book@63961c42
【main()方法】 = Book@65b54208
范例：觀察this與對象的關(guān)聯(lián)
class Book{
public void print() {
System.out.println("【Book類-print()方法】"+this);
}
}
public class DongJun //主類
{
public static void main(String avgs[]){
Book bookA = new Book();
System.out.println("【main()方法】 = " + bookA);
bookA.print();
System.out.println("---------------- 防止 ---------------- “);
Book bookB = new Book();
System.out.println(”【main()方法】 = " + bookB);
bookB.print();
}
}
【main()方法】 = Book@63961c42
【Book類-print()方法】Book@63961c42
---------------- 防止 ----------------
【main()方法】 = Book@65b54208
【Book類-print()方法】Book@65b54208
范例：使用this實現(xiàn)引用傳遞
class Message {private String title;private String content;private Channel channel;public Message(Channel channel, String title, String content){this.title = title;this.content= content;this.channel = channel;}public void send() {if (this.channel.connect()){System.out.println("【Message】消息發(fā)送，消息標(biāo)題："+ this.title + "、消息內(nèi)容：" + this.content);this.channel.close();} else {System.out.println("【Message】沒有可用的消息發(fā)送通道，消息發(fā)送失敗");}} } class Channel {private Message message;public Channel(String title, String content){this.message = new Message(this, title, content);this.message.send();}public boolean connect() {System.out.println("【Channel】建立消息信息的發(fā)送通道");return true;}public void close() {System.out.println("【Channel】關(guān)閉消息信息的發(fā)送通道");} } public class DongJun //主類 {public static void main(String avgs[]){Channel channel = new Channel("木言優(yōu)拓在線教育","編程訓(xùn)練營");} }【Channel】建立消息信息的發(fā)送通道
【Message】消息發(fā)送，消息標(biāo)題：木言優(yōu)拓在線教育、消息內(nèi)容：編程訓(xùn)練營
【Channel】關(guān)閉消息信息的發(fā)送通道
簡單Java類
在整個的Java技術(shù)學(xué)習(xí)過程之中，首先一定要明確一個核心的問題：學(xué)習(xí)一門語言如果要想盡快的上手開發(fā)，那么就必須熟練的掌握一些核心的編程模型（數(shù)學(xué)公式），只要遇見了相似的程序按照公式的形式直接定義好即可。 本次重點來研究關(guān)于簡單Java類的定義，實際上從項目的開發(fā)角度來講，使用類有一個最為核心的功能，它能夠描述有一類群體的共性特征。 簡單Java類指的是一個類之中主要由屬性以及setter、getter方法所組成的類，這個類不牽扯到各種復(fù)雜的運算邏輯，僅僅是進行相關(guān)數(shù)據(jù)的存儲，同時這種類一般都有明確的實物類型，例如：定義一個描述部門的信息類、定義一個描述雇員的信息類、定義一個描述教師的程序類。 在Java里面隨著技術(shù)學(xué)習(xí)的不斷深入，你會慢慢更加深刻的了解簡單java類的實際使用，包括一些設(shè)計上的不斷的改良，但是對于現(xiàn)在來講，給出如下的簡單java類的開發(fā)要求： |- 【必選】類名稱一定要有意義，可以明確的描述某一類的事物特征； |- 【必選】類之中所有的屬性都必須使用private封裝; |- 【必選】如果要進行屬性點設(shè)置或者是修改則一定要通過setter方法完成，而屬性的獲取要通過getter; |- 【必選】類之中可以定義若干個構(gòu)造方法，但是一定要提供有一個無參構(gòu)造方法（需要通過反射機制研究）; |- 【必選】對象中的所有信息不允許直接在類中使用"System.out.println()"輸出,所有的輸出內(nèi)容一定要返回給被調(diào)用處來進行輸出處理 |- 【可選】類中要提供有一個返回對象信息的處理方式;范例定義一個描述部門信息的簡單java類
|- 假設(shè)現(xiàn)在部門信息里面需要包含有部門編號、名稱以及位置三個核心屬性。
class Dept {private long deptno ; private String dname;private String loc;public Dept(){}public Dept(long deptno, String dname, String loc ){this.deptno=deptno;this.dname= dname;this.loc = loc ;}public void setDeptno(long deptno){this.deptno=deptno;}public void setDname(String dname){this.dname = dname;}public void setLoc(String loc){this.loc = loc ;}public long getDeptno(){return this.deptno;}public String getDname(){return this.dname;}public String getLoc(){return this.loc;}public String getInfo() {return "【部門】部門編號：" + this.deptno + "、部門名稱：" + this.dname + "、部門位置：" + this.loc;} } public class DongJun //主類 {public static void main(String avgs[]){Dept dept = new Dept(10, "沐言有哦" , "北京");System.out.println(dept.getInfo());} }【部門】部門編號：10、部門名稱：沐言有哦、部門位置：北京
對于此時的Dept類功能非常的單一，就是進行了數(shù)據(jù)的保存以及數(shù)據(jù)的獲取，所以這個類不涉及到任何的運算邏輯，就被開發(fā)中稱為簡單java類。重要提示：簡單java類是最基礎(chǔ)的模型，但是其可以考察以及覆蓋的知識點是非常全面的
|- 類的基本組成：屬性、方法（構(gòu)造方法、普通方法）；
|- 數(shù)據(jù)類型的選擇：基本類型、引用類型（后面會有更加深入的分析）;
|- 構(gòu)造方法的重載；
|- 屬性的封裝有以及setter、getter方法的定義要求；
|- 字符串的連接操作。
類與對象實例分析
面向?qū)ο笫撬谐鯇W(xué)者學(xué)習(xí)的難點，實際上在我個人學(xué)習(xí)的過程之中，對于面向?qū)ο笙肫饋矶加X得頭大，因為其所涉及的概念是非常的多的，有其實很多的同學(xué)學(xué)到現(xiàn)在的時候就會突然發(fā)懵：不知道什么時簡單java類，什么又不是簡單java類，針對于這樣的情況，本次為大家分析三道程序案例。地址類
問題一：編寫并測試一個代表地址的Address類，地址信息由國家、省份、城市、街道、郵編組成，并可以返回完整地址信息。
對于此時的設(shè)計開發(fā)要求本身并沒有過多的繁瑣，因為在之前所編寫的圖書類、部門類等等都與該類的結(jié)構(gòu)非常的相似，所以這種類嚴(yán)格來講就屬于一個簡單java類class Address {// 屬性private封裝private String country;private String province;private String city;private String street;private String zipcode;public Address(){}public Address(String country, String province, String city, String street, String zipcode){this.country = country;this.province = province;this.city = city;this.street = street;this.zipcode = zipcode;}public String getInfo(){return "【Address】國家："+ this.country +"、省份：" + this.province + "、城市：" + this.city + "、街道:"+ this.street + "、郵編:"+ this.zipcode;}public void setCountry(String country){this.country = country;}public void setProvince(String province){this.province = province;}public void setCity(String city){this.city = city;}public void setStreet(String street){this.street = street;}public void setZipcode(String Zipcode){this.zipcode = zipcode;}public String getCountry(String country){return this.country;}public String getProvince(String province){return this.province;}public String getCity(String city){return this.city;}public String getStreet(String street){return this.street;}public String getZipcode(String zipcode){return this.zipcode;} } public class DongJun //主類 {public static void main(String avgs[]){Address addr = new Address("中國","湖北","武漢","新洲區(qū)","00000");System.out.println(addr.getInfo());} }【Address】國家：中國、省份：湖北、城市：武漢、街道:新洲區(qū)、郵編:00000
對于這樣的程序開發(fā)啊，其本身屬于簡單java類，如果連這樣的基本程序都不能夠保證一次性寫對（可以快速的修改正確），那么就不建議你使用任何的開發(fā)工具進行代碼編寫員工信息類
定義并測試一個代表員工的Employee類。員工屬性包括“編號”、“姓名”、“基本薪水”、“薪水增長率”，還包括計算薪水增長額及計算增長后的工資總額的操作方法。同時在該類中要提供有四個構(gòu)造方法：
【無參構(gòu)造】編號定義為1000，姓名定義為無名氏，其他內(nèi)容均為默認(rèn)值；
【單參構(gòu)造】傳遞編號，姓名定義為“新員工”，基本薪水為3000.00,薪水增長率為1%；
【三參構(gòu)造】傳遞編號、姓名、基本工資、薪水增長率為5%；
【四參構(gòu)造】所有的屬性全部進行傳遞。
題目分析：這個程序并不能算是一個完全的簡單java類，因為這個類里面包含有一部分的業(yè)務(wù)處理邏輯（邏輯計算），但是其整體操作結(jié)構(gòu)依然是進行數(shù)據(jù)的存儲。
范例：定義并使用員工類
class Employee {private long empno ;private String ename ;private double salary;private double rate;// setter、getter操作略…… ， 實際代碼之中一定要寫上這些方法public Employee() {this(1000, "無名氏",0.0, 0.0);}public Employee(long empno) {this(empno, "新員工",3000.00,0.01);}public Employee(long empno, String ename , double salary ){this(empno, ename, salary, 0.05);}public Employee(long empno, String ename, double salary, double rate){this.empno = empno;this.ename = ename;this.salary = salary;this.rate = rate;}public double salaryIncValue(){this.salary = this.salary * (1 + this.rate) ;return this.salary ;}public String getInfo(){return "【Employee】員工編號:"+ this.empno + "、員工姓名:"+ this.ename + "、基本工資:"+ this.salary + "、增長額:" + this.rate;} } public class DongJun //主類 {public static void main(String avgs[]){Employee emp = new Employee(9527,"周星星",5000.0,0.1);System.out.println(emp.getInfo());System.out.println("工資增長："+emp.salaryIncValue());} }【Employee】員工編號:9527、員工姓名:周星星、基本工資:5000.0、增長額:0.1
工資增長：5500.0
用戶登錄邏輯
習(xí)題要求：設(shè)計一個表示用戶的User類，類中的變量有用戶名、口令、定義類的3個構(gòu)造方法（無參、為用戶名賦值、為用戶名和口令賦值）、獲取和設(shè)置口令的方法和返回類信息的方法,同時編寫一個進行登錄驗證的處理操作邏輯。
題目分析：對于當(dāng)前的程序邏輯定義類的母的是為了進行用戶登錄，如果說沒有用戶登錄的驗證需求，那么這個時候就是一個純粹的簡單java類，但是發(fā)現(xiàn)有了用戶登錄驗證的需求之后，對于當(dāng)前的程序邏輯就不再是一個簡單的存儲了。
范例：實現(xiàn)用戶的登錄驗證
class User {private String name ;private String password;public User(){this(null,null);}public User(String name){this(name, null);}public User(String name, String password){this.name = name ;this.password = password;}public boolean isLogin(String tempName, String tempPassword) {return tempName.equals(this.name) && tempPassword.equals(this.password);} } public class DongJun //主類 {public static void main(String avgs[]){User user = new User("董俊","123");if (user.isLogin("董俊","123")){System.out.println("用戶登錄成功，可以開始進行程序訪問！");} else {System.out.println("用戶登錄失敗，錯誤的用戶名和密碼！");}} }用戶登錄成功，可以開始進行程序訪問！
此時程序類是一個功能性的操作類，他不再是一個簡單java類，因為讓其存儲的是核心的業(yè)務(wù)處理邏輯。總結(jié)
以上是生活随笔為你收集整理的JavaSE基础知识的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： 16g电脑内存有什么好处_电脑内存8G和
- 下一篇： java美元兑换,（Java实现） 美元