黑马程序员_设计模式

------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------


设计模式：
设计模式是一种思想（不是技术，技术是像IO 反射 集合这样的），是一种帮助开发人员完成某些代码上的逻辑，
使代码的逻辑更严谨，是代码更加简洁，美观。（设计模式并没有提高代码的运行效率和速度，
如果想要更多的去了解如何提高程序的运行速度的思想，请去了解数据结构的思想
数据结构的思想：拿空间换时间 拿时间换空间）
通常项目比较庞大的情况下才能体现出设计模式的好处


创建型：创建对象。工厂模式，单例模式。
结构型：对象间的关系。装饰模式。
行为型：对象能够做什么。模板模式。

书籍：GOF设计模式。(23种。)
     闫闳(国内研究设计模式比较早)
论坛：CSDN,ITeye,J道,www.infoq.com





工厂模式：当我们想要获取某个对象的时候，想在获取对象之前做一些初始化的动作就用到了工厂模式
   
   简单工厂模式举例：
public abstract class Animal {
public abstract void eat();
}

public class AnimalFactory {


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


public static void main(String[] args) {

Animal a = AnimalFactory.createAnimal("dog");
a.eat();

a = AnimalFactory.createAnimal("cat");
a.eat();
}


public class Cat extends Animal {
@Override
public void eat() {
System.out.println("猫吃老鼠");
}
}


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


  工厂方法模式举例：
public abstract class Animal {
public abstract void eat();
}


public abstract class AnimalFactory {
public abstract Animal createAnimal();
}
public class Cat extends Animal {
@Override
public void eat() {
System.out.println("猫吃老鼠");
}
}
public class CatFactory extends AnimalFactory {
@Override
public Animal createAnimal() {
return new Cat();
}
}
public class Dog extends Animal {
@Override
public void eat() {
System.out.println("狗吃骨头");
}
}
public class DogFactory extends AnimalFactory {
@Override
public Animal createAnimal() {
return new Dog();
}
}
public class Pig extends Animal {
@Override
public void eat() {
System.out.println("猪吃饲料");
}
}
public class PigFactory extends AnimalFactory {
@Override
public Animal createAnimal() {
return new Pig();
}
}
public class AnimalTest {
public static void main(String[] args) {
// 使用狗工厂
AnimalFactory af = new DogFactory();
Animal a = af.createAnimal();
a.eat();


af = new CatFactory();
a = af.createAnimal();
a.eat();


af = new PigFactory();
a = af.createAnimal();
a.eat();
}
}



单例设计模式：当我们想要在所有程序运行状态中，所用的一个类的对象，都是同一个对象的时候就用单例模式
   
   单例饿汉式举例：
public class Student {
// 把构造方法私有，是为了不让外界随意创建
private Student() {
}
// 类本身要创建一个对象。
// 由于静态只能访问静态，所以这里加静态
//为了不让外界通过类名直接访问s成员变量，就加私有
private static Student s = new Student();


// 提供公共的方式让别人使用
// 为了让外界能够直接通过类名访问该方法，需要对该方法加静态
public static Student getStudent() {
// return new Student(); //这是有问题的
return s;
}
}


   单例懒汉式举例：
public class Teacher {


private Teacher() {
}
private static Teacher t = null;
public synchronized static Teacher getTeacher() {
// t1,t2,t3三个线程过来了
// 如果t是null的时候，才创建对象
if (t == null) {
//t1进来了,CPU的执行权就被t2抢到了,同理t3
t = new Teacher();
}
return t;
}
}


模板设计模式：当我们执行的某些程序时发现执行的所有的程序 外面的框框都不会变，只需要改变同样地方的一些东西的时候，就可以使用模板模式
public class PrintDemo1 extends PrintTemplet {
@Override
public void printHead() {
System.out.println("采用第一种方案打印头");
}
@Override
public void printBody() {
System.out.println("采用第一种方案打印中间");
}
@Override
public void printBottom() {
System.out.println("采用第一种方案打印尾");
}
}


public class PrintDemo2 extends PrintTemplet {
@Override
public void printHead() {
System.out.println("采用第二种方案打印头");
}
@Override
public void printBody() {
System.out.println("采用第二种方案打印中间");
}
@Override
public void printBottom() {
System.out.println("采用第二种方案打印尾");
}
}
public abstract class PrintTemplet {
public void print() {
printHead();
printBody();
printBottom();
}
public abstract void printHead();
public abstract void printBody();
public abstract void printBottom();
}
public class PrintTest {
public static void main(String[] args) {
PrintTemplet pt = new PrintDemo1();
pt.print();
System.out.println("------------");
pt = new PrintDemo2();
pt.print();
}
}


装饰者模式：当我们觉得某个类的内容需要拓展一些功能的时候，我们会首先想到继承，确实继承可以解决在原来的基础上拓展功能
但是当子类想用原来的功能，就必须要用父类来实现，但是如果某一天父类功能改变了，我还想让子类有同样的功能和拓展功能，
这样是不能实现的。
所以我们有了装饰者设计模式，建一个装饰类，把被装饰的类作为构造方法的参数传进来，就可以实现功能的拓展，
这就是装饰者模式


   装饰者模式举例：
public interface Phone {
public abstract void call();
}
public class PhoneImpl implements Phone {
@Override
public void call() {
System.out.println("用手机打电话");
}
}
public abstract class PhoneDecorate implements Phone {
private Phone phone;
public PhoneDecorate(Phone phone) {
this.phone = phone;
}
@Override
public void call() {
this.phone.call();
}
}


public class GuangGaoPhoneDecorate extends PhoneDecorate {
public GuangGaoPhoneDecorate(Phone phone) {
super(phone);
}
@Override
public void call() {
super.call();
System.out.println("播放广告");
}
}


public class ColorPhoneDecorate extends PhoneDecorate {
public ColorPhoneDecorate(Phone phone) {
super(phone);
}
@Override
public void call() {
System.out.println("播放彩铃");
super.call();
}
}
public class PhoneTest {
public static void main(String[] args) {
Phone p = new PhoneImpl();
p.call();
System.out.println("---------------");


PhoneDecorate pd = new ColorPhoneDecorate(p);
pd.call();
System.out.println("---------------");


pd = new GuangGaoPhoneDecorate(p);
pd.call();
System.out.println("---------------");


ColorPhoneDecorate cc =new ColorPhoneDecorate(p);
pd = new GuangGaoPhoneDecorate(cc);
pd.call();
}
}




------- <a href="http://www.itheima.com" target="blank">android培训</a>、<a href="http://www.itheima.com" target="blank">java培训</a>、期待与您交流！ ----------