Java Evolution: EEE 32502

Java Fundamentals

• The course code for this material is EEE 32502, focusing on Java programming and applications.

Course Outline

• Topics include Java evolution, an overview of Java, and the first program code.

Java Evolution

• Understanding Java requires understanding the reasons behind its creation.
• Computer language innovation stems from adapting to changing environments and refining programming techniques.
• Java's syntax is derived from C.
• Java's object-oriented features were influenced by C++.
• Language design is driven by the need to solve problems that preceding languages could not.
• Java enhances object-oriented methods used by C++, supports multithreading, and simplifies Internet access.
• The Internet helped propel Java's programming and Java impacted the Internet.
• Java introduced the applet, which changed online content.
• An applet is a program designed to be transmitted over the Internet and executed by a Java-compatible web browser.
• Java solved security and portability issues with programs by using these features.
• A servlet is a small program that executes on the server, in the same way that applets can extend the functionality of a web browser.
• The Java compiler outputs bytecode, a set of instructions for the Java Virtual Machine (JVM).

Key Origins & Concepts of Java

• Java was created to handle the complexity that C had limitations with.
• C++ allows programmers to manage larger programs.
• Bjarne Stroustrup invented C++ in 1979 at Bell Laboratories, initially called "C with Classes."
• C++ extends C with object-oriented features, building on C’s foundation.
• C++ was an enhancement, not a replacement, for C.
• In 1991, Java was conceived by James Gosling, Patrick Naughton, Chris Warth, Ed Frank, and Mike Sheridan at Sun Microsystems, Inc.
• Initially named "Oak", the language was renamed "Java" in 1995
• Java requires you to understand the reasons behind its creation.

Core Java Concepts

• The JVM is known as the Java run-time system.
• Key buzzwords include simple, secure, portable, object-oriented, robust, multithreaded, architecture-neutral, interpreted, high performance, distributed, and dynamic.
• Object-oriented programming (OOP) is central to Java.
• All computer programs consist of code and data.
• The process-oriented model characterizes a program as a series of linear steps.
• Object-oriented programming organizes a program around its data and interfaces.
• Abstraction is an essential element of object-oriented programming.
• Hierarchical classifications manage abstraction.
• Data in process-oriented programs can be transformed into component objects through abstraction.
• Java objects are concrete entities that uniquely respond to messages.
• Java implements encapsulation, inheritance, and polymorphism.

Encapsulation

• Binds code and data, protecting them from outside interference, through a protective wrapper.
• The basis of encapsulation is the class, which defines structure and behavior for objects.
• Classes hide implementation complexity and use private or public markers.
• The public interface represents what external users need to know.
• Private methods and data are accessible only by members of the class.

Inheritance

• Inheritance is when one object acquires the properties of another, supporting hierarchical classification.
• Inheritance interacts with encapsulation, where subclasses inherit attributes from a class.
• A new subclass inherits all attributes of its ancestors.

Polymorphism

• Polymorphism allows one interface to be used for a general class of actions.
• Polymorphism allows the specific action is determined by the exact nature of the situation.
• Polymorphism allows you to specify a general set of stack routines, each with the same name.
• Polymorphism, encapsulation, and inheritance create robust programming environments.

First Java Program

• File names are important, unlike most languages. The file name should coincide with the class name
• The class name is also Example.
• Compiling needs to execute javac.
• Bytecode is the intermediate representation executed by the Java Virtual Machine.
• The Java application launcher is called java, used to run the program.
• Individual classes are put into output files with the .class extension
• When executing java on a class, java searches for a file with the same name but that has the .class extension.
• The compiler ignores comments.
• The keyword class declares a new class.
• main() is the first method: it is an access modifier, where public controls member visibility.
• A public member can be accessed outside its class.
• The keyword static allows main() to be called without instantiating the class.
• The keyword void specifies that main() does not return a value.
• The Java compiler can compile classes without a main() method, but there is no way to run these classes through Java.
• String args[] declares args as an array of String class instances.
• Command-line arguments are given to args when the program is executed.
• System is a predefined class, where out is the connected output stream.

OOP vs POP

• In POP, large programs are split into parts, considered as a sequence of procedure or functions.
• In POP, each procedure consists of a series of instructions that can call other procedures.
• Calling a procedure involve writing the function name.
• In POP, not much attention paid to the data used by functions.
• In POP, there is a major emphasis on procedure instead of data.
• In POP, important data items may be global, making them vulnerable
• One example of POP is the C programming language.
• OOP treats data as a critical element and does not allow it to flow freely around the system.
• In OOP, there is a major emphasis put on the data instead of procedures
• It ties data more closely to the functions.
• OOP decomposes a problem into objects, building functions around these objects.
• The data of an object can only be accessed by its own functions.
• Examples if OOP: C++, Java, Python

Java JDK, JRE and JVM

• The Java Development Kit (JDK) is an environment/kit used to develop and execute Java
• JDK provides development tools used to develop Java programs and the JRE used to execute them.
• The Java Runtime Environment (JRE) is used to run Java programs.
• The Java Virtual Machine (JVM) acts as a run-time engine to run Java applications and is also known as an interpreter.

Encapsulation (Revisited)

• Encapsulation is defined as wrapping up of data under a single unit
• Encapsulation is a mechanism that binds data and code together.
• It acts as a protective shield that prevents data from being accessed by outside code.
• Technically, variables of a class are hidden and can only be accessed through member functions of their own class.
• Hiding the data inside a class makes it also achieve a combination of data-hiding and abstraction.
• Encapsulation declares variables in classes as private but uses public methods to set and get the values of these variables.
• Encapsulation is defined by implementing the setter and getter methods.

Advantages of Encapsulation

• Data hiding restricts access to data members by hiding implementation details.
• Increased flexibility allows variables to be read-only or write-only depending on code requirement.
• Encapsulation improves reusability.
• Encapsulated code is easy to test for unit tests.

Modifiers

• Modifiers are divided into Access Modifiers and Non-Access Modifiers.
• Access Modifiers control the access level.
• Non-Access Modifiers provide information about class functionalities to the JVM, but do not control the access level.

Access Modifiers Breakdown

• With access modifiers, classes can use either Public or Default.
• Use Public to make the class accessible by any other class
• Use Default to make the class accessible by classes in the same package, specifying no modifier.
• For attributes, methods, and constructors there is Public, Private, Default, and Protected
• Public can be accessed for any class.
• Private can only be accessed by attributes, methods, and constructors of the declared class.
• Default can only be accessed if the attributes, methods, and constructors are in the same package.
• Protected can be accessed in the same package and in subclasses.

Non-Access Modifiers Breakdown

• For classes, Non Access modifiers use the Final modifier
• Use Final to make the class not be inherited by other classes

Non-Access Modifiers (Attributes, Methods)

• For attributes and methods some Non Access modifiers are Final, Static, and Abstract.
• Use Final to make the attributes and methods not be overridden/modified
• Use Static to designate attributes and methods to belong the class rather than to an object
• Use Abstract if in an abstract class, making it need to be inherited by another class in order to be accessed.

Core Inheritance Concepts in Java

• Inheritance creates classes based on existing ones.
• Reusability: allows for code reuse and reducing duplication of code.
• Abstraction enables abstract classes to define interfaces in related classes, promoting abstraction.
• Class Hierarchy uses class hierarchy is able to model real-world objects and their relationships.
• An object can take multiple forms because subclasses can override superclass methods

Polymorphism Deep Dive

• Polymorphism is when a message is displayed in many forms.
• “poly” means many and “morphs” means forms.
• Compile-time polymorphism (static) is achieved by function/operator overloading.
• Runtime polymorphism (dynamic) is achieved by method overriding, resolved at runtime.

Understanding Abstraction

• With abstraction, only essential details presented to the user.
• Non-essential units are hidden from the user.
• Data abstraction is where Irrelevant details are ignored, and only required object characteristics are used/emphasized. Interfaces and abstract classes are achieved by using abstraction.

Encapsulation vs Data Abstraction

• Encapsulation is data (information) hiding, abstraction is detailed (implementation).
• Encapsulation groups data and methods, hiding the details.
• Abstract classes and interfaces implement abstraction. Encapsulation is implementation level while abstraction is design level.

Key OOP Concepts

• Encapsulation, hiding data, inheritance, polymorphism, and abstraction.

Java Packages

• Package used to encapsulate groups of classes, sub packages, and interfaces.
• Used for preventing naming conflicts.
• Used for making it easier to search and use classes, interfaces, enumerations and annotations
• Protected and default packages are able to provide controlled access
• Packages act as data encapsulation/data-hiding.
• Related classes are put into packages and simply have an import class.
• Packages contain groups of related classes where some classes are accessible and exposed and some are kept internal
• You can reuse classes in packages as times as need.
• Package names and directory structure are related.
• More classes can be added using the package name and saving it in the package directory
• These are imported with the import declaration

Subpackages

• Packages inside other packages.
• These are not imported by default
• Members of a subpackage can only have access privileges if, for example, import java.util.*; and util is a subpackage.
• 2 Types: User defined and Built in packages

Core Packages

• These are a part of the Java API
• java.lang: language support classes. This package is automatically imported
• java.io: supporting input / output operations (I/O)
• java.util: utility classes to implement data structures, Date / Time operations.
• java.applet: creates Applets
• java.awt: implementing components for graphical user interfaces (GUIs)
• java.net: supporting networking operations.

User Defined packages

• These are the packages defined.
• Directory name should be the same as name of the package.
• MyClass is created inside the directory.
• The first statement is the package names to create this.

Exceptions in Handling

• User and programmer errors can cause issues.
• Programs anticipate these to prevent it.

Exception Handling Idea

• When an error occurs, an exception is thrown.
• The error code stops executing immediately and is transferred to the catch clause.
• A try block may be in if the function cannot handle the exception so then it is “passed up” the call chain to catch and resolve the problem. If nothing is handled, an error message is printed and code stops.
• Exceptions are either check or unchecked.
• If a method includes code that could cause a checked exception to be thrown, then a throws clause must be used or the code must be inside a try block with a catch clause.