目录
学习笔记
数据表与简单Java类映射转换
简单Java是学习到现在面向对象的简单Java类设计基础，但是对于实际开发中，简单Java类的定义有依据的，根据数据表的结构来实现简单Java类。
在数据库中实际上提供了若干个数据表，那么一个实体数据表都可以变数出一些具体的事物概念，例如：雇员信息表、部门信息表，一看就知道描述部门的信息。
那么按照这个思路，程序类的设计和这些实体表的设计差别不大；所以在实际的开发之中数据表与简单Java类之间的映射关系如下：
- 数据表的设计 = 类的定义 ；
- 表中的字段 = 类的成员属性 ；
- 表的外键关联 = 引用实现；
- 表的一行记录 = 类的一个实例化对象 ；
- 表的多行记录 = 对象数组 ；
以上图中可以发现如下关联关系：
- 一个部门可以对应多个部员；
- 一个雇员属于一个部门 ；
- 一个雇员有一个领导 ；
将以上的数据表转换为简单Java类的定义，在整体程序代码之中，要求获得以下信息：
- 根据部门信息，获取以下内容：
|- 一个部门完整信息
|- 一个部门中所有雇员的信息
|- 一个雇员的领导信息
- 根据雇员信息获得以下内容：
|- 一个雇员所在的部门信息
|-一个雇员对应的领导信息
对于数据表与简单Java之间的映射，最好的解决步骤：先抛开所有的关联字段不看，写出类的基本组成，而后根据引用配置关联字段的关系。
第一步：定义Empt、Dept 实体类
class Dept{
private long deptno ; //描述数据表主键时候建议类型用long
private String dname ;
private String loc ;
public Dept(){}
public Dept(long deptno, String dname, String loc){
this.deptno = deptno ;
this.dname = dname ;
this.loc = loc ;
}
public String getInfo(){
return "【部门信息】部门编号：" + this.deptno +
"、部门名称：" + this.dname +
"、部门位置：" + this.loc ;
}
//setter、getter略
}
class Emp{
private long empno ;
private String ename ;
private String job ;
private double sal ;
private double comm ;
public Emp(){}
public Emp(long empno, String ename, String job, double sal, double comm){
this.empno = empno ;
this.ename = ename ;
this.job = job ;
this.sal = sal ;
this.comm = comm ;
}
public String getInfo(){
return "【雇员信息】雇员编号：" + this.ename +
"、雇员名字：" + this.ename +
"、雇员职位：" + this.job +
"、基本工资：" + this.sal +
"、佣金：" + this.comm ;
}
//setter getter 略
}
public class ArrayDemo{
public static void main(String args[]){
}
}
第二步：配置所有的关联字段
class Dept{
private long deptno ; //描述数据表主键时候建议类型用long
private String dname ;
private String loc ;
private Emp emps [] ;
public Dept(){}
public Dept(long deptno, String dname, String loc){
this.deptno = deptno ;
this.dname = dname ;
this.loc = loc ;
}
public void setEmp(Emp [] emps){
this.emps = emps ;
}
public Emp [] getEmp(){
return this.emps ;
}
public String getInfo(){
return "【部门信息】部门编号：" + this.deptno +
"、部门名称：" + this.dname +
"、部门位置：" + this.loc ;
}
//setter、getter略
}
class Emp{
private long empno ;
private String ename ;
private String job ;
private double sal ;
private double comm ;
private Dept dept ; //所属部门
private Emp mgr ; // 所属领导
public Emp(){}
public Emp(long empno, String ename, String job, double sal, double comm){
this.empno = empno ;
this.ename = ename ;
this.job = job ;
this.sal = sal ;
this.comm = comm ;
}
public void setDept(Dept dept){
this.dept = dept ;
}
public void setMgr(Emp mgr){
this.mgr = mgr ;
}
public Dept getDeept(){
return this.dept ;
}
public Emp getMgr(){
return this.mgr ;
}
public String getInfo(){
return "【雇员信息】雇员编号：" + this.ename +
"、雇员名字：" + this.ename +
"、雇员职位：" + this.job +
"、基本工资：" + this.sal +
"、佣金：" + this.comm ;
}
//setter getter 略
}
public class ArrayDemo{
public static void main(String args[]){
}
}
在以后项目开发中，一定分两个步骤实现的：
- 第一步：根据表的结构关系进行表的配置（本文分第一、二步）；
- 第二步：根据要求根据结构获取数据 ；
范例：实现项目的开发要求
class Dept{
private long deptno ; //描述数据表主键时候建议类型用long
private String dname ;
private String loc ;
private Emp emps [] ;
public Dept(){}
public Dept(long deptno, String dname, String loc){
this.deptno = deptno ;
this.dname = dname ;
this.loc = loc ;
}
public void setEmp(Emp [] emps){
this.emps = emps ;
}
public Emp [] getEmp(){
return this.emps ;
}
public String getInfo(){
return "【部门信息】部门编号：" + this.deptno +
"、部门名称：" + this.dname +
"、部门位置：" + this.loc ;
}
//setter、getter略
}
class Emp{
private long empno ;
private String ename ;
private String job ;
private double sal ;
private double comm ;
private Dept dept ; //所属部门
private Emp mgr ; // 所属领导
public Emp(){}
public Emp(long empno, String ename, String job, double sal, double comm){
this.empno = empno ;
this.ename = ename ;
this.job = job ;
this.sal = sal ;
this.comm = comm ;
}
public void setDept(Dept dept){
this.dept = dept ;
}
public void setMgr(Emp mgr){
this.mgr = mgr ;
}
public Dept getDept(){
return this.dept ;
}
public Emp getMgr(){
return this.mgr ;
}
public String getInfo(){
return "【雇员信息】雇员编号：" + this.ename +
"、雇员名字：" + this.ename +
"、雇员职位：" + this.job +
"、基本工资：" + this.sal +
"、佣金：" + this.comm ;
}
//setter getter 略
}
public class ArrayDemo{
public static void main(String args[]){
// 第一步：根据关系进行类的定义, 定义出各个关系的实例化对象，此时没有任何的关联定义
Dept dept = new Dept(10, "财务部", "上海");
Emp empA = new Emp(5478L, "张三", "程序员", 800.00, 0.0) ;
Emp empB = new Emp(2478L, "李四", "事务员", 500.00, 1320.0) ;
Emp empC = new Emp(5478L, "王五", "KING", 5430.00, 450.0) ;
// 进行关联设计
empA.setDept(dept) ; // 设置部员与部门的关联
empB.setDept(dept) ;
empC.setDept(dept) ;
empA.setMgr(empC) ; // 设置部员与领导的关联
empB.setMgr(empC) ;
dept.setEmp(new Emp [] {empA, empB, empC} ) ; // 设置部门与雇员的关联
// 第二步：根据关系获取数据
System.out.println(dept.getInfo()) ;
for (int i = 0; i < dept.getEmp().length ; i ++){
System.out.println( "\t|- " + dept.getEmp()[i].getInfo() ) ;
if(dept.getEmp()[i].getMgr() != null){
System.out.println("\t\t|-【领导信息】" + dept.getEmp()[i].getMgr().getInfo()) ;
}
}
System.out.println("----------------------------------------------");
System.out.println(empA.getDept().getInfo()) ;
System.out.println(empB.getDept().getInfo()) ;
System.out.println(empC.getDept().getInfo()) ;
}
}
这种转换形式需要熟练的掌握，牵扯到引用和代码链的使用。
一对多映射
按照要求将表结构转换为类结构，同时获取如下信息：
- 获取一个完整的分类信息
- 可以根据分类获取其对应的所有子类信息
class Item{
private long iid ;
private String title ;
private SubItem subItems [] ;
public Item(){}
public Item(long iid, String title){
this.iid = iid ;
this.title = title ;
}
public void setSubItems(SubItem subItems []){
this.subItems = subItems ;
}
public SubItem [] getSubItems(){
return this.subItems ;
}
public String getInfo(){
return "【分类信息】分类ID: " + this.iid +
"、分类名称：" + this.title ;
}
// setter getter略
}
class SubItem{
private long sid ;
private String title ;
private Item item;
public SubItem(){}
public SubItem(long sid, String title){
this.sid = sid ;
this.title = title ;
}
public void setItem(Item item){
this.item = item ;
}
public Item getItem(){
return this.item ;
}
public String getInfo(){
return "【子分类信息】分类id: " + this.sid +
"、分类名称：" + this.title ;
}
//setter getter 略
}
public class ArrayDemo{
public static void main(String args[]){
// 第一步： 根据结构设置设置数据
Item item = new Item(12343L, "java");
SubItem subitems [] = new SubItem [] {
new SubItem(13453L, "基础知识"),
new SubItem(56443L, "引用知识"),
new SubItem(87543L, "高级特性")
} ;
item.setSubItems(subitems) ;
for (int i = 0; i < subitems.length ; i ++){
subitems[i].setItem(item) ;
}
// 第二步 ： 获取数据
System.out.println(item.getInfo()) ;
for (int i = 0; i < item.getSubItems().length ; i++){
System.out.println("\t|- " + item.getSubItems()[i].getInfo()) ;
}
}
}
多对多映射
此时这个程序只需要考虑实体表的设计即可，也就是说对于中间的访问信息表不要求进行转换处理，只需要定义两个类。
class Member{
private String mid ;
private String name ;
private Product products [] ;
public Member(){}
public Member(String mid, String name){
this.mid = mid ;
this.name = name ;
}
public void setProducts(Product products []){
this.products = products ;
}
public Product [] getProducts(){
return this.products ;
}
public String getInfo(){
return "【用户信息】Id:" + this.mid +
"、姓名：" + this.name ;
}
//setter getter 略
}
class Product{
private long pid ;
private String title ;
private double price ;
private Member members[] ;
public Product(){}
public Product(long pid, String title, double price){
this.pid = pid ;
this.title = title ;
this.price = price ;
}
public void setMembers(Member members []){
this.members = members ;
}
public Member [] getMembers(){
return this.members ;
}
public String getInfo(){
return "【商品信息】ID:" + this.pid +
"、名称：" + this.title +
"、价格：" + this.price ;
}
//setter getter 略
}
public class ArrayDemo{
public static void main(String args[]){
// 第一步： 根据结构设置对象数组
Member memA = new Member("575", "张三") ;
Member memB = new Member("577", "李四") ;
Product proA = new Product(1L, "java开发", 79.8) ;
Product proB = new Product(2L, "耳机", 2479.8) ;
Product proC = new Product(3L, "手机", 3079.8) ;
memA.setProducts(new Product[] {proA, proB, proC}) ;
memB.setProducts(new Product[] {proA}) ;
proA.setMembers(new Member [] {memA, memB}) ;
proB.setMembers(new Member [] {memA}) ;
proC.setMembers(new Member [] {memA}) ;
// 第二步：根据要求获取数据
System.out.println("----------根据用户查看浏览商品信息----------") ;
System.out.println(memA.getInfo()) ;
for (int i = 0; i < memA.getProducts().length ; i++ ){
System.out.println("\t|- " + memA.getProducts()[i].getInfo()) ;
}
System.out.println("----------根据商品找到被浏览信息----------") ;
System.out.println(proA.getInfo()) ;
for (int i = 0; i < proA.getMembers().length ; i++ ){
System.out.println("\t|- " + proA.getMembers()[i].getInfo()) ;
}
}
}角色与权限
四个表但是定义三个类，关系表不作为一个类的出现。
class Member{
private String mid ;
private String name ;
private Role roles [] ;
public Member(){}
public Member(String mid, String name ){
this.mid = mid ;
this.name = name ;
}
public void setRoles(Role roles []){
this.roles = roles ;
}
public Role [] getRoles(){
return this.roles ;
}
public String getInfo(){
return "【用户信息】ID：" + this.mid +
"、名称：" + this.name ;
}
// setter getter略
}
class Role{
private long rid ;
private String title;
private Member members [];
private Privilege privileges [] ;
public Role(){}
public Role(long rid, String title){
this.rid = rid ;
this.title = title ;
}
public void setMembers(Member members []){
this.members = members;
}
public void setPrivileges(Privilege privileges []){
this.privileges = privileges ;
}
public Member [] getMembers(){
return this.members ;
}
public Privilege [] getPrivileges(){
return this.privileges ;
}
public String getInfo(){
return "【角色信息】ID：" + this.rid +
"、名称：" + this.title ;
}
// setter getter略
}
class Privilege{
private long pid ;
private String title ;
private Role role ;
public Privilege(){}
public Privilege(long pid, String title){
this.pid = pid ;
this.title = title ;
}
public void setRole(Role role){
this.role =role ;
}
public Role getRole(){
return this.role ;
}
public String getInfo(){
return "【权限信息】ID：" + this.pid +
"、名称：" + this.title ;
}
// setter getter略
}
public class ArrayDemo{
public static void main(String args[]){
// 第一步： 根据结构设置对象数组
Member memA = new Member("4566", "张三") ;
Member memB = new Member("5466", "李四") ;
Role roleA = new Role(1L, "系统配置") ;
Role roleB = new Role(2L, "备份服务") ;
Role roleC = new Role(3L, "人事管理") ;
Privilege priA = new Privilege(1000L, "系统初始化") ;
Privilege priB = new Privilege(1001L, "系统还原") ;
Privilege priC = new Privilege(1002L, "系统环境处理") ;
Privilege priD = new Privilege(2000L, "备份员工数据") ;
Privilege priE = new Privilege(2001L, "备份部门数据") ;
Privilege priF = new Privilege(2002L, "备份公文数据") ;
Privilege priG = new Privilege(3000L, "增加员工") ;
Privilege priH = new Privilege(3001L, "编辑员工") ;
Privilege priI = new Privilege(3002L, "浏览员工") ;
Privilege priJ = new Privilege(3003L, "员工离职") ;
// 增加角色与权限的对应关系
roleA.setPrivileges(new Privilege[] {priA, priB, priC} ) ;
roleB.setPrivileges(new Privilege[] {priD, priE, priF} ) ;
roleC.setPrivileges(new Privilege[] {priG, priH, priI, priJ} ) ;
//增加权限与角色的对应
priA.setRole(roleA) ;
priB.setRole(roleA) ;
priC.setRole(roleA) ;
priD.setRole(roleB) ;
priE.setRole(roleB) ;
priF.setRole(roleB) ;
priG.setRole(roleC) ;
priH.setRole(roleC) ;
priI.setRole(roleC) ;
priJ.setRole(roleC) ;
// 增加用户与角色的对应关系
memA.setRoles(new Role [] {roleA, roleB}) ;
memB.setRoles(new Role [] {roleA, roleB, roleC}) ;
roleA.setMembers(new Member[] {memA, memB}) ;
roleB.setMembers(new Member[] {memA, memB}) ;
roleC.setMembers(new Member[] {memB}) ;
// 第二步：根据要求获取数据
System.out.println("-----------根据用户查找信息--------") ;
System.out.println(memA.getInfo()) ;
for (int i = 0 ; i < memA.getRoles().length ; i ++ ){
System.out.println("\t|- " + memA.getRoles()[i].getInfo()) ;
for (int j = 0; j < memA.getRoles()[i].getPrivileges().length ; j ++){
System.out.println("\t\t|- " + memA.getRoles()[i].getPrivileges()[j].getInfo()) ;
}
}
System.out.println("-----------根据角色查找信息--------") ;
System.out.println(roleA.getInfo() ) ;
System.out.println("\t|- 浏览此角色下的所有权限信息") ;
for (int i = 0; i < roleA.getPrivileges().length ; i++){
System.out.println("\t\t|- " + roleA.getPrivileges()[i].getInfo());
}
System.out.println("\t|- 浏览此角色下的所有用户信息") ;
for (int i = 0 ; i < roleA.getMembers().length; i++ ){
System.out.println("\t\t|- " + roleA.getMembers()[i].getInfo()) ;
}
System.out.println("-----------根据权限查找信息--------") ;
System.out.println(priA.getInfo() ) ;
for (int i = 0 ; i < priA.getRole().getMembers().length; i++){
System.out.println("\t|- " +priA.getRole().getMembers()[i].getInfo() );
}
}
}
997
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
