Introducción a las clases: escribir tus propias clases, constructores.

¡Hola! Hoy hablaremos de clases en Java. Se puede decir que las clases son el núcleo de la programación Java. Cuando te conviertas en programador, tu tarea principal será escribir tus propias clases con diferentes funcionalidades. Averigüemos qué es esto y cómo funciona :) Como ya sabes, Java es un lenguaje de programación orientado a objetos. Todos los programas constan de objetos que de alguna manera están conectados entre sí. Una clase es esencialmente una plantilla para un objeto. Determina cómo se verá un objeto y qué funciones tendrá. Todo objeto es un objeto de alguna clase . Veamos el ejemplo más simple:

public class Cat {

    String name;
    int age;

}

Digamos que estamos escribiendo un programa y en este programa necesitamos gatos para algo (por ejemplo, tenemos una clínica veterinaria con la posibilidad de programar una cita en línea). Creamos una clase Caty le especificamos dos variables: una cadena namey un número age. Estas variables de clase se denominan campos . Básicamente, esta es una plantilla para todos los gatos que crearemos en el futuro. Cada gato (objeto de clase Cat) tendrá dos variables: nombre y edad.

public class Cat {

    String name;
    int age;

    public static void main(String[] args) {
        Cat barsik = new Cat();
        barsik.age = 3;
        barsik.name = "Barsik";

        System.out.println("Creamos un gato llamado" + barsik.name + ", su edad - " + barsik.age);
    }

}

¡Asi es como funciona! Creamos un gato, le dimos un nombre y una edad y lo enviamos todo a la consola. Nada complicado :) Las clases suelen describir objetos y fenómenos del mundo circundante. Un gato, una mesa, una persona, un rayo, una página de un libro, una rueda: todo esto se creará en su programa utilizando clases separadas. Ahora echemos un vistazo a las variables que creamos en la clase Cat. Estos se denominan campos o variables de instancia . El nombre, de hecho, revela toda su esencia. Cada instancia (objeto) de la clase tendrá estas variables Cat. Cada gato que creemos tendrá su propia variable namey su propio age. En general, es lógico: con los gatos reales todo es igual :) Además de las variables de instancia, hay otras: variables de clase o estáticas. Agreguemos a nuestro ejemplo:

public class Cat {

    String name;
    int age;

    static int count = 0;

    public static void main(String[] args) {
        Cat barsik = new Cat();
        barsik.age = 3;
        barsik.name = "Barsik";
        count++;

        Cat vasia = new Cat();
        vasia.age = 5;
        vasia.name = "vasya";
        count++;

        System.out.println("Creamos un gato llamado" + barsik.name + ", su edad - " + barsik.age);
        System.out.println("Creamos un gato llamado" + vasia.name + ", su edad - " + vasia.age);

        System.out.println("Número total de gatos = " + count);
    }
}

Salida de consola:

Мы создали кота по имени Барсик, его возраст - 3
Мы создали кота по имени Вася, его возраст - 5
Общее количество котов = 2

Ahora tenemos una nueva variable en nuestra clase: count(cantidad). Ella es la responsable de contar los gatos creados. Cada vez que creamos un gato en el método principal, incrementamos esta variable en 1. Esta variable está designada por la palabra clave estática . Esto significa que pertenece a la clase y no a un objeto específico de la clase. Lo cual, por supuesto, es lógico: si cada gato debe tener su propio nombre, entonces necesitamos un contador de gatos para todos. Esto es exactamente lo que la palabra estática permite lograr : countla misma variable para todos los gatos. Tenga en cuenta: cuando lo imprimimos en la consola, no escribimos barsik.countni vasia.count. Ella no pertenece ni a Barsik ni a Vasya; pertenece a toda la clase Cat. Por tanto, es sencillo count. También puedes escribir Cat.count; eso también será correcto. nameEsto no funcionaría al enviar una variable a la consola :

public class Cat {

    String name;
    int age;

    static int count = 0;

    public static void main(String[] args) {
        Cat barsik = new Cat();
        barsik.age = 3;
        barsik.name = "Barsik";
        count++;

        System.out.println("Creamos un gato llamado" + name + ", su edad - " + barsik.age);

        System.out.println("Número total de gatos = " + count);
    }
}

¡Error! nameCada gato tiene el suyo. Aquí es donde el compilador se confunde. "¿Enviar el nombre a la consola? ¿De quién es el nombre? :/"

Métodos

Además de las variables, cada clase tiene métodos. Hablaremos de ellos con más detalle en una conferencia aparte, pero los puntos generales son bastante simples. Los métodos son la funcionalidad de tu clase; qué objetos de esta clase pueden hacer. Ya está familiarizado con uno de los métodos: este es el main(). Pero el método main, como recordarás, es estático, es decir, pertenece a toda la clase (la lógica es la misma que con las variables). Y los métodos ordinarios y no estáticos solo se pueden invocar en objetos específicos que hayamos creado. Por ejemplo, si queremos escribir una clase para un gato, necesitamos entender qué funciones debe tener el gato en nuestro programa. En base a esto, escribamos un par de métodos para ello:

public class Cat {

    String name;
    int age;

    public void sayMeow() {
        System.out.println("¡Maullar!");
    }

    public void jump() {
        System.out.println("¡Saltando al galope!");
    }

    public static void main(String[] args) {
        Cat barsik = new Cat();
        barsik.age = 3;
        barsik.name = "Barsik";

        barsik.sayMeow();
        barsik.jump();

    }
}

Bueno, ¡ahora nuestra clase se parece mucho más a la descripción de un gato real! Ahora no sólo tenemos un gato llamado Barsik con nombre y edad. ¡También puede maullar y saltar! ¿Qué tipo de gato hay sin esa "funcionalidad" :) Tomamos un objeto específico - barsiky llamamos a sus métodos sayMeow()y jump(). Miramos la consola:

Мяу!
Прыг-скок!

¡Un gato de verdad! :)

Creando tus propias clases. Abstracción

En el futuro tendrás que escribir tus propias clases. ¿A qué debes prestar atención al escribirlos? Si hablamos de variables, es necesario utilizar algo llamado abstracción . La abstracción es uno de los cuatro principios fundamentales de la programación orientada a objetos. Implica resaltar las características principales y más significativas de un objeto y viceversa: descartar las secundarias e insignificantes. Por ejemplo, estamos creando un fichero de empleados de la empresa. Para crear objetos de empleado, escribimos una clase Employee. ¿Qué características son importantes para describir a un empleado en un expediente de empresa? Nombre completo, fecha de nacimiento, número de seguro social, número de identificación fiscal. Pero es poco probable que necesitemos su altura, color de ojos y color de cabello en la tarjeta de empleado de una empresa. La empresa no necesita esta información. Por lo tanto, para la clase Employeeestableceremos las variables String name, int agey , y abandonaremos la información que sea innecesaria para nosotros (como el color de ojos) y int socialInsuranceNumberla abstraeremos . Pero si creamos un archivo de fotografías de modelos para una agencia de modelos, la situación cambia drásticamente. Para describir una modelo, la altura, el color de ojos y el color de cabello son muy importantes para nosotros, pero el número TIN no nos importa en absoluto. Por lo tanto, en la clase necesitamos crear variables , , . Así funciona la abstracción, ¡es sencillo! :) int taxNumberModelint heightString hairString eyes

Constructores

Volvamos a nuestro ejemplo del gato.

public class Cat {

    String name;
    int age;

    public static void main(String[] args) {
        Cat barsik = new Cat();

        System.out.println("Algo ha estado pasando en el programa durante 2 horas...");

        barsik.age = 3;
        barsik.name = "Barsik";

    }
}

Mire este código e intente adivinar qué está mal en nuestro programa. ¡Durante dos horas en nuestro programa hubo un gato sin nombre ni edad! Por supuesto, esto es completamente incorrecto. En la base de datos de la clínica veterinaria no debe haber gatos sin información sobre ellos. Ahora se lo dejamos al programador. Si no se olvida de indicar su nombre y edad, todo irá bien. Si lo olvida, habrá un error en la base de datos, gatos desconocidos. ¿Cómo podemos solucionar este problema? Es necesario prohibir de alguna manera la creación de gatos sin nombre ni edad. Aquí es donde las funciones constructoras vienen en nuestra ayuda . He aquí un ejemplo:

public class Cat {

    String name;
    int age;

    //constructor para la clase Gato
    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public static void main(String[] args) {

        Cat barsik = new Cat("Barsik", 5);
    }
}

Un constructor es esencialmente una plantilla para objetos de clase. En este caso, especificamos que para cada objeto catse deben especificar dos argumentos: una cadena y un número. Si ahora intentamos crear un gato sin nombre, no lo conseguiremos.

public class Cat {

    String name;
    int age;

    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public static void main(String[] args) {

        Cat barsik = new Cat(); //¡error!
    }
}

Ahora que una clase tiene un constructor, el compilador de Java sabe cómo deberían verse los objetos y no permitirá que se creen objetos sin los argumentos especificados en él. Ahora veamos la palabra clave thisque ves dentro del constructor. Con él también todo es sencillo. "esto" en inglés significa "esto, esto". Es decir, esta palabra indica un objeto específico. Código en el constructor

public Cat(String name, int age) {
    this.name = name;
    this.age = age;
}

se puede traducir casi literalmente: " nombre para este gato (que estamos creando) = el argumento de nombre especificado en el constructor. edad para este gato (que estamos creando) = el argumento de edad especificado en el constructor". Después de que se active el constructor, puedes comprobar que a nuestro gato se le han asignado todos los valores necesarios:

public class Cat {

    String name;
    int age;

    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public static void main(String[] args) {

        Cat barsik = new Cat("Barsik", 5);
        System.out.println(barsik.name);
        System.out.println(barsik.age);
    }
}

Salida de consola:

Барсик
5

Cuando el constructor haya completado:

Cat barsik = new Cat("Barsik", 5);

En realidad sucedió lo siguiente en el interior:

this.name = "Barsik";
this.age = 5;

Y al objeto barsik(es this) se le asignaron valores de los argumentos del constructor. De hecho, si no especifica constructores en la clase, ¡ aún así se activará el constructor ! Pero, ¿cómo es esto posible? O_O El hecho es que en Java todas las clases tienen el llamado constructor predeterminado . No tiene ningún argumento, pero se activa cada vez que se crea un objeto de cualquier clase.

public class Cat {

    public static void main(String[] args) {

        Cat barsik = new Cat(); //aquí es donde trabajaba el constructor por defecto
    }
}

A primera vista esto no se nota. Bueno, creamos un objeto y lo creamos, ¿dónde está el trabajo del diseñador? Para ver esto, escribamos a mano un constructor vacío para la clase Caty dentro de él imprimamos alguna frase en la consola. Si se muestra, entonces el constructor ha funcionado.

public class Cat {

    public Cat() {
        System.out.println("¡Creó un gato!");
    }

    public static void main(String[] args) {

        Cat barsik = new Cat(); //aquí es donde trabajaba el constructor por defecto
    }
}

Salida de consola:

Создали кота!

Aquí está la confirmación. El constructor predeterminado siempre está presente de forma invisible en tus clases. Pero necesitas conocer una característica más. El constructor predeterminado desaparece de la clase cuando creas algún constructor con argumentos. La prueba de esto, de hecho, ya la hemos visto anteriormente. Aquí en este código:

public class Cat {

    String name;
    int age;

    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public static void main(String[] args) {

        Cat barsik = new Cat(); //¡error!
    }
}

No pudimos crear un gato sin nombre y edad porque definimos un constructor para Cat: cadena + número. El constructor predeterminado desapareció de la clase inmediatamente después de esto. Por lo tanto, asegúrese de recordar: si necesita varios constructores en su clase, incluido uno vacío, debe crearlo por separado . Por ejemplo, nuestra clínica veterinaria quiere hacer buenas obras y ayudar a los gatos callejeros, cuyos nombres y edades desconocemos. Entonces nuestro código debería verse así:

public class Cat {

    String name;
    int age;

    //para gatos domésticos
    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    //para gatos callejeros
    public Cat() {
    }

    public static void main(String[] args) {

        Cat barsik = new Cat("Barsik", 5);
        Cat streetCat = new Cat();
    }
}

Ahora que hemos especificado explícitamente un constructor predeterminado, podemos crear ambos tipos de gatos. En el constructor, puede asignar valores explícitamente y no simplemente tomarlos de los argumentos. Por ejemplo, podemos registrar todos los gatos callejeros en una base de datos con el nombre "Número de gato callejero...":

public class Cat {

    String name;
    int age;

    static int count = 0;

    public Cat() {
        count++;
        this.name = "Número de gato callejero" + count;
    }

    public Cat(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public static void main(String[] args) {

        Cat streetCat1 = new Cat();
        Cat streetCat2 = new Cat();
        System.out.println(streetCat1.name);
        System.out.println(streetCat2.name);
    }
}

Tenemos una variable countque es un contador de gatos callejeros. Cada vez que ejecutamos el constructor predeterminado, lo incrementamos en 1 y asignamos ese número como el nombre del gato. Para un constructor, el orden de los argumentos es muy importante. Intercambiemos los argumentos de nombre y edad en nuestro constructor.

public class Cat {

    String name;
    int age;

    public Cat(int age, String name) {
        this.name = name;
        this.age = age;
    }

    public static void main(String[] args) {

        Cat barsik = new Cat("Barsik", 10); //¡error!
    }
}

¡Error! El constructor lo describe claramente: al crear un objeto, Catse le debe pasar un número y una cadena, en ese orden . Por eso nuestro código no funciona. Asegúrese de recordar esto y tenerlo en cuenta al crear sus propias clases:

public Cat(String name, int age) {
    this.name = name;
    this.age = age;
}

public Cat(int age, String name) {
    this.age = age;
    this.name = name;
}

¡Estos son dos diseñadores completamente diferentes! Ahora resuelve algunos problemas para consolidar el material :)

• Museo de Antigüedades.

Tu tarea es diseñar la clase Artifact. Los artefactos que se conservan en el museo son de tres tipos. Del primero es del que no se sabe nada salvo el número de serie asignado por el museo (por ejemplo: 212121). La segunda es sobre que se conoce el número de serie y la cultura por la cual fue creado (por ejemplo: 212121, “Aztecas”). El tercer tipo es sobre el que se conoce el número de serie, la cultura por la que fue creado y la edad exacta de su creación (por ejemplo: 212121, “Aztecas”, 12). Cree una clase Artifactque describa las antigüedades almacenadas en el museo y escriba la cantidad requerida de constructores para ella. En el método main(), cree un artefacto de cada tipo.

public class Artifact {

    public static void main(String[] args) {
    }
}

• Sitio web de la reunión

Estás creando una base de datos de usuarios para un sitio de citas. Pero el problema es que has olvidado en qué orden hay que especificarlos y no tienes las especificaciones técnicas a mano. Diseñe una clase Userque tenga campos: nombre ( String), edad ( short) y altura ( int). Cree la cantidad requerida de constructores para que el nombre, la edad y la altura se puedan especificar en cualquier orden.

public class User {

    String name;
    short age;
    int height;

    public static void main(String[] args) {

    }
}