Bantu saya untuk mengetahui apa yang saya lewatkan sejak Java 1.4.2 [ditutup]

Saya akan memulai posisi karir profesional pertama saya sebagai pengembang perangkat lunak, dan saya cenderung akan menulis banyak kode Java. Saya tidak tahu banyak tentang apa yang spesifik saya akan menulis, dan selain itu, saya memiliki minat yang cukup luas ketika datang ke kode.

Untuk alasan yang tidak layak dibahas, magang terakhir saya meminta saya mengkode hanya untuk Java 1.3 dan 1.4 SDK. Selain itu, pendidikan universitas saya berfokus terutama pada algoritma, struktur data, dan teori lainnya, bukan fitur bahasa atau perpustakaan.

Jadi, dengan pemikiran di atas, fitur apa, kelas, dll dalam versi Java saat ini (nomor berapa kita sekarang?) Akan sepadan dengan waktu saya untuk membaca dan mengapa? Apa yang saya lewatkan sejak 1.4.2 yang membuat hidup Anda sebagai programmer lebih mudah?

Contoh dan cerita tentang bagaimana Anda menemukan paket tertentu atau semacamnya dan menggunakannya juga akan bagus.

Perubahan yang saya anggap paling penting adalah:

• Generik (mis. Koleksi yang diketik, seperti Set)

• Ditingkatkan untuk loop (untuk (String s: set) {...})

• Autoboxing / unboxing (secara otomatis mengkonversi antara tipe-tipe seperti Integer ke int dan sebaliknya)

• Typesafe enums (enum sekarang menjadi kata kunci, jenis dapat dibuat dari enums)

• Varargs (untuk fungsi printf (), memungkinkan sejumlah variabel argumen)

• Impor statis (sekarang dapat mengimpor metode statis suatu kelas, seperti java.lang.Math)

• Anotasi

• java.util.concurrent (Mendemonstrasikan konkurensi java)

Baca juga Java apa yang Anda tuju? , untuk mendapatkan pemahaman yang lebih baik dari masing-masing dari tiga versi.

Satu-satunya perubahan terpenting dalam kehidupan pemrograman Anda sehari-hari adalah pengenalan generik yang kemungkinan besar akan digunakan dalam setiap modul baru yang akan Anda tulis, dan itu adalah sintaks baru yang membingungkan.

Generik adalah mekanisme yang memungkinkan misalnya a Listuntuk berisi string, bukan objek telanjang, di mana kompiler memberlakukan bahwa item yang akan dimasukkan ke dalam daftar adalah String, dan ia tahu bahwa ketika Anda mendapatkan item dari daftar itu adalah String. .

Ini membuat program yang lebih baik karena Anda menghindari runtime yang dilemparkan secara eksplisit ke tipe target (yang merupakan sumber kesalahan yang sering terjadi jika Anda salah) dan IDE dapat membantu Anda melakukan semua pekerjaan kotor karena ia tahu lebih banyak tentang kode Anda daripada itu terjadi ketika itu hanya daftar objek.

Joshua Bloch telah menulis pengantar yang baik untuk Generics, yang tersedia sebagai bab contoh di http://java.sun.com/docs/books/effective/

Autoboxing adalah fitur bagus yang diperkenalkan dengan Java 5. Sama seperti di C # kompiler sekarang membuat konversi otomatis antara tipe primitif (dasar) dan kelas objek pembungkus yang sesuai (int ke Integer dll) dan kembali lagi. Itu membuat bekerja dengan Koleksi Jawa jauh lebih sedikit rasa sakit.

Untuk-setiap perulangan adalah baru di Java 5, juga, saya pikir. Itu membuat iterasi dari array (dan koleksi) lebih mudah, karena menghilangkan banyak kekacauan yang biasanya melibatkan pengaturan dan pengelolaan variabel indeks atau iterator. Sebagai contoh:

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

Enum , untuk menggantikan statika dan konstanta terakhir dan membantu Anda menghapus referensi ke string dan angka ajaib. Contoh yang diambil dari orang-orang baik di matahari / ramalan :

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

dan

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 diperkenalkan pada 1.5. Sumber daya terbaik untuk mempelajarinya adalah (mungkin) buku Java Concurrency in Practice . Konkurensi IMHO adalah keunggulan kompetitif Jawa yang paling penting dibandingkan dengan yang lain sehingga layak untuk diketahui dengan baik.

Ya, StringBuildermembantu saya mempercepat program saya. Ini setara dengan StringBufferkeamanan tanpa benang.

Saya akan membantu dengan mengkategorikan jawaban yang bermanfaat dari @kombinator. Daftarnya adalah daftar elemen yang akan Anda gunakan setiap hari saat melakukan pengembangan java "umum".

Dampak rendah dan kesulitan rendah:

• Ditingkatkan untuk loop (untuk (String s: set) {...})
• Autoboxing / unboxing (secara otomatis mengkonversi antara tipe-tipe seperti Integer ke int dan sebaliknya)
• Varargs (untuk fungsi printf (), memungkinkan sejumlah variabel argumen)
• Impor statis (sekarang dapat mengimpor metode statis suatu kelas, seperti java.lang.Math)

Dampak tinggi dan kesulitan sedang:

• Typesafe enums (enum sekarang menjadi kata kunci, jenis dapat dibuat dari enums)

Dampak tinggi dan kesulitan tinggi:

• Anotasi
• Generik

Dampak rendah dan sulit tinggi (hanya akan digunakan kecuali jika Anda melakukan threading lanjutan)

• java.util.concurrent (Mendemonstrasikan konkurensi java)

Oleh karena itu saya menyarankan agar Anda membaca dokumen / bantuan pada dampak rendah dan potongan-potongan sulit - mereka mudah diambil. Luangkan waktu untuk Anotasi dan Generik - anotasi sangat berguna, dan obat generik bisa menjadi agak rumit.

Hanya melihat konten konkurensi baru jika Anda perlu melakukan threading.

Karena saya tidak bisa berkomentar karena saya di bawah 50 saya akan meninggalkan jawaban. Sudah disebutkan tetapi saya akan mengulanginya lagi: Anotasi! Metadata semacam ini menjadi hal terpenting dalam pengalaman saya selama bertahun-tahun di Jawa. Ini digunakan dengan baik seperti beberapa framework yang membuatnya membuat kode lebih ringkas dan bersih. Misalnya, anotasi dapat:

• Konversi objek menjadi entitas @ Entitas
• Ubah metode menjadi layanan REST @GET
• Jelaskan bahwa suatu metode tidak akan pernah mengembalikan null @nonnull
• Setel objek ke bidang untuk injeksi ketergantungan @inject

Dan tentu saja Anda dapat membuat anotasi Anda sendiri dan mengetahui apakah suatu metode, kelas, atau bidang dijelaskan menggunakan refleksi.

Belajar dengan contoh bermanfaat bagi saya

Berikut adalah contoh cepat Java 6 idiomatik

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

  }
}

Jangan repot-repot dengan Java5, itu sudah usang sehubungan dengan Java6.

Langkah selanjutnya, anotasi. Ini hanya mendefinisikan aspek kode Anda yang memungkinkan pembaca anotasi untuk mengisi konfigurasi boilerplate untuk Anda. Pertimbangkan layanan web sederhana yang menggunakan spesifikasi JAX-RS (mengerti URI tenang). Anda tidak ingin repot-repot melakukan semua WSDL jahat dan bercanda dengan Axis2 dll, Anda ingin hasil yang cepat. Benar, lakukan ini:

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

Bang Dengan sedikit tabir konfigurasi sihir di web.xml Anda tidak aktif. Jika Anda membangun dengan Maven dan mengonfigurasi plugin Jetty, proyek Anda akan memiliki server web kecil itu sendiri di luar kotak (tidak ada mengutak-atik JBoss atau Tomcat untuk Anda), dan kode di atas akan menanggapi URI dari bentuk:

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

Pekerjaan selesai.

Wow itu adalah ledakan dari masa lalu! Saya tidak menggunakan Java selama 4 tahun sekarang - dan tidak ada yang berubah sama sekali pada waktu itu!

Ada daftar fitur berdasarkan versi , tetapi inilah bagian penting (tentu saja dijiplak) ...

J2SE 5.0 (30 September 2004)

• Generik: Memberikan keamanan tipe waktu kompilasi (statis) untuk koleksi dan menghilangkan kebutuhan akan sebagian besar typecast (konversi tipe).
• Metadata: Disebut juga anotasi; memungkinkan konstruksi bahasa seperti kelas dan metode yang akan ditandai dengan data tambahan, yang kemudian dapat diproses oleh utilitas metadata-aware.
• Autoboxing / unboxing: Konversi otomatis antara tipe primitif (seperti int) dan kelas wrapper primitif (seperti Integer).
• Pencacahan: Kata kunci enum membuat daftar nilai yang aman, tertata (seperti Hari. Senin, Hari. SELASA, dll.). Sebelumnya ini hanya dapat dicapai oleh integer konstan non-typesafe atau kelas yang dibangun secara manual (pola typesafe enum).
• Ayunan: Tampilan dan nuansa baru yang dapat dikeraskan, disebut synth.
• Varargs: Parameter terakhir dari suatu metode sekarang dapat dideklarasikan menggunakan nama tipe diikuti oleh tiga titik (misalnya void drawtext (String ... lines)). Dalam kode panggilan sejumlah parameter dari jenis itu dapat digunakan dan mereka kemudian ditempatkan dalam array untuk diteruskan ke metode, atau alternatifnya kode panggilan dapat melewati array jenis itu.
• Ditingkatkan untuk setiap loop: Sintaks for loop diperluas dengan sintaks khusus untuk iterasi atas setiap anggota baik array atau Iterable, seperti kelas Koleksi standar, menggunakan konstruksi formulir:

Java SE 6 (11 Desember 2006)

• Dukungan untuk versi Win9x lama turun. Secara tidak resmi Java 6 Update 7 adalah rilis terakhir Java yang terbukti berfungsi pada versi Windows ini. Ini diyakini karena perubahan besar dalam Pembaruan 10.
• Dukungan Bahasa Skrip: API Generik untuk integrasi ketat dengan bahasa scripting, dan integrasi Rhino JavaScript Mozilla bawaan
• Peningkatan kinerja yang dramatis untuk platform inti, dan Swing.
• Dukungan Layanan Web yang ditingkatkan melalui JAX-WS
• Dukungan JDBC 4.0.
• Java Compiler API, sebuah API yang memungkinkan program Java memilih dan memohon Java Compiler secara terprogram.
• Upgrade JAXB ke versi 2.0: Termasuk integrasi parser StAX.
• Dukungan untuk penjelasan pluggable
• Banyak peningkatan GUI, seperti integrasi SwingWorker di API, pengurutan dan pemfilteran tabel, dan benar buffer ganda Swing (menghilangkan efek area abu-abu).
• Peningkatan JVM meliputi: sinkronisasi dan optimisasi kinerja kompiler, algoritma baru dan peningkatan pada algoritma pengumpulan sampah yang ada, dan kinerja start-up aplikasi.

Itu saja. Java SE 7.0 terlihat lebih menarik tetapi belum dirilis.

Mempertimbangkan berapa banyak fitur bahasa baru dan API telah ditambahkan ke C # dalam 4 tahun terakhir, saya cukup heran. Apa yang terjadi di Sun / Oracle?