设计模式之创建型模式
创建型模式
简单工厂模式
描述：通过工厂对象来决定创建哪一种产品的实例。
方式一：继承
注：子类可以向上转型 （用子类去实例化父类）
方式二：实现接口
注：实例化接口类返回所需产品
情景：
1.一个类不知道它创建的类
2.一个类希望由它的子类来指定它所创建的对象
3.希望使用者不知道究竟是哪个类进行了实例化。（如寄包裹，邮递员不知道内容）
简单工厂模式
- 一个JAVA类文件可以有多各类，但只能有一个是public经行向上转型时，属性不会经行动态绑定（隐藏），只有方法会经行动态绑定（覆盖）。
- 子类不会继承父类的构造函数，但可以通过super进行调用
public class 简单工厂模式 {
public static void main(String[] args) {
Factory a=new FactoryA();
Factory b=new FactoryB();
a.runMechine();
b.runMechine();
}
}
class Factory
{
public void runMechine()
{
System.out.println("这是父类工厂");
}
}
class FactoryA extends Factory
{
public void runMechine()
{
System.out.println("这是工厂A");
}
}
class FactoryB extends Factory
{
public void runMechine()
{
System.out.println("这是工厂B");
}
}简单工厂模式之接口
- 静态方法不能直接实例化内部类
public interface FactoryInterface {
void runMechine();
}
public class 工厂接口 {
@Test
public void test()
{
//静态方法不能直接实例化内部类
FactoryInterface a=new FactoryA();
FactoryInterface b=new FactoryB();
a.runMechine();
b.runMechine();
}
class FactoryA implements FactoryInterface
{
@Override
public void runMechine() {
// TODO Auto-generated method stub
System.out.println("这是工厂A");
}
}
class FactoryB implements FactoryInterface
{
@Override
public void runMechine() {
// TODO Auto-generated method stub
System.out.println("这是工厂B");
}
}
}抽象工厂模式
描述：相对于简单工厂来说，抽象工厂有更多业务
抛弃继承，实现接口，进行不同业务的组合
反射：通过Java反射机制，可以在程序访问过程中已经加载到JVM中的JAVA对象的描述从而达到修改的目的。
如何通过一个接口获得黑面包和白巧克力
public interface AbstartFactory {
void Breakmaking();
void Chocolatmaking();
}
//黑工厂
public class FactoryA implements AbstartFactory
{
@Override
public void Breakmaking() {
// TODO Auto-generated method stub
System.out.println("制作黑面包");
}
@Override
public void Chocolatmaking() {
// TODO Auto-generated method stub
System.out.println("制作黑巧克");
}
}
//白工厂
public class FactoryB implements AbstartFactory
{
@Override
public void Breakmaking() {
// TODO Auto-generated method stub
System.out.println("制作白面包");
}
@Override
public void Chocolatmaking() {
// TODO Auto-generated method stub
System.out.println("制作白巧克");
}
}
//测试类
import org.junit.Test;
public class TestFactory {
@Test
public void test()
{
AbstartFactory a=new FactoryA();
//AbstartFactory b=new FactoryB();
System.out.println("需要黑面包");
a.Breakmaking();
System.out.println("需要白巧克力");
try {
Class <?> c=Class.forName("抽象工厂模式.FactoryB");
a=(AbstartFactory)c.newInstance();
a.Chocolatmaking();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InstantiationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}单例模式
使用场景：资源共享的情况
描述：单例模式自行实例化且实例化一次 构造函数必须是私有的
类别：懒汉单例模式和饥汉单例模式
- 懒汉单例模式：在调用资源时，如果没有进行实例化的话，就进行一次实例化。为了避免重复线程干扰要标记临界区或者借助锁机制。(双重校验的方式)
- 饥汉单例模式：在没有调用时就已经自行实例化了。 注：对象属性和get方法都要用static标记
public class SingleA
{
public static SingleA singleA=null;
private SingleA()
{
System.out.println("这是懒汉单例模式");
}
public static synchronized SingleA getSingleA() {
if(singleA==null)
{
singleA=new SingleA();
}
return singleA;
}
}
public class SingleB
{
public static SingleB singleB=new SingleB();
private SingleB()
{
System.out.println("这是饥汉单例模式");
}
public static SingleB getSingleB() {
return singleB;
}
}
//测试类
import org.junit.Test;
public class 单例模式 {
@Test
public void test()
{
SingleA.getSingleA();
SingleB.getSingleB();
}
}
建造模式
描述：相同的成员函数，执行顺序不同结果不同（化学实验步骤不同结果不同）
如：用其他类，起到流程监控执导的作用。
public interface Student {
void learnMath();
void learnEnglish();
}
public class StudentA implements Student{
@Override
public void learnMath() {
// TODO Auto-generated method stub
System.out.println("A类学生学数学");
}
@Override
public void learnEnglish() {
// TODO Auto-generated method stub
System.out.println("A类学生学英语");
}
}
public class StudentB implements Student{
@Override
public void learnMath() {
// TODO Auto-generated method stub
System.out.println("B类学生学数学");
}
@Override
public void learnEnglish() {
// TODO Auto-generated method stub
System.out.println("B类学生学英语");
}
}
public class teacher {
private static Student a=new StudentA();
private static Student b=new StudentB();
private static teacher t=new teacher();
public static void main(String[] args) {
System.out.println("指导A类学生");
t.conductA();
System.out.println("指导B类学生");
t.conductB();
}
//指导A类学生 先学数学后学英语
public static void conductA()
{
a.learnMath();
a.learnEnglish();
}
//指导B类学生 先学英语后学数学
public static void conductB()
{
b.learnEnglish();
b.learnMath();
}
}原型模式
原理：依托一个已经实例化的对象去创建另一个可以经行定制的对象。避免多次new浪费资源。
场景：进一批货，填表很多信息已经相同。避免重新实例化，使用set注入参数。
注：直接使用等号复制，是一种引用，对新的对象经行修改会对先前的对象产生印象。
- 数组可以用system.arraycopy()进行复制
- 可以在clone（）方法类就行修改
public class Student implements Cloneable {
public String name;
public String sex;
public Student(String name, String sex) {
this.name = name;
this.sex = sex;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getSex() {
return sex;
}
public void setSex(String sex) {
this.sex = sex;
}
@Override
public String toString() {
return "Student [name=" + name + ", sex=" + sex + "]";
}
protected Object clone()
{
try {
return super.clone();
} catch (CloneNotSupportedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
return null;
}
}
}
public class Test {
@org.junit.Test
public void test001()
{
Student s=new Student("luo","1");
System.out.println(s);
Student a=(Student)s.clone();
a.setName("li");
System.out.println(a);
System.out.println(s);
}
}
