哈工大软件构造-对于able接口的总结

able接口

Throwable

1.error

由外部原因导致，程序员无能为力，大多是设备原因，比如未联网

2.Exception

①RuntimeException
属于unchecked异常（之静态检查不会检查），在编译器运行时检查，属于程序员认为错误，须要对代码进行改正
例如：数组越界，空指针问题，除0异常
②其他异常
属于checked异常，由于外部原因导致，可以预测并补救，如果没有try…catch异常或throws异常，在静态检查阶段会报错。
例如：文件未找到，用户输入非法
注：我们通常的自定义类都继承自Exception，而不是RuntimeException

Comparable比较器

Comparable是java提供的接口，源码如下：

package java.lang;
import java.util.*;

package java.lang;
public interface Comparable<T> {
    public int compareTo(T o);
}

运用delegation，将需要与this比较的类作为参数传递进compareTo中，例如：

package try1;
import java.util.*;

public class try2 implements Comparable<try2>{
	int i;
	public int compareTo(try2 t) {
		if(this.i>t.i) return 1;
		if(this.i<t.i) return -1;
		else return 0;
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
	}

}

注：注意用List.sort时，返回的数字是固定的1，-1，0；
在类中直接调用即可
顺便谈一下另一个接口，Comparator

package java.util;

import java.io.Serializable;
import java.util.function.Function;
import java.util.function.ToIntFunction;
import java.util.function.ToLongFunction;
import java.util.function.ToDoubleFunction;
import java.util.Comparators;

public interface Comparator<T> {
	int compare(T o1, T o2);
	//还有很多其他方法...
}

Comparater同样利用delegation，将本身作为参数传进Collections.sort，并将两个被排序类作为参数传入内部方法compare，此实现方法类似于进程的创建。

Collections.sort(list, new Comparator<被排序类>() {
            @Override
            public int compare(被排序类 o1, 被排序类 o2) {
                return  o1.get() > o2.get() ? 1 : (o1.get() == o2.get() ? 0 : -1);
            }
        });
        

Iterable迭代器

Interable是Java中的迭代器接口，iterator为Java中的迭代器对象，是能够对List这样的集合进行迭代遍历的底层依赖。而iterable接口里定义了返回iterator的方法，相当于对iterator的封装，同时实现了iterable接口的类可以支持for each循环。这里用到了两颗继承树间的delegation。
我们自己定义的iterator实例如下：

import java.util.*;
public class try3 implements Iterable<String>{
	public Iterator<String> iterator() {
		return new try3Iterator();
	}
}
class try3Iterator implements Iterator<String>{
	public boolean hasNext() {
		return true;
	}
	public String next() {
		return "sss";
	}
}

Observable观察者模式

运用双向delegation，一对多的对应形式，可以类比为明星与粉丝之间的关系。明星中位置一个“我的粉丝”的对象列表，而粉丝中维持一个“我的爱豆”对象。
二者之间存在双向联系，新创建粉丝对象会在明星那备案。而明星更新状态会通知所有粉丝。

public class Fan {
	private final Star s;
	private String starstate;
	public Fan(Star s) {
		this.s=s;
		s.newfan(this);
		this.starstate=s.getstate();
	}
	public void newfan(Fan f) {
		fans.add(f);
	}
	public void SetState(String newstate) {
		starstate=newstate;
	}
}

import java.util.List;
import java.util.ArrayList;
public class Star {
	private final List<Fan> fans=new ArrayList<>();
	private String state;
	public void changstate(String newstate) {
		state=newstate;
		for(Fan f:fans) {
			f.SetState(newstate);
		}
	}
	public String getstate() {
		return state;
	}
}