Java Programming Basics

Variable Declaration

• Basic Syntax:
  • Data Type followed by variable name, ending with a semicolon.
  • Example: int age;
• Initialization:
  • Assign a value at the time of declaration or later.
  • Example: int age = 25;
• Data Types:
  • Primitive Types: int, float, double, char, boolean
  • Reference Types: Any object (e.g., instances of classes)
• Final Variables:
  • Declared with the final keyword.
  • Cannot be reassigned after initial assignment.
  • Example: final int MAX_VALUE = 100;

Control Statements

• Conditional Statements:
  • if, else if, else
  • Example:

    if (condition) {
        // code block
    } else {
        // code block
    }
    

  • switch statement for multiple conditions.
• Looping Statements:
  • for, while, do-while
  • Example of for loop:

    for (int i = 0; i < 10; i++) {
        // code block
    }
    

• Break and Continue:
  • break: exits the loop or switch statement.
  • continue: skips the current iteration and proceeds to the next.

Methods And Functions

• Definition: A method is a block of code that performs a specific task.
• Syntax:
  • Return Type, Method Name, Parameters (optional).
  • Example:

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

• Overloading: Same method name with different parameters.
• Static Methods: Can be called without creating an instance of a class.
• Main Method: Entry point of any Java program.
  • Syntax: public static void main(String[] args)

Object-oriented Principles

• Encapsulation:
  • Bundling data (variables) and methods that operate on the data into a single unit (class).
  • Access modifiers: private, public, protected
• Inheritance:
  • Mechanism where one class acquires properties (methods and fields) of another class.
  • Use of extends keyword.
• Polymorphism:
  • Ability to present the same interface for different underlying data types.
  • Types: Compile-time (method overloading) and Runtime (method overriding).
• Abstraction:
  • Hiding complex implementation details and showing only the essentials.
  • Achieved using abstract classes and interfaces.

Exception Handling

• Purpose: To manage runtime errors and maintain normal program flow.
• Keywords:
  • try: Block of code to be tested for exceptions.
  • catch: Block that handles the exception.
  • finally: Block that runs regardless of exception occurrence.
  • throw: Used to explicitly throw an exception.
  • throws: Indicates that a method can throw an exception.
• Syntax:

  try {
      // code that may throw an exception
  } catch (ExceptionType e) {
      // handler code
  } finally {
      // code that runs regardless of exception
  }
  

• Custom Exceptions: Create user-defined exceptions by extending the Exception class.

Declaració de Variables

• Sintaxi Bàsica: Especifiqueu el tipus de dada seguit pel nom de la variable, amb un punt i coma al final. Exemple: int age;
• Inicialització: Assignació d'un valor en el moment de la declaració o posteriorment. Exemple: int age = 25;
• Tipus de Dades:
  • Tipus Primitiv: int, float, double, char, boolean
  • Tipus de Referència: Qualsevol objecte (per exemple, instàncies de classes)
• Variables Finals: Declarades amb la paraula clau final, no es poden reasignar després de la seva assignació inicial. Exemple: final int MAX_VALUE = 100;

Declaracions de Control

• Declaracions Condicionals:
  • Utilitzen if, else if, else per determinar el flux del programa.
  • Exemple de if:

    if (condition) {
        // bloc de codi
    } else {
        // bloc de codi
    }
    

  • Declaracions switch per gestionar múltiples condicions.
• Declaracions de Bucle:
  • Comportament de repetició amb for, while, do-while.
  • Exemple de bucle for:

    for (int i = 0; i < 10; i++) {
        // bloc de codi
    }
    

• Break i Continue:
  • break: Surt del bucle o declaració switch.
  • continue: Salta la iteració actual i continua amb la seguent.

Mètodes i Funcions

• Definició: Cal destacar que un mètode és un bloc de codi que realitza una tasca específica.
• Sintaxi:
  • Tipus de retorn, nom del mètode i paràmetres (opcions). Exemple:

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

• Sobrecàrrega: Permet tenir el mateix nom de mètode amb diferents paràmetres.
• Mètodes Estàtics: Poden ser cridats sense crear una instància d'una classe.
• Mètode Principal: Punt d'entrada de qualsevol programa Java. Sintaxi: public static void main(String[] args)

Principis de Programació Orientada a Objectes

• Encapsulació: Agrupació de dades (variables) i mètodes en una única unitat (classe). Modificadors d'accés: private, public, protected.
• Herència: Mecanisme permetent que una classe adquireixi propietats (mètodes i camps) d'una altra classe, utilitzant la paraula clau extends.
• Polimorfisme: Capacitat de presentar la mateixa interfície per a diferents tipus de dades subjacents. Tipus:
  • En temps de compilació (sobrecàrrega de mètodes)
  • En temps d'execució (sobreescriptura de mètodes).
• Abstracció: Ometre detalls d'implementació complexos i mostrar només l'essencial, aconseguit mitjançant classes abstractes i interfícies.

Gestió d'Excepcions

• Propòsit: Gestionar errors en temps d'execució i mantenir el flux normal del programa.
• Paraules clau:
  • try: Bloc de codi a provar per excepcions.
  • catch: Bloc que gestiona l'excepció.
  • finally: Bloc que sempre s'executa, independentment de si hi ha excepcions.
  • throw: Utilitzada per llançar explícitament una excepció.
  • throws: Indica que un mètode pot llançar una excepció.
• Sintaxi d'Excepcions:

  try {
      // codi que pot llençar una excepció
  } catch (ExceptionType e) {
      // codi de gestió
  } finally {
      // codi que s'executa independentment de l'excepció
  }
  

• Excepcions Personalitzades: Es poden crear excepcions definides per l'usuari ampliant la classe Exception.