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