什么是工厂设计模式，如何实现

在面向对象编程中, 最通常的方法是一个new操作符产生一个对象实例,new操作符就是用来构造对象实例的。但是在一些情况下, new操作符直接生成对象会带来一些问题。举例来说, 许多类型对象的创造需要一系列的步骤: 你可能需要计算或取得对象的初始设置; 选择生成哪个子对象实例; 或在生成你需要的对象之前必须先生成一些辅助功能的对象。 在这些情况, 新对象的建立就是一个 “过程”，不仅是一个操作，像一部大机器中的一个齿轮传动。

就比如下面

import org.hibernate.*;
import org.hibernate.cfg.*;


public class HibernateUtil {
        private static final SessionFactory sessionFactory;
       
        static {
                try{
                        sessionFactory=new AnnotationConfiguration().configure().buildSessionFactory();
                       
                }catch(Exception e){
                        e.printStackTrace();
                        throw new ExceptionInInitializerError(e);
                }       
               
        }
       
        public static SessionFactory getSessionFactory(){
                return sessionFactory;
               
        }
       
       

}

上面的代码不好，换乘下面的，这个看起来明显点
import com.chuanqi.team.service.*;

public class ServiceFactory {

        public TeamService getTeamService(String className) throws Exception {
                TeamService teamService = null;
               
                try {
                        teamService = (TeamService)Class.forName(className).newInstance();
                }
                catch(Exception e) {
                        e.printStackTrace();
                        throw new Exception("工厂异常");
                }
               
                return teamService;
        }
       
        public StudentService getStudentService(String className) throws Exception {
                StudentService  studentService = null;
               
                try {
                        studentService = (StudentService)Class.forName(className).newInstance();
                }
                catch(Exception e) {
                        e.printStackTrace();
                        throw new Exception("工厂异常");
                }
               
                return studentService;
        }
       
        public AdminService getAdminService(String className) throws Exception {
                AdminService adminService = null;
               
                try {
                        adminService = (AdminService)Class.forName(className).newInstance();
                }
                catch(Exception e) {
                        e.printStackTrace();
                        throw new Exception("工厂异常");
                }
               
                return adminService;
        }
}

谢谢了，受教了

class User {
        private String name;
        private int age;
        public void setName(String name){
                this.name=name;
        }
        public void setAge(int age){
                this.age=age;
        }
        public String getName(){
                return this.name;
        }
        public int getAge(){
                return this.age;
        }
}
interface UserDAO {
        public boolean doCreate(User user)throws Exception;
}
class UserDAOImpl implements UserDAO {
        private String str=null;
        public UserDAOImpl(String str){
                this.str=str;
        }
        public boolean doCreate(User user)throws Exception{
                boolean flag=false;
                try{
                        System.out.println("真实主题类的数据库增加操作");
                }catch(Exception e){
                        e.printStackTrace();
                }finally{
                       
                }
                return flag;
        }
}
class UserDAOProxy implements UserDAO {
        private UserDAOImpl dao=null;
        private String str=null;                //此处其实应该传入一个数据库的连接到真实主题类的，不过这里只是个演示，所有以字符串的形式传了进去
        public UserDAOProxy(){
                this.str=new String();
                this.dao=new UserDAOImpl(this.str);
        }
        public boolean doCreate(User user)throws Exception{
                boolean flag=true;
                System.out.println("代理类的操作，打开数据库，同时取得真实主题类的实例去调用真实的数据层操作");
                try{
                        this.dao.doCreate(user);
                }catch(Exception e){
                        e.printStackTrace();
                }finally{
                        System.out.println("代理类的操作，调用完真实主题类的操作，同时关闭数据库");
                }
                return flag;
        }
}
class UserDAOFactory {
        public static UserDAO getUserDAONewInstance(){
                System.out.println("通过工厂类取得代理类的实例去调用代理类的操作。");
                return new UserDAOProxy();
        }
}
public class FactoryDemo {
        public static void main(String args[])throws Exception{
                User user=new User();
                user.setName("jhjjs");
                user.setAge(20);
                UserDAOFactory.getUserDAONewInstance().doCreate(user);
        }
}

抽象工厂模式，他用来创建一组相关或者相互依赖的对象。他与工厂方法模式的区别就在于，工厂方法模式针对的是一个产品等级结构；而抽象工厂模式则是针对的多个产品等级结构。在编程中，通常一个产品结构，表现为一个接口或者抽象类，也就是说，工厂方法模式提供的所有产品都是衍生自同一个接口或抽象类，而抽象工厂模式所提供的产品则是衍生自不同的接口或抽象类。

能解释下这样的好处吗？一直不死很理解。为什么短的代码可以实现，要写很多行。