Estructura de una clase: campos, métodos, constructores

1. Campos de la clase: dónde guardamos el estado del objeto

Un campo es una variable que se declara dentro de una clase pero fuera de cualquier método. Los campos se encargan de que cada objeto tenga su propio «estado». Por ejemplo, si tenemos una clase Person, los campos pueden ser así:

• name — nombre de la persona
• age — edad
• balance — saldo en la cuenta (si, por ejemplo, estamos creando una aplicación bancaria)
• isStudent — indicador de si la persona es estudiante

Sintaxis de la declaración de un campo

La declaración de un campo se parece a la de una variable normal, solo que no está dentro de un método, sino directamente en la clase:

public class Person {
    String name;
    int age;
}

Aquí hemos declarado dos campos: una cadena name y un entero age. Cada campo pertenecerá a un objeto concreto de esta clase. Eso significa que distintos objetos tendrán sus propios valores. Por ejemplo:

Person p1 = new Person();
p1.name = "Olya";
p1.age = 20;

Person p2 = new Person();
p2.name = "Igor";
p2.age = 25;

El primer objeto tiene el nombre «Olya» y la edad 20, y el segundo — «Igor» y 25. Ambos están hechos a partir de la misma clase, pero sus campos almacenan datos distintos.

Modificadores de acceso (public/private)

Los campos pueden ser públicos (public) o privados (private). En la vida real no cuentas a cualquiera tu saldo bancario, ¿verdad? Pues en programación a menudo se hacen los campos private para que no se pueda acceder a ellos directamente desde otras clases. Esto forma parte del principio de encapsulación (más detalles en próximas sesiones).

Ejemplo:

public class Person {
    private String name;
    private int age;
}

De momento no complicaremos más, pero recuerda: si un campo es private, no se puede acceder a él directamente desde otra clase.

2. Métodos de la clase: cómo «actúan» los objetos

Un método es una función que describe el comportamiento de un objeto. Los métodos permiten que el objeto haga cosas: hablar, calcular, correr, saltar, mostrar información sobre sí mismo, etc.

Sintaxis de declaración de un método

tip_vozvrashchaemogo_znacheniya imyaMetoda(parametry) {
    // cuerpo del método
}

Ejemplo de un método que dice «Hola»:

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

Aquí:

• public — modificador de acceso.
• void — el método no devuelve nada (solo hace algo).
• sayHello — nombre del método.
• Dentro del método usamos el campo name para saludar al usuario.

Otro ejemplo: un método que devuelve la edad

public int getAge() {
    return age;
}

Los métodos pueden devolver valores (int, String, etc.) o pueden «no devolver nada» — en ese caso escribimos void.

3. Constructores: cómo «nacen» los objetos

Un constructor es un método especial que se ejecuta al crear un nuevo objeto. Su tarea es inicializar los campos del objeto con valores iniciales, es decir, llenar los «bolsillos vacíos» del objeto con datos concretos. Por ejemplo, establecer el nombre y la edad de una persona en el momento de su creación en lugar de dejarlos vacíos.

• El nombre del constructor siempre coincide con el nombre de la clase.
• Un constructor no tiene tipo de retorno (ni siquiera se escribe void).
• Los constructores pueden recibir parámetros (por ejemplo, nombre y edad) o no tenerlos.

Ejemplo de constructor

public class Person {
    String name;
    int age;

    // Constructor con dos parámetros
    public Person(String name, int age) {
        this.name = name; // this.name — campo del objeto, name — parámetro del constructor
        this.age = age;
    }
}

Probablemente te estés preguntando qué es eso de this. Pues bien, la palabra clave this es una referencia al objeto actual. Desde dentro. La usamos para distinguir el campo de la clase del parámetro con el mismo nombre. Sin this, el compilador se confundiría acerca de qué es exactamente lo que queremos inicializar.

Constructor por defecto

Si no declaras ningún constructor, el compilador de Java añadirá automáticamente un constructor vacío sin parámetros. Tiene este aspecto:

public Person() {
    // no hace nada, pero permite crear un objeto sin parámetros
}

¡PERO! Si declaras al menos un constructor propio (por ejemplo, con parámetros), el constructor por defecto ya no se genera automáticamente. Si lo necesitas, escríbelo explícitamente.

4. Ejemplo de una clase completa

Juntémoslo todo: campos, métodos y constructor.

public class Person {
    String name;
    int age;

    // Constructor
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // Método: saludar
    public void sayHello() {
        System.out.println("¡Hola! Me llamo " + name + ", tengo " + age + " años.");
    }

    // Método: aumentar la edad en 1
    public void haveBirthday() {
        age = age + 1;
        System.out.println("¡Hurra! Ahora tengo " + age + " años!");
    }
}

¿Cómo usarlo en un programa?

public class Main {
    public static void main(String[] args) {
        Person vasya = new Person("Vasya", 18);
        vasya.sayHello();      // ¡Hola! Me llamo Vasya, tengo 18 años.
        vasya.haveBirthday();  // ¡Hurra! Ahora tengo 19 años!
    }
}

5. Práctica: haz crecer tu aplicación

Supongamos que estás haciendo una aplicación sencilla para llevar el registro de usuarios. En clases anteriores trabajamos solo con variables y métodos dentro de main. Ahora crearemos nuestra propia clase User con campos, métodos y constructor.

public class User {
    String username;
    int score;

    // Constructor
    public User(String username, int score) {
        this.username = username;
        this.score = score;
    }

    // Método: mostrar información del usuario
    public void printInfo() {
        System.out.println("Nombre de usuario: " + username + ", puntos: " + score);
    }

    // Método: aumentar los puntos
    public void addScore(int points) {
        score += points;
        System.out.println(username + " recibió " + points + " puntos. ¡Ahora tiene " + score + " puntos!");
    }
}

Uso:

public class Main {
    public static void main(String[] args) {
        User alice = new User("Alice", 10);
        User bob = new User("Bob", 5);

        alice.printInfo(); // Nombre de usuario: Alice, puntos: 10
        bob.printInfo();   // Nombre de usuario: Bob, puntos: 5

        alice.addScore(7); // Alice recibió 7 puntos. ¡Ahora tiene 17 puntos!
        bob.addScore(3);   // Bob recibió 3 puntos. ¡Ahora tiene 8 puntos!
    }
}

Observa: cada objeto tiene sus propios campos y los cambios en un objeto no afectan a otro.

6. Breve sobre los modificadores de acceso

En nuestros ejemplos los campos eran públicos (String name;). En la práctica, a menudo se hacen los campos private para que no se puedan modificar por accidente (o a propósito) desde otra clase. Veremos más en el tema de encapsulación, pero aquí tienes un ejemplo:

public class User {
    private String username;
    private int score;

    public User(String username, int score) {
        this.username = username;
        this.score = score;
    }

    public void printInfo() {
        System.out.println("Nombre de usuario: " + username + ", puntos: " + score);
    }

    public void addScore(int points) {
        score += points;
    }
}

Ahora, si alguien intenta escribir alice.score = 100500; fuera de la clase — el compilador dirá «¡no se puede!».

7. Errores típicos al trabajar con campos, métodos y constructores

Error n.º 1: Campos no inicializados.
Si no asignas valores a los campos, obtienen valores por defecto: los números — 0, boolean — false, las referencias (por ejemplo, String) — null. Si te olvidas de inicializar un campo, puedes obtener un resultado inesperado o incluso NullPointerException al intentar hacer algo con él.

Error n.º 2: confundir parámetros y campos.
En el constructor, los principiantes a menudo escriben simplemente name = name; — eso no inicializa el campo, solo asigna el parámetro a sí mismo. ¡Usa siempre this.name = name!

Error n.º 3: no hay constructor por defecto.
Si declaras un constructor con parámetros pero olvidas añadir explícitamente un constructor vacío, entonces new Person() ya no funcionará.

Error n.º 4: mismos nombres para métodos y clases.
En Java, el nombre del constructor debe coincidir con el de la clase, pero los métodos no. A veces por error se llama a un método como la clase y el compilador protesta.

Error n.º 5: olvidarse de los modificadores de acceso.
Si haces los campos public, se podrán cambiar en cualquier parte — esto es peligroso para programas grandes. Es mejor acostumbrarse desde el principio a private y usar métodos para el acceso.