Concepto de clase y objeto

1. ¿Qué es una clase y un objeto?

Empecemos con una analogía. Imagina el plano de un coche. En el plano se indica que el coche tiene cuatro ruedas, un motor, un color, asientos, etc. Pero el plano en sí no circula por las carreteras, no hace ruido de motor ni consume gasolina. Es solo una descripción de cómo está construido el coche.

Una clase en programación es ese mismo «plano» (o plantilla) que define qué datos (campos) y qué acciones (métodos) tendrán sus instancias.

Un objeto es el coche «real» ensamblado según ese plano, es decir, un ejemplar concreto. Cada objeto tiene su propio estado (por ejemplo, un coche puede ser rojo y otro — azul) y su comportamiento: cada objeto puede realizar las acciones definidas en la clase (por ejemplo, avanzar, frenar, pitar).

Ejemplos de la vida real

• Clase: Persona (Person): la descripción de que una persona tiene nombre, edad, estatura y que puede hablar o correr.
• Objetos: Vasya, Petya, Katya — personas concretas, cada una con su propio nombre y edad.

Person

name = "Vasya" 
age = 25

name = "Katya" 
age = 30

¿Por qué son importantes las clases?

• Agrupar variables y métodos relacionados.
• Crear tantos objetos como se quiera con la misma estructura, pero con datos diferentes.
• Describir fácilmente entidades complejas: por ejemplo, «Cuenta bancaria», «Producto», «Libro», «Usuario».

2. Sintaxis para declarar una clase

En Java, una clase se declara con la palabra clave class. A continuación va el nombre de la clase (por tradición, con mayúscula inicial) y luego las llaves, dentro de las cuales se escriben los campos y los métodos.

Ejemplo más simple

public class Person {
    // Aquí irán los campos y los métodos
}

Explicación:

• public — modificador de acceso.
• class — le dice al compilador: «estoy declarando una clase».
• Person — nombre de la clase (lo eliges tú, pero con mayúscula inicial).

Reglas importantes de nomenclatura de clases

• El nombre de la clase debe empezar por mayúscula (por ejemplo, Car, Account, Book).
• En el nombre de la clase no se permiten espacios ni caracteres especiales, salvo el guion bajo y $ (aunque esto último es raro).
• Si el nombre consta de varias palabras, usa el estilo CamelCase: BankAccount, BookStore.

¿Dónde escribir clases?

Una clase puede declararse en un archivo aparte (lo habitual: un archivo — una clase) o dentro de otra clase (hablaremos de clases anidadas más adelante).

Por ejemplo, el archivo Person.java:

public class Person {
    // campos y métodos
}

3. Campos y métodos de una clase (breve)

De momento solo hemos declarado una clase, pero está vacía — como una caja sin contenido. Añadamos «propiedades» (campos) y «acciones» (métodos).

Campos (variables dentro de la clase)

Los campos describen qué datos tendrá cada objeto de esa clase.

public class Person {
    String name; // nombre de la persona
    int age;     // edad
}

Métodos (funciones dentro de la clase)

Los métodos describen qué sabe hacer el objeto.

public class Person {
    String name;
    int age;

    void sayHello() {
        System.out.println("¡Hola, me llamo " + name + "!");
    }
}

Explicación:

• void — el método no devuelve nada (hablaremos de valores de retorno más adelante).
• sayHello() — nombre del método; los paréntesis son obligatorios.
• Dentro del método se puede acceder a los campos de la clase (por ejemplo, a name).

4. Creación de un objeto

¡Y ahora — la magia! ¿Cómo convertir el plano en un «coche real»? Para ello se usa la palabra clave new.

Sintaxis de creación de un objeto

Person John = new Person();

• Person — el tipo de la variable (nuestra clase).
• John — el nombre de la variable (puede ser cualquiera).
• new Person() — creación de un nuevo objeto de tipo Person.

Ahora tenemos la variable John, que referencia a un objeto de la clase Person. Ese objeto tiene sus propios campos y métodos.

Acceso a campos y métodos

Accedemos a los campos y métodos con el punto:

John.name = "Vasya";
John.age = 25;

John.sayHello(); // Imprimirá: ¡Hola, me llamo Vasya!

Se pueden crear tantos objetos como se quiera

Person Pete = new Person();
Pete.name = "Petya";
Pete.age = 30;

Pete.sayHello(); // ¡Hola, me llamo Petya!

Cada objeto es una «copia» independiente con sus propios datos.

5. Relación con temas anteriores

Hasta hoy, todas las variables y métodos los declarábamos directamente dentro de la clase con el método main, sin plantearnos crear tipos propios. Ahora podemos crear nuestros propios «contenedores» de datos y funciones.

¡Esto abre enormes posibilidades! Ahora puedes describir cualquier entidad que aparezca en tu problema: clientes, productos, cuentas, pedidos, animales, coches — lo que sea. Los programas se vuelven más estructurados, legibles y escalables.

Ejemplo: nuestra primera clase propia

Escribamos una clase sencilla para nuestro mini‑programa — por ejemplo, «Cuenta bancaria» (BankAccount). Iremos ampliando este ejemplo a medida que avance el curso.

public class BankAccount {
    String owner;     // titular de la cuenta
    int balance;      // saldo de la cuenta

    void printInfo() {
        System.out.println("Titular: " + owner + ", saldo: " + balance + " euros.");
    }
}

Ahora, en el método principal main (que sigue siendo necesario para ejecutar el programa) podemos crear objetos de esta clase:

public class Main {
    public static void main(String[] args) {
        BankAccount account1 = new BankAccount();
        account1.owner = "Ivan";
        account1.balance = 1000;
        account1.printInfo(); // Titular: Ivan, saldo: 1000 euros.

        BankAccount account2 = new BankAccount();
        account2.owner = "Maria";
        account2.balance = 2000;
        account2.printInfo(); // Titular: Maria, saldo: 2000 euros.
    }
}

Atención: cada objeto tiene sus propios valores de campos. Si cambias el saldo de account1, eso no afectará a account2.

Esquema visual: clase y objetos

graph TD
    subgraph Class
        Person["Class Person | name:String | age:int | sayHello()"]
    end

    subgraph Objects
        John["John : Person | name = 'Vasya' | age = 20"]
        Pete["Pete : Person | name = 'Petya' | age = 25"]
    end

    John --> Person
    Pete --> Person

Explicación:

• Person — es la clase (plantilla).
• John y Pete — son objetos (instancias) creados a partir de esa plantilla.

6. Errores típicos al declarar clases y crear objetos

Error n.º 1: nombre de la clase en minúscula.
En Java se acostumbra (el compilador no se queja, ¡pero los programadores con experiencia sí!) a nombrar las clases con mayúscula inicial. No escribas class person — escribe class Person.

Error n.º 2: falta de llaves.
No olvides que el cuerpo de la clase siempre debe ir entre llaves.

public class Person // ¡error!
    String name;

Correcto:

public class Person {
    String name;
}

Error n.º 3: intentar acceder a campos y métodos de la clase sin crear un objeto.
Si el método o el campo no están declarados como static, solo se puede acceder a ellos a través de un objeto:

Person.sayHello(); // ¡error!

Correcto:

Person John = new Person();
John.sayHello();

Error n.º 4: discrepancia entre el nombre del archivo y el de la clase (para una clase public).
Si la clase se declara como public, el nombre del archivo debe coincidir con el de la clase:

// Archivo Person.java
public class Person { ... }

Si el archivo se llama de otra forma, el compilador producirá un error.

Error n.º 5: usar campos de la clase sin inicializar un objeto.
Los campos de clase (no static) pertenecen al objeto, no a la clase en sí.