Java Evolution: EEE 32502

Java Programming & Applications

• Course Code: EEE 32502

Java Evolution

• Understanding Java's creation is key to understanding Java itself.
• Computer language innovation occurs for two key reasons: Adapting to changing environments and uses, as well as refining programming techniques.
• Java relates to C++, which is a descendant of C.
• Java inherited much of its character from these two languages.
• Java syntax is derived from C.
• Many of Java's object-oriented aspects are influenced by C++.
• The need to solve fundamental problems drives language design innovation, which is true for Java.
• Although C is a great language, its limit is its ability to handle complexity.
• Problems appear when a program becomes too large and difficult to grasp as a whole.
• C++ allows programmers to manage larger programs.
• C++ was created in 1979 by Bjarne Stroustrup at Bell Laboratories.
• The new language was called "C with Classes" and renamed C++ in 1983.
• C++ enhances C with object-oriented features and includes all of C's features, explaining its success.
• C++ was intended as improvement rather than as a new language.
• The rise of the web and the Internet precipitated a programming revolution.
• Java was conceived by James Gosling, Patrick Naughton, Chris Warth, Ed Frank, and Mike Sheridan at Sun Microsystems, Inc. in 1991.
• The first working version took 18 months and was initially named "Oak" but was renamed "Java" in 1995.
• The need for platform-independent programs for the Internet prompted its creation.
• Java refines object-oriented approaches using C++.
• Java adds multithreading support, library simplifies Internet access and embodies an approach to programming.
• Java simplified web programming, innovated applets, which changed online content.
• An applet is designed to be transmitted over the internet and executed by a Java-compatible web browser.
• Security and portability are problematic when it comes to applets.
• Java provides security and portability that allows the program to run under different systems, and prevents it from doing harm.
• Java is useful on the server side, resulting in the servlet.
• The servlet is a small program that executes on the server.
• Servlets extends the functionality of the web server, similarly to how applets extend the functionality of the web browser.
• Java compiler outputs bytecode instead of executable code.
• Bytecode is a set of optimized instructions for the Java run-time system, which is called the JVM.
• Key buzzwords used by the Java team:
• Simple
• Secure
• Portable
• Object-oriented
• Robust
• Multithreaded
• Architecture-neutral
• Interpreted & High performance
• Distributed
• Dynamic

Overview of Java

• OOP is at the core of Java.
• Programs consist of data and code.
• Program construction is governed by two paradigms.
• The process-oriented model is the first model.
• Programs are a series of code-based linear steps.
• Code acts on data in the process-oriented model.
• Procedural languages such as C employ this model.
• Problems arise when programs grow larger and complex.
• Object-oriented programming manages complexity.
• Object-oriented programming programs are based around objects and well-defined interfaces to objects.
• Data controls code in object-oriented programs.
• Abstraction is essential to OOP.
• Hierarchical classifications manage abstraction.
• Hierarchical abstractions apply to computer programs.
• Data is transformed into component objects.
• Process steps become messages between objects.
• Each object describes its unique behavior.
• Treat objects as entities that respond to messages.
• This encapsulates OOP.
• All OOP languages implement the object-oriented model.
• Object-oriented models include encapsulation, inheritance, and polymorphism.
• Encapsulation ensures interference and misuse safety.
• Encapsulation prevents code and data that is arbitrarily accessed.
• Access is tightly controlled with a well-defined interface.
• The basis of encapsulation in Java is the class.
• A class defines code and data structure.
• Hiding complexity is important within a class.
• Class has markable methods or variables that are either public or private.
• Public interface of the class represents what external users need or may need.
• Private data and private methods can only be accessed by members of the class.
• Other code cannot access a private variable or private method.
• Inheritance allows an object to acquire another object's properties.
• Hierarchy is supported through inheritance.
• Inheritance interacts with encapsulation.
• A subclass that encapsulates properties also has any additions that is part of its specialization.
• A class inherits all attributes of ancestor attributes.
• Polymorphism allows a class of actions to use one interface to determine specific actions.
• With a stack of last-in, first-out lists, it requires three types of stacks which stores integers, floating points, and characters.
• The algorithm is the same, regardless of data.
• Non-OOP requires three separate sets of stack routines whereas Java uses polymorphism to specify routines that share the same name.
• Encapsulation, inheritance and poymorphism combines to create a robust programming environment.
• This promotes scaleable programs.

First Program Code

• The name of the source file is important in Java.
• The name and class must be the same.
• Execute the compiler, javac, to compile the Example program.
• The javac compiler will create a file called example.class.
• Bytecode contains instructions that the Java virtual machine that will execute.
• The output of javac cannot be directly executed.
• Use the Java application launcher to actually run the program.
• When Java is compiled, each class is put into a specific output.class.
• The name of its class matches that of the source file.
• Executing Java needs the name of class, which will search for a.class file.
• The code will execute if the match is found.
• The compiler skips the first four lines.
• Class is a keyword that declares the new code.
• The method begins with main.
• Public keyword is the access modifier for managing member visibility.
• Public allows access outside of the class, whereas private does not allow access outside of the class.
• Public must be declared by Main() since, code calls it when the program starts.
• Static allows main() to be called without setting a base in the Class.
• Void lets the compiler know that main() will not return a value.
• The Java compiler compiles classes without a main() method.
• There's no function to run the class.
• String args[] declares parameter args as an array of String classes.
• String types store character strings and args receives the lines, if it's present.
• Output is through a built-in println() method and System provides system access and out is the connected output stream.

Difference between OOP and POP

• In the procedure oriented approach POP, large programs are divided into smaller programs parts.
• These parts are considered functions or procedures.
• Each procedure contains a series of instructions for a specific task.
• Each procedure can be called by other procedures during program execution.
• To call a procedure, write the function name of the procedure.
• Developing functions, a concentrated effort is applied, which gives little consideration to data.
• The major emphasis with POP is on procedure and not on data.
• Important data may be placed as global so that all functions can access it.
• Local data is used by each function.
• Changes to global data may be accidental.
• Identifying which date to use becomes increasingly difficult.
• C programming language is an example of POP.
• OOP treats data as critical.
• OOP prevents data to freely flow in the system.
• OOP mainly focuses on data rather than process.
• Function with the data function which protects function modification.
• Decomposition into entities builds data and functions around those data.
• Data of an object is only by the associated fuction.
• C++, Java, and Python are OOP languages.

Java JDK, JRE, and JVM

• JDK is a kit for developing and executing a Java program, includes development tools to develop programs and JRE to execute it.
• JRE is an environment that can only run code.
• JVM acts as a run-time engine and functions as an interpreter.

Encapsulation

• Wrapping data under a single unit is encapsulation.
• Encapsulation binds data and codes and it manipulates.
• The protective shield only allows certain codes to access the data, and restricts the outside access.
• Variables or data is hidden from other classes inside of a member.
• Data is hidden from other classes with a data hiding concept which is achieved by making members or methods of a class private
• The class is exposed to the end-user without implementation details behind abstraction and becomes a combination of data-hiding.
• Declare all variables as private and use public methods to set variables to achieve encapsulation.
• Setter and getter methods further exemplify encapsulation.

Advantages of Encapsulation

• Data Hiding: restrict access to our data members by hiding the implementation details.
• Increased flexibility to easily make variables read/write-only.
• Encapsulation to improve reusability and is easy to change.
• Unit testing.

Modifiers

• Divided into two groups:
• Access Modifiers - controls the access level
• Non-Access Modifiers - provide information about class functionalities to JVM but do not control access level.

Access Modifiers

• Modifiers for classes are public and default, where the class is accessible (public) by any other class, else accessible by the same package only (default).
• Access modifiers for methods, attributes, and constructors are public, private, default, and protected.
• The code is accessible for all classes (public), within declared class (private), only in the same package (default), and only in the same package and subclasses (protected).

Non-access Modifiers

• For classes: final (where the class can never be inherited) and abstract (which cannot be used to create objects).
• For attributes and methods: final, static, and abstract, where methods/attributes can't be overrided, belong to the class than object, and can be used in an abstract class with abstract void run().

Inheritance

• Creating a new class from an old one where the new class inherits methods and fields.
• An inherited class may add fields and methods as well.

Advantages of Inheritance:

• Code reusability and reduces the amount of code that need to be rewritten.
• Abstractions let one create abstracted classes for the inheritance.
• Inheritance makes code easier to maintain and extend.
• Modeling real-world objects in a hierarchy through inheritance.
• Subclasses change behaviors by overriding the superclass.

Polymorphism

• Defining polymorphism as one form having many forms, with "poly" refers to "many" and "morphs" means "forms", so it means many forms.

Different Types of Polymorphism

• Compile-time - Static, achieved by function overloading or operator overloading.
• Run-time - Dynamic Method Dispatch and achieved through Method Overriding when a derived class defines a member of a base lass, that base function is said to be overridden.

Abstraction

• Displays essential details to the user.
• Removes trivial and non-essentials.
• Focuses on necessary characteristics, so behaviors help classify a particular entity.
• Achieved through abstraction using interfaces and abstract classes.

Abstraction vs Encapsulation

• Data vs Hiding - Encapsulation (info. hiding) vs Abstraction (implementation hiding).
• Data Management - Encapsulation (methods for data) vs Abstraction (only expose the interface to user, not implementation).
• Abstraction & hiding - Encapsulation (Java classes that follow data-hiding/abstraction) vs Abstraction with Abstract classes/ interfaces.
• Processes - Encapsulation (Implementation-level) vs Abstraction (design-level).

Summary OOP:

• The main OOP concepts are:

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

Packages

• Mechanism to encapsulate classes, it is used for:
• Preventing name conflict.
• Making searching classes, easy.
• Provide controlled access protected access only to member or sub class in package default access to same package.
• Acts as data encapsulation.
• Related classes into packages - Import classes from packages.
• Packages are related classes that are accessible to reused and name structures are related.
• Adding classes with package name and saving it in package directory. Packages of directory are imported using privileges for protected and default access:
• import java.util.*;
• util is a subpackage created inside java package.

Packages

• Types of packages:

1. Built-in packages
2. User-defined packages

Built-In Packages

• Packages consist of API which language support classes defining data types and operations is automatically imported:

1. java.lang
2. java.io
3. java.util
4. java.applet
5. java.awt
6. java.net

User Defined packages

• These are the directory user should define name should be same name as the package, the first statement being for the package name.

Exception Handling

• Errors may be caused by user that should be anticipated and handled or due to a programmer.
• Thrown when an error is detected and when that happens, the code that caused that error stops immediately: transferred to the catch clause.
• The try block might be in the current function
• If the exception is not handled correctly, a message prints and the program stops.
• An exception is either checked or unchecked.
• If a method includes code that could cause an exception (checked):
• Declare the exception must be declared in the method header, using a throws clause
• The code that might cause the exception to be thrown must be inside a try block with a catch clause for that exception.