第6章 数组

本章需要掌握数组在程序中的主要作用以及定义语法，掌握数组引用传递的操作，并且可以掌握数组引用传递内存分析方法，掌握数组相关操作案例，可以实现数字排序与数组专指的操作实现，掌握对象数组的应用，并且可以深刻理解对象数组的存在意义，掌握简单Java类与对象数组在实际开发中使用模式。

数组实在程序设计中提供的一种重要的数据类型，在Java中数组属于引用数据类型，所以数组也会涉及到堆栈空间的分配与引用传递的问题。

6.1 数组定义

数组是一组相关变量的集合。例如，如果说现在要想定义100个整形变量，按照传统的思路：
int i1,i2....i100; //一共写100各变量

以上的形势的确可以满足技术要求，但是这里有一个问题，这100个白亮没有任何逻辑控制关系，各个白能量完全独立，就会出现不方便管理的问题，那么在这种情况下既可以利用好素组来解决此类问题，而数组本身也属于引用数据类型，所以数组的定义语法如下：
声明并开辟数组([]可以定义在数字名称前也可以在数组名称后)
数据类型 数组名称 []=new 数据类型 [长度];
数据类型 [] 数组名称=new 数据类型 [长度];
分步完成
声明数组 ：数据类型 数组名称 []=null;
开辟数组：数组名称= new 数据类型 [长度]

当数组开辟空间之后，那么就可以使用素组名称[下标|索引]的形式进行访问，但是所有数组下标都是从0开始，即如果是3个长度的数组，则下标可用范围：0-2(0、1、2一共三个内容)。如果访问的时候超出了数组的允许下标长度，那么就会出现数组越界异常。
        以上给出的数组定义结构使用的是动态初始化的方式，即数组首先开辟内存空间，但是数组中的内容都是其对应数据类型的默认值，如果喜爱真乃声明的是int数组，则数组里面都是默认值0，由于数组是一种顺序结构，并且数组的长度都是固定的，那么可以使用循环的方式输出，很明显用到for循环结构。而且java为了方便数组的输出，提供了一个"数组名称.length"属性，可以直接获得数组长度：
范例：定义并使用数组

public class ArrayDemo
{
public static void main(String args[])
{
int data [] =new  int [3];
data[0]=1;
data[1]=2;
data[2]=3;
for(int x=0;x<data.length;x++)
{
System.out.println(data[x]);
}
}
}

本程序利用数组动态初始化开辟了3个长度的数组内容，并且为数组中的每一个元素进行初始化，由于数组的长度是固定的，所以使用了for循环实现了数组的访问下标控制实现了数组内容的输出。
        数组核心的操作就是声明并分配内存空间，而后根据索引进行访问。但是需要注意的是，数组属于引用数据类型，代码中需要进行内存分配。数组与对象唯一区别在于：对象中的堆内存保存的是属性，以上程序内存划分如上图

数组本身分为动态初始化与静态初始化，以上范例使用的是动态初始化，动态初始化后会发现数组中的每一个元素的内容都是其对应数据的默认值，随后可以通过下标为数组设置内容。如果希望定义数组时就设置内容，则可以采用静态初始化的方式完成。

范例：使用静态数组初始化定义数组

public class ArrayDemo
{
public static void main(String args[])
{
int [] data=new int []{11,22,33};
for(int x=0;x<data.length;x++)
{
System.out.println(data[x]);
}
}
}

本程序采用静态初始化，在数组定义的时候就为其设置了具体的数据内容，避免了先开辟后赋值的重复操作

6.2 数组引用传递分析

数组属于引用数据类型，在数组使用时需要通过关键字new开辟堆内存空间，一块堆内存空间可以被多个栈内存所指向，进行引用数据操作

范例：数组引用传递

public class ArrayDemo
{
public static void main(String args[])
{
int data[]=new int []{10,20,30};
int temp[]=data;
temp[0]=99;
for(int x=0;x<data.length;x++)
{
System.out.printl(data[x]);
}
}
}

本程序首先定义了一个int型数组，通过引用数据传毒将数组内容传递给temp,并利用temp修改了数组的内容。

注意：不能够直接使用为开辟堆内存空间的数组
数组本身属于引用数据类型，如果用户现在直接使用了未开辟空间的数组，男一定会出现NullPointerException(空指向异常)。

范例：使用未开辟空间的数组

public class ArrayDemo
{
public static void main(String args[])
{
int data[]=null;
System.out.println(data[0]);
}
}

6.3 foreach输出

数组是一个定长的数据结构，在进行数组输出的时候往往会结合for循环并且利用下标的形式访问数组元素，为了简化数组与集合数据的输出问题，提供有foreach结构(加强型for循环)，其语法如下
fro(数据类型 变量：数组|集合)
{
循环体代码
}
范例：使用foreach结构输出数组内容

public class ArrayDemo
{
public static void main(String args[])
{
int data[]=new int []{1,2,3,4,5,6};
for(int temp:data)
{
System.out.println(temp+"、");
}
}
}

6.4 二维数组

在数组定义时需要在变量上使用[]标记，对于之前的数组实际上是一种线性结构，只需要利用一个下标就可以定位一个具体的数据内容，这样的数组被称为一维数组
 

下标	0	1	2	3
数据	890	90	90	11

如果想要描述出多行多列的结构(表结构形式)，那么就可以通过二维数组的形式进行定义，则在定义二维数组时就需要使用两个[][]声明，在二维数组中通过行下标和列下表才可以定位一个数据内容：
 

下标	0	1	2
0	90	90	90
1	90	90	90
2	90	21	21

提示：关于多维数组
二维及其以上维度的数组都成为多维数组。二维数组需要行或列两个下标才可以访问其数组元素，其结构为一张表(本质上是数组的嵌套)；如果是三维数组就可以描述出一个立体结构。理论上可以继续增加数组的维数，其处理得复杂度就越高，在项目中尽量不要使用多维数组。

在Java中，对于二维数组可以使用的定义语法如下：
动态初始化：数据类型 数组名称[][]=new 数据类型[行的个数][列的个数]
静态初始化：数据类型 数组名称[][]=new 数据类型[][]{{值，值，值}，{值，值，值}}
范例：定义二维数组

public class ArrayDemo
{
public static void main(String args[])
{
int data[][]=new int [][]{{1,2,3,4,5},{1,2,3},{5,6,7,8}};
for(int x=0;x<data.length;x++)
{
for(int y=0;y<data[x].length;y++)
{
System.out.printl("data["+x+"]["+y+"]="+data[x][y]);
}
}
System.out.println();
}
}

范例：使用foreach结构输出数组

public class ArrayDemo
{
public static void main(String args[])
{
int data[][]=new int [][]{{1,2,3,4,5},{1,2,3},{5,6,7,8}};
for(int temp[]:data)
{
for(int num:temp)
{
System.out.printl(num);
}
}
System.out.println();
}
}

6.5 数组与方法

在数组进行引用传递的处理中，最常见的形式就是基于方法进行引用数据的处理或返回，下面将通过几个案例对此类操作进行说明

范例：使用方法接收数组引用

public class ArrayDemo
{
public static void main(String args)
{
int data[]=new int[]{1,2,3};
printArray(data);
}

public static void printArray(int temp[])
{
for(int x=0;x<temp.length;x++)
{
System.out.println(temp[x]);
}
}
}

本程序利用数组静态初始化定义数组，随后将其引用地址传递给了printArray()方法中的temp变量：
在策划那峡谷方法中可以接受一个数组的引用，那么方法也可以返回一个数组的引用，此时只需在方法的返回值上将其定义为对应的数组类型即可
范例：方法返回数组

public class ArrayDemo
{
public static void main(String args[])
{
int data[]=initArray();
printArray(data);
}

public static int[] initArray()
{
int arr[]=new int[]{1,2,3};
return arr;
}

public static void printArray(int temp[])
{
for(int num:temp)
{
System.out.print(num);
}
}
}

本程序定义的initArray()方法的主要功能就是返回一个数组的引用，由于initArray()方法的返回值类型为int[],所以必须使用同类型的数组接收，即int data[]=initArray(),过程如上图所示

范例：通过方法修改数组内容

public class JavaDemo
{
public static void main(String args[])
{
int data[]=new int[]{1,2,3};
changeArray(data);
printArray(data);
}

public static void changeArray(int arr[])
{
for(int x=0;x<arr.length;x++)
{
arr[x]*=2;
}
}

public static void printArray(int temp[])
{
for(int num:temp)
{
System.out.print(temp[x]);
}
}
}

本程序中changeArray方法的主要功能是修改接收到的数组内容，由于发生的是引用关系，所以修改后的结果直接影响到原始内容，通过以上分析，可以清楚了解数组与方法之间的引用传递问题。但是现在所有的程序代码都是在主类中编写，并没有使用过多的面向对象设计思想，下面将结合面向对象的设计思想实现一个数组的操作案例，本操作案例要求如下：随意定义一个int数组，要求可以计算出这个数组元素的总和、最大值、最小值、平均值。

范例：结合面向对象设计实现数组内容统计

class ArrayUtil
{
private int sum;
private double avg;
private int max;
private int min;

public ArrayUtil(int data[])
{
this.max=data[0];
this.min=data[0];
for(int num:data)
{
if(num>max)
{
max=num;
}else if(num<min)
{
min=num;
}

this.num+=data[x];
}
this.avg=this.sum/data.length;
}

public int getSum()
{
return this.sum;
}
public double getAvg()
{
return this.avg;
}
public int getMax()
{
return this.max;
}
public int getMin()
{
return this.min;
}
}

public class ArrayDemo
{
public static void main(String args[])
{
int data[]=new int []{1,2,3,4,5,6};
ArrayUtil util=new ArrayUtil(data);
System.out.println(util.getSum);
System.out.println(util.getAvg);
System.out.println(util.getMax);
System.out.println(util.getMin);
}
}

本程序为了实现案例的要求，采用面向对象的形式定义了一个专门的数组操作类，并且此类的构造方法中实现了数组内容的相关统计操作。

6.6 数组案例分析

数组是一种结构化的线性数据类型，也是数据操作的重要组成部分，下面将通过两个常见案例进行说明。

6.6.1 数组排序案例分析

数组排序是指将一个无序的数组按照大小关系进行排序，使之可以进行有序保存：

范例：实现数组排序

class ArrayUtil
{
public static void sort(int data[])
{
for(int x=0;x<data.length;x++)
{
for(int y=0;y<data.length-x-1;y++)
{
if(data[y]>data[y+1])
{
int temp=data[y];
data[y]=data[y+1];
data[y+1]=data[y];
}
}
}
}

public static void printArray(int temp[])
{
for(int x=0;x<temp.length;x++)
{
System.out.print(temp[x]);
}
System.out.println();

}
}

public class ArrayDemo
{
public static void main(String args[])
{
int data[]=new int[]{1,2,2,3,4,5,6,6,8};
ArrayUtil.sort(data);
ArrayUtil.printArray(data);
}
}

本程序为了实现数组的排序与内容输出功能定义了ArrayUtil类。
提问：为什么要定义static方法，定义为普通的方法用对象调用不可以吗
在进行数组操作提供的ArrayUtil类中，为什么不将方法定义为以下形式
class ArrayUtil
{
public void sort(int data[]){}
public void printArray(int temp[]){}
}
回答：减少无用对象产生
在本程序中ArrayUtil类里面并没有提供任何的成员属性定义，所以即使产生了ArrayUtil类的实例化对象，也没有任何意义

6.2.2 数组转置案例分析

数组专指是指实现一个数组内容的首尾信息交换：
范例：数组转置
class ArrayUtil
{
public static void reverse(int data[])
{
int center=data.length/2;
int head=0;
int tail=data.length-1;
for(int x=0;x<center;x++)
{
int temp=data[head];

data[head]=data[tail];
head++;
tail--;
}
}

public static void printArray(int temp[])
{
for(int num:temp)
{
System.out.print(num);
}
}
}

public class ArrayDemo
{
int data[]=new int[]{1,2,3,4,5,6,7,8,9};
ArrayUtil.reverse(data);
ArrayUtil.printArray(data);
}

范例：实现二维数组的转置

class ArrayUtil
{
public static void reverse(int temp[][])
{
for(int x=0;x<tem.length;x++)
{
for(int y=0;y<temp[x].length;y++)
{
int t=temp[x][y];
temp[x][y]=temp[y][x];
temp[y][x]=t;
}
}
}

public static void printArray(int temp[][])
{
for(int x=0;x<temp.length;x++)
{
for(int y=0;y<temp[x].length;y++)
{
System.out.print(temp[x][y]);
}
}

System.out.println();
}
}

6.7 数组类库支持

放了方便开发者进行代码的编写，Java也提供了一些与数组相关的操作，考虑到学习的层次，本部分先为读者讲解两个数组的常用操作方法：数组排序、数组复制。

1数组排序

可以按照由小到大的顺序对基本数据类型的数组(例如int数组、double数组都为基本类型的数组)进行排序，操作语法：java.util.Arrays.sort(数组名称)
提示：先按照语法使用：java.util是一个java系统包的名称,而Arrays是该包中的一个工具类。

范例：数组排序

public class ArrayDemo
{
public static void main(String args[])
{
int data[]=new int[]{1,2,2,34,5,5};
java.util.Arrays.sort(data);
}
}

本程序利用JDK提供的类库实现了数组排序处理，需要注意的是，java.util.Arrays.sort()方法主要针对一维数组的排序，但对数组类型无限制。

2数组复制

从一个数组中复制部分内容到另外一个数组中，方法为System.arraycopy(原数组名称，原数组开始点，目标数组名称，目标数组开始点，复制长度)；
提示：与原始定义的方法名称稍有不同
范例：数组复制

public class ArrayDemo
{
int []dataA=new int[]{1,2,3,4,5,6,67,8,9};
int dataB[]=new int[]{11,12,13,13,13,14,14};
System.arraycopy(dataA,3,dataB,3,3);
}

6.8 方法可变参数

为了方便开发者可以灵活的定义方法，避免方法中参数的执行限制，所以Java提供了方法可变参数的支持，利用这一特点可以在方法调用时采用动态形式传递若干个参数数据，可变参数定义语法如下：public [static][finale] 返回值类型 方法名称(参数类型...变量){虽然定义方式改变了，但是本质上是个数组}
范例：使用可变参数

class ArrayUtil
{
public static int sum(int... data)
{
int sum=0;
for(int num:data)
{
sum+=num;
}
}
}

提示：关于混合参数定义

需要注意的是，如果此时方法中需要接收普通参数和可变参数，则可变参数一定要定义到最后，并且一个方法只能定义一个可变参数
范例：混合参数

class ArrayUtil
{
public static void sum(String name,String url,int ...data)

{}
}

6.9 对象数组

在Java中所有的数据类型均可以定义为数组，即除了基本数据类型定义为数组外，引用数据类型也可以定义为数组，这样的数组就被称为对象数组：
对象数组的动态初始化：类 对象数组名称=new 类[长度]
对象数组静态初始化：类 对象数组名称=new 类 []{实例化对象，实例化对象}
范例：使用动态初始化定义对象数组

class Person
{
private String name;
private int age;
public Person(String name,int age)
{
this.name=name;
this.age=age;
}

public String getInfo()
{
return ""+this.name+this.age;
}

}

public class ArrayDemo
{
public static void main(String args[])
{
Person per=new Person[3];
per[0]=new Person("1",20);
per[1]=new Person("2",20);
per[2]=new Person("3",20);
for(Person p:per)
{
p.getInfo();
}
}
}

本程序利用对象数组的动态初始化开辟了三个元素的数组内容(默认情况下数组的每个元素都为null)，随后为数组的每一个对象进行了对象实例化的操作，内存分配如上图
       范例：对象数组静态初始化

public class ArrayDemo
{
public static void main(String args[])
{
Person per[]=new Person[]{new Person("1",11),new Person("2",11)};
for(Person p:per)
{
System.out.println(p.getInfo());
}
}
}

提示：对象数组内容初始化时也可以利用引用传入
以上的两个程序都实例化了Person类的对象，实际上如果在程序中已经存在若干个实例化对象，只要类型符合也可以直接设置为对象数组的内容
动态初始化操作：
Person perA=new Person("1",11);
Person perB=new Person("1",11);
Person perB=new Person("1",11);
Person per[]=new Person [3];
per[0]=perA;
per[1]=perB;
per[2]=perC;

6.10 引用传递应用案例

引用传递是整个Java项目中最为核心的内容，同样也是在实际开发中最为常见的一种操作，在读者了解了对象数组的概念后，就可以基于此概念与简单Java类实现一些现实的事物关系模型。

6.10.1 类关联结构

在现实的开发意义上，类是可以描述一类事物共性的结构体。现在假设要描述出这样一种关系：一个人拥有一辆汽车，此时就可以定义两个类Person和car，然后通过引用的形式配置彼此的关系。

范例：描述人与汽车的关系

class Car
{
private String name;
private double price;
private Person person;
public Car(String name,double price)
{
this.name=name;
this.price=price;
}

public void setPerson(Person person)
{
this.person=person;
}

public Person getPerson()
{
return this.person;
}

public String getInfo()
{
return ""+this.name+this.price;
}
}

class Person
{
private String name;
private int age;
private Car car;
public Person(String name,int age)
{
this.name=name;
this.age=age;
}

public void setCar(Car car)
{
this.car=car;
}

public Car getCar()
{
return this.car;
}

public String getInfo()
{
return ""+this.name+this.age;
}
}

public class JavaDemo
{
public static void main(String args[])
{
Person person=new person("11",29);
Car car=new car("111",150);
person.setCar(car);
car.setPerson(person);
 

根据关系获取数据

System.out.println(person.getCar().getInfo());
System.out.println(car.getPerson().getInfo());
}
}

本程序定义了两个简单Java类：Person(描述人的信息)、Car(描述车的信息)，并且在两个类的内部分别设置了一个自定义的引用类型(Person类提供car成员属性、car提供person成员属性)，用于描述两者之间的引用联系，在主类操作时首先根据两个类的关系设置了引用关系，随后就可以根据引用关系获取相应类的相关信息。

提示：关于代码链的编写

在本程序编写信息获取时，读者可以发现有如下的代码形式

System.out.println(person.getCar().getInfo());//通过人获取汽车的信息
实际上这就属于代码链的形势，因为Person类内部的getCar()方法返回的是Car实例化对象(通过关联设置已经确定返回的内容不是null)，所以可以继续利用此方法调用Car类中的方法。
Car tempcar=Person.getCar();
System.out.println(tempcar.getInfo());
相比较使用代码链而言，这类操作比较繁琐，所以应该习惯用代码链的方式。

6.10.2 自身关联结构

在进行类关联描述的时候，除了可以关联其他类之外，也可以实现自身的关联操作，例如，现在假设一个人员会有一辆车，那么每个人员可能还有子女，而子女也有可能有一辆车，这个时候后就可以利用自身关联的形势描述人员后代的关系。

范例：实现自身关联

class Car
{
private String name;
private double price;
private Person person;
public Car(String name,double price)
{
this.name=name;
this.price=price;
}
public void setPerson(Person person)
{
this.person=person;
}
public Person getPerson()
{
return this.person;
}
public String getInfo()
{
return ""+this.name+this.price;
}
}

class Person
{
private String name;
private int age;
private Car car;
private Person children[];
public Person(String name,int age)
{
this.name=name;
this.age=age;
}
public void setCar(Car car)
{
this.car=car;
}
public void setChidren(Person children[])
{
this.chidren=children;
}

public Car getcar()
{
return this.car;
}
public String getInfo()
{
return ""+this.name+this.age;
}
}

public class JavaDemo
{
public static void main(String args[])
{
Person person=new Person("1",20);
Person childA=new Person("2",28);
Person childB=new Person("3",24);
chidA.setCar(new Car("BMW",2000));
chidB.setCar(new Car("法拉利",2000));
person.setChildren(new Person[]{childA,childB});
Car car=new Car("G50",1111);
person.setCar(car);
car.setPerson(person);
//第二步根据关系获取数据

System.out.println(person.getCar().getInfo());
System.out.println(person.getPerson().getInfo());
for(int x=0;x<person.getChidren().length;x++)
{
System.out.println(person.getChildren()[x].getInfo());
System.out.println(person.getChildren()[x].getCar().getInfo());
}
}
}

在本程序中利用对象数组(private Person children[];)描述了一个人拥有的孩子的信息，这样就在Person类的内部定义了一个自身引用，并且其结构与Person完全相同，于是孩子可以继续描述拥有的汽车或后代的信息关联。
提示：对象数组的作用：
在本程序中使用对象数组描述了一个人的后代信息，实际上读者可以发现，对象数组在整体设计中描述的是一种多得概念，如果没有此结构很难住哪却描述出多个子女这一特点。

6.10.3 合成设计模式

将对象的引用关联进一步扩展就可以实现更多的结构描述，在Java中有一种合成设计模式(Composite Pattern),此设计模式的核心思想是：通过不同的泪实现子结构定义，随后将其在一个父类中整合。例如，现在要描述一台计算机组成的类结构，那么在这样的状态下就可以进行拆分，计算机分为两个部分：显示器和主机，而主机上需要配置一系列的硬件
范例：伪代码描述合成设计思想

class 计算机
{
private 显示器 对象数组[];
private 主机 对象；
}
class 显示器{}
class 主机
{
private 主板 对象；
private 鼠标 对象;
private 键盘 对象;

}
class 主板
{
private 内存 对象数组[];
private CPU 对象数组[];
private 显卡 对象;
private 硬盘 对象数组[];
}

class 键盘{}
class 鼠标{}
class 内存{}
class CPU{}
class 显卡{}
class 硬盘{}

6.11数据表与简单Java类映射转换

现代项目开发中数据库时核心组成部分，几乎所有的项目代码都是围绕着数据表的业务逻辑展开的，那么在程序中往往会使用简单Java类进行数据表结构的描述。本节将通过具体的案例，分析数据表与简单Java类之间的转换
在数据库中包含若干数据表，每一张实体数据表实际上都可以描述出一些具体的实物概念。例如，在数据库中如果要想描述出一个部门存在多个故园的逻辑关系，那么就需要有两张表：部门(dept)、雇员(emp),关系如下

在这个数据表中一共存在3种对应关系：一个部门有多个雇员、一个雇员属于一个部门、每个雇员都有一个领导信息。

提示：数据表与简单Java类的相关概念对比

程序类的定义形式实际上和这些朱提标的差别并不大，所以在实际的项目开发中数据表与简单Java类之间的基本映射关系如下：
数据实体表设计=类的定义。
表中的字段=类的成员属性
表的外键关联=对象引用关联
表的一行记录=类的一个实例化对象
表的多行数据=对象数组
如果要描述出上图的表结构，那么就需要提供两个实体类，这两个实体类需要根据表结构关联定义类结构，通过成员属性的引用关系描述链接}
范例：实现一对多数据结构转换

class Dept //描述部门(Dept)
{
private long depyno;//部门编号
private String dname;//部门名称
private String loc;//部门位置
private Emp emps[];
public Dept(long 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 ""+this.deptno+this.dname+this.loc;
}
}

class Emp //描述雇员(emp)
{
private long empno; //雇员编号
private String ename;//雇员姓名
private String job;//雇员职位
private double sal;      //基本工资
private double comm;//雇员佣金
private Dept dept;//所属部门
private Emp mgr;//所属领导
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.empno+this.job+this.sal+this.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;
}

}

本程序提供的两个简单Java类，彼此之间存在以下3个对应关系
【dept】类 private Emp emps[]:一个部门对应多个雇员信息，通过对象数组描述。
【emp】类private Emp mgr:一个雇员有一个领导，由于领导也是雇员，所以自身关联。
【emp类】：private Dept dept:一个雇员属于一个部门；

范例：设置数据并根据引用关系获取数据内容

public class JavaDemo
{
public static void main(String args[])
{
Dept dept=new Dept(10,"11","北京");
Emp empA=new Emp(111,"22","CLERK",800,0.0);
Emp empB=new Emp(111,"22","CLERK1",800,0.0);
Emp empC=new Emp(111,"22","CLERK2",800,0.0);
//根据数据表定义的数据关联关系，利用引用进行对象间的联系
empA.setDept(dept);
empB.setDept(dept);
empC.setDept(dept);
empA.setMgr(empB);
empB.setMgr(empC);
dept.setEmps(new Emps[]{empA,empB,empC})

//第二步
根据关系获取数据
System.out.println(dept.getInfo());
for(int x=0;x<dept.getEmps().length;x++)
{
System.out.println(dept.getEmps()[x].getInfo());
if(dept.getEmps()[x].getMgr()!=null)
{
System.out.println(dept.getMgr()[x].getInfo());
}
}

System.out.println(empB.getDept().getInfo());
System.out.println(empB.getMgr().getInfo());
}

}