Java por qué el diseñador es reemplazado por el método. Diseñadores de java

El hecho es que:

1. Si crea una clase y define el constructor con argumentos (Clase Aclass, en la que solo un constructor que acepta INT i), el compilador ya no creará el diseñador predeterminado. Porque violaría el contrato de clase de ACLASS, que no se puede inicializar sin argumentos. Si desea tener un diseñador predeterminado, ahora lo especifique con claridad.

De lo contrario, sería imposible prohibir la creación de un diseñador predeterminado, que sería malo.

2. Al crear diseñadores de clase BCLASS, que se hereda de otra clase, el compilador requiere que la primera línea del diseñador llame a otro diseñador (heredado o en esta clase).

¿Por qué? Porque desde que se le hereda de alguna clase, desea reutilizarlo lógica. El diseñador trae una instancia de la clase en algún tipo de estado holístico inicial. En su caso, la inicialización de ACLASS requiere un argumento sin el cual JVM no sabe cómo inicializar la instancia de clase.

Si la clase no define constructores, intenta crear un diseñador predeterminado, es decir, Sin argumentos:

Clase pública aclass1 ()

Dado que aquí están claramente diseñadores no definidos y la clase no se hereda de otras clases, el compilador crea el diseñador predeterminado.

Esto es equivalente a esta definición:

Clase pública Aclass1 (Pública Aclass1 () ())

Ahora mira BCLASS1:

Clase pública BCLASS1 extiende ACLASS1 ()

Aquí, también, claramente los constructores no están definidos, y el compilador intenta crear un diseñador predeterminado. Dado que la clase ACLASS1 tiene un diseñador predeterminado, creará un diseñador predeterminado que llamará al constructor Aclass1. Este código es equivalente a esto:

La clase pública BCLASS1 extiende ACLASS1 (BCLASS1 PÚBLICO () (SUPER ();))

En su caso, se crea una clase sin diseñador predeterminado:

ACLASS PÚBLICO (ACLASS PÚBLICO (INT I) ())

Dado que se describe aquí (al menos uno) constructor, ya no se crea el diseñador predeterminado. Es decir, este código ya no compilará:

ACLASS A \u003d NUEVO ACLASS (); // No funciona

necesita algo como

ACLASS A \u003d NUEVA ACLASS (1);

Por consiguiente, cualquier constructor BCLASS requerirá una llamada a un constructor de aclase o Bclass. Con esta descripción, el compilador jurará:

Public Bclass se extiende con ACLASS ()

Debido a que habrá un intento de llamar a una estructura de construcción predeterminada, que no está definida:

BCLASS PÚBLICO extiende la aclass (super (); // Error; en la clase ACLASS no hay tal diseñador))

Sin embargo, puede crear una clase BClass con el diseñador predeterminado configurando algún valor para el constructor de ACLASS:

Clase pública BCLASS extiende la aclass (super (1);))

Será compilado

El diseñador es similar al método de la estructura, cuyo propósito es crear una instancia de clase. Características del diseñador:

• El nombre del diseñador debe coincidir con el nombre de la clase (por acuerdo, la primera letra, el título, generalmente el nombre del sustantivo);
• El diseñador está disponible en cualquier clase. Incluso si no lo ha escrito, el compilador Java creará el diseñador predeterminado (constructor predeterminado), que estará vacío y no hace nada más que la llamada del constructor SuperClass.
• El diseñador es similar al método, pero no es un método, ni siquiera se considera un miembro de clase. Por lo tanto, es imposible heredar o anular en la subclase;
• Los diseñadores no son heredados;
• Los diseñadores pueden ser algo en la clase. En este caso, los diseñadores se llaman sobrecargados;
• Si el constructor no se describe en la clase, el compilador agrega automáticamente un constructor en código sin parámetros;
• El constructor no tiene un tipo devuelto, ni siquiera pueden ser el tipo de vacío si se devuelve el tipo de vacío, entonces esto ya no es un constructor y el método, a pesar de la coincidencia con el nombre de la clase.
• El operador de retorno está permitido en el constructor, pero solo vacío, sin ningún valor de retorno;
• El diseñador le permite usar los modificadores de acceso, puede especificar uno de los modificadores: público, protegido, privado o sin modificador.
• El diseñador no puede tener modificadores abstractos, finales, nativos, estáticos o sincronizados;
• La palabra clave se ve en otro diseñador en la misma clase. Si se usa, la apelación debe ser la primera cadena del diseñador;
• Super palabra clave causa un diseñador de clase madre. Si se usa, debe haber una apelación a la primera línea del diseñador;
• Si el diseñador no llama al constructor de requisitos previos de la clase (con argumentos o sin argumentos), el compilador agrega automáticamente la llamada a la llamada de llamada de llamada a la clase sin argumentos;

Diseñador por defecto

El diseñador está disponible en cualquier clase. Incluso si no lo ha escrito, el compilador Java creará el diseñador predeterminado (constructor predeterminado). Este diseñador está vacío y no hace nada, excepto el desafío del diseñador SuperClass. Esos. Si escribe: Ejemplo de clase pública () Esto es equivalente a la escritura: Ejemplo de clase pública (ejemplo () (super;)) En este caso, el ancestro no se especifica en este caso, y de forma predeterminada, todas las clases de Java heredan el Clase de objetos Por lo tanto, el constructor de clase de objeto se llama. Si la clase se define en la clase con parámetros, y no hay un constructor sobrecargado sin parámetros, entonces la llamada constructor sin parámetros es un error. Sin embargo, en Java, comenzando con la versión 1.5, se pueden usar diseñadores con argumentos de longitud variable. Y si hay un constructor que tiene un argumento de longitud variable, entonces el constructor predeterminado no será el error. No se debe a que el argumento de la longitud variable puede estar vacío. Por ejemplo, el siguiente ejemplo no se compilará, sin embargo, si el constructor se cancela con el argumento de la longitud de la variable, entonces la compilación y el lanzamiento tendrán éxito y, como resultado de la operación del defectoDEMO DD \u003d NUEVO DEFAULTEDEMO () fila de código; DefaultDemo Constructor (int ... v). Naturalmente, en este caso necesitas usar JSDK 1.5. Archivo defaultDEMO.JAVA Clase defaultDEMO (DEFAULTEDEMO (STRING S) (SISTEMA. OUT. Imprimir ("PredeterminadoDemo (cadena)));) / * DefaultDemo (int ... v) (System.out.println ("PredeterminadoDemo (int ...)");) * / PUBLIC ESTÁTICA ESTÁNICA PRINCIPAL (CAINTA ARGS) (DEFAULTEDEMO DD \u003d NUEVO DEFAULTEDEMO ();)) El resultado de la salida del programa con un diseñador romántico: DEFAULTDEMO (INT ....) Sin embargo, en un caso generalizado, cuando no es un único constructor Se ha definido en el aula. El diseñador predeterminado (sin parámetros) será un fenómeno obligatorio, ya que el constructor predeterminado es automáticamente.

Al crear un objeto, se siguen los siguientes pasos:

• Buscando una clase de un objeto entre las clases ya utilizadas en el programa. Si no lo es, está buscando en todos los directorios y bibliotecas disponibles. Después de crear una clase en el directorio o la biblioteca, se realizan la creación y la inicialización de los campos de la clase estática. Esos. Para cada clase, los campos estáticos se inicializan solo una vez.
• Memoria asignada para el objeto.
• Se realiza la inicialización de los campos de clase.
• Ofrece un diseñador de clase.
• Se forma una referencia al objeto creado e inicializado. Esta referencia es el valor de una expresión que crea un objeto. El objeto se puede crear y llamando al método NewInstance () java.lang.class. En este caso, el diseñador se usa sin una lista de parámetros.

Sobrecarga de diseñadores

Los diseñadores de la misma clase pueden tener el mismo nombre y diferentes firmas. Esta propiedad se llama combinación o sobrecarga (sobrecarga). Si la clase tiene varios constructores, hay una sobrecarga de los diseñadores.

Constructores parametrados

La firma del constructor es la cantidad y los tipos de parámetros, así como la secuencia de sus tipos en la lista de parámetros de diseño. El tipo de resultado devuelto no se tiene en cuenta. El constructor no devuelve ningún parámetro. Esta disposición explica en cierto sentido, ya que Java distingue a los constructores o métodos sobrecargados. Java distingue los métodos sobrecargados no al devolver el tipo, sino por el número, los tipos y la secuencia de tipos de parámetros de entrada. El constructor no puede devolver un tipo de vacío, de lo contrario, se convertirá en un método regular, incluso a pesar de la similitud con el nombre de la clase. El siguiente ejemplo lo demuestra. Archivo voiddemo.java clase voiddemo ( / ** * Este es un diseñador * / Voiddemo () (Sistema. Out. Println ("constructor");) Voiddemo () (Sistema. Out. Println ("Método");) Pública Estático Estático principal (String S) (VoidDemo M \u003d Nuevo Voiddemo (); ) Como resultado, el programa se retirará: Constructor Esto demuestra una vez más que el diseñador es el método sin parámetros devueltos. Sin embargo, para el diseñador, puede especificar uno de los tres modificadores públicos, privados o protegidos. Y el ejemplo ahora se verá así: el archivo VoidDemo2.Java Class VoidDEMO2 ( / ** * Este es un diseñador * / VOIDDEMO2 PÚBLICO () (SISTEMA. OUT. PULSULN ("constructor");) / ** * y este es un método ordinario, incluso a pesar de la similitud con el nombre de la clase *, ya que hay un tipo de vacío devuelto * / Vacío privado Voiddemo2 () (Sistema. Out. Println ("Método");) Pública de Vacío Estático Público (String S) (VoidDemo2 M \u003d Nuevo VoidDemo2 ();)) En el constructor, se permite grabar el operador de retorno, Pero solo vacío, sin ningún valor de retorno. Archivo returndemo.java clase retorndemo ( / ** * El diseño permite el * operador de retorno sin parámetros. * / Rendimiento público () (Sistema. Fuera. Println ("constructor"); devolución;) Público Estático Estático PRINCIPAL (STRINGDEMO R \u003d NUEVO RENDETDEMO ();)))

Diseñadores, argumentos de longitud variable parametrizada

Java SDK 1.5 tiene una herramienta tan esperada: argumentos de longitud variable para diseñadores y métodos (argumentos de longitud variable). Antes de esto, la variable número de documentos fue procesada por dos formas inconvenientes. El primero fue diseñado para el hecho de que el número máximo de argumentos se limita a una pequeña cantidad y se conoce de antemano. En este caso, fue posible crear versiones sobrecargadas del método, una para cada versión de la lista de argumentos transmitidos al método. El segundo método está diseñado para un desconocido por adelantado y una gran cantidad de argumentos. En este caso, los argumentos se colocaron en una matriz, y esta matriz se transfirió al método. Los argumentos de la longitud variable se involucran con mayor frecuencia en las manipulaciones posteriores con la inicialización de las variables. La ausencia de algunos de los argumentos o métodos del diseñador esperado se reemplaza convenientemente por valores predeterminados. El argumento de la longitud de la variable es una matriz, y se procesa como una matriz. Por ejemplo, un constructor para una clase de verificación con un número variable de argumentos se verá así: la comprobación de la clase (comprobación pública (Int. N) ()) Combinación de Symx ... Informa al compilador que el número variable de argumentos será utilizado, y que se utilizarán estos argumentos se almacenarán en una matriz, el valor de la referencia a la que figura en la variable n. El diseñador se puede llamar con diferentes números de argumentos, incluida su ausencia completa. Los argumentos se colocan automáticamente en una matriz y se transmiten a través de n. En ausencia de argumentos, la longitud de la matriz es 0. En la lista de parámetros, junto con los argumentos de la longitud de la variable, se pueden incluir parámetros obligatorios. En este caso, un parámetro que contiene un número alternativo de argumentos debe ser necesariamente el último en la lista de parámetros. Por ejemplo: Comprobación de clase (Comprobación pública (STRING S, INT. N) ()) Una limitación completamente obvia se refiere al número de parámetros con una longitud variable. En la lista de parámetros, debe haber solo un parámetro de longitud variable. Si hay dos parámetros de longitud de la variable, el compilador no se puede determinar donde finaliza un parámetro y el otro comienza. Por ejemplo: Comprobación de clase (Comprobación pública (String S, Int. N, Double. D) // Error! ()) Comprobación de archivos. Java, por ejemplo, hay un instrumento capaz de reconocer los números de automóviles y memorizar cuadrados de área, donde Visité cada uno de los coches por día. Es necesario seleccionar aquellos de la masa total de vehículos fijos que durante el día visitaron dos cuadrados específicos, dicen 22 y 15, según el área del área. Es bastante natural que el automóvil pueda visitar muchos cuadrados durante el día, y tal vez solo en uno. Obviamente, el número de cuadrados visitados está limitado por la velocidad física del automóvil. Haremos un pequeño programa donde el diseñador de clase se tomará como el número de automóvil como un argumento como un parámetro obligatorio y un número de cuadrados de área visitada, el número de lo cual puede ser variable. El diseñador verificará si el automóvil no apareció en dos cuadrados, si aparece, luego emite su número en la pantalla.

Transferencia de parámetros al diseñador.

En los lenguajes de programación, hay principalmente dos tipos de parámetros:

• tipos principales (primitivos);
• enlaces a objetos.

El término convocar el valor (llamada por valor) significa que el diseñador obtiene el valor transmitido por el módulo de llamadas. En contraste, la llamada por referencia (llamada por referencia) significa que el diseñador llega de módulo de llamada Dirección variable. El idioma Java utiliza solo una llamada al valor. Por el valor del parámetro y el valor de la referencia de parámetros. Java no utiliza una llamada para los objetos enlace (aunque muchos programadores y autores de algunos libros reclaman). Los parámetros al transmitir objetos en Java se llevan a cabo. sin referencia, pero enlaces significativos a objetos. ! En cualquier caso, el constructor recibe copias de los valores de todos los parámetros. El constructor no puede hacer con sus parámetros de entrada:

• el diseñador no puede cambiar los valores de los parámetros de entrada de los tipos principales (primitivos);
• el diseñador no puede cambiar los enlaces de los parámetros de entrada;
• el constructor no puede reasignar los enlaces de los parámetros de entrada a objetos nuevos.

El diseñador puede hacer con sus parámetros de entrada:

• cambie el estado del objeto transmitido como el parámetro de entrada.

El siguiente ejemplo demuestra que en Java, los parámetros de entrada para el diseñador se transmiten por el valor de la referencia al objeto. Además, este ejemplo refleja que el constructor no puede cambiar los enlaces de los parámetros de entrada, y en realidad cambia las referencias de copias de los parámetros de entrada. Employee.Java Clase Employee (String X, String Y) (String Temp \u003d X; X \u003d Y; y \u003d TEMP;) Público Estático Estático Página principal (Cadena Args) (String Name1 \u003d New String ("Alice"); String Name2 \u003d Nueva cadena ("Mary"); Empleado A \u003d nuevo empleado (Name1, Name2); Sistema. Out. Println ("Name1 \u003d" + Name1); Sistema. Out. Println ("Name2 \u003d" + Name2)))) El resultado de la salida del programa: Name1 \u003d Alice Name2 \u003d Mary Si se usó un enlace en el idioma Java para transmitir objetos como parámetros, el diseñador cambiaría en este ejemplo en algunos lugares Name1 y Name2. De hecho, el diseñador no cambiará los enlaces de objeto almacenados en las variables Name1 y Name2. Esto sugiere que los parámetros del diseñador se inicializan mediante copias de estos enlaces. Luego, el diseñador cambia en lugares ya copias. Al finalizar el diseñador, las variables X e Y se destruyen, y las variables originales Name1 y Name2 continúan referirse a los objetos anteriores.

Cambio de los parámetros transmitidos al constructor.

El diseñador no puede modificar los parámetros transmitidos de los tipos principales. Sin embargo, el constructor puede modificar el estado del objeto transmitido como un parámetro. Por ejemplo, considere el siguiente programa: ARCHIVO SALARY1.JAVA SALARY1 (SALARY1 (INT X) (X \u003d X * 3; SISTEMA. SISTEMA. PRINCIPIO ("x \u003d" + x);) Público de la cadena estática (cadena args) (valor int \u003d 1000; salario1 s1 \u003d nuevo salario1 (valor); Sistema. Out. Println ("Value \u003d" (! Lang: + Valor)))) El resultado de la salida del programa: X \u003d 3000 Valor \u003d 1000 Obviamente, este método no cambiará el parámetro del tipo primario. Por lo tanto, después de la llamada constructor, el valor de la variable de valor permanece 1000. De hecho, hay tres acciones:

1. La variable X se inicializa mediante una copia del valor del parámetro de valor (es decir, el número 1000).
2. El valor de la variable X se triplicó, ahora es igual a 3000. Sin embargo, el valor de la variable de valor sigue siendo igual a 1000.
3. El diseñador completa su trabajo, y la variable X ya no se usa.

En el siguiente ejemplo, el salario del empleado se triplica con éxito, ya que el valor de referencia del objeto se transmite como un parámetro. File SALARY2.JAVA SALARIO DE CLASE2 (valor int \u003d 1000; salario2 () () salario2 (salario2 x) (x. Valor \u003d x. Valor * 3;) Público estático vacío principal (cadena args) (salario2 s1 \u003d nuevo salario2 () ; Salario2 S2 \u003d nuevo salario2 (S1); Sistema. Fuera. Println ("s1.value=" + S1. Valor); Sistema. Fuera. Println ("s2.value=" + S2. Valor); )) El resultado de la salida del programa: S1. Valor \u003d 3000 S2. Valor \u003d 1000 El valor del enlace al objeto se usa como parámetro. Al ejecutar el salario2 S2 \u003d nueva fila de salario2 (S1); El constructor salary2 (salario x) se envía al valor del enlace al objeto variable S1, y el constructor en realidad triple el salario para S1.value, ya que incluso una copia (salario x), creada dentro del constructor indica el objeto de la variable S1.

Diseñadores, parametrizados por primitivos.

En caso de que los parámetros del constructor sobrecargado usen una primitiva que se pueda estrecharse (por ejemplo, INT<- double), то вызов метода со суженным значением возможен, несмотря на то, что метода, перегруженного с таким параметром нет. Например: Файл Primitive.java class Primitive { Primitive (double d) { d = d + 10 ; System. out. println (!}"d=" + d) ; } public static void main (String args ) { int i = 20 ; Primitive s1 = new Primitive (i) ; } } El resultado de la salida del programa: D \u003d 30.0 A pesar del hecho de que en la clase primitiva no hay constructor, que tiene un parámetro INT, el diseñador funcionará con el parámetro de entrada doble. Antes de llamar al diseñador, la variable se extenderá de tipo al tipo de doble. La versión inversa cuando la variable sería un tipo doble, y el diseñador solo estaría con el parámetro INT, en esta situación llevaría a un error de compilación.

Llame al diseñador y al operador Nuevo

El diseñador siempre es llamado por el nuevo operador. Al llamar al diseñador por el nuevo operador, el diseñador siempre genera un enlace a un nuevo objeto. Para forzar al constructor a formarse en lugar de referencia a un nuevo enlace de objeto a un objeto existente, no puede ser, excepto la sustitución del objeto deserializado. Y con el nuevo operador, en lugar de referencia a un nuevo objeto, un enlace a un objeto existente es imposible. Por ejemplo: Salary3.Java Clase SALARY3 Archivo (Valor int \u003d 1000; salario3 () () salario3 (salario3 x) (x. Valor \u003d x. Valor * 3;) Público estático estático principal (cadena args) (salario3 s1 \u003d nuevo Salario3 (); Sistema. Fuera. Println ("Primera creación de objetos:" + S1. Valor); salario3 s2 \u003d nuevo salario3 (S1); Sistema. Salida. Println ("Segunda creación de objetos:" + S2. Valor); Sistema . Fuera. Println (+ S1. Valor); salario3 S3 \u003d nuevo salario3 (S1); Sistema. Out. Println ("Tercera creación de objetos:" + S3. Valor); Sistema. Salida. "¿Qué pasa con el primer objeto?:"+ S1. Valor); )) El resultado de la salida del programa: First Object Creation: 1000 Second Object Creation: 1000 ¿Qué hay en el primer objeto?: 3000 Tercera Creación de objetos: 1000 ¿Qué se posdan con el primer objeto? : 9000 primero usando el salario3 S1 \u003d nueva línea de salario (); Se crea un nuevo objeto. A continuación, si usa el salario3 S2 \u003d nueva fila de salario (S1); o salario3 S3 \u003d nuevas líneas de salario3 (S1); Sería posible crear una referencia a un objeto ya existente, entonces S1.value S2.Value y S3.Value se almacenarán el mismo valor de 1000. De hecho, en el salario3 S2 \u003d nueva línea de salario (S1); Se creará un nuevo objeto para la variable S2 y se cambia el estado del objeto para la variable S1, a través de la transmisión de su valor de referencia al objeto, en el parámetro del diseñador. Esto se puede ver en función de los resultados de la salida. Y al ejecutar el salario3 S3 \u003d nueva línea de salario (S1); Se creará un nuevo objeto para la variable S3 y el estado del objeto para la variable S1 cambiará nuevamente.

Diseñadores e bloques de inicialización, secuencia de acciones al llamar a un diseñador

En la creación de un objeto y diseñadores enumera las acciones de una naturaleza general que se fabrican al crear un objeto. Entre ellos se encuentran la inicialización de las construcciones de los campos de clase y el desarrollo de un diseñador de clases, que a su vez también tiene un orden interno:

1. Todos los campos de datos están inicializados por sus valores predeterminados (0, FALSO o NULL).
2. Los inicializadores de todos los campos y bloques de inicialización se ejecutan en el orden de su enumeración en la Declaración de Clase.
3. Si se llama otro constructor en la primera fila del diseñador, se llama al constructor.
4. Se realiza el cuerpo del diseñador.

El diseñador está relacionado con la inicialización, porque en Java hay tres formas de inicializar el campo en el aula:

• asignar un valor en el anuncio;
• asignar valores en la unidad de inicialización;
• establezca su valor en el diseñador.

Naturalmente, debe organizar el código de inicialización para que sea fácil resolverlo. Como ejemplo, se da la siguiente clase: inicialización de clase (int i; corto z \u003d 10; estático int x; flootea estática y; estática (x \u003d 2000; y \u003d 3.141;) Inicialización () (Sistema. Fuera. Println ( "I \u003d" + i); Sistema. Fuera. Println ("Z \u003d" + Z); z \u003d 20; Sistema. Extender. Println ("Z \u003d" + Z);)) En el ejemplo anterior, las variables son Inicializado en el siguiente orden: primero las variables estáticas X e Y se inicializan por valores predeterminados. A continuación, se realiza una unidad de inicialización estática. Luego, inicializando la variable I por el valor predeterminado y está inicializado por la variable Z. El diseñador entra en funcionamiento aún más. Los diseñadores de clases de llamadas no deben depender de la Declaración del Orden. Esto puede llevar a errores.

Diseñadores e herencia

Los diseñadores no son heredados. Por ejemplo: Ejemplo de clase pública (ejemplo () () void público Sayhi () (Sistema. Out. Println ("HI");)) Subclase de clase pública extiende el ejemplo () La clase de subclase hereda automáticamente el método Sayhi () () definido en la clase principal. Al mismo tiempo, el ejemplo del constructor () de la clase principal no está heredada por su descendiente de Subclase.

La palabra clave de esto en diseñadores.

Los diseñadores utilizan esto para referirse a otro diseñador en la misma clase, pero con otra lista de parámetros. Si el diseñador usa esta palabra clave, entonces debe estar en la primera línea, ignorar esta regla resultará en el error del compilador. Por ejemplo: terceremo.java Clase pública de la clase pública de este archivo (nombre de cadena; este \u003d s; System. Out. Println (nombre);) thisDEMO () (esto ("John");) Público Estático Estático principal (Cadena Args) (ARG) TD1 \u003d Nuevo ThisDEMO ("Mary"); thisDEMO TD2 \u003d NUEVO THEDEMO ();)) El resultado de la salida del programa: Mary John hay dos constructores en este ejemplo. El primero recibe un argumento de cadena. El segundo no recibe ningún argumento, simplemente llama al primer diseñador utilizando el nombre "John" de forma predeterminada. Por lo tanto, es posible inicializar explícitamente los valores de los valores de campo y de forma predeterminada, lo que a menudo es necesario en los programas.

Super palabra clave en los diseñadores

Los diseñadores usan Super para llamar al diseñador SuperClass. Si el diseñador usa Super, entonces esta llamada debe estar en la primera línea, de lo contrario, el compilador le dará un error. A continuación se muestra un ejemplo: archivo superclassdemo.java clase pública superclassdemo (superclassdemo () ()), el niño de clase extiende superclassdemo (niño () (súper ();)) En este ejemplo simple, el constructor secundario () contiene una llamada al super. () que crea una clase de superclassdemo de la instancia, además de la clase secundaria. Dado que SUPER debe ser el primer operador realizado en el diseñador de subclase, este pedido es siempre el mismo y no depende de si se usa Super (). Si no se usa, primero será el diseñador predeterminado (sin parámetros) de cada superclase a partir de la clase base. El siguiente programa demuestra cuando se realizan diseñadores. Archivo call.java. // crear una superclase A Clase A (A () (Sistema. Out. Println ("Dentro de un constructor");)) // crear una subclase B, expandiendo la clase A La clase B extiende A (B () (Sistema. Out. Println ("Constructor de Dentro B");)) // crear una clase (c), en expansión de la clase en Clase C se extiende B (C () (Sistema. Out. Println ("Interior del Constructor C");)) Llamada de clase (cadena args) (C C \u003d nuevo C ();)))) Conclusión de este programa: Dentro de un constructor. Dentro del constructor b. Dentro del constructor C. Los diseñadores son llamados para subordinar las clases. Este es un cierto significado. Dado que la superclase no tiene conocimiento de ninguna subclase, entonces cualquier inicialización que necesita ser ejecutada es separada. Si es posible, debe preceder a cualquier inicialización realizada por la subclase. Por lo tanto, se debe realizar primero.

Diseñadores personalizados

El mecanismo de identificación de tipo durante la ejecución es uno de los principales principios básicos del idioma Java, que implementa polimorfismo. Sin embargo, tal mecanismo no asegura al desarrollador del tipo de tipo incompatible en algunos casos. El caso más común es una manipulación de un grupo de objetos, los diversos tipos de los cuales se desconocen de antemano y se determinan durante la ejecución. Dado que los errores asociados con la incompatibilidad de los tipos se pueden manifestar solo en la etapa de ejecución, dificulta la búsqueda y eliminarlos. La introducción de tipos personalizados en Java 2 5.0 avanza parcialmente la aparición de dichos errores desde el paso de ejecución hasta la etapa de compilación y garantiza la seguridad del tipo faltante. No es necesario traer claramente tipos al cambiar del tipo de objeto a un tipo específico. Debe tenerse en cuenta que las herramientas de ajuste de tipo solo funcionan con objetos y no se aplican a los tipos de datos primitivos que se encuentran fuera del árbol de herencia de clase. Gracias a los tipos personalizables, todas las unidades se realizan automáticamente y ocultas. Esto le permite asegurar la inconsistencia de los tipos y es mucho más probable que reutilice el código. Los tipos personalizados se pueden utilizar en constructores. Los diseñadores pueden ser personalizables, incluso si su clase no es un tipo personalizable. Por ejemplo: Clase Genconstructor (Double Val privado;< T extends Number > Genconstructor (T arg) (Val \u003d arg. DoubleValue ();) PrintValue void () (Sistema. Out. Println ("Val:" + Val);)) Clase GenconstructDEMO (Público Estático Void Main (Cadena Args) (GEnconstructor GC1 \u003d nueva genconstructor (100); genconstructor gc2 \u003d nueva gerconstructor (123.5F); gc1. PrintValue (); GC2. PrintValue ();)) Dado que el diseñador de genconstructor establece el parámetro de tipo de configuración para ser una clase derivada del número de clase, puede ser llamado con lóbulos

1. Concepto de diseñador predeterminado

El constructor predeterminado es un diseñador que no tiene parámetros. El diseñador predeterminado se puede declarar en la clase explícitamente o generado automáticamente.

En el caso más general, para la clase ClassName, el diseñador predeterminado tiene el siguiente formulario:

clase Nombre de la clase (... // Adverter Anuncio Nombre de la clase () ( // diseñador de cuerpo // ... } ... }

2. ¿En qué casos se genera el diseñador predeterminado en la clase automáticamente y en qué no? Ejemplo

Si la clase no declara un constructor único, se generará el diseñador predeterminado. Es decir, el diseñador predeterminado se genera en la clase solo solo si la clase no contiene la implementación de otros constructores. Si la clase contiene una implementación de al menos un constructor con parámetros, para declarar el diseñador predeterminado, debe declararse explícitamente en la clase.

Por ejemplo. En la siguiente declaración de clase, el diseñador predeterminado se genera automáticamente.

clase Cmylass ( en t. D; en t. Obtener d () ( regreso. D; ) vacío.Setd ( en t.nd) (d \u003d nd;))

El código anterior significa que se puede declarar un objeto de clase utilizando el diseñador predeterminado:

// funciona, como no un diseñador único ya no se implementa en la clase CMYCLASS MC \u003d. nuevo Cmylass ();

Si agrega al menos otro constructor en el cuerpo de la clase CMYLASS (por ejemplo, un constructor con un parámetro), entonces el diseñador predeterminado generará automáticamente.

clase Cmylass ( en t. D; // El diseñador predeterminado ya no se genera automáticamente. Cmylass ( en t. nd) (d \u003d nd;) en t.Obtener d () ( regreso. D; ) vacío.Colocar ( en t. nd) (d \u003d nd;))

Después de la implementación anterior, no será posible declarar un objeto utilizando el diseñador del diseñador. Sin embargo, puede declarar un objeto utilizando un diseñador con un parámetro

// error de finalización, ya que otro diseñador ya ha sido anunciado en el aula // CMYCLASS MC \u003d NUEVO CMYCLASS (); CMYCLASS MC2 \u003d. nuevo CMYCLASS (7); // y este código funciona

Como resultado de la ejecución de la fila anterior, se emitirá un error de compilación:

La cmylass de construcción () no está definida

Para tener el diseñador predeterminado y declarar un objeto de clase utilizando el diseñador predeterminado, debe especificarse explícitamente. Esto puede ser, por ejemplo, de la siguiente manera.

claseCmylass ( en t. D; // Explicit predeterminado de diseño ad Cmylass () (d \u003d 0;) // Declaración del diseñador con 1 parámetro, Cmylass ( en t. nd) (d \u003d nd;) en t. Obtener d () ( regreso.d; ) vacío.Colocar ( en t.nd) (d \u003d nd;))

Después de una implementación de este tipo, puede crear una instancia de una clase usando dos diseñadores, por ejemplo

CMYCLASS MC \u003d. nuevo Cmylass (); // se llama el diseñador predeterminado Mc.d \u003d 25; CMYCLASS MC2 \u003d. nuevo Cmylass (5); // el diseñador se llama con 1 parámetro

3. Llamando a los diseñadores de otros constructores. Ejemplo

El lenguaje de programación de Java le permite llamar a los diseñadores de clase de otro diseñador de la misma clase. Para hacer esto, use la palabra clave, que es una referencia a la clase actual.

Ejemplo.El ejemplo demuestra el uso de la clase CPIXEL, que implementa el píxel en la pantalla del monitor.

// clase que implementa un píxel en la pantalla del monitor público clase CPIXEL ( // Variables de clase interna Privado en t. x, y; // coordenadas de pixel Privado en t. Color; // color píxel // diseñador sin parámetros (diseñador predeterminado) Cpixel () (x \u003d y \u003d color \u003d 0;) // diseñador con 2 parámetros que inicializan solo las coordenadas CPIXEL ( en t. _X, en t. _Y) (x \u003d _x; y \u003d _y; color \u003d 0;) // diseñador con 1 parámetro que inicializa solo color CPIXEL ( en t. _Color) (color \u003d _color; x \u003d y \u003d 0;) // Constructor con 3 parámetros que causan un constructor con 2 parámetros CPIXEL ( en t. _X, en t. _y en t. _Color) ( // Llame a un constructor con 2 parámetros: asegúrese de la primera operación y solo una vez ESTO (_x, _y); // este color); // volver a llamar al diseñador está prohibido ESTO .color \u003d _color; // así es posible) // Métodos de acceso En t. Getx () ( regreso. X; ) En t. Gety () ( regreso. y; ) En t. Getcolor () ( regreso. Color; ))

Uso de la clase CPIXEL en otro código de programa (método)

CPIXEL CP1 \u003d. nuevo Cpixel (2.8); // Llamada constructor con 2 parámetros CPIXEL CP2 \u003d. nuevo CPIXEL (3,5,8); // Llama a un diseñador que llame a otro diseñador en t. D; d \u003d cp1.getx (); // d \u003d 2 d \u003d cp2.getColor (); // d \u003d 8 d \u003d cp2.gety (); // d \u003d 5 ...

4. ¿Qué restricciones (requisitos) se superponen en la llamada de otros constructores del diseñador de clases?

Para llamar correctamente a otros constructores del diseñador de clases, debe cumplir con los siguientes requisitos (restricciones):

• puedes llamar a un otro diseñador de clase. Llame a dos y más diseñadores de esta clase prohibidos. Esto sale de la lógica que el diseñador de clases está diseñado para crear un objeto de clase solo una vez (y no dos y más veces);
• llamar a otro diseñador debe ser la primera operación en el constructor de llamadas. Si en el constructor de llamadas llame a otro diseñador para implementar la segunda operación (tercero, etc.), el compilador le dará un error.

El diseñador es un método especial que se llama al crear un nuevo objeto. No siempre es conveniente inicializar todas las variables de clase al crear su instancia. A veces es más fácil para algunos valores creados por defecto al crear un objeto. En esencia, el constructor es necesario para inicializar automáticamente las variables.

El diseñador inicializa el objeto directamente durante la creación. El nombre de diseño coincide con el nombre de la clase, incluido el registro, y el constructor es similar al método sin el valor de retorno.

INT privado gato (); // Así que el método llamado Cat Cat () parece; // para que el diseñador de clase de gato se ve como

A diferencia del método, el diseñador nunca devuelve nada.

El diseñador determina las acciones realizadas al crear un objeto de clase, y es una parte importante de la clase. Como regla general, los programadores intentan especificar explícitamente al diseñador. Si no hay un diseñador explícito, entonces Java lo creará automáticamente para usar el valor predeterminado. Cuando implementamos clase Caja., No creé ningún diseñador.

Agregue un constructor a la clase, que simplemente establece los valores iniciales para la caja.

Caja de clase (ANCHO INT; // Ancho de la caja de altura int; // altura de la caja en profundidad; // CAJA DE PROFUNDIDAD // CAJA DE CONSTRUCTOR () (ANCHO \u003d 10; Altura \u003d 10; profundidad \u003d 10;) // Calcular el cuadro INT Getvolume () (Ancho de retorno * Altura * Profundidad;))

Eliminamos temporalmente el método setdim () y agregó al diseñador. Veamos qué pasa:

Caja catbox \u003d nueva caja (); minfotextView.settxt ("Cuadro:" + catbox.getvolume ());

El programa mostrará el tamaño de la caja, aunque no especificamos ningún tamaño para ello. Gracias al diseño, cualquier caja generada tendrá algún tipo de volumen fijo.

Naturalmente, puedes devolver el método de vuelta. setdim () (Consulte el artículo sobre las clases) y configure sus tamaños para el cuadro:

Caja catbox \u003d nueva caja (); // Establezca sus tamaños para la casilla CatBox.SetDim (10, 20, 30); minfotextView.settxt ("Cuadro:" + catbox.getvolume ());

Ahora debe estar claro que cuando después de una palabra clave nuevo Escribimos un nombre de clase con paréntesis, de hecho, llamamos al constructor de clase.

La pregunta surge, pero primero al crear una clase, sin embargo, no creamos un constructor. nueva caja () trabajó. El hecho es que si el constructor no se define explícitamente, entonces Java creará un diseñador que se utilizará de forma predeterminada. En este caso, simplemente asignará valores cero a todas las variables. Si creó el constructor usted mismo, no se utilizará el diseñador predeterminado.

Como cualquier método, el diseñador puede tener argumentos. En los argumentos del constructor, los parámetros se transmiten para inicializar el objeto. Por ejemplo, si en clase Gato. Hay un constructor que recibe un entero como un argumento que denota la edad del gato, luego los objetos Gato. Se creará de la siguiente manera:

Gato gato \u003d nuevo gato (8); // Cote 8 años

Si un Gato (int) es el único diseñador de clase, entonces el compilador no permitirá crear objetos Gato. De alguna otra manera.

Sin embargo, volvamos a las cajas para los gatos. El diseñador que creamos no es particularmente útil, ya que crea las mismas cajas. Crea un diseñador con los parámetros en la clase. Caja. Y cometer el primer constructor sin parámetros:

// segundo diseñador de caja (int w, int h, int d) (ancho \u003d w; altura \u003d h; profundidad \u003d d;)

Si la clase contiene un constructor con parámetros, deberá especificar los valores al declarar la clase:

// este diseñador ahora no permitirá // box catbox \u003d nueva casilla (); // En el constructor, debe especificar el tamaño de los tamaños de la caja del cuadro CatBox \u003d nueva casilla (100, 200, 100); minfotextView.settxt ("Cuadro:" + catbox.getvolume ());

Por cierto, con este método de diseñador. setdim () Ya no somos necesarios. Podemos establecer el tamaño de la caja inmediatamente en el diseñador. Dado que la más probable es que la caja sea constante y no cambia sus tamaños, entonces el método es quizás más. Pero si cambiamos el tamaño de la caja, el método tendrá que irse.

La clase puede tener varios constructores. Elimine el comentario del primer constructor y cree dos cajas: la casilla predeterminada y una caja grande.

Caja de defensa de la caja \u003d nueva caja (); Minfotextview.settxt ("el volumen de la caja estándar:" + defaultbox.getvolume ()); Box bigbox \u003d nueva caja (100, 200, 200); Minfotextview.append ("\\ noby la caja grande:" + bigbox.getvolume ());

Es decir, vemos que los diseñadores apoyan la sobrecarga, como los métodos.

Por ejemplo, podemos crear otro diseñador específicamente para una caja de cubos, donde todos los lados son iguales:

// Tercer diseñador para Cuba Box (int len) (ancho \u003d altura \u003d profundidad \u003d len;)

Calcule el tamaño del cubo:

Caja cubo \u003d nueva caja (5); Int vol \u003d cubo.getvolume (); minfotextView.settxt ("Cube Volumen:" + vol);

Usa el objeto como parámetros.

Hemos utilizado tipos simples como parámetros en diseñadores. Pero puedes transmitir el objeto de la clase en sí. Añadir otro constructor:

// Use el objeto de caja de la caja (Box OB) (ancho \u003d ob.width; altura \u003d ob.hight; profundidad \u003d ob.depth;)

En el código del programa, puede usar el diseñador de la siguiente manera:

Caja box1 \u003d nueva caja (100, 200, 100); Caja clonebox \u003d caja nueva (box1); Int vol \u003d clonebox.getvolume (); MinfotextView.settxt ("Cajas:" + vol);

Clase de caja (fuente)

Paquete ru.alexanderklimov.box; Caja de clase (ANCHO INT; // Ancho de cuadro Intent AT ALTURA; // CAJA DE ALTURA INT Profundidad int; // CAJA DE PROFUNDIDAD // CAJA DE CONSTRUCTOR () (ANCHO \u003d 10; Altura \u003d 10; Departamento \u003d 10;) // Segundo Diseñador de cajas ( int w, int h, int d) (ancho \u003d w; altura \u003d h; dept \u003d d;) // tercer diseñador para Cuba (len) (anchura \u003d altura \u003d profundidad \u003d len;) // usando el tipo de objeto Caja de caja (caja OB) (ancho \u003d ob.width; altura \u003d ob.height; dept \u003d ob.depth;) // Calcular el volumen del INT getvolume (tráneo * altura * profundidad;) // instalar el tamaño de la Caja de SetDIM de Void (INT W, INT H, INT D) (Ancho \u003d W; altura \u003d H; profundidad \u003d D;))

Llame a los diseñadores sobrecargados a través de esto ()

Tratar con diseñadores sobrecargados, convenientemente una llamada constructora desde la otra a través de la palabra clave eSTO. Al realizar el diseñador esto () Primero, se realiza el constructor sobrecargado, que corresponde a la lista de parámetros. Luego, los operadores se realizan dentro del diseñador de origen si existen. Diseñador de llamadas esto () Debe ser el primer operador en el diseñador.

Para empezar, cree una clase que no use el diseñador. esto ()Para entender la diferencia.

Cat Cat (int edad; int cumpleaños; / FIVIRICIO LAS VARIABLES CLAME CAT (INT I, INT J) (EDAD \u003d I; Cumpleaños \u003d J;) // Inicializar las variables con el mismo CAT (INT i) (EDAD \u003d I ; Cumpleaños \u003d i;) // Asignar valores predeterminados 0 CAT () (Edad \u003d 0; Cumpleaños \u003d 0;))

Creamos una clase con tres diseñadores. Reescribe la clase usando un constructor esto ().

Cat Cat (int mayurio; int cumpleaños; / FIGIRIZAR LAS VARIABLAS CLAME CAT (INT I, INT J) (EDAD \u003d I; Cumpleaños \u003d J;) // Inicializar las variables con el mismo CAT (INT i) (esto (I , i); // gato (i, i) se llama;) // Asignar los valores predeterminados 0 CAT () (este (0); // se llama CAT (0);))

Ahora solo tenemos un constructor, que asigna los valores de los campos - CAT (int, int). Lo que sucede al realizar un operador:

Gato gato \u003d nuevo gato (8);

Diseñador de llamadas Gato (8) Conduce a la ejecución del diseñador. esto (8, 8)Eso es equivalente a llamar al diseñador. Gato (8, 8).

Lo que sucede al realizar un operador:

Gato cat2 \u003d nuevo gato ();

En este caso, el diseñador se llama. esto (0)Lo que lleva a la ejecución del diseñador. Gato (0)Dado que esta versión del diseñador es adecuada para la lista de parámetros. Al mismo tiempo el diseñador. Gato (0) esencialmente causa un diseñador Gato (0, 0).

Uso de constructores sobrecargados a través del diseñador. esto () Le permite excluir la duplicación de código, reduciendo las clases de tiempo de carga.

Pero debe tener cuidado porque los diseñadores que causan al diseñador. esto ()Se realizan un poco más lento.

Constructor cerrado

A veces, la clase se crea solo para almacenar algunos campos estáticos y métodos estáticos. Por lo tanto, es habitual dar nombres. Utils., pero esto es opcional. Esta clase no necesita un diseñador, pero si el autor de la clase no lo ha creado, el sistema en sí creará un diseñador predeterminado. Este diseñador no tiene sentido, y también puede servir como una fuente de errores. Para protegerse contra un problema similar, claramente tiene que crear un constructor DASY y hacerlo cerrado.

Clase pública Utils (lanza nueva AssertionError ();) ... // ¡Su código correcto // código incorrecto, solo para una demostración! Publico Estático Vacío SomeMethod () (Utils Utils \u003d New Utils (); utils. Tostring (); ))

Línea tirar New AssertionError () No es obligatorio, pero ayudará a identificar un error si llamas al constructor en la clase. El compilador se perderá esta opción, pero el programa terminará con un error.

Utils.SomeMethod (); // el programa se cierra con un error

No puedes crear una subclase para esta clase.

¡Oye! Hoy analizaremos un tema muy importante que se refiere a nuestros objetos. Aquí, sin exagerar, podemos decir que usará estos conocimientos todos los días en el trabajo real. Vamos a hablar de diseñadores.

Puede escuchar este término por primera vez, pero, de hecho, probablemente usó a los diseñadores, simplemente no se dio cuenta de esto :) Estaremos convencidos de esto más tarde.

¿Qué son los diseñadores y por qué se necesitan?

Considere dos ejemplos. Coche de clase pública (Modelo de cadena; int maxspeed; Pública de vacío estático principal (cadena args) (Coche Bugatti \u003d Coche nuevo (); Bugatti. Modelo \u003d "Bugatti Veyron"; Bugatti. MaxSpeed \u200b\u200b\u003d 407;) Hemos creado nuestro Coche e instalado para él, modelo y velocidad máxima. Sin embargo, en el proyecto real, el objeto del automóvil claramente no será 2 campos. Y, por ejemplo, 16 campos! Coche de clase pública (modelo de cadena; // modelo int maxspeed; // Velocidad máxima// Volumen del motor// propietario del apellido// Número de lugares en la cabina Cadena salonmaterial; // material de salón Seguro booleano; // Mentira asegurada// produciendo país int trunchvolume; // volumen de tronco Int acceleto100km; PUBLIC ESTÁTICA ESTÁTICA PRINCIPAL (CATO ARGS) (Coche Bugatti \u003d Coche nuevo (); Bugatti. Color \u003d "Blue"; Bugatti. Accelerferion a100km \u003d 3; Bugatti. Motorvolume \u003d 6.3; bugatti. Manufacturercountry \u003d "Italia"; Bugatti. Ownerfirstname \u003d " Amigo "; Bugatti. Añofsing \u003d 2016; Bugatti. Seguros \u003d verdadero; Bugatti. Precio \u003d 20000; Bugatti. IsNew \u003d Falso; Bugatti. PlacesInthesalon \u003d 2; Bugatti. MaxSpeed \u200b\u200b\u003d 407; Bugatti. Modelo \u003d" Bugatti Veyron "; )) Creamos un nuevo objeto de automóvil. Un problema: campos de los Estados Unidos 16, y solo 12 fueron inicializados.! ¡Intenta ahora en el código para encontrar a los que olvidamos! No tan simple, ¿sí? En tal situación, el programador se puede confundir fácilmente y omitir la inicialización de algún campo. Como resultado, el comportamiento del programa será erróneo: automóvil de clase pública (modelo de cadena; // modelo int maxspeed; // Velocidad máxima las ruedas int; // Double Enginevolume Disco Ancho; // Volumen del motor Color de cuerda; // color int anoche; // año del propietario de la cadena de lanzamientofirstname; // el nombre del propietario de String OutingLastName; // propietario del apellido Precio largo; // precio boolean isnew; // NUEVO O NO INT PONESINTHESALON; // Número de lugares en la cabina Cadena salonmaterial; // material de salón Seguro booleano; // Mentira asegurada Cadena fabricante terreno; // produciendo país int trunchvolume; // volumen de tronco Int acceleto100km; // aceleración hasta 100 km / h en segundos PUBLIC ESTÁTICA ESTÁTICA PRINCIPAL (CATO ARGS) (Coche Bugatti \u003d Coche nuevo (); Bugatti. Color \u003d "Blue"; Bugatti. Accelerferion a100km \u003d 3; Bugatti. Motorvolume \u003d 6.3; bugatti. Manufacturercountry \u003d "Italia"; Bugatti. Ownerfirstname \u003d " Amigo "; Bugatti. Añofsing \u003d 2016; Bugatti. Seguros \u003d verdadero; Bugatti. Precio \u003d 20000; Bugatti. IsNew \u003d Falso; Bugatti. PlacesInthesalon \u003d 2; Bugatti. MaxSpeed \u200b\u200b\u003d 407; Bugatti. Modelo \u003d" Bugatti Veyron "; Sistema. Sistema. Fuera. Println ( "Modelo Bugatti Veyron. Volumen del motor -" + Bugatti. Motorvolume + ", tronco -" + bugatti. Trunkvolume +. ", El salón está hecho de" + Bugatti. Salonmaterial +. ", Discos de ancho -" + Bugatti. Ruedas +. ". Fue usado en 2018 por el Sr." + Bugatti. OwnerLastName); )) Conclusión en la consola: Modelo Bugatti Veyron. Volumen del motor - 6.3, troncal - 0, el salón está hecho de nulo, ancho de los discos - 0. Se compró en 2018 por el Sr. Null Su comprador que dio $ 2 millones por un automóvil, obviamente no le gusta que se llame " sr. NULL"! Y en serio, al final, nuestro programa resultó ser un objeto creado incorrectamente: la máquina con anchos de los discos 0 (es decir, en absoluto sin discos), el tronco faltante, el interior hecho del material desconocido, y también Perteneciendo a alguien. ¡Uno solo puede imaginar cómo un error de este tipo puede "disparar" cuando se ejecuta el programa! Necesitamos de alguna manera evitar tales situaciones. Es necesario que en nuestro programa hubiera una limitación: al crear un nuevo objeto de la máquina para ello. siempre Debe indicarse, por ejemplo, modelo y velocidad máxima. De lo contrario, no permita la creación de un objeto. Con esta tarea se enfría fácilmente diseñadores de funciones. Obtuvieron su nombre no es así. El diseñador crea una clase de clase de "marco", a la que debe coincidir cada nuevo objeto de clase. Volvamos a una versión más sencilla de la clase de automóviles con dos campos. Teniendo en cuenta nuestros requisitos, el diseñador de la clase de automóviles se verá así: automóvil público (modelo de cadena, intoxmoxspeed) (este. Modelo \u003d modelo; esto. MAXPEED \u003d maxspeed;) y la creación de objetos ahora se ve así: público Main Void Static (Cadena Args) (Coche Bugatti \u003d Coche nuevo ("Bugatti Veyron", 407);) Presta atención cómo se crea el diseñador. Es similar al método habitual, pero no tiene el tipo de valor de retorno. Al mismo tiempo, en el diseñador indica el nombre de la clase, también con una letra mayúscula. En nuestro caso - coche. Además, el diseñador usa una nueva palabra clave para usted ESTO. "Esto" en inglés - "Esto, de esto". Esta palabra indica un sujeto específico. Código en el constructor: automóvil público (modelo de cadena, intoxspeed int) (este. Modelo \u003d modelo; esto. MaxSpeed \u200b\u200b\u003d MaxSpeed;) Puede traducir casi literalmente: "Modelo para esta máquina (que ahora creamos) \u003d Argumento modelo , que se especifica en el diseñador. Máximo de velocidad para esta máquina (que creamos) \u003d Argumento MaxSpeed, que se especifica en el diseñador ". Esto sucedió: coche de clase pública (modelo de cadena; int maxspeed; coche público (modelo de cadena, int maxsepeed) (esto. Modelo \u003d modelo; esto. MaxSpeed \u200b\u200b\u003d MaxSpeed;) Público Estático Void Main (Cadena Args) (Coche Bugatti) Coche nuevo ("Bugatti Veyron", 407); Sistema. Fuera. Println (Bugatti. Modelo); Sistema. Out. Println (Bugatti. Maxspeed);)) Conclusión en la consola: Bugatti Veyron 407. El diseñador asignó con éxito los valores deseados. ¡Es posible que no hayas notado que el diseñador es muy similar al método habitual! Por lo tanto, es: el constructor es un método, solo un poco específico :) Al igual que en el método, transferimos parámetros a nuestro constructor. Y al igual que la llamada de llamadas, la llamada constructor no funcionará, si no especifica: Coche de clase pública (modelo de cadena; int maxspeed; automóvil público (modelo de cadena, intoxmoxspeed) (este. Modelo \u003d modelo; esto. Modelo MAXPEED \u003d MaxSpeed;) Pública de Vacío estático (Cadena Args) (CAR BUGTTI \u003d Coche nuevo (); // ¡Error!)) Usted ve, el diseñador hizo lo que intentamos lograr. ¡Ahora no puedes crear un automóvil sin velocidad o sin modelo! Esta similitud de diseñadores y métodos no termina. Al igual que los métodos, los diseñadores pueden sobrecarga. Imagina que 2 gatos viven en casa. Uno de ellos seguía siendo un gatito, y trajiste el segundo desde la calle ya adultos y no sabes exactamente la edad que tiene. Por lo tanto, nuestro programa debería poder crear dos gatos de especies, con nombre y edad para el primer gato, y solo con el nombre, para el segundo gato. Para hacer esto, sobrecargaremos al diseñador: Clase de clase pública (nombre de cadena; Edad int; // para el primer gato // para el segundo gato Gato público (nombre de cadena) (este. Nombre \u003d Nombre;) Público Estático Estático Pasal (Cat String Args) (Cat Barsik \u003d New Cat ("Barsik", 5); Cat StreetCatNamedBob \u003d nuevo gato ("Bob");) Diseño inicial con los parámetros "Nombre" y "Edad", agregamos otro, solo con el nombre. Del mismo modo, los métodos sobrecargados en lecciones pasadas. Ahora podemos crear con éxito ambas opciones de gatos :)

¿Recuerdas, al comienzo de la conferencia, dijimos que ya has disfrutado de los diseñadores, simplemente no notó esto? Y ahí está. El hecho es que cada clase en Java tiene la llamada. diseñador por defecto. Él no tiene argumentos, pero funciona cada vez al crear cualquier objeto de cualquier clase. Gato de clase pública (cadena que indica el vacío principal (cadena args) (Cat Barsik \u003d nuevo gato ();)) a primera vista, esto no está destinado. Bueno, ¿creó el objeto y creado donde el diseño del diseñador? Para verlo, escribamos directamente con las manos para el constructor vacío de la clase de gato, y adentro, traeremos alguna frase a la consola. Si se saca, entonces el diseñador trabajó. Gato de clase pública (gato público () (sistema. Fuera. Println ("creó un gato!");) Público estático estático principal (cadena args) (gato barsik \u003d nuevo gato (); // Aquí trabajé el diseñador predeterminado } } Conclusión en la consola: Creado un gato! ¡Eso es confirmación! El diseñador predeterminado siempre está invisiblemente presente en sus clases. Pero necesitas saber otra característica. El diseñador predeterminado desaparece de la clase cuando crea algún tipo de constructor con argumentos. Prueba de esto, de hecho, ya hemos visto más alto. Aquí en este Código: Cat Cat (Nombre de la cadena; Edad int; gato público (nombre de cadena, intención int) (este. Nombre \u003d nombre; esto. Edad \u003d edad;) Público Estático de la Agua Página principal (Cat Barsik \u003d Nuevo gato (); // error!)) No pudimos crear un gato sin nombre y edad, porque definimos el constructor para gato: fila + Número. Diseñador predeterminado inmediatamente después de eso desaparecido de la clase. Por lo tanto, asegúrese de recordar: Si necesita varios diseñadores en su clase, incluyendo vacío, debe ser creado por separado.. Por ejemplo, creamos un programa para una clínica veterinaria. Nuestra clínica quiere hacer buenas obras y ayuda a los gatos sin hogar, sobre los cuales no conocemos ningún nombre o edad. Luego, nuestro código debería verse así: gato de clase pública (nombre de cadena; edad int // para los gatos caseros Gato público (nombre de cadena, edad int) (este. Nombre \u003d nombre; esto. Edad \u003d Edad;) // para los gatos callejeros CAT PÚBLICO () () Público Hecho estático PRINCIPAL (CATO ARGS) (Cat Barsik \u003d New Cat ("Barsik", 5); Cat Streetcat \u003d nuevo gato ();)) Ahora que nos recetamos explícitamente el diseñador predeterminado, podemos crear Gatos de ambos tipos :) Para el diseñador (en cuanto a cualquier método), el orden de los argumentos es muy importante. Cambiamos en nuestro diseñador los argumentos del nombre y la edad en lugares. Gato de clase pública (nombre de cadena; int edad; gato público (envejecido en la edad, nombre de cadena) (este. Nombre \u003d nombre; esto. Edad \u003d edad;) Público estático estático principal (cadena args) (gato barsik ("barsik ", 10); // error!)) ¡Error! El diseñador describe claramente: al crear el objeto CAT, debe ser transmitido número y cadena, exactamente en este orden.. Por lo tanto, nuestro código no funciona. Asegúrese de recordar esto y considere la creación de sus propias clases: gato público (nombre de cadena, intente int) (este. Nombre \u003d nombre; esto. Edad \u003d edad;) Gato público (Edad int, Nombre de la cadena) (esto. Edad \u003d Edad; este. Nombre \u003d nombre;) ¡Estos son dos constructores absolutamente diferentes! Si expresas en una oración respuesta a la pregunta. "¿Por qué necesitas un diseñador?", puedes decir: para que los objetos estén en el estado correcto.. Cuando usa constructores, todas sus variables se inicializarán correctamente, y el programa no tendrá máquinas a una velocidad de 0 y otros objetos "incorrectos". Su uso es muy beneficioso principalmente para el programa de programador. Si inicializa los campos usted mismo, el riesgo de saltarse algo y cometer un error. Y con el diseñador no habrá tal: si no le dio todos los argumentos requeridos o confundidos sus tipos, el compilador le dará un error de inmediato. Por separado, vale la pena decir que dentro del diseñador no debe poner la lógica de su programa.. Para hacer esto, está a su disposición. métodosen el que puedes describir toda la funcionalidad que necesitas. Veamos por qué la lógica en el constructor es una mala idea: Clase pública Carfactory (nombre de cadena; INT CARSCOUNT; CARFERÍA PÚBLICA (Nombre de la cadena, Edad int, INT CARSCOUNT) (este. Nombre \u003d Nombre; esto. Edad \u003d Edad; esto. Puntería de edad \u003d Relación de coches; Sistema. Fuera. Println ( "Ella fue fundada" "En promedio produce" + (esto. Puntería de coches / esto. Edad) + "Coches por año"); ) Publico Estático Vacío (Cadena Args) (Carfactory Ford \u003d New Carfactory ("Ford", 115, 50000000);) Tenemos una clase Carfante.Describiendo una fábrica para la producción de autos. Dentro del diseñador, inicializamos todos los campos, y la lógica se coloca aquí: Tomamos información sobre la fábrica en la consola. Parecería: no hay nada de malo en eso, el programa funcionó perfectamente. Conclusión en la consola: Nuestra fábrica de automóviles se llama Ford. Se fundó hace 115 años durante este tiempo se produjo 500,000,000 automóviles en promedio. Produce 434782 automóviles por año. Pero, de hecho, sentamos una mini cámara lenta. Y este código puede conducir fácilmente a errores. Imagínenos que ahora decimos que no sobre Ford, sino sobre la nueva fábrica de Motores Amigo, que existe menos de un año y produjimos 1000 autos: Clase pública Carfactory (Nombre de la cadena; INT CARSCOUNT; CARFERY PUBLIC (Nombre de la cadena, Edad int, INT CARSCOUNT ) (esto. Nombre \u003d Nombre; esto. Edad \u003d Edad; esto. CARSEAR \u003d CARSEAR \u003d SISTEMA. PRINCIPAL "Nuestra fábrica de automóviles se llama" + esto. Nombre); Sistema. Fuera. Println ( "Ella fue fundada" + esto. EDAD + "Hace años"); Sistema. Fuera. Println ( "Durante este tiempo se produjo en él" + esto. Puntería de coches + "Coches"); Sistema. Fuera. Println ( "En promedio produce" + (esto. Puntería de coches / esto. Edad) + "Coches por año"); ) PUBLICA ESTÁTICA ESTÁTICO PRINCIPAL (CARNA ARGS) (Carfactory Ford \u003d New Carfactory ("AMIGO MOTORES", 0, 1000);) Conclusión en la consola: Nuestra fábrica de automóviles se llama excepción de los motores de Amigo en el hilo "principal" java.lang.arithmeticException: / por cero se fundó hace 0 años durante este tiempo había 1000 en automóviles cariños. (Carfactory.java:15) en carfactory.main (carfactory.java:23) proceso terminado con el código de salida 1 ¡Llegamos! El programa terminó con algún error incomprensible. Intenta adivinar cuál es la razón? La razón está en la lógica que colocamos en el diseñador. Y específicamente, aquí en esta línea: Sistema. Fuera. Println ( "En promedio produce" + (esto. Puntería de coches / esto. Edad) + "Coches por año"); Aquí realizamos cálculos y dividemos el número de máquinas producidas para la edad de la fábrica. Y dado que nuestra fábrica es nueva (es decir, tiene 0 años de edad), como resultado, se obtiene una división por 0, que está prohibida en las matemáticas. Como resultado, el programa se completa con un error. ¿Cómo costamos? Para hacer toda la lógica en un método separado y llámelo, por ejemplo, PrintFactoryInfo (). Como parámetro, se puede transferir al objeto carfante. También se puede colocar toda la lógica, y al mismo tiempo, procesar posibles errores, como los nuestros con cero años. A cada uno lo suyo. Los diseñadores son necesarios para la tarea correcta del estado del objeto. Para la lógica de negocios, tenemos métodos. No mezcle uno con otro. Aquí hay algunos enlaces útiles donde puede leer adicionalmente sobre los diseñadores: