封裝的概念
面向對象程序三大特性：封裝、繼承、多態。而類和對象階段，主要研究的就是封裝特性。何為封裝呢？簡單來說 就是套殼屏蔽細節。
比如：對于電腦這樣一個復雜的設備，提供給用戶的就只是：開關機、通過鍵盤輸入，顯示器，USB插孔等，讓用 戶來和計算機進行交互，完成日常事務。
但實際上：電腦真正工作的卻是CPU、顯卡、內存等一些硬件元件。
對于計算機使用者而言，不用關心內部核心部件，比如主板上線路是如何布局的，CPU內部是如何設計的等，用戶 只需要知道，怎么開機、怎么通過鍵盤和鼠標與計算機進行交互即可。因此計算機廠商在出廠時，在外部套上殼 子，將內部實現細節隱藏起來，僅僅對外提供開關機、鼠標以及鍵盤插孔等，讓用戶可以與計算機進行交互即可。
封裝：將數據和操作數據的方法進行有機結合，隱藏對象的屬性和實現細節，僅對外公開接口來和對象進行 交互
訪問限定符?
Java中主要通過類和訪問權限來實現封裝：類可以將數據以及封裝數據的方法結合在一起，更符合人類對事物的認 知，而訪問權限用來控制方法或者字段能否直接在類外使用。Java中提供了四種訪問限定符：
比如：
public：可以理解為一個人的外貌特征，誰都可以看得到
default: 對于自己家族中(同一個包中)不是什么秘密，對于其他人來說就是隱私了
private：只有自己知道，其他人都不知道?
說明
protected主要是用在繼承中，繼承部分詳細介紹
default權限指：什么都不寫時的默認權限
訪問權限除了可以限定類中成員的可見性，也可以控制類的可見性
public class Computer {private String cpu; // cpuprivate String memory; // 內存public String screen; // 屏幕String brand; // 品牌---->default屬性public Computer(String brand, String cpu, String memory, String screen) {this.brand = brand;this.cpu = cpu;this.memory = memory;this.screen = screen;}public void Boot(){System.out.println("開機~~~");}public void PowerO?(){System.out.println("關機~~~");}public void SurfInternet(){System.out.println("上網~~~"); }}public class TestComputer {public static void main(String[] args) {Computer p = new Computer("HW", "i7", "8G", "13*14");System.out.println(p.brand);?// default屬性：只能被本包中類訪問System.out.println(p.screen); //?public屬性： 可以任何其他類訪問// ?System.out.println(p.cpu);??// private屬性：只能在Computer類中訪問，不能被其他類訪問}}注意：一般情況下成員變量設置為private，成員方法設置為public。
封裝擴展之包
包的概念
在面向對象體系中，提出了一個軟件包的概念，即：為了更好的管理類，把多個類收集在一起成為一組，稱為軟件包。有點類似于目錄。比如：為了更好的管理電腦中的歌曲，一種好的方式就是將相同屬性的歌曲放在相同文件 下，也可以對某個文件夾下的音樂進行更詳細的分類。
在Java中也引入了包，包是對類、接口等的封裝機制的體現，是一種對類或者接口等的很好的組織方式，比如：一 個包中的類不想被其他包中的類使用。包還有一個重要的作用：在同一個工程中允許存在相同名稱的類，只要處在不同的包中即可。
導入包中的類?
Java 中已經提供了很多現成的類供我們使用. 例如Date類：可以使用類. java.util.Date 導入java.util 這個包中的 Date類
public class Test {public static void main(String[] args) {java.util.Date date = new java.util.Date();// 得到一個毫秒級別的時間戳System.out.println(date.getTime());}}但是這種寫法比較麻煩一些, 可以使用 import語句導入包.
import java.util.Date; public class Test {public static void main(String[] args) {Date date = new Date(); // 得到一個毫秒級別的時間戳System.out.println(date.getTime());}}如果需要使用 java.util 中的其他類, 可以使用 import java.util.*
import java.util.*;public class Test {public static void main(String[] args) {Date date = new Date(); // 得到一個毫秒級別的時間戳System.out.println(date.getTime());}}但是我們更建議顯式的指定要導入的類名. 否則還是容易出現沖突的情況.
import java.util.*;import java.sql.*;public class Test {public static void main(String[] args) {// util 和 sql 中都存在一個 Date 這樣的類, 此時就會出現歧義, 編譯出錯Date date = new Date();System.out.println(date.getTime());}}// 編譯出錯 Error:(5, 9) java: 對Date的引用不明確 java.sql 中的類 java.sql.Date 和 java.util 中的類 java.util.Date 都匹配在這種情況下需要使用完整的類名
import java.util.*;import java.sql.*;public class Test {public static void main(String[] args) {java.util.Date date = new java.util.Date();System.out.println(date.getTime());}}可以使用import static導入包中靜態的方法和字段?
注意事項: import 和 C++ 的 #include import 只是為了寫代碼的時候更方便.
import static java.lang.Math.*;public class Test {public static void main(String[] args) {double x = 30;double y = 40;// 靜態導入的方式寫起來更方便一些.// double result = Math.sqrt(Math.pow(x, 2) + Math.pow(y, 2));double result = sqrt(pow(x, 2) + pow(y, 2));System.out.println(result);}
}注意事項: import 和 C++ 的 #include 差別很大. C++ 必須 #include 來引入其他文件內容, 但是 Java 不需要. import 只是為了寫代碼的時候更方便.?import 更類似于 C++ 的 namespace 和 using
自定義包
基本規則
1. 在文件的最上方加上一個 package 語句指定該代碼在哪個包中.
2. 包名需要盡量指定成唯一的名字, 通常會用公司的域名的顛倒形式(例如 com.bit.demo1).
3. 包名要和代碼路徑相匹配. 例如創建 com.bit.demo1 的包, 那么會存在一個對應的路徑
com/bit/demo1?來存儲代碼.
4. 如果一個類沒有 package 語句, 則該類被放到一個默認包中.
操作步驟
1. 在 IDEA 中先新建一個包: 右鍵 src -> 新建 -> 包
2. 在彈出的對話框中輸入包名, 例如 com.bit.demo1?在包中創建類, 右鍵包名 -> 新建 -> 類, 然后輸入類名即可.
4. 此時可以看到我們的磁盤上的目錄結構已經被 IDEA 自動創建出來了
?
5. 同時我們也看到了, 在新創建的 Test.java 文件的最上方, 就出現了一個 package 語句
?包的訪問權限控制舉例
Computer類位于com.bit.demo1包中，TestComputer位置com.bit.demo2包中：
package com.bit.demo1;public class Computer {private String cpu; // cpu
private String memory; // 內存
public String screen; // 屏幕
String brand; // 品牌public Computer(String brand, String cpu, String memory, String screen) { this.brand = brand;
this.cpu = cpu;
this.memory = memory;
this.screen = screen;
}public void Boot(){
System.out.println("開機~~~");
}public void PowerO?(){
System.out.println("關機~~~");
}public void SurfInternet(){
System.out.println("上網~~~");
}
}/// package com.bite.demo2;import com.bite.demo1.Computer;public class TestComputer { public static void main(String[] args) {Computer p = new Computer("HW", "i7", "8G", "13*14");System.out.println(p.screen);
// System.out.println(p.cpu); // 報錯：cup是私有的，不允許被其他類訪問 // System.out.println(p.brand); // 報錯：brand是default，不允許被其他包中的類訪問}}// 注意：如果去掉Computer類之前的public修飾符，代碼也會編譯失敗常見的包?
1. java.lang:系統常用基礎類(String、Object),此包從JDK1.1后自動導入。
2. java.lang.re?ect:java 反射編程包;
3. java.net:進行網絡編程開發包。
4. java.sql:進行數據庫開發的支持包。
5. java.util:是java提供的工具程序包。(集合類等) 非常重要
6. java.io:I/O編程開發包。
static成員
再談學生類
使用前文中介紹的學生類實例化三個對象s1、s2、s3，每個對象都有自己特有的名字、性別，年齡，學分績點等成 員信息，這些信息就是對不同學生來進行描述的，如下所示：
public class Student{// ...public static void main(String[] args) {Student s1 = new Student("Li leilei", "男", 18, 3.8);Student s2 = new Student("Han MeiMei", "女", 19, 4.0);Student s3 = new Student("Jim", "男", 18, 2.6); }}
?
假設三個同學是同一個班的，那么他們上課肯定是在同一個教室，那既然在同一個教室，那能否給類中再加一個成 員變量，來保存同學上課時的教室呢？答案是不行的。
之前在Student類中定義的成員變量，每個對象中都會包含一份(稱之為實例變量)，因為需要使用這些信息來描述 具體的學生。而現在要表示學生上課的教室，這個教室的屬性并不需要每個學生對象中都存儲一份，而是需要讓所 有的學生來共享。在Java中，被static修飾的成員，稱之為靜態成員，也可以稱為類成員，其不屬于某個具體的對象，是所有對象所共享的。
static修飾成員變量
?static修飾的成員變量，稱為靜態成員變量，靜態成員變量最大的特性：不屬于某個具體的對象，是所有對象所共享的。
【靜態成員變量特性】
1. 不屬于某個具體的對象，是類的屬性，所有對象共享的，不存儲在某個對象的空間中
2. 既可以通過對象訪問，也可以通過類名訪問，但一般更推薦使用類名訪問
3. 類變量存儲在方法區當中
4. 生命周期伴隨類的一生(即：隨類的加載而創建，隨類的卸載而銷毀)
public class Student{public String name;
public String gender;
public int age;
public double score;
public static String classRoom = "Bit306";// ...public static void main(String[] args) {// 靜態成員變量可以直接通過類名訪問
System.out.println(Student.classRoom);Student s1 = new Student("Li leilei", "男", 18, 3.8);
Student s2 = new Student("Han MeiMei", "女", 19, 4.0);
Student s3 = new Student("Jim", "男", 18, 2.6);// 也可以通過對象訪問：但是classRoom是三個對象共享的
System.out.println(s1.classRoom);
System.out.println(s2.classRoom);
System.out.println(s3.classRoom);
}}大家以調試方式運行上述代碼，然后在監視窗口中可以看到，靜態成員變量并沒有存儲到某個具體的對象中。
static修飾成員方法
一般類中的數據成員都設置為private，而成員方法設置為public，那設置之后，Student類中classRoom屬性如何 在類外訪問呢？
public class Student{
private String name;
private String gender;
private int age;
private double score;
private static String classRoom = "Bit306";// ...}public class TestStudent {
public static void main(String[] args) {
System.out.println(Student.classRoom);
}
}編譯失敗：Error:(10, 35) java: classRoom 在 extend01.Student 中是 private 訪問控制那static屬性應該如何訪問呢？
Java中，被static修飾的成員方法稱為靜態成員方法，是類的方法，不是某個對象所特有的。靜態成員一般是通過 靜態方法來訪問的。
public class Student{ // ...private static String classRoom = "Bit306";// ...public static String getClassRoom(){
return classRoom;
}}public class TestStudent {public static void main(String[] args) { System.out.println(Student.getClassRoom()); }}
輸出：Bit306【靜態方法特性】
1. 不屬于某個具體的對象，是類方法
2. 可以通過對象調用，也可以通過類名.靜態方法名(...)方式調用，更推薦使用后者
3. 不能在靜態方法中訪問任何非靜態成員變量
public static String getClassRoom(){
System.out.println(this);
return classRoom;
}// 編譯失敗：Error:(35, 28) java: 無法從靜態上下文中引用非靜態 變量 thispublic static String getClassRoom(){age += 1;return classRoom;}// 編譯失敗：Error:(35, 9) java: 無法從靜態上下文中引用非靜態 變量 age4. 靜態方法中不能調用任何非靜態方法，因為非靜態方法有this參數，在靜態方法中調用時候無法傳遞this引用
public static String getClassRoom(){
doClass();
return classRoom;
}// 編譯報錯：Error:(35, 9) java: 無法從靜態上下文中引用非靜態 方法 doClass()static成員變量初始化
注意：靜態成員變量一般不會放在構造方法中來初始化，構造方法中初始化的是與對象相關的實例屬性 靜態成員變量的初始化分為兩種：就地初始化 和 靜態代碼塊初始化。
1. 就地初始化
就地初始化指的是：在定義時直接給出初始值
public class Student{private String name;private String gender;private int age;private double score;private static String classRoom = "Bit306";// ...}2. 靜態代碼塊初始化
那什么是代碼塊呢？繼續往后看 :) ~~~
代碼塊
代碼塊概念以及分類
使用 {}定義的一段代碼稱為代碼塊。根據代碼塊定義的位置以及關鍵字，又可分為以下四種：
普通代碼塊
構造塊
靜態塊
同步代碼塊（后續講解多線程部分再談）
普通代碼塊
普通代碼塊：定義在方法中的代碼塊.
public class Main{public static void main(String[] args) {
{ //直接使用{}定義，普通方法塊int x = 10 ;System.out.println("x1 = " +x);}int x = 100 ;System.out.println("x2 = " +x);}}// 執行結果x1 = 10x2 = 100這種用法較少見
構造代碼塊
構造塊：定義在類中的代碼塊(不加修飾符)。也叫：實例代碼塊。構造代碼塊一般用于初始化實例成員變量。
public class Student{//實例成員變量private String name;private String gender;private int age;private double score;public Student() {System.out.println("I am Student init()!");}//實例代碼塊{this.name = "bit";this.age = 12;this.sex = "man";System.out.println("I am instance init()!");}public void show(){System.out.println("name: "+name+" age: "+age+" sex: "+sex);}}public class Main {public static void main(String[] args) {Student stu = new Student(); stu.show();}}// 運行結果I am instance init()!I am Student init()!name: bit age: 12 sex: man靜態代碼塊
使用static定義的代碼塊稱為靜態代碼塊。一般用于初始化靜態成員變量。
public class Student{private String name;private String gender;private int age; private double score;private static String classRoom;//實例代碼塊{this.name = "bit";this.age = 12;this.gender = "man";System.out.println("I am instance init()!");}// 靜態代碼塊static {classRoom = "bit306";System.out.println("I am static init()!");}public Student(){System.out.println("I am Student init()!");}public static void main(String[] args) {Student s1 = new Student();Student s2 = new Student();}}注意事項
靜態代碼塊不管生成多少個對象，其只會執行一次
靜態成員變量是類的屬性，因此是在JVM加載類時開辟空間并初始化的
如果一個類中包含多個靜態代碼塊，在編譯代碼時，編譯器會按照定義的先后次序依次執行(合并)
實例代碼塊只有在創建對象時才會執行
內部類
當一個事物的內部，還有一個部分需要一個完整的結構進行描述，而這個內部的完整的結構又只為外部事物提供服 務，那么這個內部的完整結構最好使用內部類。在 Java 中，可以將一個類定義在另一個類或者一個方法的內部， 前者稱為內部類，后者稱為外部類。內部類也是封裝的一種體現。
public class OutClass {
class InnerClass{}}// OutClass是外部類
// InnerClass是內部類【注意事項】
1. 定義在class 類名{}花括號外部的，即使是在一個文件里，都不能稱為內部類
public class A{}class B{}// A 和 B是兩個獨立的類，彼此之前沒有關系2. 內部類和外部類共用同一個java源文件，但是經過編譯之后，內部類會形成單獨的字節碼文件
內部類的分類
先來看下，內部類都可以在一個類的那些位置進行定義
public class OutClass {// 成員位置定義：未被static修飾 --->實例內部類
public class InnerClass1{ }// 成員位置定義：被static修飾 ---> 靜態內部類
static class InnerClass2{}public void method(){// 方法中也可以定義內部類 ---> 局部內部類：幾乎不用
class InnerClass5{}}}根據內部類定義的位置不同，一般可以分為以下幾種形式：
1. 成員內部類(普通內部類：未被static修飾的成員內部類 和 靜態內部類：被static修飾的成員內部類)
2. 局部內部類(不談修飾符)、匿名內部類
注意：內部類其實日常開發中使用并不是非常多，大家在看一些庫中的代碼時候可能會遇到的比較多，日常開始中 使用最多的是匿名內部類。
內部類
在外部類中，內部類定義位置與外部類成員所處的位置相同，因此稱為成員內部類。
實例內部類
即未被static修飾的成員內部類。
public class OutClass {private int a;
static int b;
int c; public void methodA(){a = 10;System.out.println(a);}public static void methodB(){ System.out.println(b); }// 實例內部類：未被static修飾 class InnerClass{int c; public void methodInner(){ // 在實例內部類中可以直接訪問外部類中：任意訪問限定符修飾的成員a = 100;b =200;methodA(); methodB();// 如果外部類和實例內部類中具有相同名稱成員時，優先訪問的是內部類自己的c = 300;System.out.println(c);// 如果要訪問外部類同名成員時候，必須：外部類名稱.this.同名成員名字 OutClass.this.c = 400; System.out.println(OutClass.this.c);}}public static void main(String[] args) {// 外部類：對象創建 以及 成員訪問 OutClass outClass = new OutClass(); System.out.println(outClass.a); System.out.println(outClass.b); System.out.println(outClass.c); outClass.methodA(); outClass.methodB();System.out.println("=============實例內部類的訪問=============");// 要訪問實例內部類中成員，必須要創建實例內部類的對象
// 而普通內部類定義與外部類成員定義位置相同，因此創建實例內部類對象時必須借助外部類// 創建實例內部類對象
OutClass.InnerClass innerClass1 = new OutClass().new InnerClass();// 上述語法比較怪異，也可以先將外部類對象先創建出來，然后再創建實例內部類對象 OutClass.InnerClass innerClass2 = outClass.new InnerClass(); innerClass2.methodInner();} }
【注意事項】
1. 外部類中的任何成員都可以在實例內部類方法中直接訪問
2. 實例內部類所處的位置與外部類成員位置相同，因此也受public、private等訪問限定符的約束
3. 在實例內部類方法中訪問同名的成員時，優先訪問自己的，如果要訪問外部類同名的成員，必須：外部類名 稱.this.同名成員 來訪問
4. 實例內部類對象必須在先有外部類對象前提下才能創建
5. 實例內部類的非靜態方法中包含了一個指向外部類對象的引用
6. 外部類中，不能直接訪問實例內部類中的成員，如果要訪問必須先要創建內部類的對象。
靜態內部類
被static修飾的內部成員類稱為靜態內部類。
public class OutClass {private int a;
static int b;
public void methodA(){a = 10;System.out.println(a);}public static void methodB(){
System.out.println(b); }// 靜態內部類：被static修飾的成員內部類
static class InnerClass{public void methodInner(){
// 在內部類中只能訪問外部類的靜態成員
// a = 100; // 編譯失敗，因為a不是類成員變量b =200;// methodA(); methodB();// 編譯失敗，因為methodB()不是類成員方法}}public static void main(String[] args) {
// 靜態內部類對象創建 & 成員訪問
OutClass.InnerClass innerClass = new OutClass.InnerClass(); innerClass.methodInner(); }}【注意事項】
1. 在靜態內部類中只能訪問外部類中的靜態成員
如果確實想訪問，我們該如何做？
2. 創建靜態內部類對象時，不需要先創建外部類對象
局部內部類
定義在外部類的方法體或者{}中，該種內部類只能在其定義的位置使用，一般使用的非常少，此處簡單了解下語法格式。
public class OutClass {int a = 10;public void method(){int b = 10;// 局部內部類：定義在方法體內部 // 不能被public、static等訪問限定符修飾
class InnerClass{public void methodInnerClass(){System.out.println(a);System.out.println(b);}
}// 只能在該方法體內部使用，其他位置都不能用
InnerClass innerClass = new InnerClass();
innerClass.methodInnerClass();}public static void main(String[] args) {
// OutClass.InnerClass innerClass = null; 編譯失敗 }}【注意事項】
1. 局部內部類只能在所定義的方法體內部使用
2. 不能被public、static等修飾符修飾
3. 編譯器也有自己獨立的字節碼文件，命名格式：外部類名字$數字內部類名字.class
4. 幾乎不會使用
對象的打印
public class Person { String name; String gender; int age;public Person(String name, String gender, int age) { this.name = name; this.gender = gender; this.age = age;
}public static void main(String[] args) { Person person = new Person("Jim","男", 18); System.out.println(person); }}// 打印結果：day20210829.Person@1b6d3586如果想要默認打印對象中的屬性該如何處理呢？答案：重寫toString方法即可。
public class Person { String name; String gender; int age;public Person(String name, String gender, int age) { this.name = name; this.gender = gender; this.age = age;
}@Override
public String toString() { return "[" + name + "," + gender + "," + age + "]"; }public static void main(String[] args) { Person person = new Person("Jim","男", 18); System.out.println(person); }}// 輸出結果：[Jim,男,18]???????
)
 不要通過 throw 變換生成器狀態)
