Java的隐藏特性

阅读之后，我想知道Java的一些隐藏特性是什么？

语言级别assert关键字。

我认为Java的另一个“被忽视”的特性是JVM本身。它可能是可用的最好的VM。它支持许多有趣和有用的语言（Jython、JRuby、Scala、Groovy）。所有这些语言都可以轻松无缝地进行协作

如果您设计了一种新的语言（如scala案例），您立即拥有了所有现有的库，因此您的语言从一开始就是“有用的”

所有这些语言都使用热点优化。虚拟机具有良好的监视和调试能力

几个月前，当我第一次发现它时，我感到惊讶，以前从未听说过它

通常情况下，存储每个线程状态的方法并不广为人知

---

由于JDK 1.5 Java除了锁之外，还拥有非常好的实现和健壮的并发工具，它们存在于其中，一个特别有趣的例子是包含线程安全原语的子包，这些原语实现了操作，并且可以映射到这些操作的实际本机硬件支持版本。

自JDK 1.5以来一直存在的协变返回类型如何？它的宣传相当差，因为它是一个非固定的添加，但据我所知，它对于泛型的工作是绝对必要的

本质上，编译器现在允许子类将重写方法的返回类型缩小为原始方法返回类型的子类。所以这是允许的：

class Souper {
    Collection<String> values() {
        ...
    }
}

class ThreadSafeSortedSub extends Souper {
    @Override
    ConcurrentSkipListSet<String> values() {
        ...
    }
}

class Souper{
集合值（）{
...
}
}
类ThreadSafeSortedSub扩展了Souper{
@凌驾
ConcurrentSkipListSet值（）{
...
}
}

---

您可以调用子类的

values

方法，获得一个排序的

String

s线程安全

Set

，而不必向下转换到

ConcurrentSkipListSet

，对于我采访的大多数人来说，Java开发人员的职位标签块是非常令人惊讶的。以下是一个例子：

// code goes here

getmeout:{
    for (int i = 0; i < N; ++i) {
        for (int j = i; j < N; ++j) {
            for (int k = j; k < N; ++k) {
                //do something here
                break getmeout;
            }
        }
    }
}

//代码在这里
getmeout：{
对于（int i=0；i

---

谁说java中的

goto

只是一个关键词

（在1.3中添加）允许您在运行时定义符合接口的新类型。它的使用次数惊人。

类型参数变化中的联合：

public class Baz<T extends Foo & Bar> {}

公共类Baz{}

例如，如果要获取既可比较又是集合的参数：

public static <A, B extends Collection<A> & Comparable<B>>
boolean foo(B b1, B b2, A a) {
   return (b1.compareTo(b2) == 0) || b1.contains(a) || b2.contains(a);
}

公共静态
布尔foo（b1，b2，aa）{
返回值（b1.compareTo（b2）==0）| | b1.contains（a）| | b2.contains（a）；
}

---

如果两个给定集合相等或其中任何一个包含给定元素，则此人为方法返回true，否则返回false。需要注意的是，您可以对参数b1和b2调用Comparable和Collection的方法。

前几天我对实例初始值设定项感到惊讶。我删除了一些代码折叠方法，最终创建了多个实例初始值设定项：

public class App {
    public App(String name) { System.out.println(name + "'s constructor called"); }

    static { System.out.println("static initializer called"); }

    { System.out.println("instance initializer called"); }

    static { System.out.println("static initializer2 called"); }

    { System.out.println("instance initializer2 called"); }

    public static void main( String[] args ) {
        new App("one");
        new App("two");
  }
}

执行

main

方法将显示：

static initializer called
static initializer2 called
instance initializer called
instance initializer2 called
one's constructor called
instance initializer called
instance initializer2 called
two's constructor called

我想如果您有多个构造函数并且需要公共代码，这些将非常有用

它们还为初始化类提供语法糖：

List<Integer> numbers = new ArrayList<Integer>(){{ add(1); add(2); }};

Map<String,String> codes = new HashMap<String,String>(){{ 
  put("1","one"); 
  put("2","two");
}};

List number=new ArrayList（）{{add（1）；add（2）；}；
映射代码=新的HashMap（）{
付诸表决（“1”、“1”）；
付诸表决（“2”、“2”）；
}};

允许在枚举中使用方法和构造函数让我大吃一惊。例如：

enum Cats {
  FELIX(2), SHEEBA(3), RUFUS(7);

  private int mAge;
  Cats(int age) {
    mAge = age;
  }
  public int getAge() {
    return mAge;
   }
}

您甚至可以有一个“常量特定的类主体”，它允许特定的枚举值重写方法

---

更多文档。

实际上不是Java语言的一部分，但是Sun的JDK附带的javap反汇编程序并不广为人知或广泛使用。

JDK 1.6_07+包含一个名为VisualVM（bin/jvisualvm.exe）的应用程序，它是许多工具之上的一个很好的GUI。它似乎比JConsole更全面。

泛型方法的类型参数可以这样显式指定：

Collections.<String,Integer>emptyMap()

Collections.emptyMap（）

java.util.array中的方法允许varargs、泛型方法和自动装箱的良好组合：

List<Integer> ints = Arrays.asList(1,2,3);

List ints=Arrays.asList（1,2,3）；

在finally块中传输控制权会丢弃任何异常。以下代码不会引发RuntimeException——它已丢失

public static void doSomething() {
    try {
      //Normally you would have code that doesn't explicitly appear 
      //to throw exceptions so it would be harder to see the problem.
      throw new RuntimeException();
    } finally {
      return;
    }
  }

---

从

开始，在1.5中为每个循环构造添加了。我不是一个真正的功能，而是我最近在某个网页上发现的一个有趣的技巧：

class Example
{
  public static void main(String[] args)
  {
    System.out.println("Hello World!");
    http://Phi.Lho.free.fr

    System.exit(0);
  }
}

是有效的Java程序（尽管它会生成警告）。

---

如果你不明白为什么，请看格雷戈里的答案！；-）好吧，这里的语法突出显示也给出了一个提示

我的最爱：将所有线程堆栈跟踪转储到标准输出

windows:java cmd/控制台窗口中的CTRL键中断

---

unix:

kill-3PID

使用此关键字从内部类访问包含类的字段/方法。在下面的示例中，我们希望使用匿名内部类中容器类的sortAscending字段。使用ContainerClass.this.sortAscending而不是this.sortAscending可以实现这一点

import java.util.Comparator;

public class ContainerClass {
boolean sortAscending;
public Comparator createComparator(final boolean sortAscending){
    Comparator comparator = new Comparator<Integer>() {

        public int compare(Integer o1, Integer o2) {
            if (sortAscending || ContainerClass.this.sortAscending) {
                return o1 - o2;
            } else {
                return o2 - o1;
            }
        }

    };
    return comparator;
}
}

import java.util.Comparator；
公共类集装箱类{
布尔排序；
公共比较器createComparator（最终布尔排序）{
比较器比较器=新比较器（）{
公共整数比较（整数o1，整数o2）{
if（排序| | container class.this.sortAscending）{
返回o1-o2；
}否则{
返回o2-o1；
}
}
};
返回比较器；
}
}

这并不完全是“隐藏功能”，也不是很有用，但可能是极端的

// Returns the sum of the elements of a
int sum(int[] a) {
  int result = 0;
  for (int i : a)
    result += i;
  return result;
}

class Example
{
  public static void main(String[] args)
  {
    System.out.println("Hello World!");
    http://Phi.Lho.free.fr

    System.exit(0);
  }
}

import java.util.Comparator;

public class ContainerClass {
boolean sortAscending;
public Comparator createComparator(final boolean sortAscending){
    Comparator comparator = new Comparator<Integer>() {

        public int compare(Integer o1, Integer o2) {
            if (sortAscending || ContainerClass.this.sortAscending) {
                return o1 - o2;
            } else {
                return o2 - o1;
            }
        }

    };
    return comparator;
}
}

public class UnsafeUtil {

    public static Unsafe unsafe;
    private static long fieldOffset;
    private static UnsafeUtil instance = new UnsafeUtil();

    private Object obj;

    static {
        try {
            Field f = Unsafe.class.getDeclaredField("theUnsafe");
            f.setAccessible(true);

            unsafe = (Unsafe)f.get(null);
            fieldOffset = unsafe.objectFieldOffset(UnsafeUtil.class.getDeclaredField("obj"));
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    };
}

public Object getElementAt(int index) {
    final Object element;
    if (index == 0) {
         element = "Result 1";
    } else if (index == 1) {
         element = "Result 2";
    } else {
         element = "Result 3";
    }
    return element;
}

Map map = new HashMap() {{
    put("a key", "a value");
    put("another key", "another value");
}};

JFrame frame = new JFrame();

JPanel panel = new JPanel(); 

panel.add( new JLabel("Hey there"){{ 
    setBackground(Color.black);
    setForeground( Color.white);
}});

panel.add( new JButton("Ok"){{
    addActionListener( new ActionListener(){
        public void actionPerformed( ActionEvent ae ){
            System.out.println("Button pushed");
        }
     });
 }});


 frame.add( panel );

    JFrame frame = new JFrame(){{
         add( new JPanel(){{
               add( new JLabel("Hey there"){{ 
                    setBackground(Color.black);
                    setForeground( Color.white);
                }});

                add( new JButton("Ok"){{
                    addActionListener( new ActionListener(){
                        public void actionPerformed( ActionEvent ae ){
                            System.out.println("Button pushed");
                        }
                     });
                 }});
        }});
    }};

public void foo(String... bars) {
   for (String bar: bars)
      System.out.println(bar);
}

if( null != aObject && aObject instanceof String )
{
    ...
}

if( aObject instanceof String )
{
    ...
}

public interface Room {
   public Room north();
   public Room south();
   public Room east();
   public Room west();
}

public enum Rooms implements Room {
   FIRST {
      public Room north() {
         return SECOND;
      }
   },
   SECOND {
      public Room south() {
         return FIRST;
      }
   }

   public Room north() { return null; }
   public Room south() { return null; }
   public Room east() { return null; }
   public Room west() { return null; }
}

public enum AffinityStrategies implements AffinityStrategy {

new Object() {
  void foo(String s) {
    System.out.println(s);
  }
}.foo("Hello");

java -classpath ./lib/* so.Main

java -classpath ./lib/log4j.jar:./lib/commons-codec.jar:./lib/commons-httpclient.jar:./lib/commons-collections.jar:./lib/myApp.jar so.Main