「java工厂模式代码」java中工厂模式
本篇文章给大家谈谈java工厂模式代码，以及java中工厂模式对应的知识点，希望对各位有所帮助，不要忘了收藏本站喔。
本文目录一览：
Java的几个工厂方法解析
Java工厂模式可分为三种：
1.静态工厂模式
2.工厂方法模式
3.抽象工厂模式
一、静态工厂模式：用静态的方法实现，其创建的对象具有一定的特性
举例如下：
Vehicle类：
public abstract class Vehicle
{
private String name;
public Vehicle (){
super();
}
public Vehicle (String name){
super();
this.name=name;
}
public abstract void run();
public String getName(){
return name;
}
public void setName(String name){
this.name=name;
}
}
Bus类：
public class Bus extends Vehicle
{
private String name;
public Bus(){}
public Bus(String name){
super(name);
}
@Override
public abstract void run(){
System.out.println("Bus is running");
}
}
Car类：
public class Car extends Vehicle
{
private String name;
public Car(){}
public Car(String name){
super(name);
}
@Override
public abstract void run(){
System.out.println("Car is running");
}
}
静态工厂类：
（静态工厂创建一个对象，
静态工厂创建的对象一般都有一个共同的特性，
继承自某一个类，
或者引用一个接口）
public class StaticFactory{
public static Object getInstance(String className){
Object instance=null;
try{
Class c=Class.forName(className);
instance=c.newInstance();
}catch(Exception e){}
return instance;
}
public static Object getInstance(String className,Object ...args){
Class c=null;
try{
c=Class.forName(className);
}catch(Exception e){}
Constructor[] cons=c.getConstructors();
Object instance=null;
for(Constructor con:cons){
Class?[] cs=con.getParmeterTypes();
if(cs.length0){
boolean isConstructor=true;
for(int i=0;ics.length;i++){
Class t=cs[i];
if(!t.isInstance(args[i])){
isConstructor=false;
}
}
if(isConstructor){
try{
instance=con.newInstance(args);
break;
}catch(Exception e){}
}else{
continue;
}
}
}
return instance;
}
}
二、工厂方法模式：主要是对各类东西分类生产，但分类生产的对象仍然具有某一特性。
如果说静态工厂是一个综合的交通工具建造工厂，
那么工厂方法模式就是具体分工，分成Bus与Car的工厂，
各自生产各自的产品，但是造出来的还是交通工具。
交通工具制造接口：
public interface VehicleMake{
/**制造交通工具**/
public Vehicle make();
}
Bus制造类：
public class BusMake implements VehicleMake{
@Override
public Vehicle make(){
Vehicle bus=new Bus();
System.out.println("Bus工厂制造了一辆Bus");
return bus;
}
}
Car制造类：
public class CarMake implements VehicleMake{
@Override
public Vehicle make(){
Vehicle car=new Car();
System.out.println("Car工厂制造了一辆Car");
return car;
}
}
三、抽象工厂模式：抽象工厂生产的对象可能是没有共同特性的。比如，一个制造工厂BusMake不仅能制造Bus还能生产轮胎wheel等配件，Bus是交通工具，wheel是配件（代码中有部分类没具体写出来只给了类名）
总工厂（抽象工厂总接口）：
public interface WheelVehicleMake extends VehicleMake{
/**制造轮胎**/
public Wheel makeWheel();
}
轮子BusMake：
public class WheelBusMake implements WheelVehicleMake{
@Override
public Vehicle make(){
Vehicle bus=new Bus();
System.out.println("WheelBusMake生产了一辆Bus");
return bus;
}
@Override
public Wheel makeWheel(){
Wheel busWheel=new BusWheel();
System.out.println("WheelBusMake生产了一个Bus轮子");
return busWheel;
}
}
轮子CarMake：
public class WheelCarMake implements WheelVehicleMake{
@Override
public Vehicle make(){
Vehicle car=new Car();
System.out.println("WheelCarMake生产了一辆Car");
return car;
}
@Override
public Wheel makeWheel(){
Wheel carWheel=new CarWheel();
System.out.println("WheelCarMake生产了一个Car轮子");
return carWheel;
}
}
写一个抽象工厂模式 java实例 出来
工厂模式java实例如下：
public interface Work {
void doWork();
}
ConcreteProduct
public class StudentWork implements Work {
public void doWork() {
System.out.println("学生做作业!");
}
}
public class TeacherWork implements Work {
public void doWork() {
System.out.println("老师审批作业!");
}
}
生产者
public interface IWorkFactory {
Work getWork();
}
ConcreteCreator
public class StudentWorkFactory implements IWorkFactory {
public Work getWork() {
return new StudentWork();
}
}
public class TeacherWorkFactory implements IWorkFactory {
public Work getWork() {
return new TeacherWork();
}
}
Test
public class Test {
public static void main(String[] args) {
IWorkFactory studentWorkFactory = new StudentWorkFactory();
studentWorkFactory.getWork().doWork();
IWorkFactory teacherWorkFactory = new TeacherWorkFactory();
teacherWorkFactory.getWork().doWork();
}
}
字符串反转如下：
public String getReverseStr(String str)
{
String reverseStr = "";
if (null != str !str.equals(""))
{
for (int i = 1 ; i =str.length(); i++){
reverseStr += str.charAt(str.length() - i);
// 依次按与原字符串相反的顺序拼装字符串，内部会自动进行类型转换
//str.length() - i刚好是str的下标，因为i是从1开始
}
}
return reverseStr;
}
冒泡排序算法，从小到大
public int[] sortArr(int[] targetArr){
//小到大的排序
int temp = 0;
for(int i = 0;itargetArr.length;i++){
for(int j = i;jtargetArr.length;j++){
if(targetArr[i]targetArr[j]){
temp = targetArr[i];
targetArr[i] = targetArr[j];
targetArr[j] = temp;
}
}
}
return targetArr;
}
求java工厂模式的一个简单代码例子，尽量简单
这个应该比较简单一点。
某系统日志记录器要求支持多种日志记录方式，如文件记录、数据库记录等，且用户可以根据要求动态选择日志记录方式。现使用工厂方法模式设计该系统,并写出相应Java代码。
interface Log{
public void writeLog();
}
class FileLog implements Log{
public void writeLog(){
System.out.println("文件记录");
}
}
class DatabaseLog implements Log{
public void writeLog(){
System.out.println("数据库记录");
}
}
interface LogFactory{
public Log createLog();
}
class FileLogFactory implements LogFactory{
public Log createLog(){
return new FileLog();
}
}
class DatabaseLogFactory implements LogFactory{
public Log createLog(){
return new DatabaseLog();
}
}
public class Client{
public static void main(String[] args) {
try{
Log log;
LogFactory factory;
//这里可以改成使用DOM和Java反射机制读取XML文件，获取工厂类名
factory=new DatabaseLogFactory ();
log=factory.createLog();
log.writeLog();
}
catch(Exception e){
System.out.println(e.getMessage());
}
}
}
java 抽象工厂模式
工厂模式在项目中是常常用到的,有人说只有大项目才会用到,小项目是体会不出来.其实使用设计模式与项目的大小没有实质性的联系.设计模式是经验的总结而不是衡量项目大小的标准.
以开发项目的DAO层为例,在项目中客户的需求是常常变动的,临时更换数据库的需求也是常常发生的,那我们要如何解决跨数据库的功能,这里就要使用到抽象工厂模式了.工厂模式常常用于创建多系列化的对象(如Orale系列,MySql系列)
1.首先定义相关接口(与平常的做法没什么区别)
Java代码
// 角色表DAO接口
interface IroleDao {
void insert();
void update();
}
// 用户表DAO接口
interface IuserDao {
void find();
void delete();
}
// 角色表DAO接口
interface IroleDao {
void insert();
void update();
}
// 用户表DAO接口
interface IuserDao {
void find();
void delete();
} 2.不同的数据库有不同的SQL语句所以实现时必须分数据库来实现
Java代码
// 用户表Oralce数据库DAO
class OracleuserDao implements IuserDao {
public void delete() {
System.out.println("Oralce 删除用户表数据");
}
public void find() {
System.out.println("Oralce 查询用户表数据");
}
}
// 用户表MySql数据库DAO
class MySqluserDao implements IuserDao {
public void delete() {
System.out.println("MySql 删除用户数据");
}
public void find() {
System.out.println("MySql 查询用户数据");
}
}
// 角色表Oracle数据库DAO
class OracleroleDao implements IroleDao {
public void insert() {
System.out.println("Oralce 对角色表插入数据");
}
public void update() {
System.out.println("Oracle 对角色表更新数据");
}
}
// 角色表MySql数据库DAO
class MySqlroleDAO implements IroleDao {
public void insert() {
System.out.println("MySql 对角色表插入数据");
}
public void update() {
System.out.println("Mysql 对角色表更新数据");
}
}
// 用户表Oralce数据库DAO
class OracleuserDao implements IuserDao {
public void delete() {
System.out.println("Oralce 删除用户表数据");
}
public void find() {
System.out.println("Oralce 查询用户表数据");
}
}
// 用户表MySql数据库DAO
class MySqluserDao implements IuserDao {
public void delete() {
System.out.println("MySql 删除用户数据");
}
public void find() {
System.out.println("MySql 查询用户数据");
}
}
// 角色表Oracle数据库DAO
class OracleroleDao implements IroleDao {
public void insert() {
System.out.println("Oralce 对角色表插入数据");
}
public void update() {
System.out.println("Oracle 对角色表更新数据");
}
}
// 角色表MySql数据库DAO
class MySqlroleDAO implements IroleDao {
public void insert() {
System.out.println("MySql 对角色表插入数据");
}
public void update() {
System.out.println("Mysql 对角色表更新数据");
}
}
这里增加了一套DAO的实现 (与平时有所不同,如果有10个数据库就要加上10种不同的实现,比较麻烦呀)
3.定义DAO工厂接口与实现(利用java反射机制生产出你需要的DAO如:userDAO,roleDao)
Java代码
// DAO工厂
abstract class DaoFactory {
public static DaoFactory getInstance(String classname) {
DaoFactory dao = null;
try {
dao = (DaoFactory) Class.forName(classname).newInstance();
} catch (Exception e) {
e.printStackTrace();
}
return dao;
}
abstract IuserDao getuserdao();
abstract IroleDao getroledao();
}
// Oralce工厂
class OracleFactory extends DaoFactory {
public IroleDao getroledao() {
return new OracleroleDao();
}
public IuserDao getuserdao() {
return new OracleuserDao();
}
}
// MySql工厂
class MysqlFactory extends DaoFactory {
public IroleDao getroledao() {
return new MySqlroleDAO();
}
public IuserDao getuserdao() {
return new MySqluserDao();
}
}
// DAO工厂
abstract class DaoFactory {
public static DaoFactory getInstance(String classname) {
DaoFactory dao = null;
try {
dao = (DaoFactory) Class.forName(classname).newInstance();
} catch (Exception e) {
e.printStackTrace();
}
return dao;
}
abstract IuserDao getuserdao();
abstract IroleDao getroledao();
}
// Oralce工厂
class OracleFactory extends DaoFactory {
public IroleDao getroledao() {
return new OracleroleDao();
}
public IuserDao getuserdao() {
return new OracleuserDao();
}
}
// MySql工厂
class MysqlFactory extends DaoFactory {
public IroleDao getroledao() {
return new MySqlroleDAO();
}
public IuserDao getuserdao() {
return new MySqluserDao();
}
}
4. 定义配置文件
Java代码
class Config {
// Oralce
static final String ORALCE = "org.abc.OracleFactory";
static final String MYSQL = "org.abc.MysqlFactory";
}
class Config {
// Oralce
static final String ORALCE = "org.abc.OracleFactory";
static final String MYSQL = "org.abc.MysqlFactory";
}
配置文件可以定义到XML中去(好处:修改配置项之后不需要对JAVA文件进行编译.)
5.测试你的输出的DAO
Java代码
public class Dao {
public static void main(String[] args) {
DaoFactory.getInstance(Config.ORALCE).getroledao().insert();
DaoFactory.getInstance(Config.MYSQL).getroledao().insert();
}
}
public class Dao {
public static void main(String[] args) {
DaoFactory.getInstance(Config.ORALCE).getroledao().insert();
DaoFactory.getInstance(Config.MYSQL).getroledao().insert();
}
}
总结
使用条件：一系列接口有一系列的实现
如上IuserDao、IroleDao等一系列的接口，他们可以有一系列的实现(Oracle方式、MySql方式)
OracleuserDao、OracleroleDao、MySqluserDao、MySqlroleDAO
组成元素(以上面例子)
一系列接口：IuserDao、IroleDao
一系列实现：Oracle系列、MySql系列
系列工厂类：Oracle系列工厂类、MySql系列工厂类(必须继承抽象工厂类)
抽象工厂类：DaoFactory
java工厂模式代码的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于java中工厂模式、java工厂模式代码的信息别忘了在本站进行查找喔。