Помогите мне узнать, что я пропустил с Java 1.4.2 [закрыто]

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

По причинам, которые не стоит обсуждать, моя последняя стажировка заставляла меня писать только для Java 1.3 и 1.4 SDK. Кроме того, мое университетское образование было сосредоточено главным образом на алгоритмах, структурах данных и других теориях, а не на особенностях языка или библиотеках.

Итак, с учетом вышесказанного, какие функции, классы и т. Д. В текущей версии Java (в каком количестве мы сейчас находимся?) Стоило бы потратить мое время на чтение и почему? Что я упустил после 1.4.2, чтобы упростить вашу жизнь программиста?

Примеры и истории о том, как вы обнаружили конкретный пакет или что-то подобное и применили его, также были бы великолепны.

Изменения, которые я считаю наиболее важными:

• Обобщения (например, типизированные коллекции, такие как Set)

• Улучшено для цикла (для (String s: set) {...})

• Автобокс / распаковка (автоматическое преобразование между типами, такими как Integer, в int и наоборот)

• Перечисления Typesafe (enum теперь является ключевым словом, типы можно создавать из перечислений)

• Varargs (для функции printf (), допускает переменное количество аргументов)

• Статический импорт (теперь можно импортировать статические методы класса, такие как java.lang.Math).

• Аннотации

• java.util.concurrent (демонстрирует параллелизм Java)

Также прочитайте, на какую Java вы нацелены? , чтобы получить лучшее понимание каждой из трех версий.

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

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

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

Джошуа Блох написал хорошее введение в Generics, которое доступно в качестве примера главы на http://java.sun.com/docs/books/effective/

Autoboxing - хорошая функция, представленная в Java 5. Как и в C #, компилятор теперь выполняет автоматическое преобразование между примитивными (базовыми) типами и соответствующими им классами обертки объектов (int в Integer и т. Д.) И обратно. Это значительно облегчает работу с коллекциями Java.

Я думаю, что каждое повторение было новым в Java 5. Это облегчает итерацию по массивам (и коллекциям), поскольку устраняет большую часть обычного беспорядка, связанного с настройкой и управлением индексной переменной или итераторами. Пример:

void myMethod(Collection<myObjectType> c) {
    for (myObjectType o : c)
        o.foo();
}

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

public enum Planet {
    MERCURY (3.303e+23, 2.4397e6),
    VENUS   (4.869e+24, 6.0518e6),
    EARTH   (5.976e+24, 6.37814e6),
    MARS    (6.421e+23, 3.3972e6),
    JUPITER (1.9e+27,   7.1492e7),
    SATURN  (5.688e+26, 6.0268e7),
    URANUS  (8.686e+25, 2.5559e7),
    NEPTUNE (1.024e+26, 2.4746e7),
    PLUTO   (1.27e+22,  1.137e6);

    private final double mass;   // in kilograms
    private final double radius; // in meters
    Planet(double mass, double radius) {
        this.mass = mass;
        this.radius = radius;
    }
    public double mass()   { return mass; }
    public double radius() { return radius; }

    // universal gravitational constant  (m3 kg-1 s-2)
    public static final double G = 6.67300E-11;

    public double surfaceGravity() {
        return G * mass / (radius * radius);
    }
    public double surfaceWeight(double otherMass) {
        return otherMass * surfaceGravity();
    }
}

и

public static void main(String[] args) {
        double earthWeight = Double.parseDouble(args[0]);
        double mass = earthWeight/EARTH.surfaceGravity();
        for (Planet p : Planet.values())
           System.out.printf("Your weight on %s is %f%n",
                             p, p.surfaceWeight(mass));
    }

java.util.concurrent был введен в версии 1.5. Лучший ресурс для изучения это (вероятно) книга Java Concurrency in Practice . IMHO параллелизм является наиболее важным конкурентным преимуществом Java по сравнению с чем-либо еще, поэтому его определенно стоит знать хорошо.

Ну, StringBuilderпомог мне ускорить мою программу. Это эквивалент StringBufferбезопасности без резьбы.

Я помогу, классифицируя полезный ответ от @ykombinator. Его список - это список элементов, которые вы будете использовать ежедневно при «общей» разработке java.

Низкое воздействие и низкая сложность:

• Улучшено для цикла (для (String s: set) {...})
• Автобокс / распаковка (автоматическое преобразование между типами, такими как Integer, в int и наоборот)
• Varargs (для функции printf (), допускает переменное количество аргументов)
• Статический импорт (теперь можно импортировать статические методы класса, такие как java.lang.Math).

Высокий удар и средняя сложность:

• Перечисления Typesafe (enum теперь является ключевым словом, типы можно создавать из перечислений)

Высокий удар и высокая сложность:

• Аннотации
• Дженерики

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

• java.util.concurrent (демонстрирует параллелизм Java)

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

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

Поскольку я не могу комментировать, потому что мне меньше 50, я оставлю ответ. Это уже упоминалось, но я повторю еще раз: аннотации! Этот вид метаданных стал самым важным в моих годах опыта Java. Он хорошо используется, как это делают некоторые фреймворки, что делает код намного более лаконичным и чистым. Например, аннотации могут:

• Преобразовать объект в сущность @Entity
• Преобразовать метод в службу REST @GET
• Объясните, что метод никогда не вернет ноль @nonnull
• Установить объект в поле для внедрения зависимости @inject

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

Обучение на примере работает для меня

Вот быстрый пример идиоматической Java 6

public class Main {
  public static void main(String[] args) {
    // Shows a list forced to be Strings only
    // The Arrays helper uses generics to identify the return type
    // and takes varargs (...) to allow arbitary number of arguments
    List<String> genericisedList = Arrays.asList("A","B","C");

    // Demonstrates a for:each loop (read as for each item in genericisedList)
    for (String item: genericisedList) {
      System.out.printf("Using print formatting: %s%n",item);
    }

    // Note that the object is initialised directly with a primitive (autoboxing)
    Integer autoboxedInteger = 1;
    System.out.println(autoboxedInteger);

  }
}

Не беспокойтесь о Java5, она устарела по отношению к Java6.

Следующий шаг, аннотации. Они просто определяют аспекты вашего кода, которые позволяют читателям аннотаций заполнять шаблонную конфигурацию для вас. Рассмотрим простой веб-сервис, который использует спецификацию JAX-RS (он понимает RESTful URI). Вы не хотите беспокоиться о том, чтобы делать все неприятные WSDL и дурачиться с Axis2 и т. Д., Вам нужен быстрый результат. Хорошо, сделайте это:

// Response to URIs that start with /Service (after the application context name)
@Path("/Service")
public class WebService {

  // Respond to GET requests within the /Service selection
  @GET
  // Specify a path matcher that takes anything and assigns it to rawPathParams
  @Path("/{rawPathParams:.*}")
  public Response service(@Context HttpServletRequest request, @PathParam("rawPathParams") String rawPathParams) {
    // Do some stuff with the raw path parameters 

    // Return a 200_OK
    return Response.status(200).build();
  }
}

Взрыва. Приложив немного волшебства конфигурации в ваш web.xml, вы отключились. Если вы работаете с Maven и у вас настроен плагин Jetty, ваш проект будет иметь свой собственный маленький веб-сервер прямо из коробки (вам не придется возиться с JBoss или Tomcat), и приведенный выше код будет реагировать на URI-адреса образуют:

GET http://localhost:8080/contextName/Service/the/raw/path/params

Работа сделана.

Вау, это был взрыв из прошлого! Я не использую Java уже 4 года - и за это время ничего не изменилось!

Там есть список функций по версии , но вот важный момент (конечно, плагиат) ...

J2SE 5.0 (30 сентября 2004 г.)

• Обобщения: обеспечивает безопасность типов во время компиляции (статический) для коллекций и устраняет необходимость в большинстве типов типов (преобразование типов).
• Метаданные: также называемые аннотациями; позволяет помечать языковые конструкции, такие как классы и методы, дополнительными данными, которые затем могут обрабатываться утилитами, поддерживающими метаданные.
• Автобокс / распаковка: автоматическое преобразование между примитивными типами (такими как int) и примитивными классами-обертками (такими как Integer).
• Перечисления: ключевое слово enum создает типизированный, упорядоченный список значений (например, Day.MONDAY, Day.TUESDAY и т. Д.). Ранее это могло быть достигнуто только с помощью целочисленных значений, не являющихся безопасными типами, или созданных вручную классов (шаблон типа перечисления типов).
• Swing: новый скиновый вид, называемый synth.
• Varargs: последний параметр метода теперь может быть объявлен с использованием имени типа, за которым следуют три точки (например, void drawtext (String ... lines)). В коде вызова может использоваться любое количество параметров этого типа, и они затем помещаются в массив для передачи в метод, или, альтернативно, код вызова может передавать массив этого типа.
• Улучшено для каждого цикла. Синтаксис цикла for расширен специальным синтаксисом для итерации по каждому члену массива или любого элемента Iterable, такого как стандартные классы Collection, с использованием конструкции в форме:

Java SE 6 (11 декабря 2006 г.)

• Поддержка старых версий Win9x прекращена. Неофициально Java 6 Update 7 является последним выпуском Java, показанным для работы с этими версиями Windows. Считается, что это связано с серьезными изменениями в обновлении 10.
• Поддержка языка сценариев: универсальный API для тесной интеграции с языками сценариев и встроенная интеграция Mozilla JavaScript Rhino
• Значительные улучшения производительности для основной платформы и Swing.
• Улучшенная поддержка веб-сервисов через JAX-WS
• Поддержка JDBC 4.0.
• Java Compiler API - API, позволяющий Java-программе программно выбирать и вызывать Java-компилятор.
• Обновление JAXB до версии 2.0: включая интеграцию анализатора StAX.
• Поддержка сменных аннотаций
• Множество улучшений GUI, таких как интеграция SwingWorker в API, сортировка и фильтрация таблиц и двойная буферизация Swing (исключая эффект серой области).
• Улучшения JVM включают в себя: синхронизацию и оптимизацию производительности компилятора, новые алгоритмы и обновления существующих алгоритмов сборки мусора, а также производительность при запуске приложений.

Вот и все. Java SE 7.0 выглядит интереснее, но еще не выпущена.

Учитывая, сколько новых языковых функций и API было добавлено в C # за последние 4 года, я очень удивлен. Что происходит в Sun / Oracle?