Conceptos básicos de instancia y herencia.

¡Hola! En conferencias anteriores ya nos hemos topado varias veces brevemente con el concepto de herencia. Hoy también tocaremos este tema, pero tampoco demasiado en profundidad. Habrá una conferencia detallada sobre esto más adelante, pero hoy solo veremos ejemplos prácticos y nos familiarizaremos con un operador interesante en Java.

herencia de java

Entonces, ¿qué es exactamente la herencia? La herencia es un mecanismo en programación, incluido Java, que le permite describir una nueva clase basada en una existente. Luego, la clase descendiente obtiene acceso a los campos y métodos de la clase principal. ¿Por qué podría ser necesario? Bueno, por ejemplo, imagina que necesitas crear varias clases de autos en el programa: camioneta, carreras, sedán, camioneta, etc. Incluso sin empezar a escribir código, sabes con certeza que estas clases tienen mucho en común: todos los coches tienen un nombre de modelo, año de fabricación, tamaño del motor, velocidad máxima, etc. (sin mencionar el hecho de que todos tienen ruedas y otras piezas). En tal situación, puedes:

• Cree estos campos en cada clase y agréguelos a las nuevas clases de automóviles cuando se creen
• Mueva los campos comunes a todas las máquinas a la clase principal Car, y todas las clases de tipos específicos de máquinas heredarán el Caruso de la palabra extiende .

La segunda opción, por supuesto, es mucho más cómoda:

public class Car {

   private String model;
   private int maxSpeed;
   private int yearOfManufacture;

   public Car(String model, int maxSpeed, int yearOfManufacture) {
       this.model = model;
       this.maxSpeed = maxSpeed;
       this.yearOfManufacture = yearOfManufacture;
   }
}

public class Truck extends Car {

   public Truck(String model, int maxSpeed, int yearOfManufacture) {
       super(model, maxSpeed, yearOfManufacture);
   }
}

public class Sedan extends Car {
   public Sedan(String model, int maxSpeed, int yearOfManufacture) {
       super(model, maxSpeed, yearOfManufacture);
   }
}

Como mínimo, hemos evitado la duplicación innecesaria de código, y esto es algo por lo que siempre debemos esforzarnos al escribir programas. Además, tenemos una estructura de clases simple y comprensible: los campos comunes a todas las máquinas se colocan en una clase. Si, por ejemplo, los camiones tienen algunos campos específicos que otros automóviles no tienen, se pueden declarar en el archivo Truck. Lo mismo ocurre con los métodos. Todos los coches tienen algún comportamiento común que se puede describir: arrancar el coche, acelerar/frenar, etc. Estos métodos generales se pueden colocar en una clase general Cary el comportamiento específico de cada tipo específico se puede describir en clases descendientes.

public class Car {

   public void gas() {
       //...gas
   }

   public void brake() {
       //...freno
   }
}


public class F1Car extends Car {

   public void pitStop() {

       //...solo los coches de carreras hacen paradas en boxes
   }

   public static void main(String[] args) {

       F1Car formula1Car = new F1Car();
       formula1Car.gas();
       formula1Car.pitStop();
       formula1Car.brake();
   }
}

Hemos trasladado los métodos comunes de todos los coches a la clase Car. Pero en la clase sucesora F1Car, que describe los coches de carreras de Fórmula 1, hay paradas en boxes (paradas para el mantenimiento urgente del coche), que se realizan únicamente en las carreras y se distinguen por un comportamiento específico.

Operador de instancia de Java

Para comprobar si un objeto se crea en función de una clase, existe un operador especial en Java: instanceof. Devuelve el valor truesi la prueba fue verdadera o falsesi el resultado fue falso. Veamos cómo funciona usando nuestras clases de autos como ejemplo:

public class Truck extends Car {

   public static void main(String[] args) {

       Truck truck = new Truck();
       System.out.println(truck instanceof Car);
   }
}

Salida: verdadera La prueba usando el operador instanceofdevolvió true, ya que tenemos un objeto de la clase Trucky todos los camiones son automóviles. La clase Truckes descendiente de la clase Car, por lo tanto, todos los camiones se crean sobre la base de un padre común: un automóvil. Presta atención al operador instanceof: está escrito sin punto, ya que es un operador, no un método (“objeto instancia de Clase”). Intentémoslo de otra manera:

public static void main(String[] args) {

   Car car = new Car();
   System.out.println(car instanceof Truck);
}

Salida: false La clase Cary, en consecuencia, su objeto no derivan de la clase Truck. Todos los camiones son automóviles, pero no todos los automóviles son camiones. Los objetos Carno se crean en función de la clase Truck. Un ejemplo más:

public static void main(String[] args) {

   Car car = new Car();
   Truck truck = new Truck();
   System.out.println(car instanceof Object && truck instanceof Object);
}

Salida: Verdadero La lógica aquí también es simple: todas las clases en Java, incluidas las que usted creó, provienen de una clase Object(aunque no escribe objetos extendidos en ellas ; este mecanismo está implícito en ellas). ¿Por qué podría ser útil esto y bajo qué circunstancias? El uso más común del operador instanceofes como anulación de método equals(). Por ejemplo, así es como se implementa el método equalsen la clase String:

public boolean equals(Object anObject) {
   if (this == anObject) {
       return true;
   }
   if (anObject instanceof String) {
       String anotherString = (String) anObject;
       int n = value.length;
       if (n == anotherString.value.length) {
           char v1[] = value;
           char v2[] = anotherString.value;
           int i = 0;
           while (n-- != 0) {
               if (v1[i] != v2[i])
                       return false;
               i++;
           }
           return true;
       }
   }
   return false;
}

Antes de comparar la cadena con el objeto pasado, el método comprueba: ¿el objeto pasado es realmente una cadena? Y sólo entonces comienza a comparar las propiedades de dos objetos. Sin esta verificación, podría pasar cualquier objeto que tenga campos de valor y longitud al método y compararlo con una cadena, lo cual, por supuesto, sería incorrecto.