JavaSE---05面向对象(下)
05 面向對象(下)
5.1 關鍵字：static
5.1.1 概念及使用
概念
1.static:靜態的。 2.static 可以用來修飾:屬性、方法、代碼塊、內部類。3.使用 static 修飾屬性:靜態變量(或類變量)。3.1 屬性:是否使用 static 修飾，又分為:靜態屬性 VS 非靜態屬性(實例變量)實例變量:我們創建了類的多個對象，每個對象都獨立的擁有了一套類中的非靜態屬 性。當修改其中一個非靜態屬性時，不會導致其他對象中同樣的屬性值的修飾。靜態變量:我們創建了類的多個對象，多個對象共享同一個靜態變量。當通過靜態變量去修改某一個變量時，會導致其他對象調用此靜態變量時，是修改過的。3.2 static 修飾屬性的其他說明:① 靜態變量隨著類的加載而加載。可以通過"類.靜態變量"的方式進行調用。② 靜態變量的加載要早于對象的創建。③ 由于類只會加載一次，則靜態變量在內存中也只會存在一次。存在方法區的靜態域中。④ 類變量 實例變量類 yes no對象 yes yes通俗說
一套三室一廳一廚一衛的房子出租，三間臥室相當于類的三個實例化對象，其中有各自的屬性如床、柜子、桌子等，彼此之前互不干擾，而廁所和廚房就像是static所修飾的屬性，是所有人共用的，一個人修改了其余人的也更改。
示例
public class StaticTest {public static void main(String[] args) {Chinese.nation = "中國";//實例化前就有了Chinese c1 = new Chinese();c1.name = "姚明";c1.age = 40;c1.nation = "CHN";Chinese c2 = new Chinese();c2.name = "馬龍";c2.age = 30;c2.nation = "CHINA";System.out.println(c1.nation); //CHINA,二者共用的nation//編譯不通過 // Chinese.name = "張繼科"; } } //中國人 class Chinese{String name;int age;static String nation; }5.1.2 類變量的內存解析
5.1.3 static修飾方法
概念
1.使用 static 修飾方法:靜態方法① 隨著類的加載而加載，可以通過"類.靜態方法"的方式調用② 靜態方法 非靜態方法類 yes no對象 yes yes③ 靜態方法中，只能調用靜態的方法或屬性!!!非靜態的方法中，可以調用所有的方法或屬性 2.static 注意點:2.1 在靜態的方法內，不能使用 this 關鍵字、super 關鍵字2.2 關于靜態屬性和靜態方法的使用，從生命周期的角度去理解。3.開發中，如何確定一個屬性是否需要聲明 static 的？- 屬性是可以被多個對象所共享的，不會隨著對象的不同而不同的。- 類中的常量也常常聲明為 static開發中，如何確定一個方法是否要聲明為 static 的？- 操作靜態屬性的方法，通常設置為 static 的- 工具類中的方法，習慣上聲明為 static 的。比如：Math、Arrays、Collections5.1.4 題目示例
//static 關鍵字的應用 public class CircleTest {public static void main(String[] args) {Circle c1 = new Circle();Circle c2 = new Circle();Circle c3 = new Circle(3.4);System.out.println("c1 的 ID:" + c1.getId());//1001System.out.println("c2 的 ID:" + c2.getId());//1002System.out.println("c3 的 ID:" + c3.getId());//1003System.out.println("創建圓的個數: " + Circle.getTotal());//3} }class Circle{private double radius;private int id; //需要自動賦值public Circle(){id = init++;total++;}public Circle(double radius){this();this.radius = radius;}private static int total;//記錄創建圓的個數private static int init = 1001;//static 聲明的屬性被所有對象所共享public double findArea(){return 3.14 * radius * radius;}public double getRadius() {return radius;}public void setRadius(double radius) {this.radius = radius;}public int getId() {return id;}public static int getTotal() {return total;} }5.1.5 單例設計模式
概念
1.所謂類的單例設計模式，就是采取一定的方法保證在整個的軟件系統中，對某個類只能存在一個對象實例
2.如何實現？
? 餓漢式 VS 懶漢式
3.區分餓漢式和懶漢式。
? 餓漢式：壞處:對象加載時間過長。
? 好處:餓漢式是線程安全的。
? 懶漢式：好處:延遲對象的創建。
? 壞處:目前的寫法，會線程不安全。—》到多線程內容時，再修改
代碼示例1—餓漢式
public class SingletonTest {public static void main(String[] args) {Bank bank1 = Bank.getInstance();Bank bank2 = Bank.getInstance();System.out.println(bank1 == bank2);//true，因為只有一個對象} }//單例的餓漢式 class Bank{//1.私有化類的構造器private Bank(){ }//2.內部創見類的對象//4.要求此對象也必須聲明為靜態的private static Bank instance = new Bank();//3.提供公共的靜態的方法，返回類的對象。public static Bank getInstance(){return instance;} }代碼示例2—懶漢式
public class SingletonTest2 {public static void main(String[] args) {Order order1 = Order.getInstance();Order order2 = Order.getInstance(); System.out.println(order1 == order2);//true} } class Order{//1.私有化類的構造器private Order(){ }//2.聲明當前類對象，沒有初始化。//此對象也必須聲明為 static 的private static Order instance = null;//3.聲明 public、static 的返回當前類對象的方法public static Order getInstance(){if(instance == null){instance = new Order(); }return instance;} }5.2 main()方法的語法（了解）
使用說明
1.main()方法作為程序的入口;
2.main()方法也是一個普通的靜態方法
3.main()方法也可以作為我們與控制臺交互的方式。(之前，使用 Scanner)
5.3 代碼塊（類的成員之四）💛
5.3.1 代碼塊概念
概念
1.代碼塊的作用：用來初始化類、對象的
2.代碼塊如果有修飾的話，只能使用static
3.分類:靜態代碼塊 vs 非靜態代碼塊
-
靜態代碼塊
- 內部可以有輸出語句
- **隨著類的加載而執行**,而且**只執行一次**
- 作用:初始化類的信息
- 如果一個類中，定義了多個靜態代碼塊，則按照聲明的先后順序執行
- 靜態代碼塊的執行，**優先于非靜態**代碼塊的執行
- 靜態代碼塊內**只能調用靜態的屬性、靜態的方法**，不能調用非靜態的結構
-
非靜態代碼塊
-
內部可以有輸出語句
-
隨著對象的創建而執行
-
每創建一個對象，就執行一次非靜態代碼塊。
-
作用:可以在創建對象時，對對象的屬性等進行初始化。
-
如果一個類中，定義了多個非靜態代碼塊，則按照聲明的先后順序執行
-
非靜態代碼塊內可以調用靜態的屬性、靜態的方法，或非靜態的屬性、非靜態的方法。
-
5.3.2 變量賦值執行順序💛
構造器、靜態、非靜態的先后順序
見Day5中的Son.java和LeafTest.java中的例子
靜態塊–>非靜態塊–>構造器
屬性賦值先后循序
對屬性可以賦值的位置: ①默認初始化 ②顯式初始化 / ⑤在代碼塊中賦值 //看誰先誰后 ③構造器中初始化 ④有了對象以后，可以通過"對象.屬性"或"對象.方法"的方式，進行賦值。執行的先后順序:① - ② / ⑤ - ③ - ④子類父類內部執行順序
父類靜態代碼塊 ->子類靜態代碼塊 ->父類非靜態代碼塊 -> 父類構造函數 -> 子類非靜態代碼塊 -> 子類構造函數。
5.4 關鍵字：final
概念
- final:最終的
-
final可以用來修飾的結構:類、方法、變量
-
final用來修飾一個類:此類不能被其他類所繼承。
- 比如:String類、System類、StringBuffer類
-
final修飾一個方法:final標記的方法不能被子類重寫。
- 比如：Object類中的getClass()。
-
final用來修飾變量:此時的"變量"(成員變量或局部變量)就是一個常量。名稱大寫，且只能被賦值一次。
-
final修飾屬性，可以賦值的位置有:顯式初始化、代碼塊中初始化、構造器中初始化(每個都要賦值)
-
final修飾局部變量:尤其是使用final修飾形參時，表明此形參是一個常量。當我們調用此方法時，給常量形參賦一個實參。一旦賦值以后，就只能在方法體內使用此形參，但不能進行重新賦值。
-
-
static final 用來修飾:全局常量
代碼示例
final int WIDTH = 0; final int LEFT; final int RIGHT;{LEFT = 1; }public FinalTest(){RIGHT = 2; }public FinalTest(int n){RIGHT = n; }5.5 抽象類與抽象方法
5.5.1 概念
概念
-
abstract:抽象的
-
abstract 可以用來修飾的結構:類、方法
-
abstract 修飾類:抽象類
-
此類不能實例化
-
抽象類中一定有構造器，便于子類實例化時調用(涉及:子類對象實例化全過程)
-
開發中，都會提供抽象類的子類，讓子類對象實例化，實現相關的操作
-
-
abstract 修飾方法:抽象方法
-
抽象方法，只有方法的聲明，沒有方法體。public abstract void eat();
-
包含抽象方法的類，一定是一個抽象類。反之，抽象類中可以沒有抽象方法
-
若子類重寫了父類中所有的抽象方法，此子類方可實例化。
若子類沒有重寫了父類中所有的抽象方法，則此子類也是一個抽象類。
-
-
abstract 使用上的注意點:
-
abstract 不能用來修飾變量、代碼塊、構造器；
-
abstract 不能用來修飾私有方法、靜態方法、final 的方法、final 的類。
-
5.5.2 抽象類的匿名子類
PersonTest類
public class PersonTest {public static void main(String[] args) {method(new Student()); //匿名對象Worker worker = new Worker(); method1(worker); //非匿名的類非匿名的對象method1(new Worker()); //非匿名的類匿名的對象System.out.println("*********************");//創建了一個匿名子類的對象:p //這樣如果只造一個對象就沒必要新造一Person p = new Person(){ //個類了，這樣創建匿名子類更方便@Overridepublic void eat() {System.out.println("吃東西");}@Overridepublic void breath() {System.out.println("呼吸空氣");} };method1(p);System.out.println("**********************"); //創建匿名子類的匿名對象method1(new Person(){@Overridepublic void eat() {System.out.println("吃零食");}@Overridepublic void breath() {System.out.println("云南的空氣");}});}public static void method1(Person p){p.eat();p.walk();}public static void method(Student s){} }class Worker extends Person{@Overridepublic void eat() {}@Overridepublic void breath() {} }5.5.3 抽象的應用–模板方法設計模式
概念
? 當功能內部一部分實現是確定的，一部分實現是不確定的。這時可以把不確定的部分暴露出去（寫成抽象方法），讓子類去實現。
? 換句話說，在軟件開發中實現一個算法時，整體步驟很固定、通用，這些步驟已經在父類中寫好了。但是某些部分易變，易變部分可以抽象出來，供不同子類實現（重寫）。這就是一種模板模式。
示例
public class TemplateMethodTest {public static void main(String[] args) {BankTemplateMethod btm = new DrawMoney();btm.process();BankTemplateMethod btm2 = new ManageMoney();btm2.process();} } abstract class BankTemplateMethod {// 具體方法public void takeNumber() {System.out.println("取號排隊");}//不確定部分（核心所在）public abstract void transact(); // 辦理具體的業務 //鉤子方法public void evaluate() {System.out.println("反饋評分");}// 模板方法，把基本操作組合到一起，子類一般不能重寫public final void process() {this.takeNumber();this.transact();// 像個鉤子，具體執行時，掛哪個子類，就執行哪個子類//的實現代碼this.evaluate();} }class DrawMoney extends BankTemplateMethod {public void transact() {System.out.println("我要取款！！！");} }class ManageMoney extends BankTemplateMethod {public void transact() {System.out.println("我要理財！我這里有 2000 萬美元!!");} }5.6 接口
5.6.1 概念及特點
概念
? 一方面，有時必須從幾個類中派生出一個子類，繼承它們所有的屬性和方法。但是，Java 不支持多重繼承。有了接口，就可以得到多重繼承的效果。
? 另一方面，有時必須從幾個類中抽取出一些共同的行為特征，而它們之間又沒有 is-a 的關系，僅僅是具有相同的行為特征而已。例如：鼠標、鍵盤、打印機、掃描儀、攝像頭、充電器、MP3 機、手機、數碼相機、移動硬盤等都支持 USB 連接。
? 接口就是規范，定義的是一組規則，體現了現實世界中“如果你是/要…則必須能…”的思想。繼承是一個"是不是"的關系，而接口實現則是"能不能"的關系。
? 接口的本質是契約，標準，規范，就像我們的法律一樣。制定好后大家都要遵守。
特點
使用
接口使用interface來定義。
在 Java 中:接口和類是并列的兩個結構
如何去定義兩個接口:定義接口中的成員
-
3.1JDK7 及以前:只能定義全局常量和抽象方法
-
全局常量:只能是public static final 的,但是書寫時，可以省略不寫。
-
抽象方法:只能是public abstract 的
-
-
3.2 JDK8:除了全局常量和抽象方法之外，還可以定義靜態方法、默認方法(略)。
接口中不能定義構造器！意味著接口不可以實例化。
Java 開發中，接口通過讓類去實現(implements)的方式來使用。
-
如果實現類覆蓋了接口中的所有方法，則此實現類就可以實例化。
-
如果實現類沒有覆蓋接口中所有的抽象方法，則此實現類仍為一個抽象類
Java 類可以實現多個接口 —>彌補了 Java 單繼承性的局限性
? 格式:class AA extends BB implementd CC,DD,EE
接口與接口之間是繼承,而且可以多繼承
接口的具體使用，體現多態性。接口的主要用途就是被實現類實現。(面向接口編程)
接口，實際可以看作是一種規范
5.6.2 示例
/** 接口的使用* 1.接口使用上也滿足多態性* 2.接口，實際上就是定義了一種規范* 3.開發中，體會面向接口編程！* */ public class USBTest {public static void main(String[] args) {Computer com = new Computer();//1.創建了接口的非匿名實現類的非匿名對象Flash flash = new Flash();com.transferData(flash); //2. 創建了接口的非匿名實現類的匿名對象com.transferData(new Printer());//3. 創建了接口的匿名實現類的非匿名對象USB phone = new USB(){@Overridepublic void start() {System.out.println("手機開始工作");}@Overridepublic void stop() {System.out.println("手機結束工作");} };com.transferData(phone);//4. 創建了接口的匿名實現類的匿名對象com.transferData(new USB(){@Overridepublic void start() {System.out.println("mp3 開始工作");}@Overridepublic void stop() {System.out.println("mp3 結束工作");}});} }class Computer{public void transferData(USB usb){//USB usb = new Flash();多態usb.start(); System.out.println("具體傳輸數據的細節");usb.stop();} }interface USB{//常量:定義了長、寬void start();void stop(); } class Flash implements USB{@Overridepublic void start() {System.out.println("U 盤開始工作");}@Overridepublic void stop() {System.out.println("U 盤結束工作");} } class Printer implements USB{@Overridepublic void start() {System.out.println("打印機開啟工作");}@Overridepublic void stop() {System.out.println("打印機結束工作");} }5.6.3 接口應用-代理模式
? 代理模式是 Java 開發中使用較多的一種設計模式。代理設計就是為其他對象提供一種代理以控制對這個對象的訪問。
public class NetWorkTest {public static void main(String[] args) {Server server = new Server();ProxyServer proxyServer = new ProxyServer(server);proxyServer.browse();//聯網前的檢查工作-真實的服務器來訪問網絡} } interface NetWork{public void browse();} //被代理類 class Server implements NetWork{@Overridepublic void browse() {System.out.println("真實的服務器來訪問網絡");} } //代理類 class ProxyServer implements NetWork{private NetWork work;public ProxyServer(NetWork work){this.work = work;}public void check(){System.out.println("聯網前的檢查工作");}@Overridepublic void browse() {check(); work.browse();} }5.6.4 面試題
排錯1
interface A {int x = 0; } class B {int x = 1; } class C extends B implements A {public void pX() { // 編譯不通過，x 不明確System.out.println(x); // System.out.println(super.x); //1 // System.out.println(A.x);//0}public static void main(String[] args) {new C().pX();} }排錯2
interface Playable {void play(); } interface Bounceable {void play(); } interface Rollable extends Playable, Bounceable {Ball ball= new Ball("PingPang"); //省略了 public static final } public class Ball implements Rollable {private String name;public String getName() {return name;}public Ball(String name) {this.name= name;}public void play() {ball = new Ball("Football"); //The final field Rollable.ball cannot be assigned.不能再被賦值System.out.println(ball.getName());} }5.6.5 Java8中關于接口的改進
Java8中除了全局常量和抽象方法之外，還可以定義靜態方法、默認方法。
靜態方法：使用 static 關鍵字修飾。可以通過接口直接調用靜態方法，并執行其方法體。
默認方法：默認方法使用 default 關鍵字修飾。可以通過實現類對象來調用。
示例
public class SubClassTest {public static void main(String[] args) {SubClass s = new SubClass(); // s.method1();//調用不了 // SubClass.method1();//調用不了 // 知識點 1：接口中定義的靜態方法，只能通過接口來調用。CompareA.method1(); // 知識點 2：通過實現類的對象，可以調用接口中的默認方法。 // 如果實現類重寫了接口中的默認方法，調用時，仍然調用的是重寫以后的方法s.method2(); // 知識點 3：如果子類(或實現類)繼承的父類和實現的接口中聲明了同名同參數的默認方法， // 那么子類在沒有重寫此方法的情況下，默認調用的是父類中的同名同參數的方法。-->類優先原則 // 知識點 4：如果實現類實現了多個接口，而這多個接口中定義了同名同參數的默認方法， // 那么在實現類沒有重寫此方法的情況下，報錯。-->接口沖突。 // 這就需要我們必須在實現類中重寫此方法s.method3();} } class SubClass extends SuperClass implements CompareA,CompareB{public void method2(){System.out.println("SubClass：上海");}public void method3(){System.out.println("SubClass：深圳");}// 知識點 5：如何在子類(或實現類)的方法中調用父類、接口中被重寫的方法public void myMethod(){method3(); //調用自己定義的重寫的方法super.method3(); //調用的是父類中聲明的 // 調用接口中的默認方法CompareA.super.method3();CompareB.super.method3();} }public interface CompareA {//靜態方法public static void method1() {System.out.println("CompareA:西安");}//默認方法public default void method2(){System.out.println("CompareA:深圳");}default void method3(){System.out.println("CompareA:杭州");} }5.7 內部類（類的成員之五）💛
概念
Java中允許將一個類A聲明在另一個類B中,則類A就是內部類,類B就是外部類.
內部類的分類:成員內部類(靜態、非靜態)VS局部內部類(方法內、代碼塊內、構造器內)
成員內部類
? - 作為外部類的成員,
? - 可以調用外部類的結構（靜態內部類的只能調用靜態方法和屬性）
? - 可以被static修飾
? - 可以被4種不同的權限修飾
? - 作為一個類，
? - 類內可以定義屬性、方法、構造器等
? - 可以被final修飾，表示此類不能被繼承。言外之意，不使用final，就可以被繼承
? - 可以abstract修飾
關注如下的3個問題
-
如何實例化成員內部類的對象
-
如何在成員內部類中區分調用外部類的結構
-
開發中局部內部類的使用 見《InnerClassTest.java》
示例代碼
public class InnerClassTest {public static void main(String[] args) {//創建Dog實例(靜態的成員內部類)Person.Dog dog = new Person.Dog();dog.show();//創建Bird實例(非靜態的成員內部類) // Person.Bird bird = new Person.Bird();//錯誤的Person p = new Person();Person.Bird bird = p.new Bird();bird.sing();System.out.println();bird.display("喜鵲");} } class Person{String name = "李雷";int age;public void eat(){System.out.println("人，吃飯");}//靜態成員內部類static class Dog{String name;int age;public void show(){System.out.println("卡拉是條狗"); // eat();}}//非靜態成員內部類class Bird{String name = "杜鵑";public Bird(){}public void sing(){System.out.println("我是一只貓頭鷹");Person.this.eat();//調用外部類的非靜態屬性eat();System.out.println(age);}public void display(String name){System.out.println(name); //方法的形參System.out.println(this.name); //內部類的屬性System.out.println(Person.this.name); //外部類的屬性}}public void method(){//局部內部類class AA{ }}//代碼塊中{//局部內部類class BB{ }}//構造器中public Person(){//局部內部類class CC{}} }局部內部類示例
// 返回一個實現了Comparable接口的類的對象public Comparable getComparable(){// 創建一個實現了Comparable接口的類:局部內部類//方式一： // class MyComparable implements Comparable{ // // @Override // public int compareTo(Object o) { // return 0; // } // // } // // return new MyComparable();//方式二：匿名方式return new Comparable(){@Overridepublic int compareTo(Object o) {return 0;} };}總結
以上是生活随笔為你收集整理的JavaSE---05面向对象(下)的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： LPNMA
- 下一篇： 【Java--面向对象(下)】