分類: 3C資訊

※自行創業缺乏曝光? 網頁設計幫您第一時間規劃公司的形象門面

網站的第一印象網頁設計，決定了客戶是否繼續瀏覽的意願。台北網動廣告製作的RWD網頁設計，採用精簡與質感的CSS語法，提升企業的專業形象與簡約舒適的瀏覽體驗，讓瀏覽者第一眼就愛上它。

在教育國際化背景下,不少家長選擇讓孩子在學習母語之外,學習另一種語言以提高孩子的核心競爭力,英語作為普及率較高的語言之一成為了不少家長的選擇。而隨着家長教育思想的轉變、國家政策的支持,不少家長選擇讓孩子出國留學。在出國前,家長和孩子往往會遇到各式各樣的問題,憑個人能力無法準確拿捏。近日,《逐夢年代》欄目組有幸請到了這樣一位嘉賓,他的企業能夠對想要出國留學的孩子提供很大的幫助,一起來分享他的教育情懷。

※綠能、環保無空污,成為電動車最新代名詞，目前市場使用率逐漸普及化

台中景泰電動車行只是一個單純的理由，將來台灣的環境，出門可以自由放心的深呼吸，讓空氣回歸自然的乾淨，減少污染，留給我們下一代有好品質無空污的優質環境

本期訪談嘉賓張景舒,杭州浩海教育諮詢有限公司董事長、浩海聯合創始人,“你好-故事”公益組織的創始人。曾獲得詹姆斯格萊格獎(康奈爾大學工程學院最高獎),康奈爾大學“歐”創業競賽銀牌,麻省理工學院脫口秀第一名, 曾任職於沃帝華等知名量化對沖基金。橫跨文學、工程、商科三個領域,擁有豐富的知識、閱歷儲備。張景舒坦言,自身的留學經歷曾因為不靠譜的留學中介帶來了陰霾,高考的分數只夠申請密歇根大學,在自身的不斷努力之下,成功轉學到康奈爾大學,為了幫助更多有留學夢的師弟師妹,他毅然投入到這份事業中來,為學子們帶來最專業的留學諮詢。

浩海留學是一家專註於美英高端留學的教育諮詢機構。機構由美國哈佛大學、麻省理工學院、康奈爾大學、密歇根大學、牛津大學、劍橋大學等知名學府畢業生創立,旨在為廣大中國赴英美留學生提供高端且專業的留學諮詢服務。不同於傳統留學中介,浩海留學智創的“互聯網+共享顧問”新模式能夠給每一位學生提供同專業名校畢業且奮戰在該領域一線的專業導師,為其量身定製該專業的背景提升規劃,申請指導,文書創作,以及就業指導來幫助申請者以相同的分數獲得更好的錄取結果;同時,公司理念區別於一般機構的“包辦”模式,浩海秉承“全程協同”、“全程透明“的模式,用心讓每個孩子找到自己的價值,挖掘出自己的潛力。

文書作為出國留學的申請材料之一,一直以來處於重要地位,因為它不僅能向錄取院校從各個角度展現申請者的求學動機,學術學習能力,還是唯一可以和招生官直接溝通的機會。正是意識到了文書的重要性,張景舒開始致力於為學生量身定製,提供個性化的教育諮詢服務,幫助學生打造最優質的軟背景,讓他們在這個國際競技舞台上脫穎而出,圓夢名校。

本站聲明:網站內容來http://www.societynews.cn/html/wh/fq/,如有侵權,請聯繫我們,我們將及時處理

※如何讓商品強力曝光呢? 網頁設計公司幫您建置最吸引人的網站，提高曝光率!

以設計的實用美學觀點，規劃出舒適、美觀的視覺畫面，有效提昇使用者的心理期待，營造出輕鬆、愉悅的網站瀏覽體驗。

※廣告預算用在刀口上，台北網頁設計公司幫您達到更多曝光效益

擁有後台管理系統的網站，將擁有強大的資料管理與更新功能，幫助您隨時新增網站的內容並節省網站開發的成本。

入冬后，花謝凋零，綠恭弘=叶 恭弘枯萎，生活中少了盎然的綠色生機。在漫長的冬季與綠色相伴成為居民們對美好生活的需求。為滿足居民的這一願望，12月11日下午，江蘇省無錫市新吳區梅村街道梅荊三社區居委會邀請園藝師，給轄區盆景愛好者舉辦了一次盆栽製作及管理的技藝講座。

※推薦台中搬家公司優質服務,可到府估價

台中搬鋼琴,台中金庫搬運,中部廢棄物處理,南投縣搬家公司,好幫手搬家,西屯區搬家

講授中，園藝老師詳細講解了製作盆景的技巧、所需的各種材料的選取，還傳授了盆栽植物的構景、具體的種植和管理方法。隨後，園藝老師把提前準備的製作材料一一分發給大家，指導大家將營養土放入盆中，並根據前低后高的原則，種植好網紋草，將土壓實，鋪上苔蘚和砂石，再插上兩個可愛的小擺件做裝飾。製作中，大家相互提示、相互交流，把對美好生活的嚮往和對綠色大自然的情感傾注於盆景製作中。經過大家的精妙構景和創意，一件件精美的盆栽應運而生。看到自己製作的盆景，大嫂們臉上露出了滿足的笑容，互相欣賞、拍照留念。

講座結束時，大嫂們猶味未盡，表示要到田野里採集宜冬種植的花草製作盆景，在隆冬的家裡享受綠色盎然的“春天”。

（吳建農  糜嘉怡）

本站聲明:網站內容來http://www.societynews.cn/html/wh/fq/,如有侵權,請聯繫我們,我們將及時處理

※台中搬家公司教你幾個打包小技巧,輕鬆整理裝箱!

還在煩惱搬家費用要多少哪？台中大展搬家線上試算搬家費用，從此不再擔心「物品怎麼計費」、「多少車才能裝完」

※廣告預算用在刀口上，台北網頁設計公司幫您達到更多曝光效益

有別於一般網頁架設公司，除了模組化的架站軟體，我們的營業主軸還包含：資料庫程式開發、網站建置、網頁設計、電子商務專案開發、系統整合、APP設計建置、專業網路行銷。

遇到認真的讀者是作者的一種幸運，真的，上一篇接口推送后，有好幾個讀者留言說，“二哥，你有一處內容需要修正，應該是接口中不能有 private 和 protected 修飾的方法。”說實話，看到這樣的留言，我內心是非常欣慰的，因為你投出去的一塊石頭在水面上激起了一串美麗的漣漪。

在 Java 中，一個類可以繼承另外一個類或者實現多個接口，我想這一點，大部分的讀者應該都知道了。還有一點，我不確定大家是否知道，就是一個接口也可以繼承另外一個接口，就像下面這樣：

public interface OneInterface extends Cloneable {
}

這樣做有什麼好處呢？我想有一部分讀者應該已經猜出來了，就是實現了 OneInterface 接口的類，也可以使用 Object.clone() 方法了。

public class TestInterface implements OneInterface {
    public static void main(String[] args) throws CloneNotSupportedException {
        TestInterface c1 = new TestInterface();
        TestInterface c2 = (TestInterface) c1.clone();
    }
}

除此之外，我們還可以在 OneInterface 接口中定義其他一些抽象方法（比如說深拷貝），使該接口擁有 Cloneable 所不具有的功能。

public interface OneInterface extends Cloneable {
    void deepClone();
}

看到了吧？這就是繼承的好處：子接口擁有了父接口的方法，使得子接口具有了父接口相同的行為；同時，子接口還可以在此基礎上自由發揮，添加屬於自己的行為。

以上，把“接口”換成“類”，結論同樣成立。讓我們來定義一個普通的父類 Wanger：

public class Wanger {
    int age;
    String name;
    void write() {
        System.out.println("我寫了本《基督山伯爵》");
    }
}

然後，我們再來定義一個子類 Wangxiaoer，使用關鍵字 extends 來繼承父類 Wanger：

public class Wangxiaoer extends Wanger{
    @Override
    void write() {
        System.out.println("我寫了本《茶花女》");
    }
}

我們可以將通用的方法和成員變量放在父類中，達到代碼復用的目的；然後將特殊的方法和成員變量放在子類中，除此之外，子類還可以覆蓋父類的方法（比如write() 方法）。這樣，子類也就煥發出了新的生命力。

Java 只支持單一繼承，這一點，我在上一篇接口的文章中已經提到過了。如果一個類在定義的時候沒有使用 extends 關鍵字，那麼它隱式地繼承了 java.lang.Object 類——在我看來，這恐怕就是 Java 號稱萬物皆對象的真正原因了。

那究竟子類繼承了父類的什麼呢？

子類可以繼承父類的非 private 成員變量，為了驗證這一點，我們來看下面這個示例。

public class Wanger {
    String defaultName;
    private String privateName;
    public String publicName;
    protected String protectedName;
}

父類 Wanger 定義了四種類型的成員變量，缺省的 defaultName、私有的 privateName、共有的 publicName、受保護的 protectedName。

在子類 Wangxiaoer 中定義一個測試方法 testVariable()：

可以確認，除了私有的 privateName，其他三種類型的成員變量都可以繼承到。

同理，子類可以繼承父類的非 private 方法，為了驗證這一點，我們來看下面這個示例。

public class Wanger {
    void write() {
    }

    private void privateWrite() {
    }

    public void publicWrite() {
    }

    protected void protectedWrite() {
    }
}

父類 Wanger 定義了四種類型的方法，缺省的 write、私有的 privateWrite()、共有的 publicWrite()、受保護的 protectedWrite()。

在子類 Wangxiaoer 中定義一個 main 方法，並使用 new 關鍵字新建一個子類對象：

※Google地圖已可更新顯示潭子電動車充電站設置地點!!

日本、大陸，發現這些先進的國家已經早就讓電動車優先上路，而且先進國家空氣品質相當好，電動車節能減碳可以減少空污

可以確認，除了私有的 privateWrite()，其他三種類型的方法都可以繼承到。

不過，子類無法繼承父類的構造方法。如果父類的構造方法是帶有參數的，代碼如下所示：

public class Wanger {
    int age;
    String name;

    public Wanger(int age, String name) {
        this.age = age;
        this.name = name;
    }
}

則必須在子類的構造器中顯式地通過 super 關鍵字進行調用，否則編譯器將提示以下錯誤：

修復后的代碼如下所示：

public class Wangxiaoer extends Wanger{
    public Wangxiaoer(int age, String name) {
        super(age, name);
    }
}

is-a 是繼承的一個明顯特徵，就是說子類的對象引用類型可以是一個父類類型。

public class Wangxiaoer extends Wanger{
    public static void main(String[] args) {
        Wanger wangxiaoer = new Wangxiaoer();
    }
}

同理，子接口的實現類的對象引用類型也可以是一個父接口類型。

public interface OneInterface extends Cloneable {
}
public class TestInterface implements OneInterface {
    public static void main(String[] args) {
        Cloneable c1 = new TestInterface();
    }
}

儘管一個類只能繼承一個類，但一個類卻可以實現多個接口，這一點，我在上一篇文章也提到過了。另外，還有一點我也提到了，就是 Java 8 之後，接口中可以定義 default 方法，這很方便，但也帶來了新的問題：

如果一個類實現了多個接口，而這些接口中定義了相同簽名的 default 方法，那麼這個類就要重寫該方法，否則編譯無法通過。

FlyInterface 是一個會飛的接口，裏面有一個簽名為 sleep() 的默認方法：

public interface FlyInterface {
    void fly();
    default void sleep() {
        System.out.println("睡着飛");
    }
}

RunInterface 是一個會跑的接口，裏面也有一個簽名為 sleep() 的默認方法：

public interface RunInterface {
    void run();
    default void sleep() {
        System.out.println("睡着跑");
    }
}

Pig 類實現了 FlyInterface 和 RunInterface 兩個接口，但這時候編譯出錯了。

原本，default 方法就是為實現該接口而不覆蓋該方法的類提供默認實現的，現在，相同方法簽名的 sleep() 方法把編譯器搞懵逼了，只能重寫了。

public class Pig implements FlyInterface, RunInterface {

    @Override
    public void fly() {
        System.out.println("會飛的豬");
    }

    @Override
    public void sleep() {
        System.out.println("只能重寫了");
    }

    @Override
    public void run() {
        System.out.println("會跑的豬");
    }
}

類雖然不能繼承多個類，但接口卻可以繼承多個接口，這一點，我不知道有沒有觸及到一些讀者的知識盲區。

public interface WalkInterface extends FlyInterface,RunInterface{
    void walk();
}

學到了吧？學到就是賺到。

我是沉默王二，一枚有趣的程序員。如果覺得文章對你有點幫助，請微信搜索「 沉默王二 」第一時間閱讀，回復【666】更有我為你精心準備的 500G 高清教學視頻（已分門別類）。

本文 GitHub 已經收錄，有大廠面試完整考點，歡迎 Star。

原創不易，莫要白票，請你為本文點個贊吧，這將是我寫作更多優質文章的最強動力。

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

※廣告預算用在刀口上，台北網頁設計公司幫您達到更多曝光效益

有別於一般網頁架設公司，除了模組化的架站軟體，我們的營業主軸還包含：資料庫程式開發、網站建置、網頁設計、電子商務專案開發、系統整合、APP設計建置、專業網路行銷。

※產品缺大量曝光嗎?你需要的是一流包裝設計!

窩窩觸角包含自媒體、自有平台及其他國家營銷業務等，多角化經營並具有國際觀的永續理念。

餓漢式

// 餓漢式單例
public class Hungry {
    
    //構造器私有
    private Hungry(){

    }
    // 一上來就把這個類加載了
    private final static  Hungry HUNGRY = new Hungry();

    public static Hungry getInstance(){
        return HUNGRY;
    }
}

// 餓漢式單例
public class Hungry {
    // 這4組數據非常耗內存資源，餓漢式一上來就把所有的內存裏面的東西全部加載進來了，就存在這個空間
    // 但這個空間現在是沒有使用的，可能會造成浪費空間
    private byte[] data1 = new byte[1024*1024];
    private byte[] data2 = new byte[1024*1024];
    private byte[] data3 = new byte[1024*1024];
    private byte[] data4 = new byte[1024*1024];
    
    //構造器私有
    private Hungry(){

    }
    // 一上來就把這個類加載了
    private final static  Hungry HUNGRY = new Hungry();

    public static Hungry getInstance(){
        return HUNGRY;
    }

}

餓漢式單例可能會造成浪費空間，所以想要用的時候再去創建這個對象，平時就先放在這個地方，於是就出現了懶漢式！

懶漢式

// 懶漢式單例
public class LazyMan {
	
   // 構造器私有
    private LazyMan(){
       
    }

    private  static LazyMan lazyMan;

   
    public static LazyMan getInstance(){
       
        if (lazyMan==null){
            lazyMan = new LazyMan(); 
        }
        return lazyMan;
    }
}

它是有問題的，單線程下確實單例ok，多線程併發就會出現問題！

測試

// 懶漢式單例
public class LazyMan {
	
   // 構造器私有
    private LazyMan(){
       System.out.println(Thread.currentThread().getName()+":: ok");
    }

    private  static LazyMan lazyMan;

   
    public static LazyMan getInstance(){
       
        if (lazyMan==null){
            lazyMan = new LazyMan(); 
        }
        return lazyMan;
    }
    
    public static void main(String[] args) {

        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                LazyMan.getInstance();
            }).start();
        }
    }
}

發現單例有問題，每次結果可能都不一樣！

解決

// 懶漢式單例
public class LazyMan {


    private LazyMan(){
        System.out.println(Thread.currentThread().getName()+":: ok");
    }

    private  static LazyMan lazyMan;

    // 雙重檢測鎖模式的 懶漢式單例 DCL懶漢式
    public static LazyMan getInstance(){
        if (lazyMan==null){
            synchronized (LazyMan.class){
                if (lazyMan==null){
                    lazyMan = new LazyMan(); 
                }
            }
        }
        return lazyMan;
    }

     public static void main(String[] args) {

         for (int i = 0; i < 10 ; i++) {
             new Thread(()->{
                LazyMan.getInstance();
             }).start();
         }
     }
}

但在極端情況下還是可能出現問題

經歷三個步驟：

1、 分配內存空間

2、 執行構造方法，初始化對象

3、 把這個對象指向這個空間

有可能會發生指令重排的操作！

比如，期望它執行 123 ，但是它真實可能執行132，比如第一個A線程過來執行了132，先分配空間再吧這個空間佔用了，佔用之後再去執行構造方法，如果現在突然來了個B線程，由於A已經指向這個空間了，它會以為這個 lazyMan 不等於 null ，直接return ，此時lazyMan還沒有完成構造，所以必須避免這個問題！

必須加上volatile

// 懶漢式單例
public class LazyMan {


    private LazyMan(){
        System.out.println(Thread.currentThread().getName()+":: ok");
    }
	// 避免指令重排
    private volatile static LazyMan lazyMan;

    // 雙重檢測鎖模式的 懶漢式單例 DCL懶漢式
    public static LazyMan getInstance(){
        if (lazyMan==null){
            synchronized (LazyMan.class){
                if (lazyMan==null){
                    lazyMan = new LazyMan(); 
                }
            }
        }
        return lazyMan;
    }

     public static void main(String[] args) {

         for (int i = 0; i < 10 ; i++) {
             new Thread(()->{
                LazyMan.getInstance();
             }).start();
         }
     }
}

靜態內部類

// 靜態內部類
public class Holder {
    private Holder(){

    }
    public static Holder getInstance(){
        return InnerClass.HOLDER;
    }
    public static  class InnerClass{
        private static final Holder HOLDER = new Holder();
    }
}

也是單例模式的一種，不安全！

單例不安全 反射

// 懶漢式單例
public class LazyMan {


    private LazyMan(){
        System.out.println(Thread.currentThread().getName()+":: ok");
    }

    private volatile static LazyMan lazyMan;

    // 雙重檢測鎖模式的 懶漢式單例 DCL懶漢式
    public static LazyMan getInstance(){
        if (lazyMan==null){
            synchronized (LazyMan.class){
                if (lazyMan==null){
                    lazyMan = new LazyMan(); //不是一個原子性操作
                }
            }
        }
        return lazyMan;
    }


    //反射
     public static void main(String[] args) throws Exception {
         LazyMan instance1 = LazyMan.getInstance();
         Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
         declaredConstructor.setAccessible(true); // 無視了私有的構造器
         // 通過反射創建對象
         LazyMan instance2 = declaredConstructor.newInstance();

         System.out.println(instance1);
         System.out.println(instance2);
     }
}

結論：反射可以破壞這種單例

解決

// 懶漢式單例
public class LazyMan {

    private LazyMan(){
        synchronized (LazyMan.class){
            if (lazyMan!=null){
                throw new RuntimeException("不要試圖使用反射破環 異常");
            }
        }
        System.out.println(Thread.currentThread().getName()+":: ok");
    }

    private volatile static LazyMan lazyMan;

    // 雙重檢測鎖模式的 懶漢式單例 DCL懶漢式
    public static LazyMan getInstance(){
        if (lazyMan==null){
            synchronized (LazyMan.class){
                if (lazyMan==null){
                    lazyMan = new LazyMan(); //不是一個原子性操作
                }
            }
        }
        return lazyMan;
    }

    //反射
     public static void main(String[] args) throws Exception {
         LazyMan instance1 = LazyMan.getInstance();
         Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
         declaredConstructor.setAccessible(true); // 無視了私有的構造器
         // 通過反射創建對象
         LazyMan instance2 = declaredConstructor.newInstance();

         System.out.println(instance1);
         System.out.println(instance2);
     }
}

但是如果都用反射創建對象的情況下，還是會破環單例！

測試

※南投搬家公司費用需注意的眉眉角角，別等搬了再說!

上新台中搬家公司提供您一套專業有效率且人性化的辦公室搬遷、公司行號搬家及工廠遷廠的搬家服務

解決

// 懶漢式單例
public class LazyMan {
      // 標誌位
    private static boolean abc = false;

    private LazyMan(){
        synchronized (LazyMan.class){
            if (abc==false){
                abc=true;
            }else {
                throw new RuntimeException("不要試圖使用反射破環 異常");
            }
          
        }
        System.out.println(Thread.currentThread().getName()+":: ok");
    }
    private volatile static LazyMan lazyMan;

    // 雙重檢測鎖模式的 懶漢式單例 DCL懶漢式
    public static LazyMan getInstance(){
        if (lazyMan==null){
            synchronized (LazyMan.class){
                if (lazyMan==null){
                    lazyMan = new LazyMan(); //不是一個原子性操作
                }
            }
        }
        return lazyMan;
    }

    //反射
    public static void main(String[] args) throws Exception {
        //LazyMan instance1 = LazyMan.getInstance();
        Constructor<LazyMan> declaredConstructor = LazyMan.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true); // 無視了私有的構造器
        // 通過反射創建對象
        LazyMan instance2 = declaredConstructor.newInstance();
        LazyMan instance1 = declaredConstructor.newInstance();

        System.out.println(instance1);
        System.out.println(instance2);
    }
}

但是如果被人知道 abc這個變量，也可以破環！

單例又被破環了！

看一下源碼

它說不能使用反射破環枚舉，枚舉是jdk1.5出現的，自帶單例模式！

測試，寫一個枚舉類

// enum 本身就是一個class類
public enum EnumSingle {

    INSTANCE;
    public EnumSingle getInstance(){
        return INSTANCE;
    }
}

查看它的源碼

試圖破環！

// enum 本身就是一個class類
public enum EnumSingle {

    INSTANCE;
    public EnumSingle getInstance(){
        return INSTANCE;
    }
}
class Test{
    public static void main(String[] args) throws Exception {
        EnumSingle instance1 = EnumSingle.INSTANCE;
        Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(null);
        declaredConstructor.setAccessible(true);
        EnumSingle instance2 = declaredConstructor.newInstance();
        System.out.println(instance1);
        System.out.println(instance2);
    }
}

它竟然說我現在的這個枚舉類中沒有空參構造器！

然後就去源碼里分析！

找到這個class文件！利用javap反編譯一下！

發現這個也显示有一個空參構造，證明這個也不對，用第三方的工具查看！

利用它再吧class文件生成java文件！

打開這個java文件

證明是idea和源碼騙了我！

再次嘗試破環！

// enum 本身就是一個class類
public enum EnumSingle {

    INSTANCE;
    public EnumSingle getInstance(){
        return INSTANCE;
    }
}
class Test{
    public static void main(String[] args) throws Exception {
        EnumSingle instance1 = EnumSingle.INSTANCE;
        Constructor<EnumSingle> declaredConstructor = EnumSingle.class.getDeclaredConstructor(String.class,int.class);
        declaredConstructor.setAccessible(true);
        EnumSingle instance2 = declaredConstructor.newInstance();
        System.out.println(instance1);
        System.out.println(instance2);
    }
}

結論：反射無法破環枚舉類！

本站聲明:網站內容來源於博客園,如有侵權,請聯繫我們,我們將及時處理

※自行創業缺乏曝光? 網頁設計幫您第一時間規劃公司的形象門面

網動廣告出品的網頁設計，採用精簡與質感的CSS語法，提升企業的專業形象與簡約舒適的瀏覽體驗，讓瀏覽者第一眼就愛上她。