Java的單例模式與final及抽象類和接口實例分析

這篇文章主要介紹“Java的單例模式與final及抽象類和接口實例分析”的相關知識，小編通過實際案例向大家展示操作過程，操作方法簡單快捷，實用性強，希望這篇“Java的單例模式與final及抽象類和接口實例分析”文章能幫助大家解決問題。

1.單例模式

1.餓漢式和懶漢式的實現

步驟：

• 將構造器私有化

• 類的內部創建對象

• 向外暴露一個靜態的公共方法

2.餓漢式

class School1 {
    //餓漢式
    private String name;
    //在類的內部直接創建對象
    private static School1 sc = new School1("清華大學");
    //將構造器私有化
    private School1(String name) {
        this.name = name;
    }
    //提供一個公共的static方法返回對象
    public static School getInstance() {
        return sc;
    }
}

3.懶漢式

class School2 {
    //懶漢式
    private String name;
    //在類的內部直接創建對象
    private static School2 sc;
    //將構造器私有化
    private School2(String name) {
        this.name = name;
    }
    //提供一個公共的static方法返回對象
    //若對象為null創建對象否則直接返回對象
    public static School2 getInstance() {
        if (sc == null) {
            sc = new School2("清華大學");
        }
        return sc;
    }
}

4.懶漢式和餓漢式的區別

• 創建對象的時機不同：餓漢式在類加載是就創建了對象，懶漢式是在使用時再創建。

• 餓漢式不存在線程安全問題，懶漢式存在線程安全問題。

• 餓漢式在類加載是就創建了對象所以存在資源浪費的問題，但懶漢式就不存在這個問題。

2.final的使用

1.基本介紹

final可以修飾類，屬性，方法和局部變量。

2.使用場景

①當不希望父類被繼承。

②當不希望父類的方法被子類重寫。

③當不希望類的某個屬性被修改

④當不希望某個局部變量被修改

final class A{};//當不希望父類被繼承。
class B{
    public final void display(){};//當不希望父類的方法被子類重寫。
    public final int A_B = 10;//當不希望類的某個屬性被修改
    public void show(){
        final int A_c = 20;//當不希望某個局部變量被修改
    }
}

3.使用注意事項和細節討論

1.final修飾的屬性又叫常量，一般用 XX_XX

2.final修飾的屬性定義時，必須在以下位置賦初值

①定義時直接賦值。

②在構造器中賦值。

③在代碼塊中賦值。(普通屬性在普通代碼塊初始化，靜態屬性在靜態代碼塊初始化)

class A {
//  定義時直接賦值。
    public final  int a = 10;
//    {
//        a = 10;//在代碼塊中賦值。
//    }
//
//    public A() {
//        a = 10;//在構造器中賦值。
//    }
}

3.如果final修飾的屬性是static，則初始化的為位置只能是

①定義時直接賦值。

②在靜態代碼塊中賦值。

class A {
//  定義時直接賦值。
    public final static int a = 10;
//    static {
//        a = 10;//在靜態代碼塊中賦值。
//    }
//    public A() {
//   final修飾的屬性是static，則初始化的為位置不能是構造器
//        a = 10;
//    }
}

4.final類不能繼承，但可以實例化對象。

5.final修飾的方法雖然不能重寫，但可以被繼承。

6.final不能修飾構造器。

7.final 和 static 搭配使用，不會導致類的加載，效率更高。

8.包裝類(Integer,Double,Float,Boolean,String等都是final修飾的)

3.抽象類

1.基本介紹

用abstract關鍵字修飾的類叫抽象類，abstract還可以用來修飾一個方法，即抽象類。

abstract class A{   
    abstract void display();
    //當一個類中有一個抽象方法，這個類也要定義為抽象類
}

2.使用注意事項和細節討論

1.抽象類不能被實例化。

2.抽象類可以沒有abstract方法。

3.當一個類中有一個抽象方法，這個類也要定義為抽象類。

4.abstract只能修飾類和方法，不能修飾屬性和其他。

5.抽象類可以有任意成員，但抽象方法不能有實現主體。

6.如果一個類繼承了抽象類，則必須要實現抽象類的所有方法。

7.抽象方法不能用private，static，final來修飾，因為這些關鍵字與重寫相違背

4.接口

1.基本介紹

interface 接口名{
    //屬性
    //方法(可以為抽象方法，靜態方法，默認方法)
    //在JDk7.0之前接口的所有方法都為抽象方法
}
class 類名 implements 接口{
    自己屬性;
    自己方法;
    必須實現的接口的抽象方法；

}

public interface UsbInterface {
    int a = 10;//實際上是public final static int a = 10;
    void connect();
    void close();//抽象方法
    default public void display(){//默認方法
        System.out.println("接口中的方法被調用~");
    }
    public static void show(){//靜態方法
        System.out.println("接口中的靜態方法被調用~");
    }
}

2.注意事項和細節討論

1.接口不能被實例化

2.接口中所有的方法時 public 方法，接口中抽象方法，可以不用 abstract 修飾

3.一個普通類實現接口。就必須將該接口的所有方法都實現，可以使用alt+enter來解決

4.抽象類去實現接口時，可以不實現接口的抽象方法。

5.當一個類實現了一個接口，這個類就可以調用接口中的所有屬性和默認方法，但不能調用接口中的靜態方法。

public class MySql implements UsbInterface{
    @Override
    public void connect() {
        System.out.println("MySql被調用");
        display();
        System.out.println(a);
    }
    @Override
    public void close() {
        System.out.println("MySql被關閉");
    }
}

3.實現接口與繼承的區別

1.繼承是將父類的所有繼承過來，子類天生就擁有父類的所有屬性，實現接口就像是后天學習其他的沒有的技能。

2.繼承的價值主要在于：解決代碼的復用性和可維護性。

3.接口的價值主要在于：設計規范。更加靈活。

4.繼承是滿足is-a的關系，接口只需滿足like-a的關系。

5.接口在一定程度上實現了代碼解耦。

4.接口與繼承同時出現如何訪問屬性

public class Interface01 {
}
interface A{
    int x = 10;
}
class B {
    int x = 20;
}
class C extends B implements A{
    public void display(){
        System.out.println( A.x + "+" + super.x );
    }
    //接口的屬性直接通過接口名訪問，父類通過super訪問
    public static void main(String[] args) {
        new C().display();
    }
}

5.接口的多態特性

1.多態參數

接口可以接受不同的對象，接口的引用也可以指向實現了接口的類的對象。

public class InterfaceDetails {
    public static void main(String[] args) {
        MySql mySql = new MySql();
        Oracle oracle = new Oracle();
        t(mySql);
        t(oracle);
       UsbInterface UIf = mySql;
    }
    public static void t(UsbInterface mb) {
        mb.close();
        mb.connect();
    }
}

2.多態數組

public interface UsbInterface {
    void work();
}
public class Phone implements UsbInterface{
    @Override
    public void work() {
        System.out.println("手機正在工作。。。");
    }
    public void call(){
        System.out.println("手機正在打電話。。。");
    }
}
public class Camera implements UsbInterface{
    @Override
    public void work() {
        System.out.println("相機正在工作。。。");
    }
}

public class Interface02 {
    public static void main(String[] args) {
        UsbInterface[] uIF = new  UsbInterface[2];
        Phone phone = new Phone();
        Camera camera = new Camera();
        uIF[0]= phone;
        uIF[1]= camera;
        for (int i = 0; i < 2; i++) {
            uIF[i].work();
            if(uIF[i] instanceof Phone){
                ((Phone) uIF[i]).call();
            }
        }
    }
}

3.接口存在多態傳遞現象

interface AA{
    void display();
}
interface BB extends AA{
}
class CC implements BB{
    @Override
    public void display() {
    }
}

關于“Java的單例模式與final及抽象類和接口實例分析”的內容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業相關的知識，可以關注億速云行業資訊頻道，小編每天都會為大家更新不同的知識點。