Introduction to Java Programming

• Java is a high-level, class-based, object-oriented programming language that is designed to have as few implementation dependencies as possible
• It is a general-purpose programming language intended to let application developers write once, run anywhere (WORA), meaning that compiled Java code can run on all platforms that support Java without the need for recompilation
• Java applications are typically compiled to bytecode that can run on any Java virtual machine (JVM) regardless of the underlying computer architecture
• The Java syntax is similar to C and C++, but it has fewer low-level facilities than either of them
• The Java runtime provides dynamic capabilities, such as reflection and runtime code modification, that are not typically available in traditional compiled languages

Key Concepts of Object-Oriented Programming (OOP) in Java

• OOP is a programming paradigm based on the concept of "objects", which contain data (attributes) and code (methods) that operate on the data
• OOP focuses on modularity, reusability, and maintainability

Core Principles of OOP

• Encapsulation
• Abstraction
• Inheritance
• Polymorphism

Encapsulation

• Encapsulation is the bundling of data (attributes) and methods that operate on that data into a single unit (class)
• It restricts direct access to some of the object's components, which is known as data hiding
• Access to the data is typically allowed through methods (getters and setters)
• This ensures data integrity and prevents unintended modification of the object's state

Example of Encapsulation

 class BankAccount {
     private double balance; // Private attribute
 
     public double getBalance() { // Getter method
         return balance;
     }
 
     public void deposit(double amount) { // Setter method
         balance += amount;
     }
 }

• In this example, the balance attribute is private, and access to it is controlled through the getBalance() and deposit() methods

Abstraction

• Abstraction is the process of hiding complex implementation details and showing only the necessary information to the user
• It simplifies the usage of objects by providing a high-level interface
• In Java, abstraction is achieved using abstract classes and interfaces

Example of Abstraction using an Abstract Class

 abstract class Shape {
     abstract double area(); // Abstract method
 
     public void display() {
         System.out.println("This is a shape.");
     }
 }
 
 class Circle extends Shape {
     double radius;
 
     public Circle(double radius) {
         this.radius = radius;
     }
 
     @Override
     double area() {
         return Math.PI * radius * radius;
     }
 }

• The Shape class provides an abstract representation of a shape, and the Circle class provides a concrete implementation

Inheritance

• Inheritance is a mechanism in which one class (subclass or derived class) inherits properties and methods from another class (superclass or base class)
• It promotes code reuse and establishes a relationship between classes
• Java supports single inheritance (a class can inherit from only one class) but allows multiple inheritance through interfaces

Example of Inheritance

 class Animal {
     String name;
 
     public void eat() {
         System.out.println("Animal is eating.");
     }
 }
 
 class Dog extends Animal {
     public void bark() {
         System.out.println("Dog is barking.");
     }
 }

• The Dog class inherits the name attribute and eat() method from the Animal class and adds its own bark() method

Polymorphism

• Polymorphism means "many forms"
• It allows objects of different classes to be treated as objects of a common type
• Java supports polymorphism through method overloading and method overriding

Method Overloading

• Method overloading occurs when multiple methods in the same class have the same name but different parameters

 class Calculator {
     public int add(int a, int b) {
         return a + b;
     }
 
     public double add(double a, double b) {
         return a + b;
     }
 }

• The add() method is overloaded to accept different types of parameters

Method Overriding

• Method overriding occurs when a subclass provides a specific implementation of a method that is already defined in its superclass

 class Animal {
     public void makeSound() {
         System.out.println("Generic animal sound.");
     }
 }
 
 class Dog extends Animal {
     @Override
     public void makeSound() {
         System.out.println("Woof!");
     }
 }

• The makeSound() method is overridden in the Dog class to provide a specific implementation

Classes and Objects in Java

• Class: A class is a blueprint or template for creating objects
• It defines the data (attributes) and behavior (methods) that the objects of the class will have
• Object: An object is an instance of a class
• It is a real-world entity with its own state and behavior

Creating Classes and Objects

 // Define a class
 class Car {
     String model;
     String color;
 
     public void start() {
         System.out.println("Car started.");
     }
 }
 
 // Create an object
 public class Main {
     public static void main(String[] args) {
         Car myCar = new Car();
         myCar.model = "Tesla Model 3";
         myCar.color = "Red";
         myCar.start();
     }
 }

• Here, Car is a class, and myCar is an object of the Car class

Key Features of Java

• Platform Independence: Java's "write once, run anywhere" capability is achieved through the Java Virtual Machine (JVM)
• Object-Oriented: Supports OOP principles, enabling modular and reusable code
• Automatic Memory Management: Java uses garbage collection to automatically manage memory, reducing memory leaks
• Robust: Java has strong compile-time and runtime error checking
• Secure: Includes features such as security manager and bytecode verification to protect against malicious code
• Multithreaded: Supports multithreading, allowing multiple threads to execute concurrently

Importance of OOP in Java

• Modularity: Breaks down complex programs into manageable objects
• Reusability: Enables code reuse through inheritance and composition
• Maintainability: Simplifies code maintenance and updates
• Flexibility: Allows easy modification and extension of code
• Scalability: Supports the development of large-scale applications