Java programming CSC 321

Java is a high-level, object-oriented programming language developed by Sun

Microsystems, released in 1995. It is designed to be platform-independent,
meaning that Java code can run on any device equipped with a Java Virtual
Machine (JVM), adhering to the principle "write once, run anywhere."

Key Features of Java

1. Object-Oriented: Java is based on objects and classes, promoting code

reuse and modularity.
2. Platform-Independent: Java code is compiled into bytecode, which can
be executed on any system with a JVM.
3. Simple and Familiar: Java's syntax is similar to C++, but with simpler
memory management and fewer low-level operations.
4. Secure: Java includes features that help develop secure applications, such
as the absence of pointers and a robust security model.
5. Multithreaded: Java supports multithreading, allowing concurrent
execution of two or more threads for maximum utilization of CPU.
6. Robust and Stable: Java has strong memory management, exception
handling, and type-checking mechanisms.
7. Portable: Java programs are portable across different platforms without
modification.
8. Dynamic: Java is designed to adapt to evolving environments, with the
ability to link new class libraries, methods, and objects dynamically.

Core Components

1. Java Development Kit (JDK): Includes the tools needed to write and
test Java programs.
 2. Java Runtime Environment (JRE): Provides the libraries, JVM, and
other components to run Java applications.
3. Java Virtual Machine (JVM): Executes Java bytecode on any device or
operating system.

Basic Concepts

1. Class: Blueprint from which individual objects are created.

2. Object: Instance of a class containing data and methods.
3. Inheritance: Mechanism by which one class inherits the fields and
methods of another class.
4. Polymorphism: Ability of different classes to respond to the same
method call in different ways.
5. Encapsulation: Restricting access to certain components and bundling
the data and methods that operate on the data.
6. Abstraction: Hiding complex implementation details and showing only
the necessary features of an object.

Example Code

Here's a simple Java program that prints "Hello, World!" to the console:

java

Basic Structure of a Java Program

A Java program typically consists of classes and methods. Each Java application
must have at least one class and one main method, which serves as the entry
point of the program.

Syntax in Java
Syntax in Java refers to the set of rules that defines the structure and
composition of valid statements and expressions in the language. It dictates how
various programming constructs should be arranged to form a correctly
structured Java program.

Basic Elements of Java Syntax

1. Keywords: Reserved words that have a predefined meaning in the

language and cannot be used for variable names. Examples include class,
public, static, void, if, else, for, while, switch, etc.
2. Identifiers: Names given to variables, classes, methods, etc. They must
start with a letter, dollar sign ($), or underscore (_) and can be followed
by letters, digits, dollar signs, or underscores. Identifiers are case-
sensitive.
3. Literals: Represent fixed values in the code. Examples include:
o Integer literals: 10, -5
o Floating-point literals: 3.14, -0.01
o Character literals: 'a', 'Z'
o String literals: "Hello, World!"
o Boolean literals: true, false
4. Operators: Symbols that perform operations on variables and values.
Examples include +, -, *, /, =, ==, !=, >, <, &&, ||, etc.
5. Separators: Characters used to separate code elements. Examples
include:
o Semicolon (;): Ends a statement
o Comma (,): Separates variables in a list
o Parentheses (()): Encloses arguments in method calls
o Curly braces ({}): Defines a block of code
o Square brackets ([]): Declares arrays
 6. Comments: Text that is ignored by the compiler and is used to add notes
to the code.
o Single-line comment: // This is a single-line comment
o Multi-line comment: /* This is a multi-line comment */
o Documentation comment: /** This is a documentation comment */

Object-Oriented Programming (OOP) is a programming paradigm based on the

concept of "objects," which are instances of classes. It aims to structure
software in a way that models real-world entities, promoting code reuse,
modularity, and maintainability. The four fundamental principles of OOP are
encapsulation, inheritance, polymorphism, and abstraction.

1. Encapsulation

Encapsulation is the mechanism of bundling data (attributes) and methods

(functions) that operate on the data into a single unit, called a class. It restricts
direct access to some of the object's components, which is a means of
preventing unintended interference and misuse of the methods and data.
Encapsulation is achieved using access modifiers like private, protected, and
public.

2. Inheritance

Inheritance is a mechanism where a new class, known as a subclass (or derived

class), inherits properties and behavior (methods) from an existing class, known
as a superclass (or base class). This promotes code reuse and establishes a
hierarchical relationship between classes.

3. Polymorphism
Polymorphism allows methods to do different things based on the object it is
acting upon, even though they share the same name. It can be achieved in two
ways: method overriding (runtime polymorphism) and method overloading
(compile-time polymorphism).

 Method Overriding: A subclass provides a specific implementation for a

method that is already defined in its superclass.

4. Abstraction

Abstraction is the concept of hiding the complex implementation details and

showing only the necessary features of an object. It helps in reducing
programming complexity and effort. In Java, abstraction is achieved using
abstract classes and interfaces.

 Abstract Class: A class that cannot be instantiated and may contain

abstract methods (without implementation).

Object-Oriented Programming (OOP) and Procedural Programming are two

prominent programming paradigms, each with its own approaches to organizing
code and solving problems. Here's a comparison of their key concepts, benefits,
and differences:

Object-Oriented Programming (OOP)

Key Concepts:

1. Classes and Objects: Programs are structured around objects, which are
instances of classes.
2. Encapsulation: Data and methods are bundled into classes, with access
control mechanisms.
 3. Inheritance: Classes can inherit properties and behaviors from other
classes.
4. Polymorphism: Methods can behave differently based on the objects
they act upon.
5. Abstraction: Complex details are hidden, exposing only the necessary
parts.

Benefits:

1. Modularity: Code is organized into classes and objects, making it easier

to manage and understand.
2. Reusability: Inheritance and polymorphism promote code reuse.
3. Maintainability: Encapsulation makes it easier to maintain and modify
code.
4. Flexibility and Scalability: OOP systems are easier to scale and extend.

Procedural Programming

Key Concepts:

1. Procedures/Functions: Programs are structured around procedures or

functions, which are blocks of code that perform specific tasks.
2. Sequential Execution: Code is executed in a linear, top-down manner.
3. Global and Local Variables: Variables can be declared globally or
locally within functions.
4. Modularity: Code is divided into functions for reusability and
organization.

Benefits:

1. Simplicity: Easier to understand and implement for small,

straightforward tasks.
 2. Performance: Can be more efficient in terms of memory and speed for
certain applications.
3. Ease of Implementation: Suitable for problems that are well-defined in a
sequential manner.

Contrasts:

1. Approach to Design:
o OOP: Focuses on modeling real-world entities as objects,
promoting a more intuitive mapping between real-world concepts
and program structures.
o Procedural: Focuses on a sequence of tasks or operations,
emphasizing the flow of control and sequence of function calls.
2. Data and Behavior:
o OOP: Data and behavior are bundled together within objects. The
state of an object is modified through its methods.
o Procedural: Data and functions are separate. Functions operate on
data, and the data state is managed globally or passed around.
3. Complexity Management:
o OOP: Better suited for managing complexity in large systems
through abstraction, encapsulation, and modularity.
o Procedural: Can lead to "spaghetti code" in large systems due to
less emphasis on modularity and data encapsulation.
4. Reusability and Extensibility:
o OOP: High, due to inheritance and polymorphism. New features
can be added with minimal changes to existing code.
o Procedural: Lower, as code reuse is limited to function calls and
often requires significant changes for new features.