封裝的概念
面向對象程序三大特性:封裝、繼承、多態。而類和對象階段,主要研究的就是封裝特性。何為封裝呢?簡單來說 就是套殼屏蔽細節。
比如:對于電腦這樣一個復雜的設備,提供給用戶的就只是:開關機、通過鍵盤輸入,顯示器,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: 無法從靜態上下文中引用非靜態 變量 age
4. 靜態方法中不能調用任何非靜態方法,因為非靜態方法有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]
???????