[阿里云大学][Java面向对象开发][课程笔记][17-42课时]

57 阅读 0 评论 38 点赞

我是靠谱客的博主清秀钢笔，最近开发中收集的这篇文章主要介绍[阿里云大学][Java面向对象开发][课程笔记][17-42课时]，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

课时17 数组的定义与使用（数组转置）
首尾交换
1. 新定义一个空数组，然后把原数组的值从后到前存入新的数组
问题：开辟了两块相同的堆内存空间，造成浪费
2. 在原数组上反转
计算数组长度/2，交换次数为n，n = (array.length -1)/2
0 和 length-1交换
1 和 length-2交换
2 和 length-3交换
n 和 length-n-1交换

课时18 数组的定义与使用（二分查找法）
指定的数组中查找某个元素的位置
前提：数组先排序
mid = head/2 + tail/2
原理
比如一个排序好的数组
0,1,2,3,4,5,6,7,8

查找7
第一次查找
from:0
to:8
mid:4
索引为4的数比7小，所以赋值（第二次查找）
from:4+1
to:8
mid:(5+8)/2 = 6
索引为6的数比7小，所以赋值（第三次查找）
from:6+1
to:8
mid:(7+8)/2 = 7
索引为7的数为7，返回索引7

查找2
第一次查找
from:0
to:8
mid:4
索引为4的数比2大，所以赋值（第二次查找）
from:0
to:4-1
mid:(0+3)/2 = 1
索引为1的数比2小，所以赋值（第三次查找）
from:1+1
to:3
mid:(2+3)/2 = 2
索引为2的数为2，返回索引2

递归的结束条件是当from >= to

课时19 数组的定义与使用（对象数组）
核心掌握
引用数据类型为主，类或者接口
对象数组动态初始化：类名称[] 对象数组名 = new 类名称[长度]
对象数组的静态初始化：类名称[] 对象数组名 = new 类名称[] {对象名,...}
class Person {
   private String name;
   private int age;
   public Person(String setName,int setAge) {
       name = setName;
       age = setAge;
   }
   public String getInfo() {
       return "name is " + name + " age is " + age;
   }
}

public class ArrayDemo {
   public static void main(String[] args) {
       Person[] per = new Person[3]; //动态初始化，默认值为null
       per[0] = new Person("A",1);
       per[1] = new Person("B",2);
       per[2] = new Person("C",3);
       for (int x = 0; x < per.length; x++) {
           System.out.println(per[x].getInfo());
       }
       Person[] per2 = new Person[] { new Person("D",4) }; //静态初始化
       System.out.println(per2[0].getInfo());
   }
}

对象保存的是堆内存的地址

普通数据数组堆内存直接保存数据，比如new int[]
而对象数组堆内存表示各个对象的真是数据地址（里面没有数据），如上图

课时20 String类的基本特点（String类两种实例化方式）
所有开发过程中都存在String类

第一种
String str = "hello";
str是一个对象，hello是保存在堆内存中

第二种
String str = new String("hello");
传入"hello"的名为String的构造函数

课时21 String类的基本特点（字符串比较）

== 和 equals的区别

==比较的是堆内存的地址，是数值比较
equals()比较的是字符串内容，区分大小小

String str1 = "hello"; //把一个匿名对象值为"hello"的对象命名为str1
String str2 = new String("hello");

str1 == str2 结果为false
str1.equals(str2) 结果为true

开发过程中必须使用equals()

课时22 String类的基本特点（字符串常量为匿名对象）

String str1 = "hello"; //把一个匿名对象值为"hello"的对象命名为str1

开发过程中，如果要判断用户输入的字符串是否等同于指定的字符串，一定要把字符串写在前面，考虑用户没有输入数据的问题

操作方法1：字符串写在前面，不会报空指向异常

课时23 String类的基本特点（String两种实例化区别）

第一种直接赋值（开发推荐做法，节省内存）
String str = "hello";
str是一个对象，hello是保存在堆内存中

多次赋值（指向的是同一个堆内存），使用了共享设计模式
JVM维护对象池，直接赋值的时候，第一次会保存到对象池，后续如果有一样的对象，就引用一样的对象
也就是一个对象数组，可以减少同样字符串的内存开销

第二种，构造方法（标准做法）
（从右往左执行）

String str = new String("hello");
传入"hello"的名为String的构造函数

会开辟2个堆内存空间，其中一个成为垃圾空间
而且这个对象没有自动保存到对象池

实现入池的操作
public String intern();

课时24 String类的基本特点（字符串常量不可变更）

字符串对象变更：

字符串内容本身是不会变化的，变化的是字符串对象的引用

开发原则：
字符串采用直接赋值模式完成
比较实用equals()方法实现
字符串不要频繁改变

课时25 String类的常用方法（DOC文档组成）

文档组成：
1. 类的相关定义，类的名字，父类，接口等
2. 类的简介
3. 成员(field)摘要，属性就是一种成员，
4. 构造（constructor）方法说明，Deprecated建议不用
5. 方法(methods)摘要，返回值，参数说明

课时26 String类的常用方法（字符串与字符数组）

字符数组变成字符串

public String(char[] value) //构造方法
public String(char[] value, int offset, int count) // offset开始,count个数，构造方法
public char charAt(int index) //返回字符串索引位置的字符，索引从0开始开发中出现的几率很低，普通方法

字符串变成字符数组
public char[] toCharArray() //普通方法

重点：字符串和字符数组的互相转换
public class StringDemo {
   public static void main(String[] args) {
       String str = "hello world";
       System.out.println("index 2 " + str.charAt(2));
       char[] data = str.toCharArray();
       for (char x : data) {
           x -= 32; //转换成大写
           System.out.print(x + "/");
       }
       System.out.println(new String(data));
       System.out.println(new String(data,6,5));
   }
}

课时27 String类的常用方法（字节与字符串）
字节：数据传输或者编码转换

支持：
构造方法：
public String(byte[] byte)
public String(byte[] byte, int offset, int length)

普通方法：
public byte[] getBytes()
public byte[] getBytes(String charsetName) throws UnsupportedEncodingException //编码转换

public class StringDemo {
   public static void main(String[] args) {
       String str = "hello world";
       byte data[] = str.getBytes();
       for (byte x : data) {
           System.out.print(x + ",");
       }
   }
}

字节 -128 到 127 无法表示中文
字符才用于表示中文

课时28 String类的常用方法（字符串比较）
equals()方法
区分大小写
public boolean equals(String anotherString)
不区分
public boolean equalsIgnoreCase(String anotherString)

public int compareTo(String anotherString) //比较两个字符串的大小关系
相等返回0
如果不相等：
小于（每个字符进行对比，根据编码数字差返回第一个不相等的字符差）
大于（每个字符进行对比，根据编码数字差返回第一个不相等的字符差）
这个方法很重要

public class StringDemo {
   public static void main(String[] args) {
       String str1 = "hello";
       System.out.println("Hello".equals(str1));
       System.out.println("Hello".equalsIgnoreCase(str1));

       System.out.println("A".compareTo("a"));
       System.out.println("a".compareTo("A"));

       System.out.println("abb".compareTo("adc"));
   }
}
/*
E:1_JAVAprojectjava_basicmldn2course_28>java StringDemo
false
true
-32
32
-2
*/

课时29 String类的常用方法（字符串查找）- 重要

contains() // 普通方法，判断一个子字符串是否存在，返回boolean JDK1.5之后追加

indexOf() // 普通方法，查找子字符串的索引，返回第一个字符的位置索引，不存在则返回-1

indexOf(String str, int index) //从指定位置开始查找

lastIndexOf() //从后向前找

lastIndexOf(String str, int index) //从指定位置从后往前找

startsWith(String prefix) // 由指定子字符串开头
startsWith(String prefix, int toffset) //从指定位置开始判断，由指定子字符串开头

endsWith(String prefix) //由指定子字符串结尾

建议使用contains()

课时30 String类的常用方法（字符串替换）

指定一个新的字符串替换字符串中的某个字符串

//需要替换的字符串目标字符串

replaceAll(String regex, String replacement)

replaceFirst(String regex, String replacement)

课时31 String类的常用方法（字符串拆分）

string[] split(String regx)

string[] split(String regx, int limit) // 部分拆分，分成几段，2 代表2段最大长度，如果没有到最大长度，那就有多少拆多少

\转义字符

课时32 String类的常用方法（字符串截取）

substring(int beginindex) //从指定索引截取到结尾
substring)int beginindex, int endindex) //指定区间截取
索引从0开始

课时33 String类的常用方法（字符串其它操作方法）

trim() //去掉字符串的左右空格，一个或者多个

toUpperCase() //转大写
toLowerCase() //转小写
这两个函数，如果不是字母，那么就不做转换

intern() //字符串存入对象池

contact(String str) //字符串连接，跟+一样

length() //字符串长度

isEmpty() //判断是否为空字符串，长度为0，非null

没有提供首字符大写的方法

实现首字母大写的方法

课时34 this关键字（this调用属性）

this 可以调用
1. 本类属性
2. 本类方法（构造和普通）
3. 当前对象（相对概念）

下面赋值运行之后，name 为 null，age 为 0；
程序以大括号为边界，不会去找外部定义的属性name

参数与属性同名，解决方法

类的方法中有需要用到属性，一定在前面加this关键字
课时35 this关键字（this调用方法）

this.函数名称(参数)
this.构造方法名称(参数)

区分方法的定义来源（继承中有用）

java支持类构造方法的互相调用：
例子，使用2个参数的调用，先调用1个参数的，再赋值age，调用1个参数的时候，使用无参数的构造函数先输出一段信息，然后再赋值name

有以下几点要求
this()

1. this()必须放在构造方法的首行
2. 使用this()构造方法的时候留出口（递归死循环）（比如在上面这个例子中无参构造里面调用2个参数的构造函数）

课时36 this关键字（表示当前对象）

this指向p1

课时37 引用传递进阶分析

java核心

3个简单例子

第一个：
class Message {
   private int num ;
   public void setNum(int num) {
       this.num = num ;
   }
   public int getNum() {
       return this.num ;
   }
}

public class TestDemo {
   public static void main(String[] args) {
       Message msg = new Message();
       msg.setNum(100);
       fun(msg);
       System.out.println(msg.getNum());
   }
   public static void fun(Message temp) {
       temp.setNum(30);
   }
}

第二个：
public class TestDemo2 {
   public static void main(String[] args) {
       String str = "hello";
       fun(str);
       System.out.println(str);
   }
   public static void fun(String temp) {
       temp = "world";
   }
}

第三个：
class Message2 {
   private String note ;
   public void setNote(String note) {
       this.note = note ;
   }
   public String getNote() {
       return this.note ;
   }
}

public class TestDemo3 {
   public static void main(String[] args) {
       Message2 msg = new Message2();
       msg.setNote("hello");
       fun(msg);
       System.out.println(msg.getNote());
   }
   public static void fun(Message2 temp) {
       temp.setNote("world");
   }
}

课时38 【第02个代码模型】综合案例：对象比较

比较两个对象的属性
实现形式1
class Person {
   private String name ;
   private int age ;
   public Person(String name, int age) {
       this.name = name ;
       this.age = age ;
   }
   public String getName() {
       return this.name ;
   }
   public int getAge() {
       return this.age ;
   }
}

public class TestDemo1 {
   public static void main(String[] args) {
       Person perA = new Person("A",20);
       Person perB = new Person("A",20);
       System.out.println(perA == perB);

       if(perA.getAge() == perB.getAge() && perA.getName().equals(perB.getName())) {
           System.out.println(" perA == perB ");
       }
   }
}

// 这种形式在开发过程中不会出现，主方法需要出现的逻辑太多了

方法2
类方法自带比较方法
compare()
class Person {
   private String name ;
   private int age ;
   public Person(String name, int age) {
       this.name = name ;
       this.age = age ;
   }
   public String getName() {
       return this.name ;
   }
   public int getAge() {
       return this.age ;
   }
   //this表示当前对象，另外一个是传入对象
   public boolean compare(Person per) {
       if (per == this) {
           return true;
       }
       if (per == null) {
           return false;
       }
       if (this.name.equals(per.name) && this.age == per.age) {
           return true;
       } else {
           return false;
       }
   }
}

public class TestDemo2 {
   public static void main(String[] args) {
       Person perA = new Person("A",20);
       Person perB = new Person("A",20);
       System.out.println(perA.compare(perB));
   }
}

判断步骤：
1. 判断地址
2. 判断是否为空
3. 判断对象的各个属性

课时39 引用传递实际应用
引用传递是java核心
合成设计模式

class Member {
   private String name;
   private int age;
   private Member child;
   //car == null, 说明此人无车
   private Car car;
   public Member(String name, int age) {
       this.name = name;
       this.age = age;
   }
   public void setName(String name) {
       this.name = name;
   }
   public String getName() {
       return this.name;
   }
   public void setAge(int age) {
       this.age = age;
   }
   public int getAge() {
       return this.age;
   }
   public void setChild(Member child) {
       this.child = child;
   }
   public Member getChild() {
       return this.child;
   }
   public void setCar(Car car) {
       this.car = car;
   }
   public Car getCar() {
       return this.car;
   }
   public String getInfo() {
       return "[Member] name = " + this.name + " age = " + this.age;
   }
}

class Car {
   private String car;
   private double price;
   private Member member;
   public Car(String car, double price) {
       this.car = car;
       this.price = price;
   }
   public void setCar(String car) {
       this.car = car;
   }
   public String getCar() {
       return this.car;
   }
   public void setPirce(double price) {
       this.price = price;
   }
   public double getPrice() {
       return this.price;
   }
   public void setMem(Member member) {
       this.member = member;
   }
   public Member getMember() {
       return this.member;
   }
   public String getInfo() {
       return "[car] car = " + this.car + " price = " + this.price;
   }
}

public class TestDemo {
   public static void main(String[] main) {
       Member mem = new Member("A",30);
       Car car = new Car("car-a",100);
       Member child = new Member("B",2);
       Car childCar = new Car("car-b",200);

       mem.setCar(car);
       mem.setChild(child);
       car.setMem(mem);
       child.setCar(childCar);
       childCar.setMem(child);

       System.out.println(mem.getInfo());
       System.out.println(mem.getCar().getInfo());
       System.out.println(car.getMember().getInfo());
       System.out.println(mem.getChild().getInfo());
       System.out.println(mem.getChild().getCar().getInfo());
   }
}

课时40 【第03个代码模型】综合案例：数据表与简单Java类（一对多）

/**
1. 先定义基本类，包括属性，构造函数，getInfo()函数
2. 定义各个类之间的关系，雇员的领导，部门里面的所有雇员，雇员属于哪个部门
3. 实现开发需求
(1) 设置类对象间的关系
(2) 获取数据
*/

class Emp {
   private int empno ;
   private String ename ;
   private String job ;
   private double sal ;
   private double comm ;
   private Emp mgr ;
   private Dept dept ;
   public Emp() {}
   public Emp(int 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 setMgr(Emp mgr) {
       this.mgr = mgr ;
   }
   public Emp getMgr() {
       return this.mgr ;
   }
   public void setDept(Dept dept) {
       this.dept = dept ;
   }
   public Dept getDept() {
       return this.dept ;
   }
   public String getInfo() {
       return "[Emp] empno = " + empno
       + " ename = " + ename
       + " job = " + job
       + " sal = " + sal
       + " comm = " + comm;
   }
}

class Dept {
   private int deptno ;
   private String dname ;
   private String loc ;
   private Emp[] emps;
   public Dept() {}
   public Dept(int deptno, String dname, String loc) {
       this.deptno = deptno ;
       this.dname = dname ;
       this.loc = loc ;
   }
   public void setEmps(Emp[] emps) {
       this.emps = emps ;
   }
   public Emp[] getEmps() {
       return this.emps ;
   }
   public String getInfo() {
       return "[Dept] deptno = " + deptno
       + " dname = " + dname
       + " loc = " + loc;
   }
}

public class TestDemo {
   public static void main(String[] args) {
       Dept dept = new Dept(10,"accounting","new york");
       Emp ea = new Emp(1,"A","Job-a",100.0,1.0);
       Emp eb = new Emp(1,"B","Job-b",200.0,2.0);
       Emp ec = new Emp(1,"C","Job-c",300.0,3.0);

       ea.setMgr(eb);
       eb.setMgr(ec);

       ea.setDept(dept);
       eb.setDept(dept);
       ec.setDept(dept);

       dept.setEmps(new Emp[] {ea,eb,ec});
       System.out.println(dept.getInfo());
       for (Emp emp : dept.getEmps()) {
           System.out.println("t |-" + emp.getInfo());
           if (emp.getMgr() != null) {
               System.out.println("tt |-" + emp.getMgr());
           }
       }
       System.out.println(eb.getInfo());
       if (eb.getMgr() != null) {
           System.out.println("t |-" + eb.getMgr().getInfo());
       }
       if (eb.getDept() != null) {
           System.out.println("tt |-" + eb.getDept().getInfo());
       }
   }
}

课时41 【第03个代码模型】综合案例：数据表与简单Java类（多对多）

/**
基本信息：
学生表：编号，姓名，年龄，
课程表：编号，名称，学分
学生-课程关系表：学生编号，课程编号，成绩

需求：
1. 找到一门课程，参加此课程的所有学生信息和成绩
2. 找到一个学生，参加的课程的课程信息和成绩

设计过程：
1. 定义基本类，前2个表，

2. 第三个表是学生选课信息

3. 筛选关系，去掉第一步做的学生中的课程对象数组，取出课程中的学生数组，因为第二部中设计的表可以
表达关系了

4. 输出关系

*/
class Student {
   private int studentId;
   private String studentName;
   private int studentAge;
   private StudentCourse[] studentCourse;
   public Student() {}
   public Student(int studentId, String studentName, int studentAge) {
       this.studentId = studentId;
       this.studentName = studentName;
       this.studentAge = studentAge;
   }
   public void setStudentCourse(StudentCourse[] studentCourse) {
       this.studentCourse = studentCourse;
   }
   public StudentCourse[] getStudentCourse() {
       return this.studentCourse;
   }
   public String getInfo() {
       return "[Student] ID = " + this.studentId
       + " Name = " + this.studentName
       + " Age = " + this.studentAge;
   }
}
class Course {
   private int courseId;
   private String courseName;
   private int credit;
   private StudentCourse[] studentCourse;
   public Course() {}
   public Course(int courseId, String courseName, int credit) {
       this.courseId = courseId;
       this.courseName = courseName;
       this.credit = credit;
   }
   public void setStudentCourse(StudentCourse[] studentCourse) {
       this.studentCourse = studentCourse;
   }
   public StudentCourse[] getStudentCourse() {
       return this.studentCourse;
   }
   public String getInfo() {
       return "[Course] ID = " + this.courseId
       + " Name = " + this.courseName
       + " credit = " + this.credit;
   }
}
class StudentCourse {
   private Student student;
   private Course course;
   private double score;

   public StudentCourse() {}
   public StudentCourse(Student student, Course course, double score) {
       this.student = student;
       this.course = course;
       this.score = score;
   }
   public Student getStudent() {
       return this.student;
   }
   public Course getCourse() {
       return this.course;
   }
   public double getScore() {
       return this.score;
   }
   public String getInfo() {
       return //this.student.getInfo()
       //+ this.course.getInfo()
       //+
       "[score] score = " + this.score;
   }
}

public class TestDemo {
   public static void main(String[] args) {
       Student a = new Student(1,"a",18);
       Student b = new Student(2,"b",19);
       Student c = new Student(3,"c",20);

       Course ca = new Course(1,"ca",10);
       Course cb = new Course(2,"cb",20);
       Course cc = new Course(3,"cc",30);

       a.setStudentCourse(new StudentCourse[] {
           new StudentCourse(a,ca,100.0),
           new StudentCourse(a,cb,100.0),
           new StudentCourse(a,cc,100.0)
       });
       b.setStudentCourse(new StudentCourse[] {
           new StudentCourse(b,ca,90.0),
           new StudentCourse(b,cb,90.0),
           new StudentCourse(b,cc,90.0)
       });
       c.setStudentCourse(new StudentCourse[] {
           new StudentCourse(c,ca,80.0),
           new StudentCourse(c,cb,80.0),
           //new StudentCourse(b,cc,90)
       });

       ca.setStudentCourse( new StudentCourse[] {
           new StudentCourse(a,ca,100.0),
           new StudentCourse(b,ca,90.0),
           new StudentCourse(c,ca,80.0)
       });
       cb.setStudentCourse( new StudentCourse[] {
           new StudentCourse(a,cb,100.0),
           new StudentCourse(b,cb,90.0),
           new StudentCourse(c,cb,80.0)
       });
       cc.setStudentCourse( new StudentCourse[] {
           new StudentCourse(a,cb,100.0),
           new StudentCourse(b,cb,90.0)
       });

       System.out.println("******************************");
       System.out.println(a.getInfo());
       System.out.println(b.getInfo());
       System.out.println(c.getInfo());

       System.out.println("******************************");
       System.out.println(ca.getInfo());
       System.out.println(cb.getInfo());
       System.out.println(cc.getInfo());

       System.out.println("******************************");
       System.out.println(ca.getInfo());
       for (int x = 0; x < ca.getStudentCourse().length; x++) {
           System.out.println("t |- " + ca.getStudentCourse()[x].getStudent().getInfo() + "ntt |- " + ca.getStudentCourse()[x].getInfo());
       }
       System.out.println("******************************");
       System.out.println(a.getInfo());
       for (int x = 0; x < a.getStudentCourse().length; x++) {
           System.out.println("t |- " + a.getStudentCourse()[x].getCourse().getInfo() + "ntt |- " + ca.getStudentCourse()[x].getInfo());
       }
   }
}

课时42 【第03个代码模型】综合案例：数据表与简单Java类（角色与权限）

1. 进行单独类的描述
Dept //部门
Emp //员工
Role //角色
Privilege //权限

属性
构造函数
getInfo()函数

2. 进行关系的描述
一个部门有多个员工，且只有一个角色
员工只有一个部门
角色有多个部门，多个权限
权限有多个角色
角色-权限是2个外键（没有其他多的数据，上个例子有个成绩），不需要建表

3. 实现数据输出
创建部门数据，2个
创建员工数据，5个
创建角色信息，2个
创建权限数据，4个

部门和雇员
雇员和部门

部门和角色
角色和部门

设置角色和权限的关系
设置权限和角色的关系

4. 取出数据

完毕

代码

class Dept {
   private int deptID;
   private String deptName;
   private Emp[] emps;
   private Role role;

   public Dept() {}
   public Dept(int deptID, String deptName) {
       this.deptID = deptID;
       this.deptName = deptName;
   }
   public void setEmps(Emp[] emps) {
       this.emps = emps;
   }
   public Emp[] getEmps() {
       return this.emps;
   }
   public void setRole(Role role) {
       this.role = role;
   }
   public Role getRole() {
       return this.role;
   }
   public String getInfo() {
       return "[Dept] deptID = " + this.deptID
       + " deptName = " + this.deptName;
   }
}
class Emp {
   private int empId;
   private String empName;
   private Dept dept;

   public Emp() {}
   public Emp(int empId, String empName) {
       this.empId = empId;
       this.empName = empName;
   }
   public void setDept(Dept dept) {
       this.dept = dept;
   }
   public Dept getDept(){
       return this.dept;
   }
   public String getInfo() {
       return "[Emp] empId = " + this.empId
       + " empName = " + this.empName;
   }
}
class Role {
   private int roleId;
   private String roleName;
   private Dept[] depts;
   private Privilege[] privileges;

   public Role() {}
   public Role(int roleId, String roleName) {
       this.roleId = roleId;
       this.roleName = roleName;
   }
   public void setDepts(Dept[] depts) {
       this.depts = depts;
   }
   public Dept[] getDepts() {
       return this.depts;
   }
   public void setPrivileges(Privilege[] privileges) {
       this.privileges = privileges;
   }
   public Privilege[] getPrivileges() {
       return this.privileges;
   }
   public String getInfo() {
       return "[Role] roleId = " + this.roleId
       + " roleName = " + roleName;
   }
}
class Privilege {
   private int pId;
   private String pName;
   private String pFlag;
   private Role[] roles;

   public Privilege() {}
   public Privilege(int pId, String pName, String pFlag) {
       this.pId = pId;
       this.pName = pName;
       this.pFlag = pFlag;
   }
   public void setRoles(Role[] roles) {
       this.roles = roles;
   }
   public Role[] getRoles() {
       return this.roles;
   }
   public String getInfo() {
       return "[Privilege] pId = " + pId
       + " pName = " + pName
       + " pFlag = " + pFlag;
   }
}

public class TestDemo {
   public static void main(String[] args) {
       Dept deptA = new Dept(1,"财务部");
       Dept deptB = new Dept(2,"技术部");
       Dept deptC = new Dept(3,"行政部");

       Emp empA = new Emp(1,"员工A");
       Emp empB = new Emp(2,"员工B");
       Emp empC = new Emp(3,"员工C");
       Emp empD = new Emp(4,"员工D");
       Emp empE = new Emp(5,"员工E");

       Role roleA = new Role(1,"普通员工");
       Role roleB = new Role(2,"高级员工");

       Privilege PA = new Privilege(1000,"查询","正常");
       Privilege PB = new Privilege(1001,"删除","正常");
       Privilege PC = new Privilege(1002,"修改","正常");

       empA.setDept(deptA);
       empB.setDept(deptA);
       empC.setDept(deptB);
       empD.setDept(deptB);
       empE.setDept(deptC);

       deptA.setEmps(new Emp[] {empA,empB});
       deptB.setEmps(new Emp[] {empC,empD});
       deptC.setEmps(new Emp[] {empE});

       deptA.setRole(roleA);
       deptB.setRole(roleA);
       deptC.setRole(roleB);

       roleA.setDepts(new Dept[] {deptA,deptB});
       roleB.setDepts(new Dept[] {deptC});

       roleA.setPrivileges(new Privilege[] {PA});
       roleB.setPrivileges(new Privilege[] {PA,PB,PC});

       PA.setRoles(new Role[] {roleA,roleB});
       PB.setRoles(new Role[] {roleB});
       PC.setRoles(new Role[] {roleB});

       System.out.println(empA.getInfo());
       System.out.println("t |-" + empA.getDept().getInfo());
       System.out.println("tt |-" + empA.getDept().getRole().getInfo());
       for (Privilege x : empA.getDept().getRole().getPrivileges()) {
           System.out.println("ttt |-" + x.getInfo());
       }
       System.out.println(roleA.getInfo());
       for (Dept x : roleA.getDepts()) {
           System.out.println("t |- " + x.getInfo());
           for (Emp y : x.getEmps()) {
               System.out.println("tt |- " + y.getInfo());
           }
       }
       System.out.println(PA.getInfo());
       for (Role x : PA.getRoles()) {
           System.out.println("t |- " + x.getInfo());
           for (Dept y : x.getDepts()) {
               System.out.println("tt |- " + y.getInfo());
               for (Emp z : y.getEmps()) {
               System.out.println("ttt |- " + z.getInfo());
           }
           }
       }
   }
}