案例題目
程式設計實作People類的封裝，特征有：姓名、年齡、國籍，要求提供列印所有特征的方法。
程式設計實作PeopleTest類，main方法中使用有參方式構造兩個對象并列印。
/*
程式設計實作People類的封裝
*/
public class People {
// 1.私有化成員變量，使用private關鍵字修飾
private String name;
private int age;
//private String country; // 隸屬于對象層級，也就是每個對象都擁有獨立的一份
//public static String country; // 隸屬于類層級，也就是整個類隻有一份并且被所有對象共享
private static String country;
// 3.在構造方法中調用set方法進行合理值的判斷
public People() {}
public People(String name, int age/*, String country*/) {
setName(name);
setAge(age);
//setCountry(country);
}
// 2.提供公有的get和set方法，并在方法體中進行合理值的判斷
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
if(age > 0 && age < 150) {
this.age = age;
} else {
System.out.println("年齡不合理哦！！！");
}
}
public static String getCountry() {
return country;
}
public static void setCountry(String country) {
//this.country = country;
People.country = country;
}
public void show() {
System.out.println("我是" + getName() + "，今年" + getAge() + "歲了，來自" + getCountry());
}
}
/*
程式設計實作People類的測試
*/
public class PeopleTest {
public static void main(String[] args) {
// 3.驗證static關鍵字修飾的靜态成員(類成員)是否與建立對象無關 類名.的方式 => 無關
//System.out.println("擷取到的國籍資訊是：" + People.country); // null
System.out.println("擷取到的國籍資訊是：" + People.getCountry()); // null
// 1.使用有參方式構造兩個People類型的對象并列印特征
People p1 = new People("zhangfei", 30/*, "China"*/);
p1.show(); // zhangfei 30 China
People p2 = new People("guanyu", 35/*, "China"*/);
p2.show(); // guanyu 35 China
System.out.println("--------------------------------------------");
// 2.驗證static關鍵字修飾的靜态成員(類成員) 是否被所有對象共享 => 共享
//p1.country = "蜀國";
p1.setCountry("蜀國");
//System.out.println("第一個對象的國籍是：" + p1.country); // 蜀國
//System.out.println("第二個對象的國籍是：" + p2.country); // 蜀國
System.out.println("第一個對象的國籍是：" + p1.getCountry()); // 蜀國
System.out.println("第二個對象的國籍是：" + p2.getCountry()); // 蜀國
People p3 = new People();
//System.out.println("第三個對象的國籍是：" + p3.country); // 蜀國
System.out.println("第三個對象的國籍是：" + p3.getCountry()); // 蜀國
}
}
擷取到的國籍資訊是：null
我是zhangfei，今年30歲了，來自null
我是guanyu，今年35歲了，來自null
--------------------------------------------
第一個對象的國籍是：蜀國
第二個對象的國籍是：蜀國
第三個對象的國籍是：蜀國
static關鍵字的由來
static關鍵字的作用
基本概念
- 使用static關鍵字修飾成員變量表示靜态的含義，此時成員變量由對象層級提升為類層級，也就是整個類隻有一份并被所有對象共享，該成員變量随着類的加載準備就緒，與是否建立對象無關。
- static關鍵字修飾的成員可以使用引用.的方式通路，但推薦類名.的方式
使用方式
-
在非靜态成員方法中既能通路非靜态的成員又能通路靜态的成員。
(成員：成員變量 + 成員方法， 靜态成員被所有對象共享)
-
在靜态成員方法中隻能通路靜态成員不能通路非靜态成員。
(成員：成員變量 + 成員方法， 因為此時可能還沒有建立對象)
-
在以後的開發中隻有隸屬于類層級并被所有對象共享的内容才可以使用
static關鍵字修飾。(不能濫用static關鍵字)
/*
程式設計實作static關鍵字的使用
*/
public class StaticTest {
private int cnt = 1; // 隸屬于對象層級，也就是每個對象都擁有獨立的一份
private static int snt = 2; // 隸屬于類層級，也就是所有對象都共享同一份
// 自定義非靜态的成員方法 需要使用引用.的方式通路
public void show() {
System.out.println("cnt = " + this.cnt); // 1
System.out.println("snt = " + this.snt); // 2 靜态成員被所有對象共享，this關鍵字可以省略
}
// 自定義靜态的成員方法 推薦使用類名.的方式通路
public static void test() {
// StaticTest st = new StaticTest();
//System.out.println("cnt = " + cnt); // 1 靜态成員方法中沒有this關鍵字，因為是可以通過類名.方式調用的
System.out.println("snt = " + snt); // 2
}
public static void main(String[] args) {
StaticTest st = new StaticTest();
st.show();
System.out.println("--------------------------------");
StaticTest.test();
}
}
cnt = 1
snt = 2
--------------------------------
snt = 2
構造塊和靜态代碼塊（熟悉）
- 構造塊：在類體中直接使用{}括起來的代碼塊。
- 每建立一個對象都會執行一次構造塊。
- 靜态代碼塊：使用static關鍵字修飾的構造塊。
- 靜态代碼塊随着類加載時執行一次
/*
程式設計實作構造塊和靜态代碼塊的使用
*/
public class BlockTest {
// 當需要在執行構造方法體之前做一些準備工作時，則将準備工作的相關代碼寫在構造塊中即可，比如：對成員變量進行的統一初始化操作
{
System.out.println("構造塊！"); // (2)
}
// 靜态代碼塊會随着類的加載而準備就緒，會先于構造塊執行
// 當需要在執行代碼塊之前随着類的加載做一些準備工作時，則編寫代碼到靜态代碼塊中，比如：加載資料庫的驅動包等
static {
System.out.println("#####################靜态代碼塊！"); // (1)
}
// 自定義構造方法
public BlockTest() {
System.out.println("====構造方法體！"); // (3)
}
public static void main(String[] args) {
BlockTest bt = new BlockTest();
BlockTest bt2 = new BlockTest();
}
}
#####################靜态代碼塊！
構造塊！
====構造方法體！
構造塊！
====構造方法體！
public class SuperTest {
{
System.out.println("SuperTest類中的構造塊！"); // (2) c
}
static {
System.out.println("SuperTest類中的靜态代碼塊！"); // (1) a
}
public SuperTest() {
System.out.println("SuperTest類中的構造方法體！"); // (3) d
}
public static void main(String[] args) {
// 使用無參方式構造對象
SuperTest st = new SuperTest();
}
}
SuperTest類中的靜态代碼塊！
SuperTest類中的構造塊！
SuperTest類中的構造方法體！
// 導入java目錄中lang目錄中System類中的靜态成員out 很少使用
import static java.lang.System.out;
public class SubSuperTest extends SuperTest {
{
System.out.println("==========SubSuperTest類中的構造塊！"); // (2) e
}
static {
System.out.println("==========SubSuperTest類中的靜态代碼塊！"); // (1) b
}
public SubSuperTest() {
//System.out.println("==========SubSuperTest類中的構造方法體！"); // (3) f
out.println("==========SubSuperTest類中的構造方法體！");
}
public static void main(String[] args) {
// 使用無參方式構造子類的對象
SubSuperTest sst = new SubSuperTest();
}
}
SuperTest類中的靜态代碼塊！==========SubSuperTest類中的靜态代碼塊！SuperTest類中的構造塊！SuperTest類中的構造方法體！==========SubSuperTest類中的構造塊！==========SubSuperTest類中的構造方法體！
又見main方法
文法格式：
public static void main(String[] args){}
參數使用的舉例
參數數組中元素的個數是：0
傳遞給main方法的實際參數為：
單例設計模式的概念
- 在某些特殊場合中，一個類對外提供且隻提供一個對象時，這樣的類叫做單例類，而設計單例的流程和思想叫做單例設計模式。
單例設計模式的實作流程
- 私有化構造方法，使用private關鍵字修飾。
- 聲明本類類型的引用指向本類類型的對象，并使用private static關鍵字共同修飾。
- 提供公有的get方法負責将對象傳回出去，并使用public static關鍵字共同修飾。
單例設計模式的實作方式
- 單例設計模式的實作方式有兩種：餓漢式 和 懶漢式，在以後的開發中推薦餓漢式。
Static案例題目
程式設計實作Singleton類的封裝。
程式設計實作SingletonTest類對Singleton類進行測試，要求main方法中能得到且隻能得到該類的一個對象
顯示結果：
true
單例設計模式的執行流程