JAVA中开闭原则-----对扩展开放， 对修改关闭。以及接口隔离原则的强大

这里用一个测量工具类来体现这个原则，此测量工具类可以对任何事物进行测量，只要对象提供测量的原则，由此这个系统可以被无限扩大，而核心代码被封装，系统完全按照一个类似框架的结构区扩大，需要测量的对象只要实现测量接口，并实现compareTo()这个方法，就可以在DataSet类中进行数据的测量和获取

public interface Measurable{
	public double measure(Object obj);
	

}
//这个是过滤接口，实现数据的过滤
public interface Filter{
	public boolean accept(Object obj);


}

DataSet中的add方法将要测量的对象存入一个可变数组中，由这个方法实现各个数据的数据采集

public class DataSet{
	private Object max;//测量的数据的最大值
	private Object min;//测量的数据的最大值
	private double avg;//平均值
	private double sum;
	private int count;
	private Measurable measurable;//测量工具
	private Filter filter;//过滤工具
	private Object[] objects;//数组存数据
	public DataSet(){
		this.objects=new Object[2];
	}
	//重置数据集
	public void reset(){
		max=null;
		min=null;
		sum=0;
		count=0;
		measurable=null;
		filter=null;


	}
	//添加要测量的对象;
	public void add(Object obj){
		if(this.measurable==null){
			return;
		}
		//TODO:增加一个过滤器的判断规则在这里
		if(filter!=null&&filter.accept(obj)==false){
			return;
		}
		//TODO:判断数组是否已经满了，如果满了，则扩大数组的长度（*2）
		//将原数组的值复制到新的数组中。
		if(count>=objects.length){
			Object[] object1=new Object[2*(objects.length)];
			System.arraycopy(objects,0,object1,0,objects.length);
			 objects=object1;//指向object1的引用变成垃圾
			System.gc();//garbadge collect 
			
			
		}
		
		//测量新对象的值
		double result=this.measurable.measure(obj);
		if(count==0){
			max=obj;
			min=obj;
		}else{
			double maxresult=this.measurable.measure(max);
			double minresult=this.measurable.measure(min);
			if(result>maxresult){
				this.max=obj;
		
			}
			if(result<minresult){
				this.min=obj;
			}

		}
		objects[count]=obj;
		count++;
		
		sum+=result;
		avg=sum/count;
		


	}
	//数组的排序方法；
	public void sort(Comparable comparable){
		if(comparable==null){
			return ;
		}
	
		for(int i=1;i<count;i++){
			Object next=objects[i];
			int j=i;
			while(j>0&&comparable.compareTo(objects[j-1],next)>0){
				objects[j]=objects[j-1];
				j--;
			}
		
		objects[j]=next;
		}
		
	}

	//得到数组中的数据集
	public Object[] getObjects(){
		Object[] result=new Object[count];
		System.arraycopy(objects,0,result,0,count);
		return result;
	}
	public void setMeasurable(Measurable measurable){
		this.measurable=measurable;
	}
	public 	void setFilter(Filter filter){
		this.filter=filter;
	}
	public Object getMax(){
		return this.max;

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



}

下面做个例子来用一下这个测量工具类，

//测量对象
public class Person{
	private String name;
	private double height;
	private double weight;
	public Person(){}
	public Person(String name,double height,double weight){
		this.name = name;
		this.height=height;
		this.weight=weight;
	}
	public String getName(){
		return name;
	}
	public double getHeight(){
		return height;
	}
	public double getWeight(){
		return weight;
	}
	public String toString(){
		return "姓名："+name+"\t身高："+height+"\t体重："+weight;
	}
	

}

//要用工具测量的person类提供的测量方法，
public class PersonBmiMeasure implements Measurable,Filter,Comparable{
	public double measure(Object obj){
		if(obj==null){
			System.out.println("输入的对象不能润为空！");
			return 0;
		}
		if(  !(obj instanceof Person) ){
			return 0;
		}
		Person p=(Person)obj;
		return (p.getWeight()/(p.getHeight()*p.getHeight()));
	}
	public boolean accept(Object object){
		if(obj==null){
			System.out.println("输入的对象不能润为空！");
			return false;
		}
		if(  !(obj instanceof Person) ){
			return false;
		}
		Person p=(Person)obj;
		if(obj.getWeight()<=0||obj.getHight()<=0){
			return false;
		}
		return true;
	}
	public double compareTo(Object obj1,Object obj2){
		if(obj1==null||obj2=null){
			System.out.println("输入的对象不能润为空！");
			return 0;
		}
		if(  !(obj1 instanceof Person) || !(obj2 instanceof Person) ){
			return 0;
		}
		Person p1=(Person)obj1;
		Person p2=(Person)obj2;
		return  p1.getHight()-p2.getHight();
	}
	

}

由上可知，再加一个将同类型对象按一定规则输出的coparable接口，就可以实现同类型的对象的排序

而核心代码DataSet类不会因为测量的对象发生变化，这个系统可以变得很灵活，并且测量的对象所用的代码格式也很有规律，极大提高了编程效率。。。作为接触JAVA技术的我来说，这段代码让我更加爱上编程，也体会到了面向对象语言的强大！