blocks|key|1467687|text|Boolean+a+=+true;
Boolean+b+=+false;
Boolean+c+=+null;|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1467688|我会用这句话。这是最直接的。|unstyled|1467689|另一种方法是使用枚举。也许这更好更快，因为不需要装箱：|1467690|public+enum+ThreeState+{
++++TRUE,
++++FALSE,
++++TRALSE
};|1467691|第一种方法的优点是你的类的用户不需要关心你的三态布尔值。他们仍然可以通过true和false。如果你不喜欢这个null，因为它在这里很少说明它的意义，你仍然可以在你的类中创建一个public+static+final+Boolean+tralse+=+null;。|offset|length|style|CODE|1467692|entityMap^0|0|0|0|0|10|4|15|5|1J|4|2H|16|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|T|8|@]|9|@]|A|$]]|$1|G|3|H|5|F|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|V|8|@]|9|@]|A|$B|C]]|$1|K|3|L|5|F|7|W|8|@$M|X|N|Y|O|P]|$M|Z|N|10|O|P]|$M|11|N|12|O|P]|$M|13|N|14|O|P]]|9|@]|A|$]]|$1|Q|3|-4|5|F|7|15|8|@]|9|@]|A|$]]]|R|$]]

<pre><code>Boolean a = true;
Boolean b = false;
Boolean c = null;
</code></pre>

I would use that. It's the most straight-forward.

Another way is to use an enumeration. Maybe that's even better and faster, since no boxing is required:

<pre><code>public enum ThreeState {
 TRUE,
 FALSE,
 TRALSE
};
</code></pre>

There is the advantage of the first that users of your class doesn't need to care about your three-state boolean. They can still pass <code>true</code> and <code>false</code>. If you don't like the <code>null</code>, since it's telling rather little about its meaning here, you can still make a <code>public static final Boolean tralse = null;</code> in your class.

blocks|key|1683049|text|虽然不是特定于Java语言的，但我自己在这个场景中的首选是定义一个ThreeState类或枚举并使用它--正如您所提到的，True、False和Undefined+(或者默认值，或者Unset，正如您的领域特定的术语所规定的那样)。与用null表示未设置/未定义相比，它感觉更好，更自然，更自我记录。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1683050|entityMap^0|3A|4|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

Although not Java-specific, my own preference in this scenario is to define a ThreeState class or enumeration and use it -- just as you mentioned, a True, a False and an Undefined (or Default, or Unset, as your domain-specific terminology dictates). It feels better, more natural and more self-documenting than representing unset/undefined with <code>null</code>.

blocks|key|1467879|text|@Nullable+Boolean得到了我的支持。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1467880|entityMap^0|A|7|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|K|8|@]|D|@]|E|$]]]|G|$]]

The @Nullable <code>Boolean</code> gets my vote.

blocks|key|1468088|text|我会简单地使用一个int+(整数)，值为0,1,2，并在程序中使用句柄。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1468089|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

I would simply use a int (integer) with values 0,1,2 and handle within program.

blocks|key|1683193|text|那得看情况。这里您提到，如果它必须从父值继承它的值，那么它将被取消设置。您是否有某种数据层次结构？如下所示：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1683194|Parent+a+{+
++++boolean+val+=+true;
++++boolean+val2+=+false;+
}
Child+b+{
++++boolean+val+=+false;
++++//here+val2+should+be+unset!
}|code-block|syntax|javascript|1683195|在这种情况下，如果可能的话，我会简单地说不要在子代中包含val2，并且让您的查找逻辑在找不到变量时搜索父代的值。|1683196|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

It depends. Here you mention it would be unset if it has to inherit its value from a parent value. Do you have some kind of data hierarchy? Something like this:

<pre><code>Parent a { 
 boolean val = true;
 boolean val2 = false; 
}
Child b {
 boolean val = false;
 //here val2 should be unset!
}
</code></pre>

In this case, if it's possible, I'd say simply don't include val2 in the Child, and have your lookup logic be such that if it doesn't find the variable, it searches the parents for the value.

blocks|key|1468129|text|除了@voho，Optional还很好地处理了lambda，使其结构更简洁：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1468130|public+class+Node+{
++private+Node+parent;
++private+Optional<Boolean>+something+=+Optional.empty();

++public+boolean+isSomething()+{
++++return+something.orElseGet(()+->+{
++++++if+(parent+!=+null)
++++++++return+parent.isSomething();
++++++return+false;
++++});
++}

++public+void+setSomething(boolean+v)+{
++++this.something+=+Optional.of(v);
++}
}|code-block|syntax|javascript|1468131|然而，它仍然没有明显比布尔型和null检查好很多：|1468132|public+class+Node+{
++private+Node+parent;
++private+Boolean+something;

++public+boolean+isSomething()+{
++++if+(something+!=+null)
++++++return+something;
++++if+(parent+!=+null)
++++++return+parent.isSomething();
++++return+false;
++}

++public+void+setSomething(boolean+v)+{
++++this.something+=+v;
++}
}|1468133|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

To add to @voho, Optional also plays nicely with lambda, making a potentially cleaner structure:

<pre><code>public class Node {
 private Node parent;
 private Optional&lt;Boolean&gt; something = Optional.empty();

 public boolean isSomething() {
 return something.orElseGet(() -&gt; {
 if (parent != null)
 return parent.isSomething();
 return false;
 });
 }

 public void setSomething(boolean v) {
 this.something = Optional.of(v);
 }
}
</code></pre>

However, it's still not obviously that much better than Boolean and a null check:

<pre><code>public class Node {
 private Node parent;
 private Boolean something;

 public boolean isSomething() {
 if (something != null)
 return something;
 if (parent != null)
 return parent.isSomething();
 return false;
 }

 public void setSomething(boolean v) {
 this.something = v;
 }
}
</code></pre>

blocks|key|1468050|text|在父类中，将布尔值初始化为null，并在子类中构建一个方法，以检查是否已设置布尔值|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1468051|在父类中|1468052|private+Boolean+a+=+null;

public+void+setA(Boolean+a)+{
++++this.a+=+a;
}


public+Boolean+getA()+{
++++return+a;
}|code-block|syntax|javascript|1468053|在Child类中|1468054|if+(a+==+true)
{
dothis;
}
else+if+(a+==+false)
{
dothat;
}
else
{
assert+false+:+"Boolean+a+has+not+been+set";
}|1468055|确保断言处于打开状态。断言仅适用于开发周期和测试周期，而不适用于运行时异常。|1468056|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|R|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|T|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

In the Parent class initiate the boolean to null and in the child class build a method to check to see if the boolean has been set

in Parent class 

<pre><code>private Boolean a = null;

public void setA(Boolean a) {
 this.a = a;
}


public Boolean getA() {
 return a;
}
</code></pre>

In the Child Class 

<pre><code>if (a == true)
{
dothis;
}
else if (a == false)
{
dothat;
}
else
{
assert false : "Boolean a has not been set";
}
</code></pre>

Make sure that assertions are turned on. Assertions are only for the development cycle and test cycle, they are not for runtime exceptions.

blocks|key|1467831|text|java.lang.Boolean为你做了这件事。有静态常量Boolean.TRUE，Boolean.False。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1467832|私有布尔myBoolean；|1467833|Boolean.TRUE将通过等价测试，但不同于"true“(自动装箱为TRUE)，这应该是您所希望的。|1467834|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|H|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|I|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|J|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|G|$]]

java.lang.Boolean does this for you. There are static constants Boolean.TRUE, Boolean.False. 

private Boolean myBoolean;

should be all you need.Note that Boolean.TRUE will pass an equivalence test but is distinct from "true" (which gets autoboxed to TRUE).

If you have a situation where you need to know where a boolean value wasn't set (for example if that unset value should inherit from a parent value) the Java boolean primitive (and the equivalent in other languages) is clearly not adequate.

What's the best practice to achieve this? Define a new simple class that is capable of expressing all three states or use the Java Boolean class and use null to indicate the unset state?

Best way to define true, false, unset state

Java

如果您需要知道在何处没有设置布尔值(例如，如果未设置值应该从父值继承)，Java布尔原语(以及其他语言中的等价物)显然是不够的。实现这一目标的最佳实践是什么？定义一个能够表达所有三种状态的新的简单类，或者使用Java Boolean类并使用null来指示未设置的状态？

问定义true、false、unset状态的最佳方法
EN

回答 8

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问定义true、false、unset状态的最佳方法EN

回答 8

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问定义true、false、unset状态的最佳方法
EN