*****学习对象组合一定要记住：一个类声明的两个对象如果具有相同的引用，则二者就具有完全相同的实体（变量）；
1、对象组合指：在一个类中的对象可以将其他类的对象作为自己的组成部分，这个过程就是对象的组合；
2、方法复用指：在完成对象的组合后，通过所组合的对象调用其类中的方法；
如下代码演示：
//对象组合指：在一个类中的对象可以将其他类的对象作为自己的组成部分，这个过程就是对象的组合；
//1、创建一个主类对象
//2、在主类中创建另一个类的空对象，用于对象的组合；
//3、求正方形面积：a的平方
public class Object_Compose {
//创建另一个类的对象，进行组合使用
object_co ocs ; //此时对象为空
//对需要组合的对象赋予引用，进而完成方法复用；
void set(object_co oc){
ocs = oc ;
}
//通过组合的对象 ocs，进行方法复用 getArea(),得到正方形的面积
double Area(){
return ocs.getArea();
}
public static void main(String[] args) {
//创建主类对象
Object_Compose OCS = new Object_Compose();
//创建副类对象，对需要组合的对象进行赋予引用
object_co o = new object_co();
OCS.set(o);
//设置边长的值
o.setArea(10);
//完成引用赋值，查看引用值
System.out.println(OCS.ocs);
//完成引用赋值后，进行方法复用，即委托组合的对象 ocs 进行方法调用
OCS.Area();
//输出面积
System.out.println("正方形的面积为："+OCS.Area());
}
}
class object_co{
double sum,sideA;
//设置边长的值
double setArea (double side){
this.sideA = side;
return sideA;
}
//计算正方形面积
double getArea (){
this.sum = sideA * sideA ;
return sum ;
}
}在以上代码中，
主类 Object_Compose 的对象 OCS 与副类 object_co 的对象 ocs 进行了组合，
并且 主对象 OCS 委托了组合的 对象 ocs 调用了方法 ocs.getArea(); 进行正方形面积的运算，
而调用方法的这一个过程就称为方法的复用；
以上代码输出：
Chapter_Four.object_co@7852e922
正方形的面积为：100.0
通过对象组合来复用方法有以下特点：
1、通过组合对象来复用方法也称为 " 黑盒 " 复用，
" 黑盒 " 复用的意思是：当前对象只能委托所包含的对象调用其方法，这样一来，当前对象对所包含的对象的方法细节（具体方法的执行过程）是不知道的；
例如以上代码演示中，
主类对象 OCS 组合了 副类对象 ocs ，并委托对象 ocs 调用其方法 getArea() ，但是对象OCS 对方法 getArea() 的执行过程是不知道的；
2、当前对象可以随时更换所包含（组合）的对象，即对象与所包含（组合）的对象属于弱耦合的关系；
对以上代码演示中，进一步演示：
//对象组合指：在一个类中的对象可以将其他类的对象作为自己的组成部分，这个过程就是对象的组合；
//1、创建一个主类对象
//2、在主类中创建另一个类的空对象，用于对象的组合；
//3、求正方形面积：a的平方
public class Object_Compose_Advanced {
//创建另一个类的对象，进行组合使用
object_cos ocs ; //此时对象为空
//对需要组合的对象赋予引用，进而完成方法复用；
void set(object_cos oc){
ocs = oc ;
}
//通过组合的对象 ocs，进行方法复用 getArea(),得到正方形的面积
double Area(){
return ocs.getArea();
}
public static void main(String[] args) {
//创建主类对象
Object_Compose_Advanced OCS = new Object_Compose_Advanced();
//创建副类对象，对需要组合的对象进行赋予引用
object_cos o = new object_cos();
OCS.set(o);
//设置边长的值
o.setArea(10);
//完成引用赋值，查看引用值
System.out.println(OCS.ocs);
//完成引用赋值后，进行方法复用，即委托组合的对象 ocs 进行方法调用
OCS.Area();
//输出面积
System.out.println("正方形的面积为："+OCS.Area());
//继续创建副类对象，用于更换所组合对象的引用
object_cos ox = new object_cos();
OCS.set(ox);
//完成引用赋值，重新查看引用值,此时主类的对象所组合的副类对象 ocs的引用已经改变了；
//即完成了对象更换所包含（组合）的对象
System.out.println(OCS.ocs);
}
}
class object_cos{
double sum,sideA;
double setArea (double side){
this.sideA = side;
return sideA;
}
double getArea (){
this.sum = sideA * sideA ;
return sum ;
}
}在代码中主类对象OCS 组合的副类对象ocs 的引用随时进行了更换，体现了对象与所包含（组合）的对象属于弱耦合的关系；
对象数组的定义 ：
1、对象数组指：数组中元素类型是类创建的对象；
2、当类中需要创建多个类对象时，就可以通过对象数组进行快速创建了；
对象数组的声明 :
//第一种声明
Object_Array [] oa = new Object_Array[3];
//第二种声明
Object_Array [] oaa ;
oaa = new Object_Array[3];需要注意的是，此时只是对象的声明，所以这些对象都是空对象，没有分配内存，需要进行对象创建，才能使用这些对象；
对象数组的创建与使用 :
如下代码演示：
public class Object_Array {
//成员变量
double test = 11.111;
public static void main(String[] args) {
//对象数组的声明
Object_Array [] oa = new Object_Array[3];
//对象数组的创建
oa[0] = new Object_Array();
oa[1] = new Object_Array();
//对象数组的使用
oa[0].test = 1.1;
oa[1].test = 11.11;
System.out.println(oa[0].test);
System.out.println(oa[1].test);
}
}代码输出结果：
1.1
11.11
通过 for 循环快速创建对象数组 :
如下代码演示：
public class Object_Array {
int number;
public static void main(String[] args) {
//通过 for 循环快速创建对象数组
Object_Array [] oatest = new Object_Array[3];
for(int i=0 ; i<oatest.length;i++){
oatest[i] = new Object_Array();
oatest[i].number = 108 + i ;
System.out.println("每个对象对应的nunber值为："+oatest[i].number);
System.out.println("每个对象对应的引用为："+oatest[i]);
}
}
}代码输出结果：每个对象对应的nunber值为：108
每个对象对应的引用为：Chapter_Four.Object_Array@7852e922
每个对象对应的nunber值为：109
每个对象对应的引用为：Chapter_Four.Object_Array@4e25154f
每个对象对应的nunber值为：110
每个对象对应的引用为：Chapter_Four.Object_Array@70dea4e
