Скрытые возможности Java

Ключевое слово утверждать на уровне языка.

Мне очень нравится переписанный Threading API из Java 1.6. Звонки отличные. По сути, это потоки с возвращаемым значением.

статический импорт для «улучшения» языка, чтобы вы могли делать приятные буквальные вещи безопасными для типов способами:

List<String> ls = List("a", "b", "c");

(также можно делать с картами, массивами, наборами).

http://gleichmann.wordpress.com/2008/01/13/building-your-own-literals-in-java-lists-and-arrays/

Продолжая:

List<Map<String, String>> data = List(Map( o("name", "michael"), o("sex", "male")));

Я думаю, что еще одна «недооцененная» особенность java - это сама JVM. Вероятно, это лучшая доступная виртуальная машина. И он поддерживает множество интересных и полезных языков (Jython, JRuby, Scala, Groovy). Все эти языки могут легко и без проблем взаимодействовать друг с другом.

Если вы разрабатываете новый язык (как в случае со scala), у вас сразу становятся доступными все существующие библиотеки, и поэтому ваш язык «полезен» с самого начала.

Все эти языки используют оптимизацию HotSpot. ВМ очень хорошо отслеживается и поддается отладке.

Инициализация двойной скобки застал меня врасплох несколько месяцев назад, когда я впервые обнаружил его, никогда раньше о нем не слышал.

Тема обычно не так широко известны как способ хранения состояния каждого потока.

Поскольку JDK 1.5 Java имеет чрезвычайно хорошо реализованные и надежные инструменты параллелизма, помимо блокировок, они живут в java.util.concurrent, и особенно интересным примером является подпакет java.util.concurrent.atomic, который содержит потокобезопасные примитивы, которые реализуют операцию сравнивать и менять местами и могут отображаться на реальное собственное оборудование, поддерживаемое версии этих операций.

На самом деле это не особенность, но меня заставляет посмеяться, что goto - это зарезервированное слово, которое ничего не делает, кроме как побуждает javac ткнуть вас в глаз. Напомню, что вы сейчас находитесь в OO-land.

Как новичок, я очень ценю программное обеспечение для мониторинга JConsole в Java 6, оно уже решило для меня несколько проблем, и я продолжаю находить для него новые применения.

По-видимому, JConsole уже была в Java 5, но я считаю, что сейчас она улучшена и, по крайней мере, на данный момент работает намного стабильнее.

JConsole в Java 5: JConsole в Java 5

JConsole в Java 6: JConsole в Java 6

И пока вы это делаете, внимательно посмотрите на другие инструменты из этой серии: Инструменты устранения неполадок Java 6

Это не совсем скрыто, но отражение невероятно полезно и мощно. Замечательно использовать простой Class.forName ("..."). NewInstance (), где тип класса настраивается. Такую фабричную реализацию легко написать.

Как насчет ковариантные возвращаемые типы, которые используются с JDK 1.5? Это довольно плохо освещается, так как это несексуальное дополнение, но, как я понимаю, абсолютно необходимо для работы дженериков.

По сути, компилятор теперь позволяет подклассу сузить тип возвращаемого значения переопределенного метода до подкласса возвращаемого типа исходного метода. Итак, это разрешено:

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

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

Вы можете вызвать метод подкласса values и получить отсортированный потокобезопасный Set из Strings без необходимости опускать для ConcurrentSkipListSet.

Функторы - это круто. Они довольно близки к указателю на функцию, что, как обычно говорят, невозможно в Java.

Функторы в Java

Для большинства людей, которых я беру интервью у 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;
            }
        }
    }
}

Кто сказал, что goto в java - это просто ключевое слово? :)

Я знал, что Java 6 включает поддержку сценариев, но недавно обнаружил рукопись, который может интерпретировать и запускать JavaScript (и, как предполагается, другие языки сценариев, такие как Groovy) в интерактивном режиме, вроде как оболочка Python или irb в Ruby

Динамические прокси (добавлен в 1.3) позволяет вам определять новый тип во время выполнения, который соответствует интерфейсу. Пригодится на удивление много раз.

Совместное объединение в вариации параметра типа:

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

Например, если вы хотите взять параметр, который является как Comparable, так и Collection:

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);
}

Этот надуманный метод возвращает истину, если две заданные коллекции равны или если одна из них содержит данный элемент, в противном случае - ложь. Следует отметить, что вы можете вызывать методы Comparable и Collection для аргументов b1 и b2.

Я знаю, что это было добавлено в версии 1.5, но новый тип перечисления - отличная функция. Отсутствие необходимости использовать старый «шаблон int enum» очень помогло моему коду. Проверьте JLS 8.9 за сладкую подливку к картофелю!

final для переменных экземпляра:

Действительно полезно для многопоточного кода и значительно упрощает споры о состоянии и правильности экземпляра. Я нечасто видел это в контексте отрасли и часто не думал о Java-классах.

static {something;}:

Используется для инициализации статических членов (также я предпочитаю для этого статический метод (потому что у него есть имя). Не думал.

На днях я был удивлен инициализаторами экземпляров. Я удалял некоторые методы с свернутым кодом и в итоге создал несколько инициализаторов экземпляров:

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");
}};

Новый Эффективная Java Джошуа Блоха - хороший ресурс.

• Местные классы.
• Создание экземпляров внутренних классов Java извне содержащего класса.

Разрешение методов и конструкторов в перечислениях меня удивило. Например:

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

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

У вас даже может быть «постоянное тело конкретного класса», которое позволяет определенному значению перечисления переопределять методы.

Дополнительная документация здесь.

На самом деле не является частью языка Java, но дизассемблер javap, который поставляется с Sun JDK, широко не известен и не используется.

Самосвязанные дженерики:

class SelfBounded<T extends SelfBounded<T>> {
}

http://www.artima.com/weblogs/viewpost.jsp?thread=136394

JDK 1.6_07 + содержит приложение под названием VisualVM (bin / jvisualvm.exe), которое представляет собой красивый графический интерфейс поверх многих инструментов. Это кажется более всеобъемлющим, чем JConsole.

Параметры типа для универсальных методов можно указать явно следующим образом:

Collections.<String,Integer>emptyMap()

Им потребовалось достаточно времени, чтобы добавить поддержку для этого,

Системный лоток

Метод asList в java.util.Arrays позволяет хорошо комбинировать varargs, общие методы и автобоксинг:

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

Некоторые трюки с потоком управления, finally вокруг оператора return:

int getCount() { 
  try { return 1; }
  finally { System.out.println("Bye!"); }
}

Правила для определенное назначение будут проверять, что последняя переменная всегда назначается с помощью простого анализа потока управления:

final int foo;
if (...)
  foo = 1;
else
  throw new Exception();
foo+1;

JVisualVM из каталога bin в дистрибутиве JDK. Мониторинг и даже профилирование любого java-приложения, даже того, которое вы не запускали с какими-либо специальными параметрами. Только в последних версиях Java 6SE JDK.

Передача управления в блоке 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;
    }
  }

От http://jamesjava.blogspot.com/2006/03/dont-return-in-finally-clause.html

Добавление конструкции цикла for-each в версии 1.5. я

// For each Object, instantiated as foo, in myCollection
for(Object foo: myCollection) {
  System.out.println(foo.toString());
}

И может использоваться во вложенных экземплярах:

for (Suit suit : suits)
  for (Rank rank : ranks)
    sortedDeck.add(new Card(suit, rank));

Конструкция for-each также применима к массивам, где она скрывает индексную переменную, а не итератор. Следующий метод возвращает сумму значений в массиве int:

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

Ссылка на документацию Sun

«const» - это ключевое слово, но вы не можете его использовать.

int const = 1;   // "not a statement"
const int i = 1; // "illegal start of expression"

Я предполагаю, что авторы компилятора думали, что он может быть использован в будущем, и им лучше оставить его зарезервированным.

Не совсем особенность, но забавный трюк, который я недавно обнаружил на какой-то веб-странице:

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

    System.exit(0);
  }
}

- допустимая программа на Java (хотя и выдает предупреждение). Если вы не понимаете почему, посмотрите ответ Грегори! ;-) Подсветка синтаксиса здесь тоже дает подсказку!

Мой любимый вариант: вывести все трассировки стека потоков в стандартный формат.

windows: CTRL-Break в окне java cmd / консоли

unix: kill -3 PID

Полномочия, которые вы можете получить над сборщиком мусора и то, как он управляет сборкой объектов, очень эффективны, особенно для долго работающих и чувствительных ко времени приложений. Он начинается со слабых, мягких и фантомных ссылок в пакете java.lang.ref. Взгляните на них, особенно для создания кешей (уже есть java.util.WeakHashMap). Теперь углубитесь в ReferenceQueue, и вы получите еще больший контроль. Наконец, возьмите документацию по самому сборщику мусора, и вы сможете контролировать, как часто он запускается, размеры различных областей сбора и типы используемых алгоритмов (для Java 5 см. http://java.sun.com/docs/hotspot/gc5.0/gc_tuning_5.html).

Использование ключевого слова это для доступа к полям / методам содержащего класса из внутреннего класса. В приведенном ниже довольно надуманном примере мы хотим использовать поле 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;
}
}

Это не совсем «скрытые функции» и не очень полезные, но в некоторых случаях могут быть чрезвычайно интересными:
Класс sun.misc.Unsafe - позволит вам реализовать прямое управление памятью на Java (вы даже можете написать с ним самомодифицирующийся код Java, если будете много стараться):

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 class Example
{
    public static void main(String[] Args)
    {
         int a = 5;
         Integer b = a; // Box!
         System.out.println("A : " + a);
         System.out.println("B : " + b);
    }
}

Как насчет файлов свойств в выбранной вами кодировке? Раньше при загрузке свойств вы предоставляли InputStream, а метод load() декодировал его как ISO-8859-1. Вы мог на самом деле храните файл в какой-то другой кодировке, но вам пришлось использовать такой отвратительный хак после загрузки, чтобы правильно декодировать данные:

String realProp = new String(prop.getBytes("ISO-8859-1"), "UTF-8");

Но, начиная с JDK 1.6, существует метод load(), который принимает Reader вместо InputStream, что означает, что вы можете использовать правильную кодировку с самого начала (есть также метод store(), который принимает Writer). Мне это кажется большим делом, но, похоже, он был прятан в JDK без всяких помпезностей. Я наткнулся на это только несколько недель назад, и быстрый поиск в Google обнаружил лишь одно случайное упоминание о нем.

Если вы много занимаетесь разработкой JavaBean и работаете с поддержкой изменения свойств, вы обычно заканчиваете писать много сеттеров следующим образом:

public void setFoo(Foo aFoo){
  Foo old = this.foo;
  this.foo = aFoo;
  changeSupport.firePropertyChange("foo", old, aFoo);
}

Недавно я наткнулся на блог, в котором предлагалось более краткое описание этого, что значительно упрощает написание кода:

public void setFoo(Foo aFoo){
  changeSupport.firePropertyChange("foo", this.foo, this.foo = aFoo);
}

Это фактически упростило ситуацию до такой степени, что я смог настроить шаблон установщика в Eclipse, чтобы метод создавался автоматически.

Фабрика строковых параметризованных классов.

Class.forName( className ).newInstance();

Загрузите ресурс (файл свойств, xml, xslt, изображение и т. д.) Из файла jar развертывания.

this.getClass().getClassLoader().getResourceAsStream( ... ) ;

Что меня действительно удивило, так это механизм настраиваемой сериализации.

Хотя это методы частный!!, они являются "таинственно", вызываемыми JVM во время сериализации объекта.

private void writeObject(ObjectOutputStream out) throws IOException;
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException;

Таким образом, вы можете создать свою собственную сериализацию, чтобы сделать ее более «любой» (безопасной, быстрой, редкой, простой и т. д.)

Это то, что действительно следует учитывать, если через узлы нужно передавать много информации. Механизм сериализации может быть изменен для отправки половины данных. Часто узкие места возникают не в платформе, но в количестве, отправленном по сети, вы можете сэкономить тысячи dll на оборудовании.

Вот статья. http://java.sun.com/developer/technicalArticles/Programming/serialization/

Вы можете объявить класс в методе:

public Foo foo(String in) {
    class FooFormat extends Format {
        public Object parse(String s, ParsePosition pp) { // parse stuff }
    }
    return (Foo) new FooFormat().parse(in);

}

API обработки аннотаций из Java 6 выглядит очень перспективным для генерации кода и проверки статического кода.

окончательную инициализацию можно отложить.

Он гарантирует, что даже при сложном потоке логики всегда будут установлены возвращаемые значения. Слишком легко пропустить регистр и случайно вернуть null. Это не делает невозможным возврат null, просто очевидно, что это сделано специально:

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;
}

Несколько лет назад, когда мне приходилось делать Java (1.4.x), я хотел метод eval (), а Suns javac был (был?) Написан на Java, поэтому нужно было просто связать tools.jar и использовать его с некоторым клеевым кодом вокруг Это.

Обработка Java делает изящный трюк с определением переменных, если вы не используете инициализатор по умолчанию.

{
   int x;

   if (whatever)
      x=1;

   if (x == 1)
      ...
}

Это приведет к ошибке во время компиляции, что у вас есть путь, в котором X не определен должным образом. Это помогло мне несколько раз, и я подумал об инициализации по умолчанию, например:

int x=0;
String s=null;

быть плохим шаблоном, поскольку он блокирует эту полезную проверку.

Тем не менее, иногда трудно обойтись - мне приходилось возвращаться и редактировать = null, когда это имело смысл по умолчанию, но я больше никогда не вставлял его на первом проходе.

Вы можете получить доступ к конечным локальным переменным и параметрам в блоках инициализации и методах локальных классов. Учти это:

    final String foo = "42";
    new Thread() {
        public void run() {
             dowhatever(foo);
        }
    }.start();

Немного похоже на закрытие, не так ли?

Значение:

new URL("http://www.yahoo.com").equals(new URL("http://209.191.93.52"))

это true.

(Из Java Puzzlers)

Несколько человек написали об инициализаторах экземпляров, вот вам хорошее применение:

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");
                        }
                     });
                 }});
        }});
    }};

Начиная с Java 1.5, Java теперь имеет гораздо более чистый синтаксис для написания функций переменной арности. Итак, вместо того, чтобы просто передавать массив, теперь вы можете сделать следующее

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

бары автоматически конвертируются в массив указанного типа. Не большая победа, но, тем не менее, победа.

Javadoc - при правильном написании (к сожалению, не всегда в случае с некоторыми разработчиками) он дает вам четкое, связное описание того, что должен делать код, в отличие от того, что он делает на самом деле. Затем его можно превратить в удобный для просмотра набор HTML-документации. Если вы используете непрерывную интеграцию и т. д., Ее можно создавать регулярно, чтобы все разработчики могли видеть последние обновления.

SwingWorker для простого управления обратными вызовами пользовательского интерфейса из фоновых потоков.

Экземпляры одного и того же класса могут иметь доступ к закрытым членам других экземпляров:

class Thing {
  private int x;

  public int addThings(Thing t2) {
    return this.x + t2.x;  // Can access t2's private value!
  }
}

По-видимому, с некоторыми отладочными сборками есть опция, которая выгружает собственный (JIT) ассемблерный код из HotSpot: http://weblogs.java.net/blog/kohsuke/archive/2008/03/deep_dive_into.html

К сожалению, я не смог найти сборку по ссылке в этом посте, если кто-нибудь сможет найти более точный URL-адрес, я бы с удовольствием поигрался с ней.

Я голосую за java.util.concurrent с его параллельными коллекциями и гибкими исполнителями, позволяющими, среди прочего, пулы потоков, запланированные задачи и скоординированные задачи. DelayQueue - мой личный фаворит, где элементы становятся доступными после определенной задержки.

java.util.Timer и TimerTask можно безопасно остановить.

Кроме того, не совсем скрыто, а в другом пакете от других классов, связанных с датой и временем. java.util.concurrent.TimeUnit полезен при преобразовании между наносекундами, микросекундами, миллисекундами и секундами.

Он читается намного лучше, чем обычные someValue * 1000 или someValue / 1000.

Ключевое слово strictfp. (Я никогда не видел, чтобы он использовался в реальном приложении :)

Вы можете получить класс для примитивных типов, используя следующую нотацию: int.class, float.class и т. д. Очень полезно при рефлексии.

Конечные массивы могут использоваться для "возврата" значений из анонимных внутренних классов (предупреждение, бесполезный пример ниже):

final boolean[] result = new boolean[1];
SwingUtilities.invokeAndWait(new Runnable() {
  public void run() { result[0] = true; }
});

Не видел, чтобы кто-нибудь упоминал instanceof, реализованный таким образом, что проверка на null не требуется.

Вместо:

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

просто используйте:

if ( aObject instanceof String )
{
    ...
}

мне понравилось

1. Taglet и doclet javadoc, которые позволяют нам настраивать вывод javadoc.
2. Инструменты JDK: jstat, jstack и т. д.

Подключаемый модуль Java следующего поколения, найденный в Java 1.6 Update 10 и более поздних версиях, имеет несколько очень полезных функций:

• Передайте параметр java_arguments, чтобы передать аргументы создаваемой JVM. Это позволяет вам контролировать объем памяти, предоставляемой апплету.
• Создавайте отдельные загрузчики классов или даже отдельные JVM для каждого апплета.
• Укажите версию JVM для использования.
• Устанавливайте частичные ядра Java в тех случаях, когда вам нужна только часть функциональных возможностей полных библиотек Java.
• Лучшая поддержка Vista.
• Поддержка (экспериментальная) перетаскивания апплета из браузера и его продолжения при переходе.

Здесь задокументировано много других вещей: http://jdk6.dev.java.net/plugin2/

Больше из этого выпуска здесь: http://jdk6.dev.java.net/6u10ea.html

Вы можете создать строку в стиле sprintf, используя String.format ().

String w = "world";
String s = String.format("Hello %s %d", w, 3);

Конечно, вы также можете использовать специальные спецификаторы для изменения вывода.

Подробнее здесь: http://java.sun.com/j2se/1.5.0/docs/api/java/util/Formatter.html#syntax

со статическим импортом вы можете делать такие классные вещи, как:

List<String> myList = list("foo", "bar");
Set<String> mySet = set("foo", "bar");
Map<String, String> myMap = map(v("foo", "2"), v("bar", "3"));

Мне нравится статический импорт методов.

Например, создайте следующий класс утилиты:

package package.name;

public class util {

     private static void doStuff1(){
        //the end
     }

     private static String doStuff2(){
        return "the end";
     }

}

Тогда используйте это так.

import static package.name.util.*;

public class main{

     public static void main(String[] args){
          doStuff1(); // wee no more typing util.doStuff1()
          System.out.print(doStuff2()); // or util.doStuff2()
     }

}

Статический импорт работает с любым классом, даже Math ...

import static java.lang.Math.*;
import static java.lang.System.out;
public class HelloWorld {
    public static void main(String[] args) {
        out.println("Hello World!");
        out.println("Considering a circle with a diameter of 5 cm, it has:");
        out.println("A circumference of " + (PI * 5) + "cm");
        out.println("And an area of " + (PI * pow(5,2)) + "sq. cm");
    }
}

List.subList возвращает представление исходного списка

Документированная, но малоизвестная функция списков. Это позволяет вам работать с частями списка с изменениями, отраженными в исходном списке.

Список подсписок (int fromIndex, int toIndex)

"This method eliminates the need for explicit range operations (of the sort that commonly exist for arrays). Any operation that expects a list can be used as a range operation by passing a subList view instead of a whole list. For example, the following idiom removes a range of elements from a list:

       list.subList(from, to).clear();

Similar idioms may be constructed for indexOf and lastIndexOf, and all of the algorithms in the Collections class can be applied to a subList."

Я лично обнаружил java.lang.Void очень поздно - улучшает читаемость кода в сочетании с дженериками, например Callable<Void>

Вы можете использовать перечисления для реализации интерфейса.

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 {

https://github.com/peter-lawrey/Java-Thread-Affinity/blob/master/src/main/java/vanilla/java/affinity/AffinityStrategies.java

Используя интерфейс, разработчики могут определять свои собственные стратегии. Использование enum означает, что я могу определить коллекцию (из пяти) встроенных.

Типы пересечений позволяют (своего рода) выполнять перечисления с иерархией наследования. Вы не можете наследовать реализацию, но можете делегировать ее вспомогательному классу.

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;
    }
}

Прочтите «Java-головоломки» Джошуа Блоха, и вы будете одновременно озарены и испуганы.

URL-адреса исходного кода. Например. вот некоторый законный исходный код Java:

http://google.com

(Да, это было в Java Puzzlers. Я засмеялся ...)

Люди иногда немного удивляются, когда понимают, что можно вызывать частные методы и получать доступ / изменять частные поля с помощью отражения ...

Рассмотрим следующий класс:

public class Foo {
    private int bar;

    public Foo() {
        setBar(17);
    }

    private void setBar(int bar) {
        this.bar=bar;
    }

    public int getBar() {
        return bar;
    }

    public String toString() {
        return "Foo[bar = "+bar+"]";
    }
}

Запуск этой программы ...

import java.lang.reflect.*;

public class AccessibleExample {
    public static void main(String[] args)
        throws NoSuchMethodException,IllegalAccessException, InvocationTargetException, NoSuchFieldException {
        Foo foo=new Foo();
        System.out.println(foo);

        Method method=Foo.class.getDeclaredMethod("setBar", int.class);
        method.setAccessible(true);
        method.invoke(foo, 42);

        System.out.println(foo);
        Field field=Foo.class.getDeclaredField("bar");
        field.setAccessible(true);
        field.set(foo, 23);
        System.out.println(foo);
    }
}

... даст следующий результат:

Foo[bar=17]
Foo[bar=42]
Foo[bar=23]

Частичная особенность, частично беспокойство: обработка строк в Java, чтобы он `` казался '' собственным типом (использование операторов на них, +, + =)

Уметь писать:

String s = "A";
s += " String"; // so s == "A String"

очень удобно, но это просто синтаксический сахар для (т.е. компилируется в):

String s = new String("A");
s = new StringBuffer(s).append(" String").toString();

например, создание экземпляра объекта и вызов 2 методов для простой конкатенации. Представьте себе, что вы создаете таким образом длинную строку внутри цикла !? И все методы StringBuffer объявляются синхронизированными. К счастью, в (я думаю) Java 5 они представили StringBuilder, который идентичен StringBuffer без синхронизации.

Цикл, такой как:

String s = "";
for (int i = 0 ; i < 1000 ; ++i)
  s += " " + i; // Really an Object instantiation & 3 method invocations!

можно (нужно) переписать в вашем коде как:

StringBuilder buf = new StringBuilder(); // Empty buffer
for (int i = 0 ; i < 1000 ; ++i)
  buf.append(' ').append(i); // Cut out the object instantiation & reduce to 2 method invocations
String s = buf.toString();

и будет работать примерно на 80% быстрее, чем исходный цикл! (до 180% в некоторых тестах, которые я проводил)

Пожалуй, самая удивительная скрытая функция - это класс sun.misc.Unsafe.

http://www.docjar.com/html/api/ClassLib/Common/sun/misc/Unsafe.java.html

Вы можете;

• Создайте объект без вызова конструктора.
• Выбрасывайте любое исключение, даже Exception, не беспокоясь о предложениях throw для методов. (Я знаю, что есть другой способ сделать это)
• Получить / установить произвольно доступные поля в объекте без использования отражения.
• выделить / освободить / скопировать / изменить размер блока памяти, который может быть длинным (64-битным) по размеру.
• Получите расположение полей в объекте или статических полей в классе.
• самостоятельно блокировать и разблокировать объектный замок. (например, синхронизировать без блока)
• определить класс из предоставленных байтовых кодов. Вместо того, чтобы определять, каким должен быть байт-код, загрузчик классов. (Вы также можете сделать это с помощью отражения)

BTW: неправильное использование этого класса убьет JVM. Я не знаю, какие JVM поддерживают этот класс, поэтому его нельзя переносить.

Вы можете определить анонимный подкласс и напрямую вызвать для него метод, даже если он не реализует интерфейсы.

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

Уловка оптимизации, которая упрощает обслуживание вашего кода и делает его менее уязвимым для ошибок параллелизма.

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 Slow
реальный 0m15.397s
$ time java Slow
реальный 0m20.012s
$ time java Slow
реальный 0m18.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 Fast
реальный 0m12.003s
$ time java Fast
реальный 0m9.840s
$ time java Fast
реальный 0m9.686s

Среднее: 10,509 с

Для ссылки на переменную области класса требуется больше байт-кодов, чем на переменную области действия метода. Добавление вызова метода перед критическим циклом добавляет небольшие накладные расходы (и в любом случае вызов может быть встроен компилятором).

Еще одно преимущество этого метода (всегда использующего аксессоры) состоит в том, что он устраняет потенциальную ошибку в классе Медленный. Если бы второй поток постоянно сбрасывал значение я в 0 (например, вызывая slow.setI( 0 )), класс Медленный никогда не смог бы завершить свой цикл. Вызов метода доступа и использование локальной переменной исключает эту возможность.

Протестировано с использованием J2SE 1.6.0_13 в Linux 2.6.27-14.

Методы доступа к свойствам Java Bean действительно должны начинаться с нет с «get» и «set».

Даже Джош Блох ошибается в Effective Java.

Я только что (заново) узнал сегодня, что $ - это допустимое имя метода или переменной в Java. В сочетании со статическим импортом он может сделать код немного более читаемым, в зависимости от вашего представления о читаемости:

http://garbagecollected.org/2008/04/06/dollarmaps/

Уже было упомянул, что последний массив может использоваться для передачи переменной из анонимных внутренних классов.

Другой, возможно, лучший и менее уродливый подход - использовать класс AtomicReference (или AtomicBoolean / AtomicInteger /…) из пакета java.util.concurrent.atomic.

Одним из преимуществ этого является то, что эти классы также предоставляют такие методы, как compareAndSet, которые могут быть полезны, если вы создаете несколько потоков, которые могут изменять одну и ту же переменную.

Еще один полезный родственный шаблон:

final AtomicBoolean dataMsgReceived = new AtomicBoolean(false);
final AtomicReference<Message> message = new AtomicReference<Message>();
withMessageHandler(new MessageHandler() {
    public void handleMessage(Message msg) {
         if (msg.isData()) {
             synchronized (dataMsgReceived) {
                 message.set(msg);
                 dataMsgReceived.set(true);
                 dataMsgReceived.notifyAll();
             }
         }
    }
}, new Interruptible() {
    public void run() throws InterruptedException {
        synchronized (dataMsgReceived) {
            while (!dataMsgReceived.get()) {
                dataMsgReceived.wait();
            }
        }
    }
});

В этом конкретном примере мы могли бы просто подождать, пока сообщение не станет ненулевым, однако null часто может быть допустимым значением, и тогда вам нужно использовать отдельный флаг, чтобы завершить ожидание.

waitMessageHandler(…), приведенный выше, является еще одним полезным шаблоном: он где-то устанавливает обработчик, затем запускает выполнение Прерывистый, которое может вызвать исключение, а затем удаляет обработчик в блоке finally, например:

private final AtomicReference<MessageHandler> messageHandler = new AtomicReference<MessageHandler>();
public void withMessageHandler(MessageHandler handler, Interruptible logic) throws InterruptedException {
    synchronized (messageHandler) {
        try {
            messageHandler.set(handler);
            logic.run();
        } finally {
            messageHandler.set(null);
        }
    }
}

Здесь я предполагаю, что метод handleMessage(…)messageHandler (если он не нулевой) вызывается другим потоком при получении сообщения. messageHandler не должен быть просто типа MessageHandler: таким образом вы будете синхронизироваться с изменяющейся переменной, что явно является ошибкой.

Конечно, это не обязательно должно быть InterruptedException, это может быть что-то вроде IOException или что-то еще, что имеет смысл в конкретном фрагменте кода.

Запятая и массив. Это допустимый синтаксис: String s [] = {
«123»,
«234» ,
};

Большинство людей не знают, что они могут клонировать массив.

int[] arr = {1, 2, 3};
int[] arr2 = arr.clone();

Используйте StringBuilder вместо StringBuffer, если вам не нужно синхронизированное управление, включенное в StringBuilder. Это повысит производительность вашего приложения.

Улучшения для Java 7 были бы даже лучше, чем любые скрытые функции Java:

• Алмазный синтаксис:Связь

Не используйте этот бесконечный синтаксис при создании экземпляра:

Map<String, List<String>> anagrams = new HashMap<String, List<String>>();

// Can now be replaced with this:

Map<String, List<String>> anagrams = new HashMap<>();

• Строки в переключателе:Связь

Используйте String в переключателе вместо old-C int:

String s = "something";
switch(s) {
 case "quux":
    processQuux(s);
    // fall-through

  case "foo":
  case "bar":
    processFooOrBar(s);
    break;

  case "baz":
     processBaz(s);
    // fall-through

  default:
    processDefault(s);
    break;
}

• Автоматическое управление ресурсамиСвязь

Этот старый код:

static void copy(String src, String dest) throws IOException {
    InputStream in = new FileInputStream(src);
    try {
        OutputStream out = new FileOutputStream(dest);
        try {
            byte[] buf = new byte[8 * 1024];
            int n;
            while ((n = in.read(buf)) >= 0)
                out.write(buf, 0, n);
        } finally {
            out.close();
        }
    } finally {
        in.close();
    }
}

теперь его можно заменить более простым кодом:

static void copy(String src, String dest) throws IOException {
    try (InputStream in = new FileInputStream(src);
            OutputStream out = new FileOutputStream(dest)) {
        byte[] buf = new byte[8192];
        int n;
        while ((n = in.read(buf)) >= 0)
            out.write(buf, 0, n);
    }
}

Вы можете переключить (это) внутри определений методов классов перечисления. Заставил меня крикнуть "ах!" громко, когда я обнаружил, что это действительно работает.

На самом деле, что мне нравится в Java, так это то, как мало там скрытых уловок. Это очень очевидный язык. Настолько, что по прошествии 15 лет почти все, о которых я могу думать, уже перечислены на этих нескольких страницах.

Возможно, большинство людей знают, что Collections.synchronizedList () добавляет синхронизацию в список. Чего вы не можете знать, если не прочитаете документацию, так это того, что вы можете безопасно выполнять итерацию по элементам этого списка, синхронизируя сам объект списка.

CopyOnWriteArrayList может быть неизвестен некоторым, а Future представляет интересный способ абстрактного многопоточного доступа к результатам.

Вы можете подключаться к виртуальным машинам (локальным или удаленным), получать информацию об активности сборщика мусора, использовании памяти, файловых дескрипторах и даже размерах объектов с помощью различных API-интерфейсов управления, агентов и подключения.

Хотя TimeUnit, возможно, лучше, чем long, я предпочитаю класс Duration от Wicket.

О, я чуть не забыл эту маленькую жемчужину. Попробуйте это на любом запущенном java-процессе:

jmap -histo: live PID

Вы получите гистограмму живых объектов кучи в данной виртуальной машине. Бесценен как быстрый способ определить некоторые виды утечек памяти. Другой метод, который я использую для их предотвращения, - это создание и использование подклассов с ограниченным размером всех классов коллекций. Это приводит к быстрым сбоям в неконтролируемых коллекциях, которые легко идентифицировать.

Функция, с помощью которой вы можете отображать заставки для консольных приложений Java.

Используйте инструмент командной строки java или javaw с параметром -splash.

например:

java -splash:C:\myfolder\myimage.png -classpath myjarfile.jar com.my.package.MyClass

содержимое C:\myfolder\myimage.png будет отображаться в центре экрана всякий раз, когда вы выполняете класс "com.my.package.MyClass"

При работе в Swing мне нравится скрытая функция Ctrl - Shift - F1.

Делает дамп дерева компонентов текущего окна. (Предполагая, что вы не связали это нажатие клавиши с чем-то другим.)

Меня удивляет, что интерфейс может расширять несколько интерфейсов, но класс может расширять только один класс.

Подстановочные знаки пути к классам начиная с Java 6.

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

См. http://java.sun.com/javase/6/docs/technotes/tools/windows/classpath.html

Хуки выключения. Это позволяет зарегистрировать поток, который будет создан немедленно, но запустится только после завершения JVM! Так что это своего рода «глобальный финализатор jvm», и вы можете делать полезные вещи в этом потоке (например, отключать ресурсы Java, такие как встроенный сервер hsqldb). Это работает с System.exit () или с CTRL-C / kill -15 (но, конечно, не с kill -9 в unix).

Более того, это довольно просто настроить.

            Runtime.getRuntime().addShutdownHook(new Thread() {
                  public void run() {
                      endApp();
                  }
            });;

Идентификаторы могут содержать символы иностранного языка, например умляуты:

вместо написания:

String title = "";

кто-то мог написать:

String Überschrift = "";

Java 6 (от Sun) поставляется со встроенным интерпретатором JavaScrip.

http://java.sun.com/javase/6/docs/technotes/guides/scripting/programmer_guide/index.html#jsengine

Не читал об этом

Integer a = 1;
Integer b = 1;
Integer c = new Integer(1);
Integer d = new Integer(1);

Integer e = 128;
Integer f = 128;

assertTrue (a == b);   // again: this is true!
assertFalse(e == f); // again: this is false!
assertFalse(c == d);   // again: this is false!

узнайте больше об этом, выполнив поиск в пуле целых чисел Java (внутренний «кеш» от -128 до 127 для автобокса) или загляните в Integer.valueOf

Вы можете переопределить метод и вызвать его конструктор суперкласса (это может стать сюрпризом для программистов на C++).

Пример

Вот мой список.

Моя любимая (и самая страшная) скрытая функция - это то, что вы можете генерировать проверенные исключения из методов, которые ничего не объявляют.

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" });
    }
}

Я думаю, что приведенный выше синтаксис мог бы заменить varargs, введенный в Java 5. И более согласованный с ранее разрешенными объявлениями массивов.

Каждый файл класса начинается с шестнадцатеричного значения 0xCAFEBABE, чтобы идентифицировать его как действительный байт-код JVM.

(Объяснение)

Вы можете добавить проверки общих типов во время выполнения с помощью объекта Class<T>, это удобно, когда класс создается где-то в файле конфигурации и нет возможности добавить проверку времени компиляции для универсального типа класса. Вы не хотите, чтобы класс взорвался во время выполнения, если приложение неправильно настроено, и вы не хотите, чтобы все ваши классы были пронизаны экземплярами проверок.

public interface SomeInterface {
  void doSomething(Object o);
}
public abstract class RuntimeCheckingTemplate<T> {
  private Class<T> clazz;
  protected RuntimeChecking(Class<T> clazz) {
    this.clazz = clazz;
  }

  public void doSomething(Object o) {
    if (clazz.isInstance(o)) {
      doSomethingWithGeneric(clazz.cast(o));
    } else {
      // log it, do something by default, throw an exception, etc.
    }
  }

  protected abstract void doSomethingWithGeneric(T t);
}

public class ClassThatWorksWithStrings extends RuntimeCheckingTemplate<String> {
  public ClassThatWorksWithStrings() {
     super(String.class);
  }

  protected abstract void doSomethingWithGeneric(T t) {
    // Do something with the generic and know that a runtime exception won't occur 
    // because of a wrong type
  }
}

Я был удивлен, когда впервые заметил тернарный оператор, равный простому выражению if-then-else:

minVal = (a < b) ? a : b;

Я могу добавить объект сканера. Лучше всего подходит для разбора.

String input = "1 fish 2 fish red fish blue fish";
Scanner s = new Scanner(input).useDelimiter("\s*fish\s*");
System.out.println(s.nextInt());
System.out.println(s.nextInt());
System.out.println(s.next());
System.out.println(s.next());
s.close();

Вы можете определять и вызывать методы анонимных внутренних классов.

Ну, они не так уж и скрыты, но мало кто знает, что с их помощью можно определить новый метод в классе и вызвать его следующим образом:

(new Object() {
    public String someMethod(){ 
        return "some value";
    }
}).someMethod();

Вероятно, это не очень распространено, потому что это тоже не очень полезно, вы можете вызвать метод Только, когда вы его определяете (или через отражение)

На самом деле это не скрытая функция, но я очень удивился, когда увидел этот скомпилированный штраф:

public int aMethod(){
    http://www.google.com
    return 1;
}

причина, по которой он компилируется, заключается в том, что строка http://www.google.com в части «http:» обрабатывается компилятором как метка, а остальная часть строки является комментарием.

Итак, если вы хотите написать какой-то причудливый код (или запутанный код), просто поместите туда много http-адресов. ;-)

Функция printf () в стиле C :)

System.out.printf("%d %f %.4f", 3,Math.E,Math.E);

Выход: 3 2,718282 2,7183

Двоичный поиск (и его возвращаемое значение)

int[] q = new int[] { 1,3,4,5};
int position = Arrays.binarySearch(q, 2);

Как и в C#, если «2» не найден в массиве, он возвращает отрицательное значение, но если вы возьмете дополнение 1 возвращаемого значения, вы фактически получите позицию, в которую можно вставить «2».

В приведенном выше примере позиция = -2, ~ позиция = 1, которая является позицией, в которую следует вставить 2 ... она также позволяет вам найти «ближайшее» совпадение в массиве.

Думаю, это здорово ... :)

Не так уж и скрыто, но интересно.

У вас может быть «Hello, world» без основного метода (это вызывает мысль NoSuchMethodError)

Первоначально опубликовано RusselW на Самая странная языковая функция

public class WithoutMain {
    static {
        System.out.println("Look ma, no main!!");
        System.exit(0);
    }
}

$ java WithoutMain
Look ma, no main!!