有必要给初学者解决下“月经题”，散分！

Question

都是关于面向对象的，http://bbs.csdn.net/topics/390528973   http://bbs.csdn.net/topics/390536618
花了点时间给两个楼主解答，同时希望初学者少走弯路，不要在为“面向对象”而面向对象，要提前理解JavaBean+DAO的模式(简单的说，就是把数据和方法完全分离；如果实在还不理解，就回忆下C语言的"结构体+函数式"编程的思想，面向过程你能理解吧，换了个更简单的面向对象怎么就纠结了？)，简化今后的编程，加快JavaSE学习的速度。
为什么现在有泛型，为什么有反射，为什么有纯POJO？这些思想就是要让你的“数据”和“操作”完全分离；类似于“冰箱具有--开打、关闭方法，汽车具有--行驶、刹车方法”的代码绝对绝对不能再出现在Pojo当中了！
以后谁再写以下这种2B代码你们项目经理跟你没完！package beantest.bean;
 
/**
 *冰箱
 *
 */
public class Fridge {
private String name;
 
public String getName() {
    return name;
}
 
public void setName(String name) {
    this.name = name;
}
 
/**
 * 冰箱具有打开的行为
 */
public void open(){
    System.out.println("打开"+name);
}
 
/**
 * 冰箱具有关闭的行为
 */
public void close(){
    System.out.println("关闭"+name);
}
}企业级的设计思路有MVC以及SSH框架的单例、代理、Aop等等，
但面向对象基本上只有Dao+JavaBean,没有其他；连继承都很少，纵观马士兵、张孝祥、韩顺平的SSH视频，只找到两个:HibernateTemplate、ActionSupport而已；所以，如果初学者再过分的纠结于所谓的抽象、封装、继承、多态，只会耽误学习Java的进度！
比如一个帖子问到：
老王和老李是夫妻。老王是一名大学教授，老李是一名会计，他们的父母都健在。老王和老李有一个儿子，15岁了，在上中学。老王有时候去打太极拳，老李有时候去兼职讲课。用OO的思想描述他们的关系 可以这样解答，诸位可能有更加优美的代码，但设计思路在20年之内是不会变的。
下面是项目的包结构：
db里边是数据库(我们现在用List代替真正的数据库)
bean包里边是实体(习惯上称为JavaBean、POJO、Entity等等)
dao包里边是增删改查的类(对一个数据的基本操作就是CRUD)
logic包是业务逻辑层(如：判断两人是否是夫妻，判断父母是否健在等等)
util包用于存放：数据字典以及一些常用的正则、IO、日期的工具类
package beantest.bean;
 
/**
 *爱好
 *
 */
public class Hobby {
    /**
     * 主键--在数据库中的下标
     */
    private int id;
/**
 * 名称
 */
private String name;
public int getId() {
    return id;
}
public void setId(int id) {
    this.id = id;
}
public String getName() {
    return name;
}
public void setName(String name) {
    this.name = name;
}
public Hobby(int id, String name) {
    super();
    this.id = id;
    this.name = name;
}
@Override
public String toString() {
    return "Hobby [id=" + id + ", name=" + name + "]";
}
 
}
package beantest.bean;
/**
 *  职业
 */
public class Job {
     
/**
 *  主键--在数据库中的下标
 */
private int id;
 
/**
 * 名称
 */
private String name;
public int getId() {
    return id;
}
public void setId(int id) {
    this.id = id;
}
public String getName() {
    return name;
}
public void setName(String name) {
    this.name = name;
}
public Job(int id, String name) {
    super();
    this.id = id;
    this.name = name;
}
public Job() {
    super();
}
@Override
public String toString() {
    return "Job [id=" + id + ", name=" + name + "]";
}
 
}
package beantest.bean;
 
import java.util.List;
/**
 *  人
 */
public class Person {
     
/**
 *  主键--在数据库中的下标
 */
private int id;
/**
 * 姓名
 */
private String name;
/**
 * 性别 1-男  2-女
 */
private int male;
/**
 * 年龄
 */
private int age;
/**
 * 是否在世  
 */
private boolean isLive;
/**
 * 父亲id引用  -1表示不存在
 */
private int fatherId;
/**
 * 母亲id引用  -1表示不存在
 */
private int motherId;
/**
 * 爱人的id引用 -1表示不存在
 */
private int loverId;
/**
 * 职业的id引用  -1表示不存在
 */
private int jobId;
/**
 * 由于可以有多个爱好，所以一个人拥有爱好ID的集合
 */
private List<Integer> hobbyList;
public List<Integer> getHobbyList() {
    return hobbyList;
}
public void setHobbyList(List<Integer> hobbyList) {
    this.hobbyList = hobbyList;
}
public int getId() {
    return id;
}
public void setId(int id) {
    this.id = id;
}
public String getName() {
    return name;
}
public void setName(String name) {
    this.name = name;
}
public int getMale() {
    return male;
}
public void setMale(int male) {
    this.male = male;
}
public int getAge() {
    return age;
}
public void setAge(int age) {
    this.age = age;
}
public boolean isLive() {
    return isLive;
}
public void setLive(boolean isLive) {
    this.isLive = isLive;
}
public int getFatherId() {
    return fatherId;
}
public void setFatherId(int fatherId) {
    this.fatherId = fatherId;
}
public int getMotherId() {
    return motherId;
}
public void setMotherId(int motherId) {
    this.motherId = motherId;
}
public int getLoverId() {
    return loverId;
}
public void setLoverId(int loverId) {
    this.loverId = loverId;
}
 
public int getJobId() {
    return jobId;
}
public void setJobId(int jobId) {
    this.jobId = jobId;
}
public Person() {
    super();
}
public Person(int id, String name, int male, int age, boolean isLive,
        int fatherId, int motherId, int loverId, int jobId) {
    super();
    this.id = id;
    this.name = name;
    this.male = male;
    this.age = age;
    this.isLive = isLive;
    this.fatherId = fatherId;
    this.motherId = motherId;
    this.loverId = loverId;
    this.jobId = jobId;
}
@Override
public String toString() {
    return "Person [id=" + id + ", name=" + name + ", male=" + male + ", age="
            + age + ", isLive=" + isLive + ", fatherId=" + fatherId
            + ", motherId=" + motherId + ", loverId=" + loverId + ", jobId="
            + jobId + "]";
}
 
 
}
package beantest.dao;
 
import java.util.List;
 
/**
 *单表 CRUD的类
 */
public class BaseDao<T> {
/**
 * 操作哪个表
 */
private List<T> table;
 
public BaseDao(List<T> table) {
    super();
    this.table = table;
}
/**
 * 插入
 */
public void insert(T t){
    table.add(t);
}
/**
 * 查询
 */
public T query(int id){
    return table.get(id);
}
 
/**
 * 修改
 */
public void update(T t,int id){
table.set(id, t);
}
/**
 * 删除
 */
public T delete(int id){
    return table.remove(id);
}
}
package beantest.db;
 
import java.util.ArrayList;
import java.util.List;
 
import beantest.bean.Hobby;
import beantest.bean.Job;
import beantest.bean.Person;
import beantest.util.Dectionary;
 
/**
 *数据库，每个数据库的记录的id从0开始
 *
 */
public class DataBase {
public static List<Person> personDb=new ArrayList<Person>();
public static List<Job> jobDb=new ArrayList<Job>();
public static List<Hobby> hobbyDb=new ArrayList<Hobby>();
//初始化数据库并设置关联
static{
    //初始化person数据库
    Person p0=new Person(0, "老王的父亲", Dectionary.Male, 60, Dectionary.Live, -1, -1, 1,-1);
    Person p1=new Person(1, "老王的母亲", Dectionary.Female, 60, Dectionary.Live, -1, -1, 0,-1);
     
    Person p2=new Person(2, "老李的父亲", Dectionary.Male, 60, Dectionary.Live, -1, -1, 3,-1);
    Person p3=new Person(3, "老李的父亲",  Dectionary.Female, 60, Dectionary.Live, -1, -1, 2,-1);
     
    Person p4=new Person(4, "老王", Dectionary.Male, 40, Dectionary.Live, 0, 1, 5,0);
    Person p5=new Person(5, "老李", Dectionary.Female, 40, Dectionary.Live, 2, 3, 4,1);
     
    Person p6=new Person(6, "儿子", Dectionary.Male, 15, Dectionary.Live, 4, 5, -1, 2);
    personDb.add(p0);    personDb.add(p1);    personDb.add(p2);    personDb.add(p3);
    personDb.add(p4);    personDb.add(p5);    personDb.add(p6);   
    //初始化job数据库
    Job job0=new Job(0, "教师");
    Job job1=new Job(1, "会计");
    Job job2=new Job(2, "上中学");
    jobDb.add(job0);jobDb.add(job1);jobDb.add(job2);
     
    //初始化hobby数据库
    Hobby h0=new Hobby(0, "太极拳");
    Hobby h1=new Hobby(0, "兼职讲课");
    hobbyDb.add(h0);
    hobbyDb.add(h1);
     
    //设置爱好
    List<Integer> wangList=new ArrayList<Integer>();
    List<Integer> liList=new ArrayList<Integer>();
    wangList.add(0);
    liList.add(1);
    p0.setHobbyList(wangList);
    p1.setHobbyList(liList);
}
}JavaOOP 月经题初学者 面向对象

Answer 1

 对照你的看了一下musicstore：1.logic分成了３个包：admin, cart, catalog2.数据库只有一个包：data
   其中 UserDB, ProductDB 等属于dao； ConnectionPool,DBUtil,SQLUtil等属于db;
   
3.初始化数据库是用sql文件生成的,
 

Answer 2

一点改动:public  void personDoSth(int personId ){
    Person p=personDao.query(personId);
    
    
    for ( Integer i: p.getHobbyList()){
      Hobby h=hobbyDao.query(i);
         System.out.println(p.getName()+ " like"+ h.getName());
    }
       
}lc.personDoSth(4);
lc.personDoSth(5);      Hobby h0=new Hobby(0, " swiming");
    Hobby h1=new Hobby(1, " part-time teacher");
    Hobby h2=new Hobby(2, " baseball");
    Hobby h3=new Hobby(3, " hiking");
    hobbyDb.add(h0);
    hobbyDb.add(h1);
    hobbyDb.add(h2);
    hobbyDb.add(h3);
      
 
    List<Integer> wangList=new ArrayList<Integer>();
    List<Integer> liList=new ArrayList<Integer>();
    wangList.add(0);
    liList.add(0);
    liList.add(1);
    liList.add(2);
    
    p4.setHobbyList(wangList);
    p5.setHobbyList(liList);
    

Answer 3

正常的开发过程中，先搞bean、db(存放ddl语句、sql脚本等等)，他们是ORM一一对应的，这样先把实体和数据库建好；
然后写BaseDao，只写基本的CRUD；再写每个实体的dao；
然后logic，logic调用dao；遇到复杂的查询，再回过头来在某个实体Dao里边写特定的SQL或HQL语句；
然后写main或junitTest测试logic的正确性；
最后再写Jsp和servlet。
Util包贯穿始终，比如写JavaBean的时候要定义常量，我们就去写
Dectionary；sql要用到日期和String的转换，我们就去写DateFormatUtil；页面要用到上传下载，我们就去写IOUtil；前台接收的参数要在servlet中判断合法性，如身份证、邮箱的验证等等，我们就需要去写RegExpUtil。

Answer 4

[quote ]
 
正常的开发过程中， 

 太感谢了，对照我的musicStore，很有感觉了。我的musicStore,logic 好象都是用servlet写的啊？

Answer 5

 太感谢了，对照我的musicStore，很有感觉了。我的musicStore,logic 好象都是用servlet写的啊？
如果项目很赶时间，可以放在servlet中，如果是比较规范的项目，就尽量让servlet控制纯粹的跳转；比如最简单的“登录”程序，可以在servlet中这样写：String userName=request.getParameter("userName");
String password=request.getParameter("password");
UserInfo userInfo=userInfologic.login(userName,password);UserInfoLogic中这样写：public UserInfo login(String userName,String password){
UserInfo userInfo=userInfoDao.queryByUserNameAndPassword(userName,password);
return userInfo;
}

Answer 6

 太感谢了，对照我的musicStore，很有感觉了。我的musicStore,logic 好象都是用servlet写的啊？
如果项目很赶时间，可以放在servlet中，如果是比较规范的项目，就尽量让servlet控制纯粹的跳转；比如最简单的“登录”程序，可以在servlet中这样写：String userName=request.getParameter("userName");
String password=request.getParameter("password");
UserInfo userInfo=userInfologic.login(userName,password);UserInfoLogic中这样写：public UserInfo login(String userName,String password){
UserInfo userInfo=userInfoDao.queryByUserNameAndPassword(userName,password);
return userInfo;
}
非常支持LZ分享了很好的东西，给大家！看到了这段代码，也想说两句。其实，分层是为了各司其职，提高代码可复用性。Dao（Data access Object）层，顾名思义，是对数据库访问的。此时，我们通过一个用户名和密码去dao中获取数据，其实是把业务逻辑放到了dao中处理。既然已经写了业务逻辑层，我认为，应该这样拆分代码：
1. Dao中，根据username获取一个userInfo对象（Dao层负责）
2. 判断UserInfo中的密码，跟请求中的密码是否一致（逻辑层负责）这样，针对按照用户名获取用户和按照用户名、密码获取用户，在应用的频率中，会有不同的。这是，个人的一点观点，希望跟大家交流~！

Answer 7

如果逻辑不复杂，这样更简单？String userName=request.getParameter("userName");
String password=request.getParameter("password");
UserInfo userInfo=userInfoDao.queryByUserNameAndPassword(userName,password);

Answer 8

MVC分层模式就很棒的，建议初学者别总往jsp中写java代码，尤其是dao层的

Answer 9

只是一个文件组织的方法，可以考虑一下~至于代码，我上面已经说清楚我的思路了啊~Logic中，public UserInfo login(String userName,String password){
    UserInfo userInfo=userInfoDao.queryByUserName(userName);
    // 执行密码验证
    checkPassword(password, userInfo.getPassword());
    return userInfo;
}

Answer 10

http://download.csdn.net/detail/smallyamateh/5875117   免积分

Answer 11

从面向对象的角度看，job和hobby都是person的一个属性，现在变成了类，挺出乎意料的。从数据库的角度想，把它们弄成类容易理解。重要的是对MVC更有感觉了。

Answer 12

我只想说，bean不是万能的，楼主有些矫枉过正。事实上，JavaBean/POJO的普及让很多新手除了bean什么都不会写。取决于你公司具体的框架设计，取决于你做的是哪个层次的工作。这句话比较赞同。

Answer 13

还没看，觉得有点高深，但应该会很有用的样子，csdn是个好地方，希望找到自己想要的东西

Answer 14

楼主，为毛我看到有些教材上面说DAO是一个接口呢？还要，vo也是表示的bean吧？

Answer 15

lz的那个设计好厉害哦，为什么我读了那段吗描述却是一片空白呢？请问lz是如何思考 如何达到这种境界的！

Answer 16

教材的比我更具体一些，Dao、DaoImpl等等，vo是用来表示前台视图来便于EL表达式的展示。

Answer 17

Person p3=new Person(3, "老李的父亲",  Dectionary.Female, 60, Dectionary.Live, -1, -1, 2,-1);
此处是不是“父亲”应该改为“母亲”，不小心看到了，就提一下，望LZ见谅哈！楼主很给力！！！

Answer 18

why use super()?public Hobby(int id, String name) {
    super();
    this.id = id;
    this.name = name;
}

Answer 19

在目前的MVC模式中基本上可以这样说，dao、service、servlet等等严格来说并不是JavaBean；而EJB里边的各种Javabeans过于复杂，暂时抛弃EJB是明智的选择。

Answer 20

虽然我是菜鸟，但我不认为为了求快而忽略基础，楼主也是过来人，学会封装，继承，多态，对理解抽象类，接口，以及面向对象的设计思路和模式有着根本性的意义，对理解jdk的API也有很大帮助，这也必将决定你以后在技术上能走多远。如果我们是为了企业而去学习快速的模式那和那些去做销售的有什么区别

Answer 21

楼上有人super()这个都不明白，这就是java里子类构造函数调用父类构造函数的方法，即使不写的话也会隐含调用，如果他不学习继承，请他懂嘛？

Answer 22

super: call a constructor or method of the superclass. 我不至于连super都不懂吧？只是觉得没必要用

Answer 23

正常的开发过程中，先搞bean、db(存放ddl语句、sql脚本等等)，他们是ORM一一对应的，这样先把实体和数据库建好；
然后写BaseDao，只写基本的CRUD；再写每个实体的dao；
然后logic，logic调用dao；遇到复杂的查询，再回过头来在某个实体Dao里边写特定的SQL或HQL语句；
然后写main或junitTest测试logic的正确性；
最后再写Jsp和servlet。
Util包贯穿始终，比如写JavaBean的时候要定义常量，我们就去写
Dectionary；sql要用到日期和String的转换，我们就去写DateFormatUtil；页面要用到上传下载，我们就去写IOUtil；前台接收的参数要在servlet中判断合法性，如身份证、邮箱的验证等等，我们就需要去写RegExpUtil。

大学自己架构过项目，Util这一步学习了

Answer 24

有几个问题:
1.logic 类如何定义? 一个实体对应一个? 当系统变大后,logic类的行数变多 2000- 3000 , 如何处理?
2.获取一个Person 是否成年的方法在logic里面还是在 Person里面?
3.javaBean 应该是指实现一类逻辑的 class?

Answer 25

1、小系统的话，一个实体对应一个Logic；大系统的话，一个小模块对应一个，如登录、日志和回复、相册管理等等都可以写成不同的类。
2、PersonLogic里，或页面直接使用JSTL标签。
3、从目前不含EJB的系统来讲，javabean==pojo==entity；其他的叫做“组件component”。