Bagaimana untuk melaksanakan corak strategi Java menggunakan kod

Corak strategi

Corak strategi ialah salah satu daripada 23 corak tingkah laku di Jawa Mari kita lihat dahulu apa itu corak strategi.

1. Apakah itu Corak Strategi?

Definisi Corak Strategi:

Corak reka bentuk ini merangkumi satu siri algoritma supaya ia boleh diganti antara satu sama lain. Perubahan algoritma tidak akan menjejaskan penggunaan pelanggan. Corak strategi tergolong dalam corak tingkah laku objek Ia merangkum algoritma, memisahkan tanggungjawab untuk menggunakan algoritma daripada pelaksanaan algoritma, dan mewakilkan pengurusan algoritma ini kepada objek yang berbeza.

Malah, dalam kehidupan sebenar, kita sering menghadapi situasi di mana terdapat pelbagai strategi untuk dipilih untuk mencapai matlamat tertentu Contohnya, semasa melancong, anda boleh menaiki kapal terbang, menaiki kereta api, menunggang basikal , atau memandu kereta persendirian anda sendiri, dsb. Atau sebagai contoh, untuk membeli-belah dalam talian, anda boleh memilih Bank Perindustrian dan Komersial China, Bank Pertanian China, Bank Pembinaan China, dll., tetapi algoritma yang mereka sediakan adalah sama, iaitu untuk membantu anda membayar.

Situasi yang sama akan dihadapi dalam pembangunan perisian Apabila terdapat berbilang algoritma atau strategi untuk melaksanakan fungsi tertentu, kita boleh memilih algoritma atau strategi yang berbeza untuk melengkapkan fungsi mengikut persekitaran atau keadaan yang berbeza. Fungsi.

2. Kelebihan dan Kelemahan Corak Strategi

Kelebihan:

• Berbilang pernyataan bersyarat sukar dikekalkan, tetapi menggunakan corak strategi boleh Elakkan menggunakan berbilang pernyataan bersyarat

• Melalui warisan, kod awam keluarga algoritma boleh diletakkan dalam kelas induk untuk mengelakkan penggunaan semula kod dan menyediakan satu siri algoritma boleh guna semula

• Menyediakan pelaksanaan yang berbeza bagi tingkah laku yang sama, pelanggan boleh memilih yang berbeza mengikut keperluan masa atau ruang yang berbeza

• Memberikan sokongan sempurna untuk pembukaan dan penutupan prinsip, Anda boleh menambah algoritma baharu secara fleksibel tanpa mengubah suai kod asal, meletakkan penggunaan algoritma

• ke dalam kelas persekitaran, dan memindahkan pelaksanaan algoritma ke dalam kelas strategi tertentu, mencapai dua Pemisahan

Kelemahan:

• Pelanggan mesti memahami perbezaan antara semua algoritma strategi untuk memilih yang sesuai pada masa yang tepat Kelas algoritma

• Corak strategi mewujudkan banyak kelas strategi, yang meningkatkan kesukaran penyelenggaraan

3 struktur corak strategi

1 .Kelas strategi abstrak: mentakrifkan antara muka awam.

2. Kelas strategi konkrit: melaksanakan antara muka yang ditakrifkan oleh strategi abstrak dan menyediakan pelaksanaan algoritma khusus.

3. Kelas persekitaran: memegang rujukan kepada kelas strategi, yang akhirnya dipanggil oleh pelanggan.

Gambar rajah struktur:

4. Pelaksanaan kod

Kini terdapat tiga ekor itik: Itik Mallard, itik merah, itik kecil (itik kecil belum boleh terbang)

Sekarang tentukan kelas induk itik: Terdapat kaedah untuk memanggil dan memaparkan rupa (kerana setiap satu berbeza, ia perlu ditulis semula oleh subkelas)

juga boleh terbang (mod strategi digunakan di sini)

public  abstract class duck {
    //鸭子都会叫：
    public void quack(){
        System.out.println("嘎嘎嘎");
    }
    //鸭子的外观，因为都不一样，所以由子类去实现
    public abstract void display();
	
	//以下使用策略模式：
    //在父类中持有该接口，并由该接口代替飞行行为（组合）
    private Flying flying;
    //提供set方法
    public void setFlying(Flying flying) {
        this.flying = flying;
    }
    public void fly(){
        flying.Fly();
    }
}

Tentukan a Antara Muka terbang:

/**
 * 策略接口：实现了鸭子的飞行行为
 */
public interface Flying {
    void Fly();
}

Kami tahu bahawa corak strategi adalah untuk merangkum algoritma yang perlu digunakan, dan ia merangkum Terbang dan <🎜 dalam pakej yang lain >Dua kaedah yang tidak boleh terbang:

boleh terbang (diwarisi kepada antara muka penerbangan di atas, mengatasi kaedah penerbangan):

public class FlyWithWin implements Flying {
    @Override
    public void Fly() {
        System.out.println("我会飞");
    }
}

Tidak boleh terbang:

public class FlyNoWay implements Flying {
    @Override
    public void Fly() {
        System.out.println("我不会飞行");
    }
}

Nota: Saya merangkum dua kaedah di atas secara berasingan sebagai keluarga algoritma, dan kemudian apabila program perlu menggunakan salah satu algoritma, The program tidak akan terjejas oleh perubahan algoritma, kerana kesan akhir algoritma adalah sama

Jenis itik merah:

/**
 * 红色鸭子
 */
public class RedDuck extends duck{
    public RedDuck(){
        super();
        //给鸭子注入飞行的能力，这里就是通过算法族里面的会飞的算法
        super.setFlying(new FlyWithWin());
    }
    @Override
    public void display() {
        System.out.println("我是红色的鸭子");
    }
}

Itik Mallard:

/**
 *
 * 绿色鸭子
 */
public class GreenDuck extends duck{
    public GreenDuck(){
        super();
        //给鸭子注入飞行的能力，这里也是通过算法族里面的会飞的算法
        super.setFlying(new FlyWithWin());
    }
    @Override
    public void display() {
        System.out.println("我是绿色的鸭子");
    }
}

Jenis itik kecil (tidak boleh terbang):

/**
 * 小鸭子，还不会飞
 */
public class SamllDuck extends duck{
    public SamllDuck(){
        super();
        //小鸭子不会飞，所以使用了算法族里面不会飞的算法
        super.setFlying(new FlyNoWay());
    }

    @Override
    public void display() {
        System.out.println("我还是小鸭子");
    }
    //因为小鸭子和大鸭子的叫声不一样，所以重写叫声方法
    public void quack(){
        System.out.println("嘎~嘎~嘎");
    }
}

Jenis ujian:

public class Test {
    public static void main(String[] args) {
        System.out.println("***测试鸭子程序***");
        duck d = null;
		//这下面是轮流运行！！！！  
        d = new RedDuck();  //测试红色的鸭子
        d = new GreenDuck();  //测试绿色的鸭子
        d = new SamllDuck();  //测试小鸭子
        d.display();
        d.quack();
        d.fly();
        System.out.println("***测试完毕***");
    }
}

Apabila menggunakan itik merah sebagai objek:

***Program itik ujian***

Saya itik merah
Kurang-kuring
Saya boleh terbang
***Ujian selesai***

Apabila menggunakan itik mallard sebagai objek:

***测试鸭子程序***
我是绿色的鸭子
嘎嘎嘎
我会飞
***测试完毕***

Apabila menggunakan itik sebagai objek Sasaran :

***Program itik ujian***

Saya masih itik kecil
Kurang~kucuh~kucuh
Saya tidak boleh terbang
* **Ujian selesai***

5 Senario aplikasi mod strategi

1 Apabila sistem perlu memilih satu daripada beberapa algoritma secara dinamik, setiap Algoritma dirangkumkan ke dalam kelas strategi

2. Kelas mentakrifkan berbilang gelagat, dan gelagat ini muncul dalam bentuk berbilang pernyataan bersyarat dalam operasi kelas ini Setiap cawangan bersyarat boleh dialihkan ke dalam kelas strategi masing-masing pernyataan bersyarat boleh digantikan

3 Apabila algoritma dalam sistem benar-benar bebas antara satu sama lain dan butiran pelaksanaan algoritma tertentu diperlukan untuk disembunyikan daripada pelanggan

.

4. Apabila sistem memerlukan pelanggan yang menggunakan algoritma tidak mengetahui data yang mereka kendalikan, corak strategi boleh digunakan untuk menyembunyikan struktur data yang berkaitan dengan algoritma

5 berbilang kelas ialah gelagat mereka yang berbeza Anda boleh menggunakan corak strategi untuk memilih gelagat tertentu secara dinamik untuk dilaksanakan pada masa jalan

Atas ialah kandungan terperinci Bagaimana untuk melaksanakan corak strategi Java menggunakan kod. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!