Java Exam revision

 Method overloading (n. traceable) and method overriding

In Java, method overloading and method overriding are two important concepts related to
polymorphism and method invocation. They allow developers to create multiple methods with
the same name but different parameters or behaviors. Here's an explanation of method
overloading and method overriding:

Method Overloading:
Method overloading refers to the practice of defining multiple methods in a class with the same
name but different parameter lists. It enables a class to have multiple methods with similar
functionality but varying input parameters. The compiler determines which overloaded method
to invoke based on the number, order, and types of arguments passed during method invocation.
Key points about method overloading include:

1. Same method name: Overloaded methods share the same name.

2. Different parameters: Overloaded methods have different parameter lists (number, order,
or types of parameters).
3. Return type: The return type of the method does not play a role in method overloading.
4. Occurs within a class: Method overloading happens within a single class.

Example of method overloading:

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

public double add(double a, double b) {

return a + b;
}
}

In the example above, the Calculator class has two add methods. One method accepts two
integers as parameters, while the other method accepts two doubles. The appropriate method is
called based on the argument types during invocation.

Method Overriding:
Method overriding occurs when a subclass provides its own implementation of a method that is
already defined in its superclass. In other words, the subclass redefines a method inherited from
the superclass to customize the behavior of that method. The method signature (name, return
type, and parameter list) must be the same in both the superclass and subclass. Key points about
method overriding include:
 1. Same method signature: Overriding methods have the same name, return type, and
parameter list as the method in the superclass.
2. Occurs in inheritance hierarchy: Method overriding happens between a superclass and its
subclass.
3. Allows customization: Subclasses can provide different or specialized implementations
of inherited methods.

Example of method overriding:

java
public class Animal {
public void makeSound() {
System.out.println("Animal makes a sound");
}
}

public class Dog extends Animal {

@Override
public void makeSound() {
System.out.println("Dog barks");
}
}

In the example above, the Animal class has a makeSound method, and the Dog class extends
Animal and overrides the makeSound method. When the makeSound method is called on a Dog
object, it executes the overridden implementation defined in the Dog class instead of the one in
the Animal class.

Method overloading and method overriding are powerful techniques in Java that allow
developers to write more flexible and reusable code by providing different behaviors for methods
based on the context or input parameters.

 Object oriented programming(OOP)

 Polymorphism
 Abstraction
 Inheritance
 Encapsulation

Certainly! Here's an explanation of the four key object-oriented programming (OOP) concepts in
Java: polymorphism, abstraction, inheritance, and encapsulation:
 1. Polymorphism:
Polymorphism is the ability of an object to take on different forms or have multiple types.
In Java, polymorphism is primarily achieved through method overriding and method
overloading.

 Method overriding: It allows a subclass to provide its own implementation of a method

that is already defined in its superclass. This enables different objects to respond to the
same method call in different ways based on their specific implementations.
 Method overloading: It involves defining multiple methods with the same name but
different parameter lists within a class. The appropriate method is chosen based on the
arguments passed during method invocation.

Polymorphism allows for code flexibility, extensibility, and the ability to write more generic and
reusable code.

2. Abstraction:
Abstraction refers to the process of simplifying complex systems by modeling and
representing only the essential features relevant to the problem domain. In Java,
abstraction is achieved through abstract classes and interfaces.

 Abstract classes: An abstract class serves as a blueprint for other classes and cannot be
instantiated on its own. It may contain abstract methods (methods without
implementation) that must be overridden by concrete subclasses.
 Interfaces: An interface defines a contract of methods that a class implementing the
interface must adhere to. It specifies a set of behaviors that an implementing class must
provide, without specifying how those behaviors are implemented.

Abstraction allows developers to create high-level and modular code by hiding implementation
details and focusing on the essential aspects of an object or system.

3. Inheritance:
Inheritance is a mechanism in Java that allows a class (called the subclass or derived
class) to inherit properties and behaviors from another class (called the superclass or base
class). The subclass inherits the fields and methods of the superclass, allowing for code
reuse and specialization.

 Single inheritance: A subclass can inherit from only one superclass.

 Multilevel inheritance: A subclass can inherit from a superclass, which in turn may
inherit from another superclass.

Inheritance supports code reuse, extensibility, and the creation of hierarchical relationships
between classes.
 4. Encapsulation:
Encapsulation is the practice of bundling data (fields) and methods that operate on that
data into a single unit called a class. It allows data to be hidden or protected from direct
access by other classes, and provides controlled access through methods (getters and
setters).

Encapsulation provides data security, maintains data integrity, and allows for better
maintainability and flexibility of code.

These four concepts are fundamental to object-oriented programming in Java and provide the
foundation for writing modular, reusable, and maintainable code.