设计模式

最新推荐文章于 2024-10-16 22:05:12 发布

精勤，荒嬉。形成思，毁于随

最新推荐文章于 2024-10-16 22:05:12 发布

阅读量112

点赞数

CC 4.0 BY-SA版权

本文链接：https://blog.youkuaiyun.com/weixin_42584545/article/details/98073030

设计模式

（一）设计模式的概述和分类

A:设计模式概述
	设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编写、代码设计经验的总结。
	使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性以及代码的结构更加清晰.
B:设计模式分类
	创建型模式(创建对象的):	单例模式、抽象工厂模式、建造者模式、工厂模式、原型模式。
	行为型模式(对象的功能):	适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。
	结构型模式(对象的组成):	模版方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、职责链模式、访问者模式。

（二）简单工厂模式概述和使用

A:简单工厂模式概述:	又叫静态工厂方法模式，它定义一个具体的工厂类负责创建一些类的实例
B:优点:	使用静态工厂模式的优点是实现责任的分割，该模式的核心是工厂类，工厂类含有必要的选择逻辑，可以决定什么时候创建哪一个产品的实例，
		而客户端则免去直接创建产品的责任，而仅仅是消费产品。也就是说静态工厂模式在不改变客户端代码的情况可以动态的增加产品。
		明确了类的职责
C:缺点
	这个静态工厂类负责所有对象的创建，如果有新的对象增加，或者某些对象的创建方式不同，
	就需要不断的修改工厂类，不利于后期的维护

public class MyTest {
    public static void main(String[] args) {
        Animal an = AnimalFactory.createAnimal("dog");
        an.eat();
        an=AnimalFactory.createAnimal("cat");
        an.eat();
        an=AnimalFactory.createAnimal("tiger");
        an.eat();

    }
}

public class AnimalFactory { //工厂类，专门用来生产动物

    private AnimalFactory() {
    }
    //生产猫对象的方法
   /* public static Cat getCat(){
        return new Cat();
    }

    public static Dog getDog() {
        return new Dog();
    }*/
    public static Animal createAnimal(String name){
        if("cat".equals(name)){
            return new Cat();
        }else if("dog".equals(name)){
           return new Dog();
        } else if ("tiger".equals(name)) {
            return new Tiger();
        }else{
            return null;
        }
    }
}
public abstract class Animal {
    abstract void eat();
}
public class Cat extends Animal{
        public void eat () {
            System.out.println("猫吃鱼");

    }
}
public class Dog extends Animal{
    public void eat(){
        System.out.println("狗吃骨头");
    }
}
public class Tiger extends Animal{
    @Override
    void eat() {
        System.out.println("老虎吃饭");
    }
}

（三）工厂方法模式的概述和使用

A:工厂方法模式概述
工厂方法模式中抽象工厂类负责定义创建对象的接口，具体对象的创建工作由继承抽象工厂的具体类实现。
B:优点
客户端不需要在负责对象的创建，从而明确了各个类的职责，如果有新的对象增加，
只需要增加一个具体的类和具体的工厂类即可，不影响已有的代码，后期维护容易，增强了系统的扩展性
C:缺点: 需要额外的编写代码，增加了工作量

public class MyTest {
    public static void main(String[] args) {
        Animal dog = new DogFactory().createAnimal();
        dog.eat();
        Animal cat = new CatFactory().createAnimal();
        cat.eat();
        Animal tiger = new TigerFactory().createAnimal();
        tiger.eat();
    }
}

public interface BigAnimalFactory { //大的工厂是个接口
    Animal createAnimal(); //创建动物的方法
}
public class CatFactory implements BigAnimalFactory{
    @Override
    public Animal createAnimal() {
        return new Cat();
    }
}
public class DogFactory implements BigAnimalFactory{
    @Override
    public Animal createAnimal() {
        return new Dog();
    }
public class TigerFactory implements BigAnimalFactory{
    @Override
    public Animal createAnimal() {
        return new Tiger();
    }
}
public abstract class Animal {
    abstract void eat();
}
public class Cat extends Animal {

    public void eat () {
        System.out.println("猫吃鱼");

}

}
public class Dog extends Animal {
    public void eat(){
        System.out.println("狗吃骨头");
    }
}
public class Tiger extends Animal{
    @Override
    void eat() {
        System.out.println("老虎吃肉");
    }
    }

（四）单例模式之懒汉式

A:案例演示:	单例模式之懒汉式
B:饿汉式和懒汉式的区别
	

	单例设计模式之懒汉式

 		开发中		饿汉式
 		面试中		懒汉式

 		面试就是想面试你们的两种思想:

 			a: 线程安全思想
 			b: 延迟加载思想

饿汉式
public class MyTest2 {
    public static void main(String[] args) {
        Teacher teacher = Teacher.getTeacher();
        Teacher teacher1 = Teacher.getTeacher();
        System.out.println(teacher==teacher1);
    }
}
public class Teacher {
    //饿汉式
    private static Teacher teacher=new Teacher();
    private Teacher() {
    }

    public static Teacher getTeacher(){

        return teacher;
    }

}
懒汉式
public class MyTest {
    public static void main(String[] args) {
       
        Student student = Student.getStudent();
        Student student1 = Student.getStudent();
        System.out.println(student==student1);
    }
public class Student {
    private static Student student=null;


    private Student() {
    }
   
    public synchronized static Student getStudent(){
        if(student==null){
            student=new Student();
        }
       return student;
    }
}

（五）单例模式的Java代码体现Runtime类

A:Runtime类概述
	每个 Java 应用程序都有一个 Runtime 类实例，使应用程序能够与其运行的环境相连接。可以通过 getRuntime 方法获取当前运行时。 
	应用程序不能创建自己的 Runtime 类实例。 
B:案例演示:	public Process  exec(String command)  //执行Dos 命令

public class MyTest {
    public static void main(String[] args) throws IOException, ParseException {
        //Runtime 采用单例模式的饿汉式
        Runtime runtime = Runtime.getRuntime();
        //exec("calc"); 可以执行一些DOS命令
        //runtime.exec("calc");
        //runtime.exec("mspaint");
        //定时关机

        Timer timer = new Timer();
        timer.schedule(new TimerTask() {
            @Override
            public void run() {
                try {
                    runtime.exec("shutdown -s -t 0");
                } catch (IOException e) {

                    e.printStackTrace();
                }
            }
        },new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse("2019-07-30 16:06:00"));

    }
}

（六）模版设计模式概述和使用

A:装饰模式概述:	装饰模式就是使用被装饰类的一个子类的实例，在客户端将这个子类的实例交给装饰类。是继承的替代方案
B:优点和缺点
	a:优点
		使用装饰模式，可以提供比继承更灵活的扩展对象的功能，它可以动态的添加对象的功能，
		并且可以随意的组合这些功能。
	b:缺点:	正因为可以随意组合，所以就可能出现一些不合理的逻辑。

public class MyTest {
    public static void main(String[] args) throws IOException {
        CalcTime myTestFor = new MyTestFor();
        myTestFor.testTime();
        myTestFor=new MyTestCopyFileTime();
        myTestFor.testTime();
    }
}
public abstract class CalcTime {
    public void testTime() throws IOException {
    
        long start = System.currentTimeMillis();
      
        testHaoShi();
        long end = System.currentTimeMillis();
        System.out.println("耗时"+(end-start)+"毫秒");
    }
}
public class MyTestCopyFileTime extends CalcTime{
    @Override
    public void testHaoShi() throws IOException {
        Files.copy(Paths.get("辛晓琪 - 领悟.mp3"), Paths.get("E:\\demo.mp3"), StandardCopyOption.REPLACE_EXISTING);
    }
}
public class MyTestFor extends CalcTime{
    @Override
    public void testHaoShi() {
        for (int i = 0; i < 10000; i++) {
            System.out.println(' ');
        }
    }
}

（七）装饰模式概述和使用

A:装饰模式概述:	装饰模式就是使用被装饰类的一个子类的实例，在客户端将这个子类的实例交给装饰类。是继承的替代方案
B:优点和缺点
	a:优点
		使用装饰模式，可以提供比继承更灵活的扩展对象的功能，它可以动态的添加对象的功能，
		并且可以随意的组合这些功能。
	b:缺点:	正因为可以随意组合，所以就可能出现一些不合理的逻辑。
C:案例演示:	装饰模式的使用

public class MyTest {
    public static void main(String[] args) {
        
        iphone = new VideoPhone(new MusicPhone(iphone));
        iphone.call();
        
    }
}
public interface Phone { //手机的接口
     void call();
}


public class BZPhone implements Phone{//他是一个包装类
    //你要把需要包装的手机传过来
    Phone phone;
    public BZPhone(Phone phone) {
        this.phone=phone;
    }

    @Override
    public void call() {
        this.phone.call();
    }
}
public class Iphone implements Phone{
    public void  call(){
        System.out.println("打电话");
    }
}
public class MusicPhone extends BZPhone{
    public MusicPhone(Phone phone) {
        super(phone);
    }

    @Override
    public void call() {
        super.call();
        System.out.println("听歌的功能");
    }
}
public class VideoPhone extends BZPhone{
    public VideoPhone(Phone phone) {
        super(phone);
    }

    @Override
    public void call() {
        super.call();
        System.out.println("看视频的功能");
    }
}

（八）观察者模式概述和使用

A: 案例: 找猎头找工作
B: 观察者 = 订阅者 + 发布者
     岗位类  求职者  猎头(注册方法,注销方法,发布方法)

public class Hunter { //中介
    //两个成员变量，一个装求职者，一个装工作岗位
    ArrayList<WokerMan> mans=new ArrayList<>();
    ArrayList<Job> jobs = new ArrayList<>();

    //添加求职者的方法
    public void addMan(WokerMan wokerMan){
        mans.add(wokerMan);
    }
    //添加工作岗位
    public void addJob(Job job){
        jobs.add(job);
        //通知
        sendJobToMan(job,mans);
    }

    //发布求职信息的方法
    private void sendJobToMan(Job job, ArrayList<WokerMan> mans) {
        for (WokerMan man : mans) {
            System.out.println(man.name+"你好，有一份"+job.jobName+"薪资"+job.sal+"欢迎你前去面试");
        }

    }

    //注销求职者的方法
    public void removeMan(WokerMan man){
        mans.remove(man);
    }
}
public class Job {//工作岗位
    public String jobName;
    public double sal;

    public Job(String jobName, double sal) {
        this.jobName = jobName;
        this.sal = sal;
    }
}
public class WokerMan { //求职者
    public String name;

    public WokerMan(String name) {
        this.name = name;
    }
}
public class MyTest {
    public static void main(String[] args) {
        WokerMan man1 = new WokerMan("杨浪");
        WokerMan man2 = new WokerMan("张超");
        WokerMan man3 = new WokerMan("刘鹏");
        Hunter hunter = new Hunter();
        hunter.addMan(man1);
        hunter.addMan(man2);
        hunter.addMan(man3);

        Job java = new Job("Java开发工程师", 10000);
        Job php = new Job("PHP开发工程师", 20000);
        Job web = new Job("WEB开发工程师", 8000);
        hunter.addJob(java);
        hunter.addJob(php);
        hunter.removeMan(man1); //注销一个求职者
        hunter.addJob(web);

    }
}