En esta ocasión vamos a ver las Clases en Java. Empezaremos introduciendo el concepto de programación orientada a objetos, veremos como declarar las Clases, como instanciar objetos y, como siempre, realizaremos ejemplos para practicar estos conceptos.

La programación orientada a objetos

Las clases y los objetos, son dos conceptos básicos de la programación orientada a objetos, que tenemos que entender muy bien. Una Clase es un molde definido por el usuario que empleamos para crear objetos. Este molde incluye una serie de propiedades y métodos que son comunes a todos los objetos creados con una clase.

La clase puede ser vista como un molde y el objeto como una implementación concreta sacada de ese molde. Por lo que con una clase podemos generar muchos objetos que tendrán las mismas características.

La programación orientada a objetos basa toda la codificación en objetos, que intentaran similar objetos reales o conceptos.  Dicho así puede sonar un poco abstracto, pero cuando practiquemos programando nos quedará claro este concepto.

Declaración de una Clase

La declaración de una clase incluye los siguientes componentes:

  • Modificadores: debe ser public para asegurar el acceso desde otras clase o tener el acceso por defecto.
  • Nombre: Para identificar a la clase. Debe de empezar con una letra mayúscula.
  • Superclase (si existe): Es el nombre de la clase padre si la tuviera. Hablaré de la clase padre cuando introduzcamos el concepto de herencia. En la declaración de la clase, el nombre de la superclase aparecerá precedido por la palabra clave extends.
  • Interfaces (si hay): Una lista de interfaces implementados por la clase, separados por comas, precedidos por la palabra clave implements. Una clase implementa uno o más interfaces.
  • Cuerpo: Bloque de instrucciones de la clase, entre corchetes { }.

Declaración de una clase:

class MiClase extends MiSuperClass implements UnInterface {

    < parámetros, construtores y métodos >

}

Este ejemplo de declaración de clase nos indica que la clase MiClase es hija de la superclase MiSuperClass y que además implementa el interface UnInterface.

Una clase tiene que ser programada en un fichero java con el nombre de la clase. Por ejemplo, la clase Coche debería estar programada en un fichero llamado Coche.java

Una clase contiene constructores que son métodos empleados para crear objetos a partir del molde de la clase. Cuando en nuestro programa, queramos crear un objeto de una clase, invocaremos a un constructor de dicha clase.

Los constructores se declaran como métodos, con la particularidad de que tienen que tener el mismo nombre que la clase y que no devuelven ningún valor.

Parámetros, constructores y métodos

Las clases representan atributos y comportamientos. Los atributos son definidos por los parámetros que son variables que definimos en la clase. Y los comportamientos están definidos por los métodos de la clase.

En la siguiente actividad, practicamos con estos dos conceptos:

Actividad 17.1: Declarando Clases

1.-Abre el compilador online:

https://www.jdoodle.com/online-java-compiler/

2.-Como vamos a trabajar con varias clases, tendremos que guardar cada una en un fichero con su nombre y la extensión java. Trabajando con el compilador online, lo primero que tenemos que hacer es cambiar al modo avanzado (Advanced java IDE) que nos permitirá trabajar con varios ficheros.

On Line Java Compiler

3.- lo primero que vamos a hacer es crear un nuevo fichero donde programaremos nuestra clase. La Clase la llamaremos Coche y por tanto el fichero será Coche.java

On Line Java Compiler IDE

Introduce el siguiente código en Coche.java:

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

public class Coche{

    int CV;

    int numeroPuertas;

    int añoFabricacion;

    String propietario;

    String color;

    String combustible;

    boolean encendido;

    int porcentajeTanqueLleno;

    public Coche(int np, String pro){

        this.numeroPuertas = np;

        this.propietario=pro;

    }

    public void arranque(){

        if (porcentajeTanqueLleno>5){

            encendido = true;

        }

    }

    public void parado(){

        encendido = false;

    }

    public int llenadoTanque(){

        if (porcentajeTanqueLleno<80){

            porcentajeTanqueLleno = 100;

        }

        return porcentajeTanqueLleno;

    }

}

 

Línea 1: Primera sentencia de la clase, declarada como pública con el nombre Coche.

Línea 2 a la 9: Declaración de todos los parámetros de la clase.

Línea 12: El constructor de la clase. Hay sólo uno pero podría haber varios siguiendo el principio de sobrecarga de métodos. Recuerda que un constructor es un método con el nombre de la clase que no devuelve ningún valor.

Este constructor admite dos parámetros: np y pro, que se guardan en los parámetros numeroPuertas y propietario, del objeto que se cree al invocar el constructor.

Línea 14: método arranque. Chequea si el tanque está lleno de combustible al menos en un 5%. Si es así, arranca el coche haciendo verdadera la variable encendido.

Línea 19: método parado, que pone a falso la variable encendido.

Línea 22: método llenadoTanque. Si el deposito está por debajo del 80% de su capacidad, entonces se llena de combustible el 100% del tanque, empleando el parámetro porcentajeTanqueLleno que lo ponemos a 100.

De momento, no hemos usado la clase, sencillamente la hemos programado y explicado su código. En las próximas actividades continuaremos desarrollando la clase y comenzaremos a utilizarla.

Instanciar un objeto

Un objeto es la pieza básica de la programación orientada a objetos y pretende representar una entidad del mundo real. Un programa java típico, creará varios objetos invocando constructores de la clase que corresponda.

Un objecto concreto viene representado por su:

  • Estado: representado por los atributos del objeto que almacenamos en los parámetros del mismo.
  • Comportamiento: representado por los métodos del objeto.
  • Identidad: el nombre que damos al objeto le proporciona una identidad única que le permite interactuar con otros objetos.

Por instanciar un objeto entendemos crear un objeto con el comando new y llamando a un constructor de la clase asociada. Decimos que hemos creado una instancia de la clase, un objeto concreto con valores particulares para sus parámetros.

Todas las instancias de objetos de una clase, comparten los mismos parámetros y métodos, como no podía ser de otra forma, ya que todos están creados con el mismo molde definido en la clase.

Para entenderlo bien, vamos a continuar con nuestra actividad, practicando con estos conceptos.

Actividad 17.2: Creando objetos

  1. Abre el compilador online:

https://www.jdoodle.com/online-java-compiler/

  1. En la actividad anterior, definimos la clase Coche pero no la usamos. En esta actividad crearemos varios objetos basados en dicha clase.

En el fichero MyClass.java introduce el siguiente código:

1

2

3

4

5

6

7

8

public class MyClass {

    public static void main(String args[]) {

 

      Coche miCoche;

      miCoche = new Coche (5,»Jesús Garcia»);

      System.out.println(«El propietario es «+ miCoche.propietario);

    }

}

 

  1. En la clase MyClass, tenemos el método main, que es el que se ejecuta al iniciar el programa. Luego empezamos el programa desde este método, instanciando y llamando a las otras clases que necesitemos en nuestro programa.

Línea 2: Empieza el método main.

Línea 4: Declaramos la variable miCoche que es del tipo Coche, la clase que definimos en la anterior actividad.

Línea 5: Instanciamos el objeto miCoche de tipo Coche. Usamos la instrucción new y un constructor de la clase. Este constructor admite dos parámetros: el número de puertas y el propietario.

Línea 6: Imprimimos por pantalla el propietario del objeto miCoche. Tenemos que indicar el nombre del objeto, seguido de un punto y el parámetro. De momento podemos acceder al parámetro directamente, más adelante veremos como acceder de manera más segura, declarando el parámetro como privado y utilizando un método para acceder al valor del mismo.

  1. Si ejecutamos el programa, obtendremos el resultado:

El propietario es Jesús Garcia

  1. Sin embargo, el resto de parámetros del objeto no han sido inicializados. Unicamente hemos definido el número de puertas y el propietario. Veamos que pasa si imprimimos sus valores, para lo que ejecutaríamos el siguiente código:
1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

public class MyClass {

    public static void main(String args[]) {

 

      Coche miCoche;

      miCoche = new Coche (5,»Jesús Garcia»);

      System.out.println(«**********dibujando los parámetros *********»);

      System.out.println(«El propietario es «+ miCoche.propietario);

      System.out.println(«La potencia es «+ miCoche.CV + » Caballos de vapor»);

      System.out.println(«El número de puertas es «+ miCoche.numeroPuertas);

      System.out.println(«El año de fabricación es «+ miCoche.añoFabricacion);

      System.out.println(«El propietario es «+ miCoche.propietario);

      System.out.println(«El color del coche es «+ miCoche.color);

      System.out.println(«El tipo de combustible es «+ miCoche.combustible);

      System.out.println(«Coche arrancado? «+ miCoche.encendido);

      System.out.println(«Porcentaje del tanque lleno:  «+ miCoche.porcentajeTanqueLleno);

    }

}

  1. Al ejecutar el programa, el resultado es:

**********dibujando los parámetros *********

El propietario es Jesús Garcia

La potencia es 0 Caballos de vapor

El número de puertas es 5

El año de fabricación es 0

El propietario es Jesús Garcia

El color del coche es null

El tipo de combustible es null

Coche arrancado? false

Porcentaje del tanque lleno:  0

 

Puedes apreciar que las variables de tipo integer que no han sido inicializadas tienen un valor de 0, mientras que las de tipo String no inicializadas tienen un valor null.

 

Accediendo a parámetros y métodos de la Clase

En la última actividad, accedimos a los parámetros de la clase, dibujándolos todos por pantalla. La forma de acceder era muy sencilla, utilizábamos el nombre del objeto seguido de un punto y el nombre del parámetro al que queríamos acceder.

Para acceder a los métodos de la clase, el procedimiento es el mismo pero cambiando el nombre del parámetro por el del método, y pasando al método todos los datos que requiera.

Veamos como funciona en la práctica:

Actividad 17.3: Creando objetos

  1. Abre el compilador online:

https://www.jdoodle.com/online-java-compiler/

  1. Empleando la clase Coche con la que ya venimos trabajando, vamos a crear dos objetos Coche, cambiar los valores de algunos de sus parámetros y llamar a alguno de sus métodos. Para hacer todo ello, introduce el siguiente código.
1

2

3

4

5

6

7

 

8

 

9

10

public class MyClass {

    public static void main(String args[]) {

      Coche primerCoche;

      Coche segundoCoche;

      primerCoche = new Coche (5,»Jesús Garcia»);

      segundoCoche = new Coche (3,»Laura Perez»);

      System.out.println(«El propietario del primer coche es: «+ primerCoche.propietario);

      System.out.println(«El propietario del segundo coche es: «+ segundoCoche.propietario);

    }

}

De momento no hacemos nada nuevo. Creamos dos objetos de tipo coche y los inicializamos utilizando el constructor de la Clase.

Línea 3 y 4: Declaramos los objetos primerCoche y segundoCoche

Línea 5 y 6: Instanciamos los dos objetos declarados usando el constructor de la Clase.

Líneas 7 y 8: Dibujamos los propietarios de los dos objetos coche.

  1. Hay varios parámetros que no hemos usado todavía, simplemente porque no los inicializamos con el constructor. ¿Cómo podemos trabajar con esos parámetros?

Teclea el siguiente código para practicar el acceso y actualización de los valores de los distintos parámetros:

1

2

3

4

5

6

7

 

8

 

9

10

11

12

13

14

 

15

 

16

17

public class MyClass {

    public static void main(String args[]) {

      Coche primerCoche;

      Coche segundoCoche;

      primerCoche = new Coche (5,»Jesús Garcia»);

      segundoCoche = new Coche (3,»Laura Perez»);

      System.out.println(«El propietario del primer coche es: «+ primerCoche.propietario);

      System.out.println(«El propietario del segundo coche es: «+ segundoCoche.propietario);

     

      primerCoche.combustible = «gasolina»;

      primerCoche.color = «negro»;

      segundoCoche.combustible = «diesel»;

      segundoCoche.color = «amarillo»;

      System.out.println(«El color del primer coche es «+ primerCoche.color + » y utiliza como combustible «+primerCoche.combustible);

      System.out.println(«El color del segundo coche es «+ segundoCoche.color + » y utiliza como combustible «+segundoCoche.combustible);

    }

}

  1. Simplemente uso el código del punto 2 de esta activida y añado código desde la línea 10. Accedo a los parámetros combustible y color de ambos objetos, almacenando valores en los mismos, para luego dibujarlos en pantalla.
  2. Lo siguiente es acceder al método de la clase. Para practicar con ello, vamos a introducir el siguiente código en la clase MyClass, donde tengo el método main.
1

2

3

4

5

6

7

 

8

9

10

11

12

 

13

14

public class MyClass {

    public static void main(String args[]) {

      Coche primerCoche;

      Coche segundoCoche;

      primerCoche = new Coche (5,»Jesús Garcia»);

      segundoCoche = new Coche (3,»Laura Perez»);

      System.out.println(«El porcentaje de tanque lleno es: «+ primerCoche.porcentajeTanqueLleno);

      if (primerCoche.porcentajeTanqueLleno<25){

          System.out.println(«Vamos a proceder a llenar el tanque»);

          primerCoche.llenadoTanque();

      }

      System.out.println(«El porcentaje de tanque lleno es: «+ primerCoche.porcentajeTanqueLleno);

    }

}

Línea 7: Dibujo por pantalla el porcentaje del tanque que está lleno, valor del parámetro porcentajeTanqueLleno. En este punto, como no hemos inicializado el parámetro, su valor es cero, valor por defecto para un integer sin inicializar.

Línea 8: Como el porcentaje anteriore está por debajo de 25, la comparación de la sentencia if es verdadera y pasamos a ejecutar las instrucciones del bloque if.

Línea 10: Llamamos al método llenadoTanque. La llamada se hace con el nombre del objeto, seguido de un punto, el nombre del método y le pasamos los parámetros que requiera el método. En este caso, como el método no requiere parámetros, los paréntesis están vacios. Puede observarse que siempre que llamemos a un método tendremos que usar paréntesis, aunque no haya que pasarle ningún parámetro. Si no hay paréntesis, significa que lo que estamos llamando no es un método sino un parámetro de la clase.

Línea 12: El porcentaje del tanque lleno se dibuja por pantalla.

Métodos Getters and Setters

La manera de acceder a los parámetros vista hasta ahora, requiere que estos estén definidos como públicos, que es el valor que toma por defecto sino utilizamos ningún modificador.

En el caso de la clase Coche, si por ejemplo tomamos el parámetro añoFabricación, este está definido como:

               int añoFabricacion

lo que es equivalente a:

               public int añoFabricacion

Esta no es una buena práctica. Al contrario, por motivos de seguridad y para tener mayor control sobre los parámetros de una clase, es conveniente declarar los parámetros internos de una clase como privados. De esta forma, sólo podrían ser accedidos desde dentro de la clase, con lo que podemos tener más control en el acceso a los mismos.

Sin embargo, los objetos de las clases van a ser usados por otras clases, con lo que al final tenemos que proporcionar este acceso.

La solución consiste en definir los parámetros como privados y crear métodos públicos para recuperar o actualizar los valores de dichos parámetros. Estos métodos se han hecho tan populares y los utilizamos siempre, que reciben el nombre de métodos getters y setters. Los primeros se emplean para recuperan los valores de los parámetros, mientras que los segundos lo hacen para establecer los valores.

Empleando estos métodos, el programador puede controlar como se accede a los parámetros de la clase, asegurando que se usan de manera correcta. Como, por ejemplo, comprobando antes de actualizar un valor que se encuentra dentro de un rango requerido.

Declaración de los métodos

getVVV() y setVVV(); donde VVV es el nombre del parámetro.

Si la variable fuera de tipo boolean, los métodos getters pueden ser nombrados como isVVV() o en su forma tradicional getVVV().

Veamos como funciona esto en la práctica, haciendo una actividad

Actividad 17.4: Métodos Getters and Setters

  1. Abre el compilador online:

https://www.jdoodle.com/online-java-compiler/

  1. Usando la clase Coche ya definida, cambiamos a privada la declaración del parámetro porcentajeTanqueLleno

private int porcentajeTanqueLleno;

Si ahora ejecutaramos el programa de la anterior actividad, obtendríamos el error:

MyClass.java:7: error: porcentajeTanqueLleno has private access in Coche

      System.out.println(«El porcentaje de tanque lleno es: «+ primerCoche.porcentajeTanqueLleno);

                                                                          ^

MyClass.java:8: error: porcentajeTanqueLleno has private access in Coche

      if (primerCoche.porcentajeTanqueLleno<25){

                     ^

MyClass.java:12: error: porcentajeTanqueLleno has private access in Coche

      System.out.println(«El porcentaje de tanque lleno es: «+ primerCoche.porcentajeTanqueLleno);

                                                                          ^

3 errors

 

Estos tres errores están ocasionados por el mismo motivo. Intentamos acceder al parámetro porcentajeTanqueLleno desde fuera de la clase Coche, pero al estar declarado como privado, esto no es posible.

Recuerda que estamos accediendo desde el método main en la clase MyClass

  1. Programemos entonces los métodos getter y setter para poder acceder a este parámetro desde fuera de la clase Coche.
1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

public class Coche{

    int CV;

    int numeroPuertas;

    int añoFabricacion;

    String propietario;

    String color;

    String combustible;

    boolean encendido;

    private int porcentajeTanqueLleno;

    public Coche(int np, String pro){

        this.numeroPuertas = np;

        this.propietario=pro;

    }

    public void arranque(){

        if (porcentajeTanqueLleno>5){

            encendido = true;

        }

    }

    public void parado(){

        encendido = false;

    }

    public int llenadoTanque(){

        if (porcentajeTanqueLleno<80){

            porcentajeTanqueLleno = 100;

        }

        return porcentajeTanqueLleno;

    }

    //metodos getters and setters

    public int getporcentajeTanqueLleno(){

        return this.porcentajeTanqueLleno;

    }

    public void setporcentajeTanqueLleno(int val){

        this.porcentajeTanqueLleno=val;

    }

}

 

Línea 29 a 34: Definición de los métodos getter y setter para el parámetro porcentajeTanqueLleno. Lo que he hecho con este parámetro habría que hacerlo para el resto de parámetros de la clase, definiendo todos los métodos getters y setters correspondientes.

Es interesante el uso de la palabra reservada this. Representa al objeto con el que estamos trabajando, por lo que podemos acceder al parámetro xxx usando <this.xxx>. En este punto del programa podemos acceder de esta manera porque estamos accediendo desde dentro de la clase, y estamos dentro del alcance de la variable aunque esta esté declarada como privada.

Una vez definidos los métodos getter y setter en la clase Coche, todavía tenemos que cambiar la llamada a estos parámetros desde el método main. El nuevo código de este método quedaría:

 

1

2

3

4

5

6

7

 

8

9

10

11

12

 

13

14

public class MyClass {

    public static void main(String args[]) {

      Coche primerCoche;

      Coche segundoCoche;

      primerCoche = new Coche (5,»Jesús Garcia»);

      segundoCoche = new Coche (3,»Laura Perez»);

      System.out.println(«El porcentaje de tanque lleno es: «+ primerCoche.getporcentajeTanqueLleno());

      if (primerCoche.getporcentajeTanqueLleno()<25){

          System.out.println(«Vamos a proceder a llenar el tanque»);

          primerCoche.llenadoTanque();

      }

      System.out.println(«El porcentaje de tanque lleno es: «+ primerCoche.getporcentajeTanqueLleno());

    }

}

En las líneas 7,8 y 12, se puede apreciar el uso de la función getter correspondiente para recuperar el valor del parámetro procentajeTanqueLleno.

Campos y métodos estáticos

Un campo o método de una clase que sea static, puede ser accedido sin necesidad de crear una instancia de la Clase, es decir, sin necesidad de crear un objeto.

Existen ocasiones en las que resulta muy útil crear parámetros o métodos static. Por ejemplo, si queremos guardar información universal de la clase, como por ejemplo el número de objetos de la clase que queremos manejar.

public class Estudiantes {

    public static int numEstudiantes = 29;

   

}

Una vez existe un parámetro definido como static, se puede acceder a él desde dentro o fuera de la Clase, sin necesidad de instanciar la Clase.

int numEstudantesEnJava = Estudiantes.numEstudiantes;

 

Método estático

Una Clase tiene tres tipos fundamentales de métodos:

  • Constructores: Ya describimos como son estos métodos, que tienen el mismo nombre que la clase y se emplean para generar un objeto.
  • Métodos instanciados: Accedemos a ellos a través del objeto.
  • Métodos estáticos: Los que nos ocupan en este momento, que pueden ser llamados sin instanciar la Clase, es decir, sin crear un objeto.

public class Estudiantes {

    private static int numEstudiantes = 0;

   private String nombre;
public Estudiantes(String nombre){

        this.nombre = nombre;

        numEstudiantes++;

    }

    public static int getNumEstudiantes(){

        return numEstudiantes;

    }    …

};

Actividad 17.5: Campos y métodos estáticos

  1. Abre el compilador online:

https://www.jdoodle.com/online-java-compiler/

  1. Usando la clase Coche ya definida, vamos a definir un parámetro estático llamado numCoches que representa el número de coches que se han creado.

La declaración del parámetro sería:

static int numCoches=0;

  1. Lo siguiente que tenemos que hacer es asegurarnos que cada vez que se cree un objeto coche nuevo, el parámetro numCoches se incremente en uno. En la práctica esto significa incrementar el parámetro cada vez que llamemos a un constructor.

Por lo tanto, escribiríamos lo siguiente en cada constructor:

numCoches++;

  1. Para acceder al valor del parámetro numCoches, tenemos que emplear el nombre de la clase, en lugar del nombre de un objeto concreto de la clase. Esto es así, ya que se trata de un parámetro estático que no está asociado a ningún objeto en concreto.

Añadimos la siguiente línea de código al final del método main:

System.out.println(«Numero de coches: «+Coche.numCoches);

Ejecutamos el programa y obtendríamos el siguiente resultado:

El porcentaje de tanque lleno es: 0

Vamos a proceder a llenar el tanque

El porcentaje de tanque lleno es: 100

Numero de coches: 2

El método main completo sería:

1

2

3

4

5

6

7

 

8

9

10

11

12

 

13

14

15

public class PracticandoConClaseCoche {

    public static void main(String args[]) {

      Coche primerCoche;

      Coche segundoCoche;

      primerCoche = new Coche (5,»Jesús Garcia»);

      segundoCoche = new Coche (3,»Laura Perez»);

      System.out.println(«El porcentaje de tanque lleno es: «+ primerCoche.getporcentajeTanqueLleno());

      if (primerCoche.getporcentajeTanqueLleno()<25){

          System.out.println(«Vamos a proceder a llenar el tanque»);

          primerCoche.llenadoTanque();

      }

      System.out.println(«El porcentaje de tanque lleno es: «+ primerCoche.getporcentajeTanqueLleno());

      System.out.println(«Numero de coches: «+Coche.numCoches);

    }

}  

  1. Todo lo comentado anteriormente acerca de la conveniencia de declarar como privados los parámetros internos de una Clase, es perfectamente valido también para los parámetros estáticos.

Por ello, añadimos private a la declaración del parámetro estático:

private static int numCoches=0;

Codificamos un método público y estático que nos devuelta el parámetro, es decir, su método get:

    public static int getNumCoches(){

        return numCoches;

    }

Y, por supuesto, usamos este método para recuperar el valor de NumCoches en las llamadas desde el método main:

System.out.println(«Numero de coches: «+Car.getNumCoches());

Sobrecarga de constructores y métodos

Los constructores son métodos de la clase con el mismo nombre que esta. Al igual que el resto de métodos soportan sobrecarga, podemos tener varios métodos distintos con el mismo nombre, siempre y cuando acepten distintos tipos de parámetros.

En el caso de los constructores, la sobrecarga es muy habitual ya que estamos obligados a que empleen el mismo nombre que la Clase. Además, normalmente definiremos varios constructores para poder inicializar los objetos de la Clase inicializando distintoso parámetros. Es relativamente común tener un constructor que inicialice todos los parámetros de la clase.

Veamos como funciona todo esto.

Actividad 17.5: Campos y métodos estáticos

  1. Abre el compilador online:

https://www.jdoodle.com/online-java-compiler/

  1. Usando la clase Coche ya definida, vamos a implementar varios constructores adicionales. Estos métodos tendrán el mismo nombre que la Clase y podremos crear tantos como queramos siempre y cuando acepten distintos parámetros.
  2. Añadamos el siguiente constructor a la clase Coche:

    public Coche(int numeroPuertas, String propietario, String color, String combustible) {

        this.numeroPuertas = numeroPuertas;

        this.propietario = propietario;

        this.color = color;

        this.combustible = combustible;

        numCoches++;

    }

La clase Coche queda como:

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

 

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

public class Coche{

    int CV;

    int numeroPuertas;

    int añoFabricacion;

    String propietario;

    String color;

    String combustible;

    boolean encendido;

    private int porcentajeTanqueLleno;

    private static int numCoches=0;

   

    //Constructores

    public Coche(int np, String pro){

        this.numeroPuertas = np;

        this.propietario=pro;

        numCoches++;

    }

 

    public Coche(int numeroPuertas, String propietario, String color, String combustible) {

        this.numeroPuertas = numeroPuertas;

        this.propietario = propietario;

        this.color = color;

        this.combustible = combustible;

        numCoches++;

    }

   

    //métodos de la clase

    public void arranque(){

        if (porcentajeTanqueLleno>5){

            encendido = true;

        }

    }

    public void parado(){

        encendido = false;

    }

    public int llenadoTanque(){

        if (porcentajeTanqueLleno<80){

            porcentajeTanqueLleno = 100;

        }

        return porcentajeTanqueLleno;

    }

    //metodos getters and setters

    public int getporcentajeTanqueLleno(){

        return this.porcentajeTanqueLleno;

    }

    public void setporcentajeTanqueLleno(int val){

        this.porcentajeTanqueLleno=val;

    }

    public static int getNumCoches(){

        return numCoches;

    }

}

 

  1. Ahora, tenemos dos constructores disponibles en la clase Coche. Usemos ambos en nuestro programa principal:
1

2

3

4

5

6

7

8

 

9

 

10

11

public class PracticandoConClaseCoche {

    public static void main(String args[]) {

      Coche primerCoche;

      Coche segundoCoche;

      primerCoche = new Coche (5,»Jesús Garcia»);

      segundoCoche = new Coche (3,»Laura Perez»,»blanco»,»gasolina»);

      System.out.println(«Existen «+Coche.getNumCoches()+» coches»);

      System.out.println(«El propietario del primer coche es «+primerCoche.propietario+». Y su color es»+primerCoche.color);

      System.out.println(«El propietario del segundo coche es «+segundoCoche.propietario+». Y su color es»+segundoCoche.color);

    }

}

Como no hemos creado los métodos getters para los parámetros propietario y color, llamamos a los parámetros directamente por su nombre, en lugar de usar los métodos getters

El resultado de ejecutar el programa sería:

 

Existen 2 coches

El propietario del primer coche es Jesús Garcia. Y su color esnull

El propietario del segundo coche es Laura Perez. Y su color esblanco

 

NOTA:

Este post es parte de la colección “Java” que reproduce los apuntes de la clase que imparto sobre el tema en ESIC. Puedes ver el índice de esta colección aquí.