复杂的基础映射转换 之 迈入数据库的最基本功；

简单的 · 映射转换传参概念（作业一）

涉及的知识点：

简单映射转换、方法传参、实例化对象、实例化对象数组、私密方法与setter/getter、利用for赋值；

public class Main {
    public static void main(String[] args) {
        Item item = new Item(10L,"图书");    //设置Item参数
        Subitem subitem[] = new Subitem[]{    //设置Subitem参数
                new Subitem(25L,"小书1"),
                new Subitem(26L,"小书2"),
                new Subitem(27L,"小书3")
        };
        item.setSubitem(subitem);    //将Item与Subitem的关系确定
        for (int x = 0;x<item.getSubitem().length;x++){    //将每个Subitem类的数组对象都赋予Item的主
            subitem[x].setItem(item);
        }
        System.out.println(item.getInfo());    //获得Item的值
        for(int x = 0;x<item.getSubitem().length;x++){    //获得Item对应的所有Subitem的对象
            System.out.println("\t|-" + item.getSubitem()[x].getInfo());
        }
    }
}
class Item{
    private long itemId;
    private String itemName;
    private Subitem subitem[];    //一个Item可以对应多个Subitem
    public Item(long itemId, String itemName){    //接受内容传参
        this.itemId = itemId;
        this.itemName = itemName;
    }

    public void setSubitem(Subitem[] subitem) {    //传入Subitem型数组
        this.subitem = subitem;
    }

    public Subitem[] getSubitem() {    //读取Subitem型数组
        return subitem;
    }

    public String getInfo(){    //Item类的回值方法
        return "主ID：" + this.itemId + "主名称：" + this.itemName;
    }
}
class Subitem{
    private long subitemId;
    private String subitemName;
    private Item item;    //一个Subitem只能对应一个Item
    public Subitem(long subitemId, String subitemName){    //数据传参定义
        this.subitemId = subitemId;
        this.subitemName = subitemName;
    }

    public void setItem(Item item) {    //设置唯一对应的Item
        this.item = item;
    }

    public Item getItem() {    //读取唯一对应的Item
        return item;
    }

    public String getInfo(){    //Subitem类的回值方法
        return "子ID：" + this.subitemId + "子名称：" + this.subitemName;
    }
}

复杂的 · 多联代码串调用的映射转换概念（作业二）

//多对多复杂数据库映射转换习题
/*权限：权限ID，用户ID，名称
* 角色：角色ID，名称
* 用户：用户ID，姓名
* 用户-角色：用户ID，角色ID
* 1、可以根据一个用户找到该用户对应的所有角色以及每一个角色对应的所有权限信息
* 2、可以根据一个角色找到该角色下的所有权限以及拥有此角色的全部用户信息
* 3、可以根据一个权限找到具备有此权限的所有用户信息*/
public class Main {
    public static void main(String[] args) {
        Role roleA = new Role(1L,"群主");    //定义一些角色
        Role roleB = new Role(2L,"管理员");
        Role roleC = new Role(3L,"监管员");
        Member memA = new Member(101,"夜战");    //定义两个用户
        Member memB = new Member(102,"游美");
        Power powA = new Power(11L,"移除");    //定义三个权限
        Power powB = new Power(12L,"禁言");
        Power powC = new Power(13L,"公告");
        memA.setRoles(new Role[]{roleA,roleB,roleC});    //为用户匹配与角色的关系
        memB.setRoles(new Role[]{roleB,roleC});
        roleA.setPowers(new Power[]{powA,powB,powC});    //为角色匹配与权限的关系
        roleA.setMembers(new Member[]{memA});    //为角色匹配与用户的关系
        roleB.setPowers(new Power[]{powB,powC});
        roleB.setMembers(new Member[]{memA,memB});
        roleC.setPowers(new Power[]{powC});
        roleC.setMembers(new Member[]{memA,memB});
        powA.setRoles(roleA);    //为权限匹配与角色的关系
        powB.setRoles(roleB);
        powC.setRoles(roleC);
        System.out.println("\n----通过用户检索角色与权限----");
        System.out.println(memA.getInfo());
        for(int x = 0;x<memA.getRoles().length;x++){
            System.out.println("\t|-" + memA.getRoles()[x].getInfo());
            for(int y = 0;y<memA.getRoles()[x].getPowers().length;y++){
                System.out.println("\t\t|-" + memA.getRoles()[x].getPowers()[y].getInfo());
            }
        }
        System.out.println(memB.getInfo());
        for(int x = 0;x<memB.getRoles().length;x++){
            System.out.println("\t|-" + memB.getRoles()[x].getInfo());
            for(int y = 0;y<memB.getRoles()[x].getPowers().length;y++){
                System.out.println("\t\t|-" + memB.getRoles()[x].getPowers()[y].getInfo());
            }
        }
        System.out.println("\n----通过角色检索权限与用户----");
        System.out.println(roleA.getInfo());
        for(int x = 0;x<roleA.getPowers().length;x++){
            System.out.println("\t|-" + roleA.getPowers()[x].getInfo());
        }
        for(int y= 0;y<roleA.getMembers().length;y++){
            System.out.println("\t\t|-" + roleA.getMembers()[y].getInfo());
        }
        System.out.println(roleB.getInfo());
        for(int x = 0;x<roleB.getPowers().length;x++){
            System.out.println("\t|-" + roleB.getPowers()[x].getInfo());
        }
        for(int y= 0;y<roleB.getMembers().length;y++){
            System.out.println("\t\t|-" + roleB.getMembers()[y].getInfo());
        }
        System.out.println(roleC.getInfo());
        for(int x = 0;x<roleC.getPowers().length;x++){
            System.out.println("\t|-" + roleC.getPowers()[x].getInfo());
        }
        for(int y= 0;y<roleC.getMembers().length;y++){
            System.out.println("\t\t|-" + roleC.getMembers()[y].getInfo());
        }
        System.out.println("\n----通过角色权限检索用户----");
        System.out.println(powA.getInfo());
        for(int x = 0;x<powA.getRoles().getMembers().length;x++){
            System.out.println("\t|-" + powA.getRoles().getMembers()[x].getInfo());
        }
        System.out.println(powB.getInfo());
        for(int x = 0;x<powB.getRoles().getMembers().length;x++){
            System.out.println("\t|-" + powB.getRoles().getMembers()[x].getInfo());
        }
        System.out.println(powC.getInfo());
        for(int x = 0;x<powC.getRoles().getMembers().length;x++){
            System.out.println("\t|-" + powC.getRoles().getMembers()[x].getInfo());
        }
    }
}
class Role{
    private long roleNum;
    private String roleTitle;
    private Power powers[];    //一个角色可以对应多个权限
    private Member members[];    //一个角色可以对应多个用户
    public Role (long roleNum,String roleTitle){
        this.roleNum = roleNum;
        this.roleTitle = roleTitle;
    }

    public void setPowers(Power[] powers) {
        this.powers = powers;
    }

    public Power[] getPowers() {
        return powers;
    }

    public void setMembers(Member[] members) {
        this.members = members;
    }

    public Member[] getMembers() {
        return members;
    }

    public String getInfo(){
        return "角色名：" + this.roleTitle + "、角色ID：" + this.roleNum;
    }
}
class Power{
    private long powerNum;
    private String powerTitle;
    private Role roles;    //一个权力只能对应一个角色
    public Power(long powerNum,String powerTitle){
        this.powerNum = powerNum;
        this.powerTitle = powerTitle;
    }

    public void setRoles(Role roles) {
        this.roles = roles;
    }

    public Role getRoles() {
        return roles;
    }

    public String getInfo(){
        return "权限名：" + this.powerTitle + "、权限ID：" + this.powerNum;
    }
}
class Member {
    private long memberNum;
    private String memberName;
    private Role roles[];    //一个用户可以对应对个角色
    public Member(long memberNum,String memberName){
        this.memberNum = memberNum;
        this.memberName = memberName;
    }

    public void setRoles(Role[] roles) {
        this.roles = roles;
    }

    public Role[] getRoles() {
        return roles;
    }

    public String getInfo(){
        return "用户姓名：" + this.memberName + "、用户ID：" + this.memberNum;
    }
}