Java设计模式小结

最新推荐文章于 2019-12-29 18:45:47 发布
最新推荐文章于 2019-12-29 18:45:47 发布
阅读量263 收藏
点赞数
分类专栏： Java基础学习 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xiakexiaohu/article/details/75307437
版权

1：设计模式（理解）

（1）面试对象的常见设计原则

        单一
        开闭
        里氏
        依赖注入
        接口
        迪米特

（2）设计模式概述和分类

        A：经验的总结
        B：三类
            创建型
            结构型
            行为型

（3）改进的设计模式

        A：简单工厂模式

package day24_Pattern;

public abstract class Animal {
    public abstract void eat();
}

package day24_Pattern;

public class Cat extends Animal {

    @Override
    public void eat() {
        // TODO Auto-generated method stub
        System.out.println("猫吃鱼");
    }

}

package day24_Pattern;

public class Dog extends Animal {

    @Override
    public void eat() {
        // TODO Auto-generated method stub
        System.out.println("狗吃肉");
    }

}

package day24_Pattern;
/*
 * 工厂类
 * */
public class AnimalFactory {
//  //私有之后，就无法通过new AnimalFactort()实现类的调用
//  //只能通过AnimalFactory.方法名调用
//  private AnimalFactory() {
//      // TODO Auto-generated constructor stub
//  }
//  
//  public static Dog createDog(){
//      return new Dog();
//  }
//  
//  public static Cat createCat(){
//      return new Cat();
//  }

    public static Animal createAnimal(String type){
        if("dog".equals(type)){
            return new Dog();
        }else if("cat".equals(type)){
            return new Cat();
        }else {
            return null;
        }
    }
}

package day24_Pattern;
/*
 * 简单工厂模式
 * */
public class AnimalDemo {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        //具体类调用
        Dog d = new Dog();
        d.eat();
        Cat c = new Cat();
        c.eat();
        System.out.println("--------------");

        //工厂有了之后，通过工厂给造
        Dog dog = AnimalFactory.createDog();
        dog.eat();
        Cat cat = AnimalFactory.createCat();
        cat.eat();  
        System.out.println("--------------");   

        //工厂改进后
        Animal a = AnimalFactory.createAnimal("dog");
        a.eat();
        a = AnimalFactory.createAnimal("cat");
        a.eat();

        //NullPointerException
        a=AnimalFactory.createAnimal("pig");
        if(a!=null){
            a.eat();
        }else{
            System.out.println("对不起，暂时不提供这种动物");
        }
    }
}

        B：工厂方法模式    

package day24_Pattern2;
/*
 * 抽象类
 * */
public abstract class Animal {
    public abstract void eat();//抽象方法
}

package day24_Pattern2;
/*
 * 工厂接口
 * */
public interface Factory {
    public abstract Animal CreateAnimal();//接口方法
}


package day24_Pattern2;

public class Cat extends Animal {

    @Override
    public void eat() {
        // TODO Auto-generated method stub
        System.out.println("猫吃鱼");
    }

}

package day24_Pattern2;

public class CatFactory implements Factory {

    @Override
    public Animal CreateAnimal() {
        // TODO Auto-generated method stub
        return new Cat();
    }

}

package day24_Pattern2;

public class Dog extends Animal {
    @Override
    public void eat() {
        // TODO Auto-generated method stub
        System.out.println("狗吃肉");
    }

}

package day24_Pattern2;

public class DogFactory implements Factory {

    @Override
    public Animal CreateAnimal() {
        // TODO Auto-generated method stub
        return new Dog();
    }

}

package day24_Pattern2;

/*
*工厂方法模式：
*   工厂方法模式中抽象工厂类负责定义创建对象的接口，
*   具体对象的创建工作由继承抽象工厂的具体类实现
*
*优点：客户端不需要负责对象的创建，从而明确了各个类的职责，如果有新的对象增加，只需要增加一个具体的类和具体的工厂即可
*   ，不影响已有的代码，后期维护容易，增强了系统的拓展性。
*
*缺点：需要额外的编写代码，增加了工作量
*/
public class AnimalDemo {
    public static void main(String[] args) {
        // 需求：我要只狗
        Factory f = new DogFactory();
        Animal a = f.CreateAnimal();
        a.eat();
        System.out.println("---------------");
        //需求：我要买只猫
        f=new CatFactory();
        a = f.CreateAnimal();
        a.eat();
    }
}

        C：单例模式(掌握)
            a:饿汉式

package day24_Pattern3;

public class Student {
    //私有构造方法
    private Student() {
        // TODO Auto-generated constructor stub
    }

    //自己造一个，饿汉式
    //静态方法只能访问静态成员变量
    //为了不让外界直接访问修改这个值，加private
    private static Student s=new Student();

    //提供一个公共访问的方法
    //为了保证外界能够直接使用该方法，加静态
    public static Student getStudent(){
        return s;
    }
}

package day24_Pattern3;
/*
 * 单例模式：（经常面试）
 *      保证在内存中只有一个对象
 * 
 * 如何保证类在内存中只有一个对象呢？
 *      A：把构造方法私有
 *      B：在成员位置自己穿件一个对象
 *      C：通过一个公共的方法提供访问
 * 
 * 饿汉式：类一加载就创建对象
 * 
 * 
 * */
public class StudentDemo {
    public static void main(String[] args) {
//      Student s1 = new Student();
//      Student s2 = new Student();
//      System.out.println(s1==s2);//false

        //通过单例如何得到对象呢？

        //Student.s=null;


        Student s1 = Student.getStudent();
        Student s2 = Student.getStudent();
        System.out.println(s1==s2);//true
        System.out.println(s1);
        System.out.println(s2);
    }
}

            b:懒汉式

package day24_Pattern3;

public class Teacher {
    private Teacher() {
        // TODO Auto-generated constructor stub
    }

    //懒汉式
    private static Teacher t=null;

    public synchronized static Teacher getTeacher(){
        if(t==null){
            //直到用的时候，才创建。
            t=new Teacher();
        }
        return t;
    }
}

package day24_Pattern3;
/*
 * 单例模式：
 *      饿汉式：类一记载就创建对象
 *      懒汉式：用的时候，才去创建对象
 * 
 * 面试题：单例模式的思想是什么？请写一个代码体现
 * 
 *      开发：饿汉式（是不会出问题的单例模式）
 *      面试：懒汉式（可能会出现问题的单例模式）
 *          A：懒加载（延迟加载）
 *          B：线程安全问题
 *              a：是否多线程问题   是   
 *              b：是否有共享数据   是
 *              c：是否有多条语句操作共享数据 是
 * */
public class TeacherDemo {
    public static void main(String[] args) {
        Teacher t1 = Teacher.getTeacher();
        Teacher t2 = Teacher.getTeacher();
        System.out.println(t1==t2);//true
        System.out.println(t1);
        System.out.println(t2);
    }
}

D：装饰设计模式

这里写图片描述

工具类：
package day27_Pattern;

public class ForDemo extends GetTime {

    @Override
    public void code() {
        // TODO Auto-generated method stub
        for(int i=0;i<10000;i++){
            System.out.println(i);
        }
    }

}

工具类：
package day27_Pattern;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;

public class IODemo extends GetTime {

    @Override
    public void code() {
        // TODO Auto-generated method stub
        try {
            BufferedInputStream bis = new BufferedInputStream(new FileInputStream("a.avi"));
            BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.avi"));

            byte[]bys=new byte[1024];
            int len=0;
            while((len=bis.read(bys))!=-1){
                bos.write(bys, 0, len);
            }

            bis.close();
            bos.close();

        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}

实现类：
package day27_Pattern;
/*
 * 需求：请给我计算一段代码的运行时间
 * */
public abstract class GetTime {
    public long getTime(){
        long start=System.currentTimeMillis();
        code();
        long end=System.currentTimeMillis();
        return end-start;
    }
    //定义抽象方法，具体实现，由继承的子类实现
    public abstract void code();
}

测试类：
package day27_Pattern;
/*
 * 模板设计模式实现具体功能具体实现，模板只负责计算时间
 * 
 * 优点：使用模板方法模式，在定义算法骨架的同时，可以很灵活的实现具体的算法，满足用户灵活多变的需求
 * 
 * 缺点：如果算法骨架有修改的话，则需要修改抽象类
 * */
public class GetTimeTest {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        GetTime gt = new ForDemo();//多态
        System.out.println(gt.getTime()+"毫秒");
        System.out.println("--------------------");

        GetTime io = new IODemo();
        System.out.println(io.getTime()+"毫秒");
    }

}

E:模板设计模式

接口：
package day27_Pattern2;

public interface Phone {
    public abstract void call();
}

实现类：
package day27_Pattern2;

public class Iphone implements Phone {

    @Override
    public void call() {
        // TODO Auto-generated method stub
        System.out.println("手机可以打电话了");
    }

}

实现类：
package day27_Pattern2;

public abstract class PhoneDecorate implements Phone {
    private Phone p;
    public PhoneDecorate(Phone p) {
        // TODO Auto-generated constructor stub
        this.p=p;
    }
    @Override
    public void call() {
        // TODO Auto-generated method stub
        this.p.call();
    }

}

继承类：
package day27_Pattern2;

public class MusicPhone extends PhoneDecorate {

    public MusicPhone(Phone p) {
        super(p);
        // TODO Auto-generated constructor stub
    }
    @Override
    public void call() {
        // TODO Auto-generated method stub
        super.call();
        System.out.println("可以听音乐了");
    }

}

继承类：
package day27_Pattern2;

public class RingPhone extends PhoneDecorate {

    public RingPhone(Phone p) {
        super(p);
        // TODO Auto-generated constructor stub

    }
    @Override
    public void call() {
        // TODO Auto-generated method stub
        System.out.println("手机可以听彩铃了");
        super.call();
    }

}

测试类：
package day27_Pattern2;

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

/*
 * 装饰模式：
 *  
 * */
public class PhoneDemo {
    public static void main(String[] args) {
        Phone p = new Iphone();
        p.call();
        System.out.println("----------------");

        //需求:我想在打电话之前听彩铃
        PhoneDecorate pd = new RingPhone(p);
        pd.call();
        System.out.println("----------------");

        //需求：我想在打电话之后听音乐
        MusicPhone mp = new MusicPhone(p);
        mp.call();
        System.out.println("----------------");

        //需求：我想在打电话之前听彩铃，接电话之后听音乐
        pd=new RingPhone(new MusicPhone(p));
        pd.call();

        //想想我们在IO流中的使用
//      
//      InputStream is = System.in;
//      InputStreamReader isr = new InputStreamReader(is);
//      BufferedReader br = new BufferedReader(isr);
        //整合
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));       
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
    }
}

（6）Runtime
JDK提供了一个单例模式应用的类
还可以调用DOS命令。

package day24_Pattern3;

import java.io.IOException;

/*
 * Runtime:每个Java应用层序都有一个Runtime类的实例，使应用程序能够与其运行的环境相连接。
 * exec(command)
 * */
public class RunTimeDemo {
    public static void main(String[] args) throws IOException {
        Runtime r = Runtime.getRuntime();
        r.exec("at 12:00 shutdown -s");
    }
}
xiakexiaohu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java设计总结或结论_java设计心得体会
weixin_31100517的博客
02-28 1936
学习java的心得我学习java已经有一年的时间了，不过虽然时间长，但是对于现在的我还是一个初学者，懂不了多少的java初学者。期间曾迷茫过，曾困惑过，走了不少的弯路，老师布置的试验作业每次都是不会做，每次都是要问同学，这个代码什么意思啊?为什么用这条代码，用别的不行吗?甚至后来根本没耐心问，索性就复制同学的作业交上去。但是都是各种0分，害的同学也这样，不过他能找老师反驳，而我却没实力。渐渐的，我...
Java 设计模式总结 Java 设计模式总结
10-01
Java设计模式是面向对象设计的重要组成部分，它是一种在特定情境下解决常见问题的标准化解决方案。设计模式总结主要包括创建型、结构型和行为型这三大类，每类模式都有其特定的应用场景和目标。 1. 创建型模式...
JAVA设计模式小结
qq_20786911的博客
12-29 114
设计模式让程序具有更好的代码重用性、可读性、可扩展性、可靠性，使得程序具有高内聚、低耦合的特性。 设计模式的7大原则： 开闭原则（Open Closed Principle，OCP） 单一职责原则（Single Responsibility Principle, SRP） 里氏替换原则（Liskov Substitution Principle，LSP） 依赖倒转原则（Dependency Inv...
Java 设计模式小结
FlyPig_Vip的博客
08-07 112
1.单例模式 保证实例的唯一 /** * 单例模式之懒汉式 线程不安全 多线程不能正常工作 */ public class Manager { private static Manager manager = null; private Manager() { } public static Manager getInstance() { if (manage...
java设计总结
weixin_36098377的博客
08-27 415
1、高可用、高性能？ 接口设计的 16 个原则：https://blog.csdn.net/gitchat/article/details/78705978 2、大型网站之分布式会话管理：http://ifeve.com/dis-session-manager/ 和https://www.cnblogs.com/smallSevens/p/6763114.html 3、教程：https://...
JavaWeb总结——开发设计
剑来
03-05 640
参考资料 知识梳理： 表达式接受数据——导入标签——XML——ajax 第十章——表达式语言 1、表达式语言简介 使用表达式语言可以避免出现过多的Scriptlet代码，最大的特点是，如果输出的内容null，则会自动使用空字符串（“”）表示 2、表达式语言的内置对象 3、四种属性范围 如果在不同的属性范围中设置了同一个属性名称，则按照如下顺序查找 page—...
java设计模式总结23种
最新发布
07-27
java设计模式总结23种
Java设计模式总结
09-18
Java设计模式是软件工程中的一种最佳实践，它们是解决常见编程问题的经验总结，可以提高代码的可重用性、可维护性和可扩展性。这里主要针对标题“Java设计模式总结”以及描述中提及的资源进行深入阐述。 1. **设计...
重学java的设计模式
05-09
在软件开发领域，设计模式是经验丰富的开发者们总结出的解决常见问题的最佳实践。Java作为一门广泛应用的开发语言，其设计模式的应用对于提高代码质量、可维护性和可扩展性至关重要。本文将着重探讨创建型模式、结构...
《Java设计模式》课程设计报告.docx
06-19
《Java设计模式》课程设计报告主要探讨了如何利用Java编程语言和MyEclipse集成开发环境来实现基于设计模式的西瓜市场系统。这个项目涵盖了四种重要的设计模式：单例模式、代理模式、建造者模式和抽象工厂模式，为...
java的设计心得
u011974247的专栏
09-16 1053
整个设计模式贯穿一个原理:面对介面编程，而不是面对实现，(面向物件编程应该改爲面向介面编程)。目标原则是:降低耦合，增强灵活性。 　　一、创建模式 　　1. 设计模式之Factory(工厂方法和抽象工厂) 　　使用工厂模式就象使用newww.100ksw.complate 　　实际上向你介绍了爲什麽要使用Java 抽象类,该模式原理简单,使用很普遍。 　　2. 设计模式之Memento
eclipse没有Web项目和Server选项
热门推荐
侠客小虎的博客
07-19 5万+
最近工作要涉及web开发，之前下载的java SE （我的是Neon） 版本默认无法新建web项目，也就是找不到Dynamic Web ，在网上看了些解决办法，最终却是解决了问题，说到底就是安装一些用于EE web开发的插件即可。具体如下：　　（1）在确定联网的情况下，在help->install new software下根据你的eclipse版本选择下拉框选项，我的是indigo，所选情况如下：
Java中局部代码块、构造代码块、静态代码块的区别？
侠客小虎的博客
05-17 8160
package day08; /* * 代码块：在Java中，使用{}括起来的代码成为代码块 * 根据其位置和声明的不同，可以分为 * 局部代码块：局部位置，用于限定变量的生命周期 * 构造代码块：在类中的成员位置，用{}括起来的代码。每次调用构造方法执行前，都会先执行构造代码块。 * 作用：可以把多个构造方法的共同代码放在一起。 * 静态代码块：在类中的成员位置，用{}括
ForkJoinPool线程池
侠客小虎的博客
01-24 7795
在Java 7中引入了一种新的线程池：ForkJoinPool。 它同ThreadPoolExecutor一样，也实现了Executor和ExecutorService接口。它使用了一个无限队列来保存需要执行的任务，而线程的数量则是通过构造函数传入，如果没有向构造函数中传入希望的线程数量，那么当前计算机可用的CPU数量会被设置为线程数量作为默认值。 ForkJoinPool主要用来使用分治法(...
Java中关于如何读取不同路径下图片/文件
侠客小虎的博客
10-09 7756
由于图片/或者文件读法相似，只需要改变不同的读取:geifile()/getImage(),此处为读取图片为例： 1.结构目录树 |----Project |---------Src |--------------(默认目录)(default package) |------------------------Demo.java |-------------------------Fi
JDK8-Optional类避免NPE
侠客小虎的博客
06-28 6618
1.需求分析 调用RPC返回结果、包装类转简单类型，拆箱过程最容易出现NPE问题。JDK8之前需要小心翼翼对各种类型进行判空，可通过JKD8-Optional类来预发未知的NPE错误。 2.关于避免NPE的常识 【强制】所有POJO类属性必须使用包装数据类型 【强制】所有RPC方法的返回和参数必须使用包装数据类型 【推荐】所有局部变量使用基本简单数据类型 Ps: POJO类属性没有初值是提醒...
Java中ArrayList集合嵌套存储和遍历
侠客小虎的博客
06-16 6543
student类：package day16_Test; /* * 学生类： * 成员变量：姓名、年龄 * 成员方法 * 构造方法 * * */ public class Student { private String name; private int age; //快捷键 //alt+shift+s+o
Server Tomcat v9.0 Server at localhost failed to start.
侠客小虎的博客
07-20 3719
同构eclipse编写web项目，遇到tomcat无法启动。如下图： 百度各种原因，最后发现是因为servlet3.0后的版本出现了新增注释@WebvServlet功能，会在我们生成一个servlet类时自动增加@WebServlet，导致和配置web.xml产生冲突，tomcat无法启动。 解决办法： 1：删除servlet类的注释@WebServlet，在web.xml中编写配置，或者删除
Java中网络编程小结
侠客小虎的博客
07-16 2497
网络编程（理解）（1）网络编程：用Java语言实现计算间数据的信息传递和资源共享（2）网络编程模型（3）网络编程的三要素 A：IP地址 a：点分十进制 b：IP地址的组成 c：IP地址的分类 d：dos命令 e：InetAddress B：端口 是应用程序的标识。范围：0-65535，其中0
Java8特性03-关于Stream中Map和FlatMap必知点
侠客小虎的博客
01-10 2457
package chap03; import java.util.ArrayList; import java.util.Arrays; import java.util.List; import java.util.stream.Collectors; public class FlatMap { public static void main(String[] args) { ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值