类型信息（8）：空对象

﹏ヽ暗。殇╰゛Y 2023-07-13 08:13 34阅读 0赞

当你使用内置的null表示缺少对象时，在每次使用引用时都必须测试其是否为null，这显得枯燥，而且势必产生相当乏味的代码。问题在于null除了在你试图用它执行任何操作来产生NullPointerException之外，它自己没有其他任何行为。有时引入空对象的思想将会很有用，它可以接受传递给它的所代表的对象的消息，但是将返回表示为实际上并不存在任何“真实”对象的值。通过这种方式，你可以假设所有的对象都是有效的，而不必浪费编程精力去检查null（并阅读所产生的代码）。

尽管想象一种可以自动为我们创建空对象的编程语言显得很有趣，但是实际上，到处使用空对象并没有任何意义——有时检查null就可以了，有时你可以合理地假设你根本不会遇到null，有时甚至通过NullPointerException来探测异常也是可以接受的。空对象最有用之处在于它更靠近数据，因为对象表示的是问题空间内的实体。有一个简单的例子，许多系统都有一个Person类，而在代码中，有很多情况是你没有一个实际的人（或者你有，但是你还没有这个人的全部信息），因此，通常你会使用一个null引用并测试它。与此不同的是，我们可以使用空对象。但是即使空对象可以响应“实际”对象可以响应的所有消息，你仍需要某种方式去测试其是否为空。要达到此目的，最简单的方式就是创建一个标记接口：

public interface Null {
    }

这使得instanceof可以探测空对象，更重要的是，这并不要求你在所有的类中都添加isNull()方法（毕竟，这只是执行RTTI的一种不同方式——为什么不使用内置的工具呢？）

import util.Null;
    
    public class Person {
    	public final String first;
    	public final String last;
    	public final String address;
    
    	public Person(String first, String last, String address) {
    		this.first = first;
    		this.last = last;
    		this.address = address;
    	}
    
    	public String toString() {
    		return "Person: " + first + " " + last + " " + address;
    	}
    
    	public static class NullPerson extends Person implements Null {
    
    		public NullPerson() {
    			super("None", "None", "None");
    		}
    
    		public String toString() {
    			return "NullPerson";
    		}
    	}
    
    	public static final Person NULL = new NullPerson();
    }

通常，空对象都是单例，因此这里将其作为静态final实例创建。这可以正常工作的，因此Person是不可变的——你只能在构造器中设置它的值，然后读取这些值，但是你不能修改它们（因为String自身具备内在的不可变性）。如果你想要修改一个NullPerson，那只能用一个新的Person对象来替换它。注意，你可以选择使用instanceof来探测泛化的Null还是更具体的NullPerson，但是由于使用了单例方式，所以你还可以只使用equals()甚至==来与Person.Null比较。

现在假设你回到了互联网刚出现时的雄心万丈的年代，并且你已经因你惊人的理念而获得了一大笔的风险投资。你现在要招兵买马了，但是在虚位以待时，你可以将Person空对象放在每个Position上：

public class Position {
    	private String title;
    	private Person person;
    
    	public Position(String jobTitle, Person employee) {
    		title = jobTitle;
    		person = employee;
    		if (person == null)
    			person = Person.NULL;
    	}
    
    	public Position(String jobTitle) {
    		title = jobTitle;
    		person = Person.NULL;
    	}
    
    	public String getTitle() {
    		return title;
    	}
    
    	public Person getPerson() {
    		return person;
    	}
    
    	public void setPerson(Person newPerson) {
    		person = newPerson;
    		if (person == null)
    			person = Person.NULL;
    	}
    
    	public String toString() {
    		return "Position: " + title + " " + person;
    	}
    }

有了Position，你就不需要创建空对象了，因为Person.Null的存在就表示这是一个空Position【稍后，你可能会发现需要增加一个显示的用于Position的空对象，但是YAGIN（You Aren‘t Going to Need It，你永不需要它）声明：在你的设计草案的初稿中，应该努力使用最简单且可以工作的事物，直至程序的某个方面要求你添加额外的特性，而不是一开始就假设它是必需的】。

import java.util.ArrayList;
    
    public class Staff extends ArrayList<Position> {
    	public void add(String title, Person person) {
    		add(new Position(title, person));
    	}
    
    	public void add(String... titles) {
    		for (String title : titles)
    			add(new Position(title));
    	}
    
    	public Staff(String... titles) {
    		add(titles);
    	}
    
    	public boolean positionAvailable(String title) {
    		for (Position position : this)
    			if (position.getTitle().equals(title) && position.getPerson() == Person.NULL)
    				return true;
    		return false;
    	}
    
    	public void fillPosition(String title, Person hire) {
    		for (Position position : this)
    			if (position.getTitle().equals(title) && position.getPerson() == Person.NULL) {
    				position.setPerson(hire);
    				return;
    			}
    		throw new RuntimeException("position " + title + " not available");
    	}
    
    	public static void main(String[] args) {
    		Staff staff = new Staff("President", "CTO", "Marketing Manager", "Product Manager", "Project Lead",
    				"Software Engineer", "Software Engineer", "Software Engineer", "Software Engineer", "Test Engineer",
    				"Technical Writer");
    		staff.fillPosition("President", new Person("Me", "Last", "The Top,Lonely At"));
    		staff.fillPosition("Project Lead", new Person("Janet", "Planner", "The Burbs"));
    		if (staff.positionAvailable("Software Engineer"))
    			staff.fillPosition("Software Engineer", new Person("Bob", "Coder", "Bright Light City"));
    		System.out.println(staff);
    	}
    }

注意，你在某些地方仍必须测试空对象，这与检查是否为null没有差异，但是在其他地方（例如本例中的toString()转换）你就不必执行额外的测试了，而可以直接假设所有对象都是有效的。

如果你用接口取代具体类，那么就可以使用DynamicProxy来自动地创建空对象。假设我们有一个Robot接口，它定义了一个名字、一个模型和一个描述Robot行为能力的List<Operation>。Operation包含一个描述和一个命令（这是一种命令模式类型）：

public interface Operation {
    
    	String description();
    
    	void command();
    }

你可以通过调用operations()来访问Robot的服务：

import java.util.List;
    import util.Null;
    
    public interface Robot {
    	String name();
    
    	String model();
    
    	List<Operation> operations();
    
    	class Test {
    		public static void test(Robot r) {
    			if (r instanceof Null)
    				System.out.println("[Null Robot]");
    			System.out.println("Robot name: " + r.name());
    			System.out.println("Robot model: " + r.model());
    			for (Operation operation : r.operations()) {
    				System.out.println(operation.description());
    				operation.command();
    			}
    		}
    	}
    }

这里也使用了嵌套类来执行测试。我们现在可以创建一个扫雪Robot：

import java.util.Arrays;
    import java.util.List;
    
    public class SnowRemovalRobot implements Robot {
    
    	private String name;
    
    	public SnowRemovalRobot(String name) {
    		this.name = name;
    	}
    
    	@Override
    	public String name() {
    		return name;
    	}
    
    	@Override
    	public String model() {
    		return "SnowBot Series 11";
    	}
    
    	@Override
    	public List<Operation> operations() {
    		return Arrays.asList(new Operation() {
    			@Override
    			public String description() {
    				return name + " can shovel snow";
    			}
    
    			@Override
    			public void command() {
    				System.out.println(name + " shoveling snow");
    			}
    		}, new Operation() {
    			@Override
    			public String description() {
    				return name + " can chip ice";
    			}
    
    			@Override
    			public void command() {
    				System.out.println(name + " chipping ice");
    			}
    		}, new Operation() {
    			@Override
    			public String description() {
    				return name + " can clear the roof";
    			}
    
    			@Override
    			public void command() {
    				System.out.println(name + " clearing roof");
    			}
    		});
    	}
    
    	public static void main(String[] args) {
    		Robot.Test.test(new SnowRemovalRobot("Slusher"));
    	}
    }

假设存在许多不同类型的Robot，我们想对每一种Robot类型都创建一个空对象，去执行某些特殊操作——在本例中，即提供空对象所代表的Robot确切类型的信息。这些信息是通过动态代理捕获的：

import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.InvocationTargetException;
    import java.lang.reflect.Method;
    import java.lang.reflect.Proxy;
    import java.util.Collections;
    import java.util.List;
    
    import com.buba.util.Null;
    
    class NullRobotProxyHandler implements InvocationHandler {
    	private String nullName;
    	private Robot proxied = new NRobot();
    
    	NullRobotProxyHandler(Class<? extends Robot> type) {
    		nullName = type.getSimpleName() + "NullRobot";
    	}
    
    	private class NRobot implements Null, Robot {
    		@Override
    		public String name() {
    			return nullName;
    		}
    
    		@Override
    		public String model() {
    			return nullName;
    		}
    
    		@Override
    		public List<Operation> operations() {
    			return Collections.emptyList();
    		}
    	}
    
    	public Object invoke(Object proxy, Method method, Object[] args)
    			throws IllegalAccessException, IllegalArgumentException, InvocationTargetException {
    		return method.invoke(proxied, args);
    	}
    }
    
    public class NullRobot {
    	public static Robot newNullRobot(Class<? extends Robot> type) {
    		return (Robot) Proxy.newProxyInstance(NullRobot.class.getClassLoader(), new Class[] { Null.class, Robot.class },
    				new NullRobotProxyHandler(type));
    	}
    
    	public static void main(String[] args) {
    		Robot[] bots = { new SnowRemovalRobot("SnowBee"), newNullRobot(SnowRemovalRobot.class) };
    		for (Robot bot : bots)
    			Robot.Test.test(bot);
    	}
    }

无论何时，如果你需要一个空Robot对象，只需调用newNullRobot()，并传递需要代理的Robot的类型。代理会满足Robot和Null接口的需求，并提供它所代理的类型的确切名字。

空对象的逻辑变体是模拟对象和桩。与空对象一样，它们都表示在最终的程序中所使用的“实际对象”。但是，模拟对象和桩都只是假扮可以传递实际信息的存活对象，而不是像空对象那样可以成为null的一种更加智能化的替代物。

模拟对象和桩之间的差异在于程度不同。模拟对象往往是轻量级和自测试的，通常很多模拟对象被创建出来是为了处理各种不同的测试情况。桩只是返回桩数据，它通常是重量级的，并且经常在测试之间被复用。桩可以根据它们被调用的方式，通过配置进行修改，因此桩是一种复杂对象，它要做很多事。然而对于模拟对象，如果你需要做很多事情，通常会创建大量小而简单的模拟对象。

**如果本文对您有很大的帮助，还请点赞关注一下。**