最终，彻底解决这个问题的唯一方法是使用不同的编程语言：

在Objective-C中，你可以在nil上调用一个方法，而绝对不会发生任何事情。这使大多数空检查变得不必要，但会使错误更难诊断。在Nice这一Java派生语言中，所有类型都有两个版本：可能为空的版本和非空的版本。只能对非空类型调用方法。通过显式检查null，可以将可能为null的类型转换为非null类型。这使得更容易知道哪些地方需要空检查，哪些地方不需要空检查。

在Java8中，如果局部变量/字段/方法参数/方法返回类型从未赋值为null（并且不检查null），则可以使用类型T；如果可以为null，则可以键入Optional＜T＞。然后使用方法map处理T->，使用方法flatMap处理T->可选<R>：

class SomeService {
    @Inject
    private CompanyDao companyDao;

    // return Optional<String>
    public Optional<String> selectCeoCityByCompanyId0(int companyId) {
        return companyDao.selectById(companyId)
                .map(Company::getCeo)
                .flatMap(Person::getHomeAddress)
                .flatMap(Address::getCity);
    }

    // return String + default value
    public String selectCeoCityByCompanyId1(int companyId) {
        return companyDao.selectById(companyId)
                .map(Company::getCeo)
                .flatMap(Person::getHomeAddress)
                .flatMap(Address::getCity)
                .orElse("UNKNOWN");
    }

    // return String + exception
    public String selectCeoCityByCompanyId2(int companyId) throws NoSuchElementException {
        return companyDao.selectById(companyId)
                .map(Company::getCeo)
                .flatMap(Person::getHomeAddress)
                .flatMap(Address::getCity)
                .orElseThrow(NoSuchElementException::new);
    }
}

interface CompanyDao {
    // real situation: no company for such id -> use Optional<Company> 
    Optional<Company> selectById(int id);
}

class Company {
    // company always has ceo -> use Person 
    Person ceo;
    public Person getCeo() {return ceo;}
}

class Person {
    // person always has name -> use String
    String firstName;
    // person can be without address -> use Optional<Address>
    Optional<Address> homeAddress = Optional.empty();

    public String getFirstName() {return firstName;}   
    public Optional<Address> getHomeAddress() {return homeAddress;}
}

class Address {
    //  address always contains country -> use String
    String country;
    //  city field is optional -> use Optional<String>
    Optional<String> city = Optional.empty();

    String getCountry() {return country;}    
    Optional<String> getCity() {return city;}
}

Java8带来了新的Java.util.Optional类，它可以解决一些问题。至少可以说，它提高了代码的可读性，并且在公共API的情况下，使API的契约对客户端开发人员更加清晰。

它们是这样工作的：

给定类型（Fruit）的可选对象被创建为方法的返回类型。它可以是空的或包含Fruit对象：

public static Optional<Fruit> find(String name, List<Fruit> fruits) {
   for (Fruit fruit : fruits) {
      if (fruit.getName().equals(name)) {
         return Optional.of(fruit);
      }
   }
   return Optional.empty();
}

现在看看这段代码，我们在其中搜索给定Fruit实例的Fruit（水果）列表：

Optional<Fruit> found = find("lemon", fruits);
if (found.isPresent()) {
   Fruit fruit = found.get();
   String name = fruit.getName();
}

您可以使用map（）运算符对可选对象执行计算，或从中提取值。orElse（）允许您为缺少的值提供回退。

String nameOrNull = find("lemon", fruits)
    .map(f -> f.getName())
    .orElse("empty-name");

当然，检查空/空值仍然是必要的，但至少开发人员意识到该值可能是空的，忘记检查的风险是有限的。

在从头开始使用Optional构建的API中，只要返回值可能为空，并且仅在不能为空时返回纯对象（惯例），客户端代码可能会放弃对简单对象返回值的空检查。。。

当然，Optional也可以用作方法参数，在某些情况下，可能比5或10个重载方法更好地指示可选参数。

可选提供了其他方便的方法，例如允许使用默认值的orElse，以及与lambda表达式一起使用的ifPresent。

我邀请您阅读这篇文章（我撰写这个答案的主要来源），其中很好地解释了NullPointerException（以及一般的空指针）问题以及Optional带来的（部分）解决方案：Java Optional Objects。

我高度无视建议在任何情况下使用空对象的答案。这种模式可能会破坏合同，将问题埋得越来越深，而不是解决问题，更不用说使用不当会产生另一堆需要未来维护的样板代码。

实际上，如果从方法返回的某个值可以为空，并且调用代码必须对此做出决定，那么应该有一个更早的调用来确保状态。

还请记住，如果不小心使用，空对象模式将占用内存。为此，NullObject的实例应该在所有者之间共享，而不是每个所有者的unigue实例。

此外，我不建议在类型是原始类型表示的情况下使用这种模式，比如数学实体，它们不是标量：向量、矩阵、复数和POD（普通旧数据）对象，它们是用来以Java内置类型的形式保存状态的。在后一种情况下，您将以任意结果调用getter方法。例如，NullPerson.getName（）方法应该返回什么？

为了避免荒谬的结果，值得考虑这样的案例。

可以在方法调用之前使用拦截器。这就是面向方面编程所关注的。

假设M1（对象测试）是一个方法，M2是一个在方法调用之前应用方面的方法，M2（对象测试2）。如果test2！=null则调用M1，否则执行另一件事。它适用于所有要应用方面的方法。如果要为实例字段和构造函数应用方面，可以使用AspectJ。对于方法方面，Spring也是最佳选择。

好的，我现在已经从技术上回答了一百万次，但我不得不这么说，因为这是一场与Java程序员的无休止的讨论。

很抱歉，我不同意以上所有内容。我们必须在Java中测试null的原因是，Java程序员一定不知道如何处理内存。

我这么说是因为我有很长的C++编程经验，而我们不这么做。换句话说，你不需要这样做。注意，在Java中，如果你命中了一个悬空指针，你会得到一个正常的异常；在C++中，此异常通常不会被捕获并终止程序。

不想这样做吗？然后遵循C/C++中的一些简单规则。

不要轻易实例化事物，认为每一个“新”都会给你带来很多麻烦，并遵循这些简单的规则。

一个类只能通过3种方式访问内存->

它可以“拥有”类成员，他们将遵循以下规则：所有“HAS”成员都是在构造函数中“新建”的。您将在析构函数或等效的close（）中关闭/取消分配同一类的Java函数，而不是其他类。

这意味着您需要记住（就像Java一样）谁是每个资源的所有者或父级，并尊重该所有权。对象只能由创建它的类删除。此外->

一些成员将被“使用”，但不拥有或“拥有”。这是另一个类中的“OWN”，并作为参数传递给构造函数。由于这些是由另一个类拥有的，我们永远不会删除或关闭它，只有父类才能删除或关闭。类中的方法还可以实例化本地对象供内部使用，这些对象永远不会传递到类的外部，或者它们应该是正常的“有”对象。

最后，要使所有这些工作正常进行，您需要有一个严格的设计，以层次结构形式使用类，并且不进行循环。

在这种设计下，遵循上述规则，层次结构设计中的子类不可能访问被破坏的指针，因为这意味着父类在子类之前被破坏，而层次结构非循环设计不允许这样做。

最后，还要记住，在启动系统时，应该从上到下构建层次结构，并从下到上销毁。任何地方都不会有空指针，或者有人违反了规则。