【Java】简单工厂模式、工厂模式、适配器模式

一、简单工厂模式

1、 又叫静态工厂方法模式，它定义一个具体的工厂类负责创建一些类的实例

2、优点： 客户端不需要在负责对象的创建，从而明确了各个类的职责

3、缺点：这个静态工厂类负责所有对象的创建，如果有新的对象增加，或者某些对象的创建方式不同，就需要不断的修改工厂类，不利于后期的维护

4、案例演示

• 动物抽象类：public abstract Animal { public abstract void eat(); }
•  具体狗类：publicclass Dog extends Animal {}
•  具体猫类：publicclass Cat extends Animal {}
• 开始，在测试类中每个具体的内容自己创建对象，但是，创建对象的工作如果比较麻烦，就需要有人专门做这个事情，所以就知道了一个专门的类来创建对象。

public class Test {
	/**
	 * @param args
	 */
	public static void main(String[] args) {		
		Dog d = (Dog) AnimalFactory.createAnimal("dog");  //工厂返回的是一个animal类，此时需要强制转换
		d.eat();
		
		Cat c = (Cat) AnimalFactory.createAnimal("cat");
		c.eat();
	}
}

public class AnimalFactory {
	/*public static Dog createDog() {
		return new Dog();
	}
	
	public static Cat createCat() {
		return new Cat();
	}*/
	
	//发现方法会定义很多,复用性太差
	//改进
	public static Animal createAnimal(String name) {   //返回的是一个animal类
		if("dog".equals(name)) {
			return new Dog();
		}else if("cat".equals(name)) {
			return new Cat();
		}else {
			return null;
		}
	}
}

二、工厂方法模式概述

    * 工厂方法模式中抽象工厂类负责定义创建对象的接口，具体对象的创建工作由继承抽象工厂的具体类实现。

1、优点

• 客户端不需要在负责对象的创建，从而明确了各个类的职责，如果有新的对象增加，只需要增加一个具体的类和具体的工厂类即可，不影响已有的代码，后期维护容易，增强了系统的扩展性

2、缺点

• 需要额外的编写代码，增加了工作量

3、实例：

public interface Factory {      //工厂
	public Animal createAnimal();
}

public abstract class Animal {    //动物类
	public abstract void eat();
}

public class DogFactory implements Factory {   //狗工厂实现工厂
	@Override
	public Animal createAnimal() {
		return new Dog();    //狗工厂创建对象，返回的是animal
	}
}

public class Dog extends Animal {  //狗继承动物
	@Override
	public void eat() {
		System.out.println("狗吃肉");
	}
}

public class Test {
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		DogFactory df = new DogFactory();    //创建狗工厂对象
		Dog d = (Dog) df.createAnimal();     //狗工厂返回的是animal，需要进行强制转换
		d.eat();                             //狗对象调用吃的方法
	} 
}

三、适配器设计模式-(掌握)

1、什么是适配器

•  在使用监听器的时候, 需要定义一个类事件监听器接口.
•  通常接口中有多个方法, 而程序中不一定所有的都用到, 但又必须重写, 这很繁琐.
• 适配器简化了这些操作, 我们定义监听器时只要继承适配器, 然后重写需要的方法即可.

2、适配器原理

• 适配器就是一个类, 实现了监听器接口, 所有抽象方法都重写了, 但是方法全是空的.
• 适配器类需要定义成抽象的,因为创建该类对象,调用空方法是没有意义的
• 目的就是为了简化程序员的操作, 定义监听器时继承适配器, 只重写需要的方法就可以了.

public class Demo1_Adapter {
	/**
	 * @param args
	 * 适配器设计模式
	 * 鲁智深
	 */
	public static void main(String[] args) {		
	}
}

interface 和尚 {
	public void 打坐();
	public void 念经();
	public void 撞钟();
	public void 习武();
}

abstract class 天罡星 implements 和尚 {    //声明成抽象的原因是,不想让其他类创建本类对象,因为创建也没有意义,方法都是空的
	@Override
	public void 打坐() {
	}
	@Override
	public void 念经() {
	}
	@Override
	public void 撞钟() {
	}
	@Override
	public void 习武() {
	}	
}

class 鲁智深 extends 天罡星 {
	public void 习武() {
		System.out.println("倒拔垂杨柳");
		System.out.println("拳打镇关西");
		System.out.println("大闹野猪林");
		System.out.println("......");
	}
}