Lesson 1

This course, the second in the Introduction to Java Series, continues to explore introductory topics that are key to understanding the Java programming language. By taking this course, you will be introduced to object-oriented programming concepts such as packages and interfaces, and you will learn about graphics in Java. The course also covers important Java topics such as threads, exceptions, I/O, and networking. Throughout Java Language Fundamentals, you will work on course projects that demonstrate many of the major Java programming topics covered in the course.

After completing the course, you will have the skills necessary to:

1. Understand how to organize Java classes into packages
2. Understand the role of Java's Abstract Windowing Toolkit (AWT)
3. Use the AWT to draw graphics primitives, text, and images
4. Understand the significance of multithreaded Java programs
5. Build multithreaded Java programs
6. Use exceptions to detect runtime errors
7. Read and write data to and from Java streams
8. Transfer information across the Internet using Java's networking features

Java 15 has premium support until March 2021. Oracle will have support for Java 11 until 2023 at a minimum.

Sun Microsystems developed the original specifications for the language in the mid 1990s. Patrick Naughton, Mike Sheridan, and James Gosling were the original inventors of Java and the language was called Oak at the beginning. Java is a full-fledged object-oriented programming language. It is platform independent and is normally interpreted rather than compiled like C/C++. It is syntactically and structurally modeled after C/C++ and performs various compile-time and run-time checking operations. Java performs automatic memory management that helps to greatly reduce the problem of memory leaks found in other languages and libraries that dynamically allocate memory. Java supports many features that, at its time of conception, were not found directly in other languages. These features include threading, networking, security, and Graphical User Interface (GUI) development. Other languages could be used to support these capabilities, but they were not integrated in the language to the extent that it was done with Java. Java uses an independent bytecode that is architecture neutral. That is, it is designed to be machine independent. The byte codes are interpreted and executed by a Java Virtual Machine (JVM). All of its primitive data types are fully specified (the more primitivfe species).
The various releases of the Java Development Kit (JDK) and other significant moments are depicted in the following timeline diagram:

Absolutely! Here's a history of the Java language from 1996 to present, with summaries of key releases and their corresponding versions:
1996-2006: Foundation and Growth

• JDK 1.0 (1996): The birth of Java. Introduced core concepts: "Write Once, Run Anywhere," applets, AWT GUI toolkit, basic networking.
• JDK 1.1 (1997): Significant additions including Inner Classes, JDBC (database connectivity), JavaBeans (software components), RMI (remote communication).
• J2SE 1.2 (1998): Refined as "Java 2." Swing GUI improvements, Collections framework, strict floating-point calculations.
• J2SE 1.3 (2000): Java HotSpot VM performance boost, sound and accessibility enhancements.
• J2SE 1.4 (2002): "Merlin" release. Assertions, NIO (New I/O) for faster input/output, XML processing, regular expressions.
• J2SE 5.0 (2004): Renamed to "Java SE" with "Tiger" as its codename. Generics, Autoboxing/Unboxing, Annotations, Enhanced 'for' Loop, Concurrency Utilities.

2006 - 2014: Maturity and Expansion

• Java SE 6 (2006): "Mustang." Performance and development tool improvements, Web service support, scripting language integration.
• Java SE 7 (2011): "Dolphin." Try-with-resources for automatic resource management, NIO.2 improvements, switch on strings, diamond operator (<>).
• Java SE 8 (2014): Major leap forward. Lambdas and functional interfaces, streams API, new Date/Time API, Nashorn JavaScript engine.

2014 - Present: Rapid Evolution

• Java SE 9 (2017): Jigsaw modularity system, process handling improvements, HTTP/2 client, JShell (interactive REPL).
• Java SE 10 (2018): First with faster 6-month release cycle. Local-Variable Type Inference (var keyword), unmodifiable collections.
• Java SE 11 (2018): Long-term support (LTS) release. Removal of Java EE and CORBA modules, HTTP client improvements.
• Java SE 12 - Java SE 17 (2019-2021): Continued short-cycle releases with switch expressions, text blocks, records, pattern matching, and more.
• Java SE 18 (2022): Pattern matching for instanceof, simple web server, code snippets in API docs
• Java SE 19 (2022): Virtual threads, structured concurrency, record patterns, foreign function and memory API

Important Notes:

• This is a simplified overview; each release contained numerous smaller features and improvements.
• After Java SE 8, the release cadence changed to a faster, six-month schedule, making it difficult to summarize every small version increment.
• Java continues to evolve actively!