java基础学习—设计模式

我理解的所谓设计模式就是早期程序员从实际编程经验总结的一些优秀的编程思想用于解决一类共通的问题。当后来的程序员遇到此类问题的时候就可以借鉴此思想解决总结所遇到的问题。

单例设计模式

当一个类的对象在系统运行的时候只希望有且只有一个（即只创建一个），则可以使用单例模式。

package designPattern;

/*
* 饿汉式单例模式，
* 不存在线程安全问题，因为共享的代码只有一行：return sin;
*/
public class Singleton {
private Singleton(){}
private static final Singleton sin = new Singleton();
public static Singleton getInstance(){
return sin;
}
}

/*
* 懒汉式，或者延迟加载，当需要的时候才创建这个类
* 懒汉式要注意的是线程安全问题
*/
class SingletonDelay{
private SingletonDelay(){};
private static SingletonDelay sin = null;
public static SingletonDelay getInstence(){
if(sin == null){//双重判断的目的是为了减少锁的比较次数，提高效率
synchronized(SingletonDelay.class){//静态方法的锁必须用类的字节码对象
if(sin==null){
sin = new SingletonDelay();
}
}
}
return sin;
}
}

装饰类设计模式：

当想要对已有的对象进行功能增强时，

可以定义类，将已有对象传入，基于已有的功能，并提供加强功能。

那么自定义的该类称为装饰类。

装饰类通常会通过构造方法接收被装饰的对象。

并基于被装饰的对象的功能，提供更强的功能。

它利用到了 多态、组合的思想组合。

package designPattern;

public class Decorator {

public static void main(String[] args) {
Person stu = new Student("haha", "34");
System.out.println(stu.name + ":" + new DecoratePerson(stu).printWork());
}
}

/*
* 抽象类人，有个打印工作的方法
*/
abstract class Person {

String name;
String age;

abstract String printWork();

public String getName() {
return name;
}

public void setName(String name) {
this.name = name;
}

public String getAge() {
return age;
}

public void setAge(String age) {
this.age = age;
}
}

/*
* 学生继承人
*/
class Student extends Person {

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

// 以前的学生只能天天学习
String printWork() {
return "天天学习";
}
}

//在被装饰的类的方法上增强其功能，现在的人可以用电脑工作了
class DecoratePerson extends Person {

Person person = null;

public DecoratePerson(Person person) {
this.person = person;
}

public String printWork() {
return "用电脑" + person.printWork();
}
}

享元设计模式：

String  s1 = new String("abc");

String s2 = new String("abc");

System.out.println(s1==s2);//打印结果为ture

Integer a = 5;

Integer b = 5;

System.out.println(a==b);//打印结果为ture

windows中的文件夹图标

这就是享元设计模式,当对象使用比较平凡，或者在多处被用到，并且这个对象不易改变，或根本不改变，则可以使用享元模式。

接口型模式：

当一个类需要扩展某项功能，但是这个功能所属的接口还有其他很多抽象方法，我们并不需要或关心其他抽象方法，

那么我们就可以先通过一个类去实现这个接口，但是对齐所有的抽象方法并不进行具体实现，全部方法体为空。

让需要扩展的类继承这个实现了接口的类，然后只覆写自己想扩展的方法。

package designPattern;

public class InterfacePattern {

public static void main(String[] args) {
new MyCar().runForward();
}

}

interface Car{
//启动
void start();
//向前跑
void runForward();
//向后跑
void runBack();
//获得能源
void addPower();
//停止
void stop();
}

/**
* 实现Car接口，但是Car的抽象方法没有具体实现
* @author fpro
*
*/
class CarAssistent implements Car{

@Override
public void start() {
}

@Override
public void runForward() {
}

@Override
public void runBack() {
}

@Override
public void addPower() {
}

@Override
public void stop() {
}

}

/**
* 我的车很特殊，只有两种状态，只能向前跑或者停止
* 那就覆写CarAssistent的这两个方法就可以了，
* 而不用实现Car接口，因为里面太多不需要的抽象方法
* @author fpro
*
*/
class MyCar extends CarAssistent{
public void runForward() {
System.out.println("我的车向前跑");
}

public void stop() {
System.out.println("我的车停止了");
}
}

不断补充中。。。。