abstract factory

package abstract_factory.inf;

public interface IAbstractfactory 
{
	public IPartA createPartA ();
	public IPartB createPartB ();
	public IPartC createPartC ();
}

package abstract_factory.inf;

public interface IPartA 
{
	public void show ();
}

package abstract_factory.inf;

public interface IPartB 
{
	public void action ();
}

package abstract_factory.inf;

public interface IPartC 
{
	public void dosomething();
}

package abstract_factory.imp;

import abstract_factory.inf.IAbstractfactory;
import abstract_factory.inf.IPartA;
import abstract_factory.inf.IPartB;
import abstract_factory.inf.IPartC;

public class Abstractfactory1 implements IAbstractfactory
{
	@Override
	public IPartA createPartA() 
	{
		return new PartA1();
	}

	@Override
	public IPartB createPartB() 
	{
		return new PartB1();
	}

	@Override
	public IPartC createPartC() 
	{
		return new PartC1();
	}
}

package abstract_factory.imp;

import abstract_factory.inf.IAbstractfactory;
import abstract_factory.inf.IPartA;
import abstract_factory.inf.IPartB;
import abstract_factory.inf.IPartC;

public class Abstractfactory2 implements IAbstractfactory
{
	@Override
	public IPartA createPartA() 
	{
		return new PartA2();
	}

	@Override
	public IPartB createPartB() 
	{
		return new PartB2();
	}

	@Override
	public IPartC createPartC() 
	{
		return new PartC2();
	}
}

package abstract_factory.imp;

import abstract_factory.inf.IPartA;

public class PartA1 implements IPartA
{
	@Override
	public void show() 
	{	
		System.out.println ("In class PartA1");
	}
}

package abstract_factory.imp;

import abstract_factory.inf.IPartA;

public class PartA2 implements IPartA
{
	@Override
	public void show() 
	{
		System.out.println ("In class PartA2");
	}
}

package abstract_factory.imp;

import abstract_factory.inf.IPartB;

public class PartB1 implements IPartB
{
	@Override
	public void action() 
	{
		System.out.println ("In class PartB1");
	}
}

package abstract_factory.imp;

import abstract_factory.inf.IPartB;

public class PartB2 implements IPartB
{
	@Override
	public void action() 
	{
		System.out.println ("In class PartB2");
	}
}

package abstract_factory.imp;

import abstract_factory.inf.IPartC;

public class PartC1 implements IPartC
{
	@Override
	public void dosomething() 
	{
		System.out.println ("In class PartC1");
	}
}

package abstract_factory;

import abstract_factory.imp.Abstractfactory1;
import abstract_factory.imp.Abstractfactory2;
import abstract_factory.inf.IAbstractfactory;
import abstract_factory.inf.IPartA;
import abstract_factory.inf.IPartB;
import abstract_factory.inf.IPartC;

public class Product {

	private IPartA partA = null;
	private IPartB partB = null;
	private IPartC partC = null;
	
	Product (IAbstractfactory af)
	{
		register (af);
	}
	
	public void show ()
	{
		partA.show();
		partB.action();
		partC.dosomething();
	}
	
	public void register (IAbstractfactory af)
	{
		this.partA = af.createPartA();
		this.partB = af.createPartB();
		this.partC = af.createPartC();
	}

	public static void main(String[] args) 
	{
		Product obj = new Product (new Abstractfactory1());
		obj.show ();
		obj.register (new Abstractfactory2());
		obj.show ();
	}
}

 

// c++ 版

 

#ifndef _abstract_factory_h_
#define _abstract_factory_h_
// interface class
class IPartA;
class IPartB;
class IPartC;
class IAbstractfactory;

class IAbstractfactory
{
public:
	virtual IPartA* createPartA () = 0;
	virtual IPartB* createPartB () = 0;
	virtual IPartC* createPartC () = 0;
	virtual ~IAbstractfactory () {}
};

class IPartA
{
public:
	virtual void showPartA () = 0;
	virtual ~IPartA () {}
};

class IPartB
{
public:
	virtual void showPartB () = 0;
	virtual ~IPartB () {}
};

class IPartC
{
public:
	virtual void showPartC () = 0;
	virtual ~IPartC () {}
};


// class product
class Product
{
public:
    Product (IAbstractfactory* af);
    ~Product ();
public:
    void changestyle (IAbstractfactory* af);
	void showself ();
private:
    IPartA* m_partA;
    IPartB* m_partB;
    IPartC* m_partC;
};


// impliment IAbstractfactory
class Abstractfactory1 : public IAbstractfactory
{
public:
	virtual IPartA* createPartA ();
	virtual IPartB* createPartB ();
	virtual IPartC* createPartC ();
	virtual ~Abstractfactory1 () {}
};

class Abstractfactroy2 : public IAbstractfactory
{
public:
	virtual IPartA* createPartA ();
	virtual IPartB* createPartB ();
	virtual IPartC* createPartC ();
	virtual ~Abstractfactroy2 () {}
};

// implement IPartA
class PartA1 : public IPartA
{
public:
	virtual ~PartA1 () {};
	virtual void showPartA ();
};

class PartA2 : public IPartA
{
public:
	virtual ~PartA2 () {};
	virtual void showPartA ();
};

// implement IPartB
class PartB1 : public IPartB
{
public:
	virtual ~PartB1 () {};
	virtual void showPartB ();
};

class PartB2 : public IPartB
{
public:
	virtual ~PartB2 () {};
	virtual void showPartB ();
};

// implement IPartC
class PartC1 : public IPartC
{
public:
	virtual ~PartC1 () {};
	virtual void showPartC ();
};

class PartC2 : public IPartC
{
public:
	virtual ~PartC2 () {};
	virtual void showPartC ();
};

#endif

 

.cpp

#include <iostream>
using namespace std;
#include "abstractfactory.h"

// Product
Product::Product (IAbstractfactory* af)
{
	m_partA = af->createPartA();
	m_partB = af->createPartB();
	m_partC = af->createPartC();
}

Product::~Product ()
{
	delete m_partA;
	delete m_partB;
	delete m_partC;
}

void Product::showself ()
{
	m_partA->showPartA ();
	m_partB->showPartB ();
	m_partC->showPartC ();
}

void Product::changestyle (IAbstractfactory* af)
{
	delete m_partA;
	m_partA = af->createPartA();
	delete m_partB;
	m_partB = af->createPartB();
	delete m_partC;
	m_partC = af->createPartC();
}

// Abstractfactory1
IPartA* Abstractfactory1::createPartA ()
{
	return new PartA1();
}

IPartB* Abstractfactory1::createPartB ()
{
	return new PartB1();
}

IPartC* Abstractfactory1::createPartC ()
{
	return new PartC1();
}

// Abstractfactory2
IPartA* Abstractfactroy2::createPartA ()
{
	return new PartA2();
}

IPartB* Abstractfactroy2::createPartB ()
{
	return new PartB2();
}

IPartC* Abstractfactroy2::createPartC ()
{
	return new PartC2();
}

// PartA1
void PartA1::showPartA ()
{
	cout<<"In class partA1"<<endl;
}
// PartA2
void PartA2::showPartA ()
{
	cout<<"In class partA2"<<endl;
}
// PartB1
void PartB1::showPartB ()
{
	cout<<"In class partB1"<<endl;
}
// PartB2
void PartB2::showPartB ()
{
	cout<<"In class partB2"<<endl;
}
// PartC1
void PartC1::showPartC ()
{
	cout<<"In class partC1"<<endl;
}
// PartC2
void PartC2::showPartC ()
{
	cout<<"In class partC2"<<endl;
}

int main ()
{
	IAbstractfactory* af1 = new Abstractfactory1();
	IAbstractfactory* af2 = new Abstractfactroy2();
	Product obj (af1);
	obj.showself ();
	obj.changestyle (af2);
	obj.showself ();
	return 0;	
}