容器模式

package com.yc;
public interface Measurable {
    /*
     * 測量方法
     * @param Objec
     */
    public double measure(Object object);
            
}

package com.yc;

public class Container {
    public static final int NUM=10;
    private Object[] objects; //对象
    private Object max; 
    private Object min;
    private double avg;
    private double total; //总和
    
    private Integer index; //数组中存的真实数据有多少个
    private Measurable measurable; //測量设备
    
    private Filter filter;    //对数据有效性的过滤性
    
    
    
    public void setFilter(Filter filter) {
        this.filter = filter;
    }

    public Container(){
        objects=new Object[NUM];
        max=null;
        min=null;
        avg=0;
        total=0;
        index=0;
        measurable=null;
    }
    
    /*
     * 加入要測量的对象到容器的方法
     * 功能： 測量obj的值，并记录最大值。最小值，平均值，并将obj存到Objects数组中
     */
    public void add(Object obj) throws Exception{
        if(obj==null){
            throw new RuntimeException("要測量的对象不能为空，您传入的对象为"+obj);  //非受检
        }
        if(this.measurable==null){
            throw new Exception("測量不能为空");  //受检异常，受检异常一定要抛出
        }
        //推断是否有过滤器
        if(this.filter!=null){
            if(this.filter.doFilter(obj)==false){
                throw new RuntimeException("要过率的对象不是有效对象");
            }
        }
        double value=this.measurable.measure(obj);
        if(index==0){
            max=obj;
            min=obj;        
        }else{
            double maxvalue=this.measurable.measure(max);
            double minvalue=this.measurable.measure(min);
            
            if(maxvalue<value){
                max=obj;
            }
            //这里不能加 else 要进行两次推断：有可能刚好是中间值，既是最大，有时最小
            if(minvalue>value){
                min=obj;
            }
        }
        //扩展object数组的大小。防止它存满溢出
        enlargeArray();
        objects[index]=obj;
        //自增index
        index++;
        total+=value;
        avg=total/index;
    }
    
    //更优方案：依照比例进行扩充，不一定要一两倍
    //或者不一定等数组满了之后才进行复制。达到%80
    private void enlargeArray() {
        if(index>=objects.length){
            Object[] newobjects=new Object[objects.length*2];
            //将原数组的数据存到新数组中
            System.arraycopy(objects, 0, newobjects, 0, index);
            //将newobject的地址复制给objects
            objects=newobjects;
            System.gc();  //gc() 垃圾回收。告诉jvm回收空间     【根本方案：重写虚拟机】
        }
    }

    //设置測量的方法
    public void setMeasurable( Measurable measurable){
        this.measurable=measurable;
    }
    
    //全部測量过后的数据，object默认10，仅仅能返回有效的数据
    public Object[] getAllData(){
        Object[] newobject=new Object[index];
        System.arraycopy(objects, 0, newobject, 0, index);
        return newobject;
    }
    
    //測量过的数据
    public int size(){
        return index;
    }

    public Object[] getObjects() {
        return objects;
    }

    public Object getMax() {
        return max;
    }

    public Object getMin() {
        return min;
    }

    public double getAvg() {
        return avg;
    }

    public double getTotal() {
        return total;
    }
    
    /*
     * 这是容器要用的排序方法
     */
    
    public void sort(){
        Object tem=null;
        //循环一次把最大数放到最后
        for(int i=0;i<index;i++){
            for( int j=0;j<index-i-1;j++){
                Object objJ=objects[j];
                Object objJ1=objects[j+1];
                //推断objJ是否实现了 Sort接口的对象
                if(objJ instanceof Sort){
                    Sort s=(Sort) objJ;
                    int result=s.doSort(objJ1);
                    if( result>0){
                        tem=objects[j];
                        objects[j]=objects[j+1];
                        objects[j+1]=tem;
                        
                    }
                }
            }
        }
    }
    
    
}

package com.lining;

import com.yc.Measurable;

public class Bmi implements Measurable{

    @Override
    public double measure(Object obj) {
        if(obj==null){
            throw new RuntimeException("要測量的对象不能为空");
        }
        if(!( obj instanceof Person)){
            throw new RuntimeException("要測量的对象必须是一个人");
        }
        //将Object强制类型转换成Person ,以取height,weight
        Person p=(Person) obj;
        double height=p.getHeight();
        double weight=p.getWeight();
        return weight/(height*height);
    }
    
}

package com.yc;

public interface Sort {
    /*
     * 比較两个对象的大小
     * 正数表示当前对象大。负数表示ob大， 0相等
     */
    public int doSort(Object obj);
}

package com.lining;

import com.yc.Sort;

public class Person implements Sort{
    private String name;
    private double weight;
    private double height;

    public Person(String name, double weight, double height) {
        super();
        this.name = name;
        this.weight = weight;
        this.height = height;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public double getWeight() {
        return weight;
    }
    public void setWeight(double weight) {
        this.weight = weight;
    }
    public double getHeight() {
        return height;
    }
    public void setHeight(double height) {
        this.height = height;
    } 
    @Override
    public String toString() {
        return "Person [name=" + name + ", weight=" + weight + ", height=" + height + "]";
    }
    @Override
    public int doSort(Object obj) {
        if(obj==null){
            throw new RuntimeException("要比較的对象不能为空");
        }
        if(!(obj instanceof Person)){
            throw new RuntimeException("要比較的对象必须是一个人");
        }
        Person p=(Person)obj;
        
        return (int)(this.weight-p.weight);
    }
    
    
}