A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© 白堇翎 高级黑马   /  2013-8-22 21:59  /  1316 人查看  /  2 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

本帖适合已经学习完java基础,开始学习高新技术的同学原帖地址猛击我

花了点时间给两个楼主解答,同时希望初学者少走弯路,不要在为“面向对象”而面向对象,要提前理解JavaBean+DAO的模式(简单的说,就是把数据和方法完全分离;如果实在还不理解,就回忆下C语言的"结构体+函数式"编程的思想,面向过程你能理解吧,换了个更简单的面向对象怎么就纠结了?),简化今后的编程,加快JavaSE学习的速度。
为什么现在有泛型,为什么有反射,为什么有纯POJO?这些思想就是要让你的“数据”和“操作”完全分离;类似于“冰箱具有--开打、关闭方法,汽车具有--行驶、刹车方法”的代码绝对绝对不能再出现在Pojo当中了!
以后谁再写以下这种2B代码你们项目经理跟你没完!
  1. package beantest.bean;

  2. /**
  3. *冰箱
  4. *
  5. */
  6. public class Fridge {
  7. private String name;

  8. public String getName() {
  9.     return name;
  10. }

  11. public void setName(String name) {
  12.     this.name = name;
  13. }

  14. /**
  15. * 冰箱具有打开的行为
  16. */
  17. public void open(){
  18.     System.out.println("打开"+name);
  19. }

  20. /**
  21. * 冰箱具有关闭的行为
  22. */
  23. public void close(){
  24.     System.out.println("关闭"+name);
  25. }
  26. }
复制代码
企业级的设计思路有MVC以及SSH框架的单例、代理、Aop等等,
但面向对象基本上只有Dao+JavaBean,没有其他;连继承都很少,纵观马士兵、张孝祥、韩顺平的SSH视频,只找到两个:HibernateTemplate、ActionSupport而已;所以,如果初学者再过分的纠结于所谓的抽象、封装、继承、多态,只会耽误学习Java的进度!
比如一个帖子问到:
老王和老李是夫妻。老王是一名大学教授,老李是一名会计,他们的父母都健在。老王和老李有一个儿子,15岁了,在上中学。老王有时候去打太极拳,老李有时候去兼职讲课。用OO的思想描述他们的关系

可以这样解答,诸位可能有更加优美的代码但设计思路在20年之内是不会变的
下面是项目的包结构:
db里边是数据库(我们现在用List代替真正的数据库)
bean包里边是实体(习惯上称为JavaBean、POJO、Entity等等)
dao包里边是增删改查的类(对一个数据的基本操作就是CRUD)
logic包是业务逻辑层(如:判断两人是否是夫妻,判断父母是否健在等等)
util包用于存放:数据字典以及一些常用的正则、IO、日期的工具类
  1. package beantest.bean;

  2. /**
  3. *爱好
  4. *
  5. */
  6. public class Hobby {
  7.     /**
  8.      * 主键--在数据库中的下标
  9.      */
  10.     private int id;
  11. /**
  12. * 名称
  13. */
  14. private String name;
  15. public int getId() {
  16.     return id;
  17. }
  18. public void setId(int id) {
  19.     this.id = id;
  20. }
  21. public String getName() {
  22.     return name;
  23. }
  24. public void setName(String name) {
  25.     this.name = name;
  26. }
  27. public Hobby(int id, String name) {
  28.     super();
  29.     this.id = id;
  30.     this.name = name;
  31. }
  32. @Override
  33. public String toString() {
  34.     return "Hobby [id=" + id + ", name=" + name + "]";
  35. }

  36. }
复制代码
  1. package beantest.bean;
  2. /**
  3. *  职业
  4. */
  5. public class Job {
  6.      
  7. /**
  8. *  主键--在数据库中的下标
  9. */
  10. private int id;

  11. /**
  12. * 名称
  13. */
  14. private String name;
  15. public int getId() {
  16.     return id;
  17. }
  18. public void setId(int id) {
  19.     this.id = id;
  20. }
  21. public String getName() {
  22.     return name;
  23. }
  24. public void setName(String name) {
  25.     this.name = name;
  26. }
  27. public Job(int id, String name) {
  28.     super();
  29.     this.id = id;
  30.     this.name = name;
  31. }
  32. public Job() {
  33.     super();
  34. }
  35. @Override
  36. public String toString() {
  37.     return "Job [id=" + id + ", name=" + name + "]";
  38. }

  39. }
复制代码
  1. package beantest.bean;

  2. import java.util.List;
  3. /**
  4. *  人
  5. */
  6. public class Person {
  7.      
  8. /**
  9. *  主键--在数据库中的下标
  10. */
  11. private int id;
  12. /**
  13. * 姓名
  14. */
  15. private String name;
  16. /**
  17. * 性别 1-男  2-女
  18. */
  19. private int male;
  20. /**
  21. * 年龄
  22. */
  23. private int age;
  24. /**
  25. * 是否在世  
  26. */
  27. private boolean isLive;
  28. /**
  29. * 父亲id引用  -1表示不存在
  30. */
  31. private int fatherId;
  32. /**
  33. * 母亲id引用  -1表示不存在
  34. */
  35. private int motherId;
  36. /**
  37. * 爱人的id引用 -1表示不存在
  38. */
  39. private int loverId;
  40. /**
  41. * 职业的id引用  -1表示不存在
  42. */
  43. private int jobId;
  44. /**
  45. * 由于可以有多个爱好,所以一个人拥有爱好ID的集合
  46. */
  47. private List<Integer> hobbyList;
  48. public List<Integer> getHobbyList() {
  49.     return hobbyList;
  50. }
  51. public void setHobbyList(List<Integer> hobbyList) {
  52.     this.hobbyList = hobbyList;
  53. }
  54. public int getId() {
  55.     return id;
  56. }
  57. public void setId(int id) {
  58.     this.id = id;
  59. }
  60. public String getName() {
  61.     return name;
  62. }
  63. public void setName(String name) {
  64.     this.name = name;
  65. }
  66. public int getMale() {
  67.     return male;
  68. }
  69. public void setMale(int male) {
  70.     this.male = male;
  71. }
  72. public int getAge() {
  73.     return age;
  74. }
  75. public void setAge(int age) {
  76.     this.age = age;
  77. }
  78. public boolean isLive() {
  79.     return isLive;
  80. }
  81. public void setLive(boolean isLive) {
  82.     this.isLive = isLive;
  83. }
  84. public int getFatherId() {
  85.     return fatherId;
  86. }
  87. public void setFatherId(int fatherId) {
  88.     this.fatherId = fatherId;
  89. }
  90. public int getMotherId() {
  91.     return motherId;
  92. }
  93. public void setMotherId(int motherId) {
  94.     this.motherId = motherId;
  95. }
  96. public int getLoverId() {
  97.     return loverId;
  98. }
  99. public void setLoverId(int loverId) {
  100.     this.loverId = loverId;
  101. }

  102. public int getJobId() {
  103.     return jobId;
  104. }
  105. public void setJobId(int jobId) {
  106.     this.jobId = jobId;
  107. }
  108. public Person() {
  109.     super();
  110. }
  111. public Person(int id, String name, int male, int age, boolean isLive,
  112.         int fatherId, int motherId, int loverId, int jobId) {
  113.     super();
  114.     this.id = id;
  115.     this.name = name;
  116.     this.male = male;
  117.     this.age = age;
  118.     this.isLive = isLive;
  119.     this.fatherId = fatherId;
  120.     this.motherId = motherId;
  121.     this.loverId = loverId;
  122.     this.jobId = jobId;
  123. }
  124. @Override
  125. public String toString() {
  126.     return "Person [id=" + id + ", name=" + name + ", male=" + male + ", age="
  127.             + age + ", isLive=" + isLive + ", fatherId=" + fatherId
  128.             + ", motherId=" + motherId + ", loverId=" + loverId + ", jobId="
  129.             + jobId + "]";
  130. }


  131. }
复制代码
  1. package beantest.dao;

  2. import java.util.List;

  3. /**
  4. *单表 CRUD的类
  5. */
  6. public class BaseDao<T> {
  7. /**
  8. * 操作哪个表
  9. */
  10. private List<T> table;

  11. public BaseDao(List<T> table) {
  12.     super();
  13.     this.table = table;
  14. }
  15. /**
  16. * 插入
  17. */
  18. public void insert(T t){
  19.     table.add(t);
  20. }
  21. /**
  22. * 查询
  23. */
  24. public T query(int id){
  25.     return table.get(id);
  26. }

  27. /**
  28. * 修改
  29. */
  30. public void update(T t,int id){
  31. table.set(id, t);
  32. }
  33. /**
  34. * 删除
  35. */
  36. public T delete(int id){
  37.     return table.remove(id);
  38. }
  39. }
复制代码
  1. package beantest.db;

  2. import java.util.ArrayList;
  3. import java.util.List;

  4. import beantest.bean.Hobby;
  5. import beantest.bean.Job;
  6. import beantest.bean.Person;
  7. import beantest.util.Dectionary;

  8. /**
  9. *数据库,每个数据库的记录的id从0开始
  10. *
  11. */
  12. public class DataBase {
  13. public static List<Person> personDb=new ArrayList<Person>();
  14. public static List<Job> jobDb=new ArrayList<Job>();
  15. public static List<Hobby> hobbyDb=new ArrayList<Hobby>();
  16. //初始化数据库并设置关联
  17. static{
  18.     //初始化person数据库
  19.     Person p0=new Person(0, "老王的父亲", Dectionary.Male, 60, Dectionary.Live, -1, -1, 1,-1);
  20.     Person p1=new Person(1, "老王的母亲", Dectionary.Female, 60, Dectionary.Live, -1, -1, 0,-1);
  21.      
  22.     Person p2=new Person(2, "老李的父亲", Dectionary.Male, 60, Dectionary.Live, -1, -1, 3,-1);
  23.     Person p3=new Person(3, "老李的父亲",  Dectionary.Female, 60, Dectionary.Live, -1, -1, 2,-1);
  24.      
  25.     Person p4=new Person(4, "老王", Dectionary.Male, 40, Dectionary.Live, 0, 1, 5,0);
  26.     Person p5=new Person(5, "老李", Dectionary.Female, 40, Dectionary.Live, 2, 3, 4,1);
  27.      
  28.     Person p6=new Person(6, "儿子", Dectionary.Male, 15, Dectionary.Live, 4, 5, -1, 2);
  29.     personDb.add(p0);    personDb.add(p1);    personDb.add(p2);    personDb.add(p3);
  30.     personDb.add(p4);    personDb.add(p5);    personDb.add(p6);   
  31.     //初始化job数据库
  32.     Job job0=new Job(0, "教师");
  33.     Job job1=new Job(1, "会计");
  34.     Job job2=new Job(2, "上中学");
  35.     jobDb.add(job0);jobDb.add(job1);jobDb.add(job2);
  36.      
  37.     //初始化hobby数据库
  38.     Hobby h0=new Hobby(0, "太极拳");
  39.     Hobby h1=new Hobby(0, "兼职讲课");
  40.     hobbyDb.add(h0);
  41.     hobbyDb.add(h1);
  42.      
  43.     //设置爱好
  44.     List<Integer> wangList=new ArrayList<Integer>();
  45.     List<Integer> liList=new ArrayList<Integer>();
  46.     wangList.add(0);
  47.     liList.add(1);
  48.     p0.setHobbyList(wangList);
  49.     p1.setHobbyList(liList);
  50. }
  51. }
复制代码

评分

参与人数 1技术分 +1 收起 理由
夜默 + 1

查看全部评分

2 个回复

倒序浏览
(接主楼)
  1. package beantest.logic;

  2. import beantest.bean.Hobby;
  3. import beantest.bean.Job;
  4. import beantest.bean.Person;
  5. import beantest.dao.BaseDao;
  6. import beantest.db.DataBase;
  7. import beantest.util.Dectionary;
  8. /**
  9. *业务逻辑的类
  10. *
  11. */
  12. public class LogicClass {
  13.     BaseDao<Person> personDao=new BaseDao<Person>(DataBase.personDb);
  14.     BaseDao<Job> jobDao=new BaseDao<Job>(DataBase.jobDb);
  15.     BaseDao<Hobby> hobbyDao=new BaseDao<Hobby>(DataBase.hobbyDb);
  16. /**
  17. * 判断两个人是否是夫妻关系,并输出谁是丈夫,谁是妻子
  18. */
  19. public  boolean assertHusbanAndWife(int id1,int id2){
  20.     Person p1=personDao.query(id1);
  21.     Person p2=personDao.query(id2);
  22.     boolean flag=false;
  23.     if(p1.getLoverId()==id2&&p2.getLoverId()==id1){
  24.         flag=true;
  25.         System.out.println(p1.getName()+"和"+p2.getName()+"是夫妻");
  26.         if(p1.getMale()==Dectionary.Male){
  27.             System.out.println(p1.getName()+"是丈夫\t"+p2.getName()+"是妻子");
  28.         }else{
  29.             System.out.println(p2.getName()+"是丈夫\t"+p1.getName()+"是妻子");
  30.         }
  31.     }
  32.     return flag;
  33. }
  34. /**
  35. *显示人的职业
  36. */
  37. public  void printPersonJob(int personId){
  38.     Person p=personDao.query(personId);
  39.     Job j=jobDao.query(p.getJobId());
  40.     System.out.println(p.getName()+"是一名"+j.getName());
  41. }
  42. /**
  43. *判断一个人的父母是否健在
  44. */
  45. public boolean juggParent(int personId){
  46.     boolean flag=false;
  47.     Person p=personDao.query(personId);
  48.     Person father=personDao.query(p.getFatherId());
  49.     Person mother=personDao.query(p.getMotherId());
  50.     if(father.isLive()&&mother.isLive()){
  51.         flag=true;
  52.         System.out.println(p.getName()+"的父母健在");
  53.     }else if(father.isLive()){
  54.         flag=false;
  55.         System.out.println(p.getName()+"只有父亲健在");
  56.     }else if(mother.isLive()){
  57.         flag=false;
  58.         System.out.println(p.getName()+"只有母亲健在");
  59.     }
  60.     return flag;
  61. }
  62. /**
  63. * 根据父母的ID查询孩子
  64. */
  65. public Person queryChildByParent(int fatherId,int motherId){
  66.     Person child=null;
  67.     for(Person p:DataBase.personDb){
  68.         if(p.getFatherId()==fatherId&&p.getMotherId()==motherId){
  69.             child=p;
  70.             Person father=personDao.query(fatherId);
  71.             Person mother=personDao.query(motherId);
  72.             Job job=jobDao.query(child.getJobId());
  73.             System.out.println(father.getName()+"和"+mother.getName()+"有一个儿子,"+child.getAge()+"岁了,在"+job.getName());
  74.             break;
  75.         }else{
  76.             continue;
  77.         }
  78.     }
  79.     return child;
  80. }
  81. /**
  82. *描述谁做什么的方法
  83. */
  84. public  void personDoSth(int personId,String what,int hobbyId){
  85.     Person p=personDao.query(personId);
  86.     Hobby h=hobbyDao.query(hobbyId);
  87.     System.out.println(p.getName()+"有时候"+what+h.getName());
  88. }
  89. public static void main(String[] args) {
  90.     LogicClass lc=new LogicClass();
  91.     //老王和老李是夫妻
  92.     lc.assertHusbanAndWife(4, 5);
  93.     //老王是一名大学教授,老李是一名会计
  94.     lc.printPersonJob(4);lc.printPersonJob(5);
  95.     //他们的父母都健在
  96.     lc.juggParent(4);lc.juggParent(5);
  97.     //老王和老李有一个儿子,15岁了,在上中学
  98.     lc.queryChildByParent(4, 5);
  99.     //老王有时候去打太极拳,老李有时候去兼职讲课
  100.     lc.personDoSth(4, "去打",0);lc.personDoSth(5, "去",1);
  101. }
  102. }
复制代码
  1. package beantest.util;

  2. /**
  3. *数据字典
  4. *
  5. */
  6. public class Dectionary {

  7. /**
  8. * 男人
  9. */
  10. public static final int Male=1;
  11. /**
  12. * 女人
  13. */
  14. public static final int Female=2;
  15. /**
  16. * 活着
  17. */
  18. public static boolean Live=true;
  19. /**
  20. * 死亡
  21. */
  22. public static boolean Dead=false;
  23. }
复制代码
输出
  1. 老王和老李是夫妻
  2. 老王是丈夫        老李是妻子
  3. 老王是一名教师
  4. 老李是一名会计
  5. 老王的父母健在
  6. 老李的父母健在
  7. 老王和老李有一个儿子,15岁了,在上中学
  8. 老王有时候去打太极拳
  9. 老李有时候去兼职讲课
复制代码
(感言)
我觉得这种描述对象的方法的确很细致.
把对象的每种属性都描述成了一个对象.
然后在人这个对象中调用各项属性的对象.最后把人存储到集合中.



回复 使用道具 举报
看的我是一头雾水啊,哥们,牛{:soso_e179:}
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马