Java使用的擴展

1、JVM的內存模型

棧和堆的區別參考：https://blog.csdn.net/jianghao233/article/details/82777789

堆存放的是對象，

棧存放的是局部變量和對象的地址

2、單例設計模式

2.1、設計模式

設計模式是在軟件工程實踐過程中，程序員們總結出的良好的編程方法。使用設計模式能夠增加系統的健壯性，易修改性和可擴展性，當你進行開發的軟件規模比較大的時候，良好的設計模式會給編程帶來便利，讓系統更加穩定，

設計模式，即軟件架構、實現思路，一方面便于后期擴展，二方面便于研發，各種框架如struts、ssh、spring mvc其實就是設計模式。

2.2、單例設計模式基本介紹

單例設計模式是在軟件系統中采用一定的方法，保證某個類只能存在一個實例對象，并且該類只能有一個靜態方法來獲取該對象。比如如果實例化一個對象需要消耗大量的時間和資源的時候你可能就需要單例模式

單例模式確保某個類只有一個實例，而且自行實例化并向整個系統提供這個實例。在計算機系統中，線程池、緩存、日志對象、對話框、打印機、顯卡的驅動程序對象常被設計成單例。這些應用都或多或少具有資源管理器的功能。每臺計算機可以有若干個打印機，但只能有一個Printer Spooler，以避免兩個打印作業同時輸出到打印機中。每臺計算機可以有若干通信端口，系統應當集中管理這些通信端口，以避免一個通信端口同時被兩個請求同時調用。總之，選擇單例模式就是為了避免不一致狀態，避免政出多頭。

單例模式有以下特點：

單例類只能有一個實例。
單例類必須自己創建自己的唯一實例。
單例類必須給所有其他對象提供這一實例。

示例代碼：

import test.Singleton;
public class Client
{
    public static void main(String[] args){
        Singleton singleton1 = Singleton.getInstance();
        Singleton singleton2 = Singleton.getInstance();
        System.out.println(singleton1 == singleton2);   //true
    }
}

2.3、餓漢式實現單例模式

該方式是靜態常量實現的餓漢式（在類加載的時候就創建實例）：

public class Singleton {
   //構造器私有化，防止new對象
    private Singleton() {}    
    
    //類內部實例化，賦值給私有的靜態變量
    private final static Singleton INSTANCE = new Singleton();

    //對外提供公有方法調用
    public static Singleton getInstance(){
        return INSTANCE;
    }
}

//使用單例設計模式的類
Singleton s = Singleton.getInstance();

餓漢式的單例模式的特點：

1）類加載的時候實例化，防止多線程問題。

2）沒有使用懶加載，類加載就產生對象，如果始終未使用則造成內存浪費。但是該對象只有一個，浪費空間也不是很大，可以使用，編寫的時候非常簡單。

2.4、懶漢式實現單例模式

懶漢式實現單例模式，也就是在第一次調用方法的時候才創建實例。懶漢式和餓漢式的區別就在于在什么時候創建實例

public class Singleton {
    private static Singleton instance;

    //構造器私有化，防止new對象
    private Singleton() {}

    //只有在第一次使用該方法的時候構造實例對象，使用synchronized避免多線程問題
    public static synchronized Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

懶漢式的單例模式的特點：

1）解決了線程不安全問題

2）效率低下，每次調用該方法都要涉及鎖的操作。

2.5、單例設計模式的使用場景

一個對象即可完成所有的工作，無需大量創建對象消耗資源。比如一個長連接，建立起來就可以不斷發送數據，此時如果每來一個請求就建立一個連接，那么資源會消耗殆盡。一般來說，如果實例化一個類對象需要消耗過多資源或者是沒必要多次創建實例對象時你就可以考慮使用單例設計模式。

3、Java中的初始化塊

Java中初始化塊（代碼塊）的作用是對 Java 對象進行初始化。

Java 中程序的執行順序：1、聲明成員變量的默認值 2、成員變量在聲明時顯式賦值 3、多個代碼塊依次被執行 4、類的構造函數對成員進行賦值

Demo04 d = new Demo04();

//下面標出在執行實例化時程序的執行順序
public class Demo04 {
    public int num = 0;   //1
    
    public Demo04() {    //4
        this.num = 10;
    }
    
    {  //2
        System.out.println("執行代碼塊");
    }
   {  //3
        System.out.println("執行代碼塊");
    }
}

3.1、靜態代碼塊

一個類中初始化塊如果有修飾符，則只能被 static 修飾，稱為靜態代碼塊。

靜態代碼塊隨著類的加載而執行，而且只執行一次。靜態代碼塊在多次創建實例對象時只會執行一次，非靜態代碼塊在每次實例化時都會被執行。靜態代碼塊的執行優先級高于非靜態的初始化塊，它會在類初始化的時候執行一次，執行完成便銷毀。

如果有些代碼必須在項目啟動的時候就執行，需要使用靜態代碼塊。我們一般使用靜態代碼塊來初始化比較復雜的類變量，即 static 修飾的數據成員。

實例代碼如下：

public class UtilTest {
    private static String val;

    static {
        UtilTest.val = "初始化值";
    }
}

4、Java中的工廠模式

工廠模式就是用工廠方法（返回一個實例化對象）來生成類的實例對象，代替 new 的操作，需要 new 一個對象的時候就直接調用工廠方法。

工廠模式可以避免一旦類發生了一些改變（比如類名改變）時，項目中所有對該類的實例化都需要修改的情況，使用了工廠模式后，類發生修改只需要修改相應的工廠方法即可。

class Mouse{
    public void sayHi(){};
}

class DellMouse extends Mouse{
    @Override
    public void sayHi() {
        System.out.println("產品：戴爾鼠標");
    }
}
class HpMouse extends Mouse{
    @Override
    public void sayHi() {
        System.out.println("產品：惠普鼠標");
    }
}

//生產工廠接口
interface MouseFactory{
    public Mouse createMouse();
}

//不同的鼠標交由不同的工廠生產
//惠普鼠標工廠方法
class HpMouseFactory implements MouseFactory{
    @Override
    public Mouse createMouse() {
        return new HpMouse();
    }
}
//戴爾鼠標工廠方法
class DellMouseFactory implements MouseFactory{
    @Override
    public Mouse createMouse() {
        return new DellMouse();
    }
}

//測試類
public class Test {
    public static void main(String[] args) {
        MouseFactory hpFact = new HpMouseFactory();
        MouseFactory dellFact = new DellMouseFactory();
        Mouse hpm = hpFact.createMouse();
        Mouse dellm = dellFact.createMouse();
        hpm.sayHi();
        dellm.sayHi();
    }
}

5、內部類

可以將一個類的定義放在里另一個類的內部，這就是內部類，內部類可以有多個。

//外部類（外部是相對內部而言）
public class Outer{
    public String name;
    //內部類
    class Inner{
        Outer.this.name = "wen";   //訪問外部類屬性
        ...
    }
}

內部類可以聲明為 final
和外部類不同，內部類可以聲明為 private 或者 protected。
內部類可以聲明為 static，但此時就不可以使用外部類的非 static 成員變量
內部類可以聲明為抽象類，被其他內部類繼承

5.1、內部類的作用

使用內部類可以間接地解決 Java 中類無法多繼承的問題。

內部類擁有類的基本特征，它可以繼承父類，實現接口，無論外部類是否已經繼承了某個類或者實現了某個接口，對于內部類都沒有影響。我們可以通過內部類來繼承其他的類，由此外部類就可以通過內部類來訪問多個其他類的方法或者屬性，間接實現了多重繼承。

//下面 A 類間接繼承了 B和C 類，擁有了 B和C 的方法
class A {
    
   //方法中調用內部類方法
    public void TestB () {
         new InnerB().testB();
    }
    public void TestC () {
         new InnerC().testC();
    }

    //通過內部類繼承B
    private class InnerB extends B {
         @Override
         public void TestB() {
              ...
         }
    }
   //通過內部類繼承C
    private class InnerC extends C {
         @Override
         public void TestB() {
              ...
         }
    }
}

class B {
    public void testB(){}
}
class C {
    public void testC(){}
}

posted @ 2020-05-05 00:11 wenxuehai 閱讀(662) 評論(0) 收藏舉報

刷新頁面返回頂部

提升自己，才有選擇的能力和勇氣