在处理框式基元时，如果需要比较相等性，则应调用框式基元的 equals() 方法，而非使用运算符 == 和 !=。Java 规范具有关于框式转换的如下说明：

"如果框式值 p 是一个整数文本（例如 -128 和 127 之间的整数），或是布尔文本 true 或 false，或者是 '\u0000' 和 '\u007f' 之间的字符文本，则使 a 和 b 作为 p 的任意两个框式转换值的结果。结果始终会是 a == b。"

这意味着，如果使用了框式基元（并非 Boolean 或 Byte），则仅会缓存或记住一个值区间。对于值的子集，使用 == 或 != 会返回正确的值，而对于此子集外的所有其他值，将返回对象地址的比较结果。

示例 1：以下示例对框式基元使用相等运算符。

  ...
  Integer mask0 = 100;
  Integer mask1 = 100;
  ...
  if (file0.readWriteAllPerms){
    mask0 = 777;
  }
  if (file1.readWriteAllPerms){
    mask1 = 777;
  }
  ...
  if (mask0 == mask1){
    //assume file0 and file1 have same permissions
    ...
  }
  ...

Example 1 中的代码会使用框式基元 Integer 尝试比较两个 int 值。如果 mask0 和 mask1 都等于 100，则 mask0 == mask1 将返回 true。但是，如果 mask0 和 mask1 都等于 777，则 mask0 == maske1 现在将返回 false，因为这些值不在这些框式基元的缓存值范围内。

如果与 NaN 进行比较，得出的计算结果将始终为 false（!= 运算符是个例外，因为 NaN 未经排序，所以始终会得出 true 结果）。

示例 1：以下示例尝试验证变量并非为 NaN。

  ...
  if (result == Double.NaN){
    //something went wrong
    throw new RuntimeException("Something went wrong, NaN found");
  }
  ...

这将尝试验证 result 并非 NaN，但是使用带有 NaN 的运算符 == 将始终得出 false 值，所以此检查将永远不会抛出异常。

如果构造函数调用了可覆盖的函数，则在该对象完全初始化之前，攻击者将可以访问 this 引用，进而导致出现漏洞。

示例 1：以下示例调用了可覆盖的方法。

  ...
  class User {
    private String username;
    private boolean valid;
    public User(String username, String password){
      this.username = username;
      this.valid = validateUser(username, password);
    }
    public boolean validateUser(String username, String password){
      //validate user is real and can authenticate
      ...
    }
    public final boolean isValid(){
      return valid;
    }
  }

由于函数 validateUser 和该类并非 final，这意味着它们是可以被覆盖的，对将覆盖此该函数的子类的变量执行初始化会允许避开 validateUser 功能。例如：

  ...
  class Attacker extends User{
    public Attacker(String username, String password){
      super(username, password);
    }
    public boolean validateUser(String username, String password){
      return true;
    }
  }
  ...
  class MainClass{
    public static void main(String[] args){
      User hacker = new Attacker("Evil", "Hacker");
      if (hacker.isValid()){
        System.out.println("Attack successful!");
      }else{
        System.out.println("Attack failed");
      }
    }
  }

Example 1 中的代码会输出“Attack successful!”，因为 Attacker 类会覆盖从超类 User 的构造函数调用的 validateUser() 函数，并且 Java 将首先在子类中查找从该构造函数调用的函数。

许多才智卓越的人都试图使用 double-checked locking 方法来提高性能，并为此付出了大量的时间，但是无一成功。

例 1：乍一看，下列代码似乎既能避免不必要的同步又能保证线程的安全性。

if (fitz == null) {
  synchronized (this) {
    if (fitz == null) {
      fitz = new Fitzer();
    }
  }
}
return fitz;

程序员希望保证仅分配一个 Fitzer() 对象，但又不希望每次调用该代码时都进行一次同步。这就是所谓的 double-checked locking 方法。

令人遗憾的是，它并不起作用，并且可以分配多个 Fitzer() 对象。有关更多详细信息，请参见 The "Double-Checked Locking is Broken" Declaration [1]。

攻击者可以故意复制类名称，使程序执行恶意代码。因此，类名称并非合适的类型标识符，且不应用作向给定对象授予信任的基础。

示例 1： 以下代码根据 inputReader 对象的类名称确认是否信任该对象的输入。如果攻击者能够提供一种执行恶意命令的 inputReader 实现方式，则此代码将无法区分该对象是善意的还是恶意的。

if (inputReader.getClass().getName().equals("com.example.TrustedClass")) {
   input = inputReader.getInput();
   ...
}

The Java Language Specification 中指出，finalize() 方法调用 super.finalize() 是一种非常好的做法 [1]。

例 1：以下方法没有调用 super.finalize()。

protected void finalize() {
  discardNative();
}

此字段被标注为 FortifyNonNegative，表示不允许使用负值。