Java Programming: Comprehensive Guide

from Basics to Advanced

1. Introduction to Java
What is Java?

● Java is a high-level, object-oriented programming language that allows developers to

write code that is easy to maintain and debug.
● Platform-independence is one of its core features, facilitated by the Java Virtual Machine
(JVM), enabling Java programs to run on diverse hardware and operating systems
without modification.
● Key Features:
○ Simple: Designed to be user-friendly and easy to learn.
○ Secure: Provides robust security features to protect data and applications.
○ Portable: Code written in Java can run anywhere without recompilation.
○ Object-Oriented: Promotes reusability and modular design.
○ Robust: Exception handling and memory management make Java programs
more reliable.
○ Multithreaded: Supports concurrent execution of code for better performance.
○ Distributed: Facilitates network-based applications.
○ Dynamic: Adapts to evolving environments with features like dynamic memory
allocation.

Setting up Java Environment

1. Download Java JDK: Obtain the latest version of the Java Development Kit (JDK)
suitable for your operating system (e.g., JDK 8, 11, or 17).
2. Install Java: Follow the installation steps specific to your operating system. Ensure to
note the installation directory for configuring environment variables.
3. Configure Environment Variables:
○ Set JAVA_HOME to the JDK installation directory.
○ Update the system PATH variable to include the bin directory of the JDK.

Verify installation:
java -version
javac -version

○ If installed correctly, these commands will display the installed Java version and
compiler version.
 4. Select an IDE: Integrated Development Environments (IDEs) like IntelliJ IDEA, Eclipse,
or lightweight editors like Visual Studio Code simplify Java development with features
like debugging, syntax highlighting, and project management.
5. Test with a Sample Program: Write and execute a simple Java program to ensure the
environment is set up correctly.

2. Java Basics
Hello World Program

The "Hello World" program is a simple example to illustrate the syntax and structure of a Java
program.

public class HelloWorld {

public static void main(String[] args) {
System.out.println("Hello, World!");
}
}

Explanation:

● public class HelloWorld: Declares a class named HelloWorld.

● public static void main(String[] args): Marks the entry point of the
program. This is where the execution starts.
● System.out.println: Outputs the specified text to the console, followed by a
newline.

Data Types

Java provides various data types to store different kinds of values. These are broadly classified
into:

1. Primitive Types:

○ Integer Types: byte, short, int, long

○ Floating-Point Types: float, double
○ Character Type: char
○ Boolean Type: boolean
○ Size and Range: Each primitive type has a specific size and range. For instance,
int is a 32-bit signed integer, while float is a 32-bit IEEE 754 floating-point.
 2. Non-Primitive Types:

○ Include String, Arrays, Classes, and Interfaces. These types store references
rather than actual values.

Example Program:
public class DataTypesExample {
public static void main(String[] args) {
int age = 25;
double salary = 55000.50;
char grade = 'A';
boolean isActive = true;

System.out.println("Age: " + age);

System.out.println("Salary: " + salary);
System.out.println("Grade: " + grade);
System.out.println("Is Active: " + isActive);
}
}

This program demonstrates the declaration, initialization, and use of various data types.

Control Statements

Control statements guide the flow of execution in a Java program. They are divided into:

1. Conditional Statements:

○ if, else, and else if are used for decision-making.

○ switch handles multiple conditions based on specific values.
2. Looping Statements:

○ for, while, and do-while execute code blocks repeatedly based on

conditions.

Example Program:
public class ControlStatementsExample {
public static void main(String[] args) {
int num = 10;

// If-Else
if (num % 2 == 0) {
System.out.println("Even number");
 } else {
System.out.println("Odd number");
}

// For Loop
for (int i = 0; i < 5; i++) {
System.out.println("i = " + i);
}

// Switch Case
switch (num) {
case 10:
System.out.println("Number is 10");
break;
default:
System.out.println("Unknown number");
}
}
}

This example demonstrates conditional logic and iterative execution in Java.

3. Object-Oriented Programming (OOP)

Key Concepts

Java emphasizes Object-Oriented Programming (OOP) principles to enhance code reusability,

modularity, and maintainability. The main pillars are:

1. Class and Object:

○ Class: Defines the structure and behavior of objects. It is a blueprint for creating
objects.
○ Object: An instance of a class containing attributes (fields) and behaviors
(methods).

Example:
class Car {
String brand;
int year;

void displayInfo() {
 System.out.println("Brand: " + brand + ", Year: " + year);
}
}

public class Main {

public static void main(String[] args) {
Car car1 = new Car();
car1.brand = "Toyota";
car1.year = 2022;
car1.displayInfo();
}
}

This example demonstrates creating and using a class and its instance.

2. Inheritance:
○ Allows a class (subclass) to inherit fields and methods from another class
(superclass).

Example:
class Animal {
void eat() {
System.out.println("This animal eats food.");
}
}

class Dog extends Animal {

void bark() {
System.out.println("The dog barks.");
}
}

public class Main {

public static void main(String[] args) {
Dog dog = new Dog();
dog.eat();
dog.bark();
}
}

This example shows how a subclass inherits methods from its superclass.

3. Polymorphism:
 ○ Allows methods to take different forms. Types include:
■ Method Overloading: Same method name but different parameters.
■ Method Overriding: A subclass provides a specific implementation of a
superclass method.

Example:
class Calculator {
// Overloading
int add(int a, int b) {
return a + b;
}

double add(double a, double b) {

return a + b;
}
}

class AdvancedCalculator extends Calculator {

// Overriding
@Override
int add(int a, int b) {
return super.add(a, b) + 10;
}
}

public class Main {

public static void main(String[] args) {
AdvancedCalculator calc = new AdvancedCalculator();
System.out.println("Sum: " + calc.add(5, 10));
}
}

4. Encapsulation:
○ Restricts direct access to fields and methods, providing controlled access via
getters and setters.

Example:
class Employee {
private String name;

public String getName() {

return name;
}
 public void setName(String name) {
this.name = name;
}
}

public class Main {

public static void main(String[] args) {
Employee emp = new Employee();
emp.setName("John Doe");
System.out.println("Employee Name: " + emp.getName());
}
}

5. Abstraction:
○ Abstraction is a mechanism to hide implementation details while exposing only
the essential features or behaviors of an object. In Java, abstraction is realized
through abstract classes and interfaces. Abstract constructs promote
modularity, scalability, and a decoupled architecture, essential for maintaining
large-scale systems.

Abstract Classes:
An abstract class can define both concrete methods (with implementations) and abstract
methods (without implementations). It is intended to serve as a blueprint for subclasses.
Example:
java
Copy code
abstract class Shape {
String color;

// Constructor
Shape(String color) {
this.color = color;
}

// Abstract method
abstract double area();

// Concrete method
void displayColor() {
System.out.println("Color: " + color);
 }
}

class Circle extends Shape {

double radius;

Circle(String color, double radius) {

super(color);
this.radius = radius;
}

@Override
double area() {
return Math.PI * radius * radius;
}
}

class Rectangle extends Shape {

double length, width;

Rectangle(String color, double length, double width) {

super(color);
this.length = length;
this.width = width;
}

@Override
double area() {
return length * width;
}
}

public class Main {

public static void main(String[] args) {
Shape circle = new Circle("Red", 5.0);
circle.displayColor();
System.out.println("Circle Area: " + circle.area());
 Shape rectangle = new Rectangle("Blue", 4.0, 6.0);
rectangle.displayColor();
System.out.println("Rectangle Area: " + rectangle.area());
}
}

6.
○ The Shape class defines the shared properties and behavior, such as color and
displayColor, while delegating the area calculation to its subclasses
(Circle and Rectangle).

Interfaces:
An interface in Java specifies a contract that implementing classes must adhere to. It can
include method declarations and, starting with Java 8, default and static methods with
implementations.
Example:
java
Copy code
interface Drawable {
void draw(); // Abstract method
}

interface Resizable {
void resize(double factor); // Abstract method
}

class Graphic implements Drawable, Resizable {

String name;

Graphic(String name) {
this.name = name;
}

@Override
public void draw() {
System.out.println(name + " is being drawn.");
}

@Override
public void resize(double factor) {
 System.out.println(name + " is resized by a factor of " +
factor);
}
}

public class Main {

public static void main(String[] args) {
Graphic graphic = new Graphic("Rectangle");
graphic.draw();
graphic.resize(2.5);
}
}

7.
○ The Drawable and Resizable interfaces specify distinct behaviors. The
Graphic class implements both interfaces, showcasing Java's support for
multiple inheritance of types.
8. Abstract Classes vs. Interfaces:
○ Abstract Classes: Suitable when there is shared state or behavior among
subclasses.
○ Interfaces: Ideal for defining capabilities or contracts that multiple classes,
potentially unrelated, can implement.

By leveraging abstraction, Java fosters a design philosophy that prioritizes high-level constructs
and separates the "what" from the "how," ensuring better code maintainability and adaptability.