Java对象组合与方法复用（黑盒复用）的关系、对象数组的使用

 

*****学习对象组合一定要记住：一个类声明的两个对象如果具有相同的引用，则二者就具有完全相同的实体（变量）；

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