在阅读了c#的隐藏特性之后，我想知道Java的隐藏特性有哪些?
当前回答
我认为java的另一个“被忽视”的特性是JVM本身。它可能是可用的最好的VM。它支持许多有趣和有用的语言(Jython, JRuby, Scala, Groovy)。所有这些语言都可以轻松无缝地合作。
如果你设计了一种新的语言(就像在scala的例子中)，你会立刻拥有所有现有的库，因此你的语言从一开始就是“有用的”。
所有这些语言都利用了HotSpot优化。VM可以很好地监控和调试。
其他回答
一个优化技巧，使您的代码更容易维护，更不容易受到并发性错误的影响。
public class Slow {
/** Loop counter; initialized to 0. */
private long i;
public static void main( String args[] ) {
Slow slow = new Slow();
slow.run();
}
private void run() {
while( i++ < 10000000000L )
;
}
}
$ time java慢 真正的0 m15.397s $ time java慢 真正的0 m20.012s $ time java慢 真正的0 m18.645s
平均:18.018秒
public class Fast {
/** Loop counter; initialized to 0. */
private long i;
public static void main( String args[] ) {
Fast fast = new Fast();
fast.run();
}
private void run() {
long i = getI();
while( i++ < 10000000000L )
;
setI( i );
}
private long setI( long i ) {
this.i = i;
}
private long getI() {
return this.i;
}
}
$ time java快速 真正的0 m12.003s $ time java快速 真正的0 m9.840s $ time java快速 真正的0 m9.686s
平均:10.509秒
引用类作用域变量比引用方法作用域变量需要更多的字节码。在关键循环之前添加方法调用几乎不会增加开销(而且编译器可能会内联调用)。
这种技术(总是使用访问器)的另一个优点是它消除了Slow类中的潜在错误。如果第二个线程要不断地将i的值重置为0(通过调用slow. xml)。setI(0)，例如)，Slow类永远不能结束它的循环。调用访问器并使用局部变量消除了这种可能性。
在Linux 2.6.27-14上使用J2SE 1.6.0_13进行测试。
交集类型允许您(有点)执行具有继承层次结构的枚举。您不能继承实现，但可以将其委托给助手类。
enum Foo1 implements Bar {}
enum Foo2 implements Bar {}
class HelperClass {
static <T extends Enum<T> & Bar> void fooBar(T the enum) {}
}
当您有许多实现某种模式的不同枚举时，这很有用。例如，许多具有父子关系的枚举对。
enum PrimaryColor {Red, Green, Blue;}
enum PastelColor {Pink, HotPink, Rockmelon, SkyBlue, BabyBlue;}
enum TransportMedium {Land, Sea, Air;}
enum Vehicle {Car, Truck, BigBoat, LittleBoat, JetFighter, HotAirBaloon;}
你可以编写泛型方法，说“好的，给定一个枚举值，它是其他一些枚举值的父枚举值，所有可能的子枚举的子类型中有多少百分比是这个特定的父值作为它们的父?”，并让它都是类型安全的，并且没有强制转换。(例如:“海洋”是所有可能的车辆的33%，“绿色”是所有可能的粉彩的20%)。
代码是这样的。这很糟糕，但有办法让它变得更好。特别要注意的是，“叶子”类本身非常整洁——泛型类的声明非常丑陋，但您只编写一次。一旦有了泛型类，使用它们就很容易了。
import java.util.EnumSet;
import javax.swing.JComponent;
public class zz extends JComponent {
public static void main(String[] args) {
System.out.println(PrimaryColor.Green + " " + ParentUtil.pctOf(PrimaryColor.Green) + "%");
System.out.println(TransportMedium.Air + " " + ParentUtil.pctOf(TransportMedium.Air) + "%");
}
}
class ParentUtil {
private ParentUtil(){}
static <P extends Enum<P> & Parent<P, C>, C extends Enum<C> & Child<P, C>> //
float pctOf(P parent) {
return (float) parent.getChildren().size() / //
(float) EnumSet.allOf(parent.getChildClass()).size() //
* 100f;
}
public static <P extends Enum<P> & Parent<P, C>, C extends Enum<C> & Child<P, C>> //
EnumSet<C> loadChildrenOf(P p) {
EnumSet<C> cc = EnumSet.noneOf(p.getChildClass());
for(C c: EnumSet.allOf(p.getChildClass())) {
if(c.getParent() == p) {
cc.add(c);
}
}
return cc;
}
}
interface Parent<P extends Enum<P> & Parent<P, C>, C extends Enum<C> & Child<P, C>> {
Class<C> getChildClass();
EnumSet<C> getChildren();
}
interface Child<P extends Enum<P> & Parent<P, C>, C extends Enum<C> & Child<P, C>> {
Class<P> getParentClass();
P getParent();
}
enum PrimaryColor implements Parent<PrimaryColor, PastelColor> {
Red, Green, Blue;
private EnumSet<PastelColor> children;
public Class<PastelColor> getChildClass() {
return PastelColor.class;
}
public EnumSet<PastelColor> getChildren() {
if(children == null) children=ParentUtil.loadChildrenOf(this);
return children;
}
}
enum PastelColor implements Child<PrimaryColor, PastelColor> {
Pink(PrimaryColor.Red), HotPink(PrimaryColor.Red), //
Rockmelon(PrimaryColor.Green), //
SkyBlue(PrimaryColor.Blue), BabyBlue(PrimaryColor.Blue);
final PrimaryColor parent;
private PastelColor(PrimaryColor parent) {
this.parent = parent;
}
public Class<PrimaryColor> getParentClass() {
return PrimaryColor.class;
}
public PrimaryColor getParent() {
return parent;
}
}
enum TransportMedium implements Parent<TransportMedium, Vehicle> {
Land, Sea, Air;
private EnumSet<Vehicle> children;
public Class<Vehicle> getChildClass() {
return Vehicle.class;
}
public EnumSet<Vehicle> getChildren() {
if(children == null) children=ParentUtil.loadChildrenOf(this);
return children;
}
}
enum Vehicle implements Child<TransportMedium, Vehicle> {
Car(TransportMedium.Land), Truck(TransportMedium.Land), //
BigBoat(TransportMedium.Sea), LittleBoat(TransportMedium.Sea), //
JetFighter(TransportMedium.Air), HotAirBaloon(TransportMedium.Air);
private final TransportMedium parent;
private Vehicle(TransportMedium parent) {
this.parent = parent;
}
public Class<TransportMedium> getParentClass() {
return TransportMedium.class;
}
public TransportMedium getParent() {
return parent;
}
}
这是我的清单。
我最喜欢的(也是最可怕的)隐藏特性是，您可以从没有声明抛出任何东西的方法中抛出检查异常。
import java.rmi.RemoteException;
class Thrower {
public static void spit(final Throwable exception) {
class EvilThrower<T extends Throwable> {
@SuppressWarnings("unchecked")
private void sneakyThrow(Throwable exception) throws T {
throw (T) exception;
}
}
new EvilThrower<RuntimeException>().sneakyThrow(exception);
}
}
public class ThrowerSample {
public static void main( String[] args ) {
Thrower.spit(new RemoteException("go unchecked!"));
}
}
此外，你可能想知道你可以抛出'null'…
public static void main(String[] args) {
throw null;
}
猜猜这打印了什么:
Long value = new Long(0);
System.out.println(value.equals(0));
猜猜这返回什么:
public int returnSomething() {
try {
throw new RuntimeException("foo!");
} finally {
return 0;
}
}
优秀的开发人员不应该对上述情况感到惊讶。
在Java中，你可以用以下几种有效的方式来声明数组:
String[] strings = new String[] { "foo", "bar" };
// the above is equivalent to the following:
String[] strings = { "foo", "bar" };
所以下面的Java代码是完全有效的:
public class Foo {
public void doSomething(String[] arg) {}
public void example() {
String[] strings = { "foo", "bar" };
doSomething(strings);
}
}
是否有任何有效的理由说明下面的代码不应该是有效的?
public class Foo {
public void doSomething(String[] arg) {}
public void example() {
doSomething({ "foo", "bar" });
}
}
我认为，上述语法可以有效地替代Java 5中引入的可变参数。并且，与之前允许的数组声明更加一致。
我认为java的另一个“被忽视”的特性是JVM本身。它可能是可用的最好的VM。它支持许多有趣和有用的语言(Jython, JRuby, Scala, Groovy)。所有这些语言都可以轻松无缝地合作。
如果你设计了一种新的语言(就像在scala的例子中)，你会立刻拥有所有现有的库，因此你的语言从一开始就是“有用的”。
所有这些语言都利用了HotSpot优化。VM可以很好地监控和调试。
Javadoc——在正确编写的情况下(不幸的是，一些开发人员并不总是这样)，它会为您提供一个清晰、连贯的描述，说明代码应该做什么，而不是它实际做什么。然后可以将其转换为一组不错的可浏览的HTML文档。如果你使用持续集成等方法，它可以定期生成，这样所有开发者都可以看到最新的更新。
推荐文章
- 在流中使用Java 8 foreach循环移动到下一项
- 访问限制:'Application'类型不是API(必需库rt.jar的限制)
- 用Java计算两个日期之间的天数
- 如何配置slf4j-simple
- 在Jar文件中运行类
- 带参数的可运行?
- 我如何得到一个字符串的前n个字符而不检查大小或出界?
- 我可以在Java中设置enum起始值吗?
- Java中的回调函数
- c#和Java中的泛型有什么不同?和模板在c++ ?
- 在Java中，流相对于循环的优势是什么?
- Jersey在未找到InjectionManagerFactory时停止工作
- 在Java流是peek真的只是调试?
- Recyclerview不调用onCreateViewHolder
- 将JSON字符串转换为HashMap
