Java History and Evolution

Java Evolution

• A complete understanding of Java requires awareness of its origins and the motivations behind its creation.
• Computer languages evolve for two key reasons:
  • To adapt to evolving environments and applications.
  • To refine and enhance programming techniques.
• Java is related to C++ and has inherited characteristics from both C++ and C.
• Java's syntax is derived from C, and its object-oriented features are influenced by C++.
• Each innovation in language design addresses a fundamental problem that earlier languages could not solve.

C and C++

• C, although one of the great programming languages, has limitations in handling complexity as programs grow.
• C++ introduced features to aid programmers in managing larger, more complex programs.
• Bjarne Stroustrup invented C++ in 1979 while at Bell Laboratories and it was initially named "C with Classes".
• C++ extends C by incorporating object-oriented features and includes all features, attributes, and benefits as C.
• C++ aimed to enhance rather than replace C.

Java's Emergence

• The rise of the World Wide Web and the Internet catalyzed another programming revolution.
• James Gosling, Patrick Naughton, Chris Warth, Ed Frank, and Mike Sheridan at Sun Microsystems, Inc. conceived Java in 1991.
• It took 18 months to develop Java’s first working version.
• Initially named "Oak", the language was renamed "Java" in 1995.
• Environmental changes, such as the need for platform-independent programs for Internet distribution, prompted Java’s development.
• Java refined the object-oriented paradigm, added multithreading support, and simplified Internet access.

Java's Impact

• Java's innovation of the applet revolutionized online content and, coupled with the Internet, propelled Java's programming prominence.
• An applet is a Java program designed for Internet transmission and automatic execution by Java-compatible web browsers.
• Java addresses security and portability issues, enabling downloaded programs to operate safely across different environments.
• Java's usefulness on the server side led to the development of the servlet.
• A servlet is a small program that executes on the server and dynamically extends the capabilities of a web server, like how applets extend web browsers.
• The output of a Java compiler is bytecode, a highly optimized set of instructions executed by the Java Virtual Machine (JVM).

Java Buzzwords

• Key design considerations:
  • Simple
  • Secure
  • Portable
  • Object-Oriented
  • Robust
  • Multithreaded
  • Architecture-Neutral
  • Interpreted and High Performance
  • Distributed
  • Dynamic

Overview of Java and OOP

• Object-oriented programming (OOP) forms the foundation of Java.
• Computer programs consist of code and data.
• Two paradigms govern program construction:
  • The process-oriented model characterizes a program as a linear series of steps (code acting on data).
  • Object-oriented programming organizes the program around data (objects) with well-defined interfaces (data controlling access to code).
• Abstraction is an essential element of OOP.
• Abstraction is managed through hierarchical classifications.
• Data from traditional process-oriented programs can be transformed by abstraction into its component objects.

Key OOP Principles

• Encapsulation binds code and manipulated data, protecting them from outside interference.
• Encapsulation uses a protective wrapper that prevents arbitrary access, with access tightly controlled through a defined interface.
• The class is Java's encapsulation basis, defining the structure and behavior shared by a set of objects.
• A class hides implementation complexity, with methods and variables marked as private or public.
• The public interface represents everything external users need to know.
• Private methods and data are accessible only to members of the class.
• Inheritance enables an object to acquire properties from another, supporting hierarchical classification.
• Inheritance interacts with encapsulation, where subclasses inherit attributes plus any specialization.
• A new subclass inherits all attributes from its ancestors.
• Polymorphism allows one interface to be used for a general class of actions, determining the specific action based on the situation.
• With polymorphism, Java enables the specification of a general set of stack routines that share the same names.
• Polymorphism, encapsulation, and inheritance combine to produce a robust programming environment, supporting the development of far more robust and scalable programs.

First Simple Java Program

• The source file name in Java is important.
• The class name defined by the program is also important.
• When compiling, execute the javac compiler to create a file called Example.class that contains the bytecode version of the program.
• Java bytecode is the intermediate representation executed by the JVM.
• Java bytecode output is not directly executable.
• Run programs using the Java application launcher "java."
• Compiled Java source code puts each class into its own output file with the .class extension.

Running the Program

• Execute java with the class name to be executed.
• Specifying the class name executes that class
• Java locates the corresponding ".class" file for execution.

Inside the Program

• The compiler ignores comments.
• The line "class Example" declares a new class named Example.
• The program begins with the "main()" method, which is the entry point for Java applications.
• The keyword "public" sets access such that the member may be accessed by code outside the class in which it is declared.
• The keyword "static" means main() can be called without instantiating an instance of the class.
• The keyword "void" specifies that main() does not return a value.
• "String args[]" declares a parameter named "args," which is an array of String class instances.
• Output is accomplished by the built-in "println()" method.
• System is a predefined class providing system access, and "out" is the output stream connected to the console.
• The Java compiler will compile classes that don't contain a main() method, but has no way to run these classes..
• String args[] declares a parameter named args, which is an array of instances of the class String, collecting the program's command line.

OOP vs POP

• In procedure-oriented programming (POP), programs are divided into smaller parts and are considered a sequence of procedures or functions.
• POP procedures contain instructions to perform specific tasks.
• POP procedures are called, requiring only the function name.
• POP primarily focuses on function development, with little attention to the data used.
• The major emphasis in POP is on the procedure (function) rather than on the data.
• Multi-function programs in POP often use global data, accessible to all functions, with each function having local data.
• Global data are vulnerable to accidental changes by functions.
• Identifying which function uses specific data is difficult in large POP programs.
• C is an example of procedural oriented programming.
• Object-oriented programming (OOP) treats data as a critical program element.
• OOP prevents data from flowing freely around the system.
• The emphasis in OOP is on data, not procedures (functions).
• OOP tightly associates data with its functions, protecting it from external modification.
• OOP decomposes problems into objects, building data and functions around these objects.
• Data in OOP can only be accessed by the functions associated with its object.
• C++, Java, and Python are examples of OOP languages.

Java Development Kit

• The JDK (Java Development Kit) is an environment to develop software and run Java programs.
• The JDK has two components: -Development Tools
  • JRE (Java Runtime Environment)
• The JRE (Java Runtime Environment) is an environment to run a Java program.
• The JVM (Java Virtual Machine) is a runtime engine for Java applications, also known as an interpreter.

Encapsulation

• Encapsulation is the wrapping up of data under a single unit.
• Encapsulation is the mechanism that binds together code and the data it manipulates.
• Encapsulation is a protective shield that keeps data from being accessed by code outside the shield.
• Variables or data of a class can be accessed through any member function of the class in which it is declared.
• Encapsulation hides data using the data hiding concept achieved by making members or methods of a class private,
• Encapsulation combines data-hiding and abstraction.
• Encapsulation can be achieved by declaring all the variables in the class as private and writing public methods in the class to set and get the values of variables.
• Encapsulation is more defined with the setter and getter method.

Encapsulation Advantages

• Data Hiding: restricts access to data members by hiding implementation details.
• Increased Flexibility: enables variables to be read-only or write-only.
• Reusability: improves re-usability and is easy to change with new requirements.
• Testing code is easy: makes code easy to test for unit testing.

Modifiers

• Modifiers are divided into two groups:
  • Access Modifiers: control the access level
  • Non-Access Modifiers: provide information about class functionalities to JVM, cannot control access level.

Access Modifiers: Classes

• The two access modifiers are: -Public: accessible by any other class
• Default: accessible by classes in the same package:

Access Modifiers: Methods, Attributes & Constructors

• Public: Can be accessed by all classes
• Private: Can be accessed within the declared class
• Default: Can be accessed within the same package
• Protected: Can be accessed in the same package and subclasses

Non-Access Modifiers: Classes

• The two non-access modifiers are:
  • Final: The class cannot be inherited by other classes
  • Abstract: The class cannot be used to create objects, but must be inherited from another class.

Non-Access Modifiers: Attributes & Methods

• Final: Attributes and methods cannot be overridden/modified
• Static: Attributes and methods belongs to the class, rather than an object
• Abstract: Only used in an abstract class, and only on methods. The method does not have a body, and the body is provided by the subclass (inherited from).

Inheritance

• Inheritance is creating new classes based on existing ones.
• A class that inherits from another class can reuse the methods and fields of that class
• You can add new fields and methods to your current class.

Advantages of Inheritance

• Code Reusability: reduces the amount of code that needs to be written.
• Abstraction: Promotes abstraction and encapsulation, making the code easier to maintain and extend.
• Class Hierarchy: Can be used to model real-world objects and their relationships.
• Polymorphism: Subclasses can override methods of the superclass, which allows them to change their behavior in different ways.

Polymorphism

• Polymorphism means having many forms or the ability of a message to be displayed in more than one form.
• Java polymorphism can be divided into two types:
  • Compile-time Polymorphism
  • Runtime Polymorphism

Compile-Time and Run Time Polymorphism

• Compile time polymorphism which is also known as static polymorphism that can be achieved by function overloading or operator overloading.
• Runtime Polymorphism is known as Dynamic Method Dispatch achieved by method overriding.
• In method overriding, a derived class has a definition for one of the member functions of the base class and is said to be overridden.

Abstraction

• Abstraction means that only the essential details are displayed to the user.
• Data Abstraction means identifying only the required characteristics of an object ignoring the irrelevant details.
• Abstraction is achieved by interfaces and abstract classes and 100% abstraction using interfaces.

Encapsulation vs Data Abstraction

• Encapsulation is data hiding, while Abstraction is detailed hiding.
• Encapsulation is a procedure at the implementation level, while abstraction is a design-level process.
• Encapsulation groups data and methods that act upon the data, data abstraction deals with exposing the interface to the user and hiding the details of implementation.
• Encapsulated classes are java classes that follow data hiding and abstraction while abstraction can be implemented by using abstract classes and interfaces.

Summary OOP

• The main OOP concepts include:

1. Encapsulation
2. Data hiding
3. Inheritance
4. Polymorphism
5. Abstraction

Packages

• A Package in Java that is a mechanism to encapsulate a group of classes, sub packages and interfaces and are used for:

  • Preventing naming conflicts.
  • Making searching and usage of classes, interfaces, enumerations and annotations easier.
  • Providing controlled access.
  • Packages that are considered as data encapsulation (or data-hiding).
    • A protected member is accessible by classes in the same package and its subclasses
    • A default member (without any access specifier) is accessible by classes in the same package only.

• All we need to do is put related classes into packages so we can simply write an import class from existing packages.

• A package is a container of a group of related classes where some of the classes are accessible classes are exposed and others are kept for internal purpose.

• To use existing classe, we can reuse existing classes from the packages.

Packages: Subpackages

• We can add more classes to a created package by using package name at the top of the Java file and saving it in the package directory.
• Packages that are inside another package are the subpackages and they are not imported by default and have to imported explicitly.

Types of Packages

• Built-in packages.
• User defined packages.

Packages: Built-In

• The core packages of java consists of classes which are a part of Java API.
• Some of the commonly used built-in packages are:
  • java.lang: Contains language support classes(e.g classed which defines primitive data types, math operations). This package is automatically imported.
  • java.io: Contains classed for supporting input / output operations. -java.util: Contains utility classes which implement data structures like Linked List, Dictionary and support for Date / Time operations.
• java.applet: Contains classes for creating Applets.
• java.awt: Contain classes for implementing the components for graphical user interfaces (like button, menus etc). -java.net: Contain classes for supporting networking operations.

Packages: User Defined

• These packages are that are defined by the user and first we create a project directory and then create directory for the package to use, starting with the package statement.

Exception Handling

• Errors can arise due to User errors or programmer errors:
  • User error consists of (for example, providing a non valid input file). A good program should be written to anticipate these situations and should deal with them.
  • Programmer errors should be detected as early as possible to provide good feedback.

Idea of Exception Handling

• Upon an error is detected, an exception is thrown where the code stops executing immediately and control is transferred to the catch clause for that exception.
• The try block might be in the current function/method causing the error that is passed up the call chain.
• If no currently active function is prepared to catch the exception, an error message is printed and the program stops.

Checked vs Unchecked

• Every exception is either a checked exception or an unchecked exception.
• Checked exceptions must be caught or declared in the method header using a throws clause.
• Checked exceptions must be thrown inside a try block with a catch clause.