Siguiente: 7 Herencia Subir: Introducción a Java y Anterior: 5 Clases Índice General

Subsecciones

6 Métodos y clases

1 Sobrecarga de métodos

Consiste en que dos o más métodos de una clase tienen el mismo nombre, pero con listas de parámetros distintos.

La sobrecarga es usada en Java para implementar el polimorfismo.
Java utiliza el tipo y/o el número de argumentos como guía para ver a cual método llamar.
El tipo que devuelve un método es insuficiente para distinguir dos versiones de un método.

P8/Overload.java

class OverloadDemo {
  void test() {
    System.out.println("Sin parametros");
  }

  // Sobrecarga el metodo test con un parámetro entero
 void test(int a) {
    System.out.println("a: " + a);
  }

  // Sobrecarga el metodo test con dos parametros enteros
  void test(int a, int b) {
    System.out.println("a y b: " + a + " " + b);
  }

  // Sobrecarga el metodo test con un parámetro double
  double test(double a) {
    System.out.println("double a: " + a);
    return a*a;
  }
}

class Overload {
  public static void main(String args[]) {
    OverloadDemo ob = new OverloadDemo();
    double result;

    // llama a todas las versiones de test()
    ob.test();
    ob.test(10);
    ob.test(10, 20);
    result = ob.test(123.2);
    System.out.println("Resultado de ob.test(123.2): " + result);
  }
}

La salida del programa sería:

Sin parametros
a: 10
a y b: 10 20
a double: 123.2
Resultado de ob.test(123.2): 15178.2

1 Sobrecarga con conversión automática de tipo

Java busca una versión del método cuyos parámetros actuales coincidan con los parámetros formales, en número y tipo. Si el tipo no es exacto puede que se aplique conversión automática de tipos.

class OverloadDemo {
  void test() {
    System.out.println("Sin parametros");
  }

  // Sobrecarga el metodo test con dos parametros enteros
 void test(int a, int b) {
    System.out.println("a y b: " + a + " " + b);
  }

  // Sobrecarga el metodo test con un parámetro double
  void test(double a) {
    System.out.println("Dentro de test(double) a: " + a);
  }
}

class Overload {
  public static void main(String args[]) {
    OverloadDemo ob = new OverloadDemo();
    int i = 88;

    ob.test();
    ob.test(10, 20);

    ob.test(i); // esto llama a test(double)
    ob.test(123.2); // esto llama a test(double)
  }
}

2 Sobrecarga de constructores

Además de los métodos normales, también pueden sobrecargarse los constructores.

P9/OverloadCons.java

class Box {
  double width;
  double height;
  double depth;

  Box(double w, double h, double d) {
    width = w;
    height = h;
    depth = d;
  }
  Box() {
    width = -1;  // utiliza -1 para indicar
    height = -1; // que una caja no está
    depth = -1;  // inicializada
  }
  Box(double len) {
    width = height = depth = len;
  }

  double volume() {
    return width * height * depth;
  }
}

class OverloadCons {
  public static void main(String args[]) {
    Box mybox1 = new Box(10, 20, 15);
    Box mybox2 = new Box();
    Box mycube = new Box(7);
    double vol;

    vol = mybox1.volume();
    System.out.println("El volumen de mybox1 es " + vol);
    vol = mybox2.volume();
    System.out.println("El volumen de mybox2 es " + vol);
    vol = mycube.volume();
    System.out.println("El volumen de mycube es " + vol);
  }
}

2 Objetos como parámetros

Un objeto de una determinada clase puede ser parámetro de un método de esa u otra clase.

P10/PassOb.java

class Test {
  int a, b;

  Test(int i, int j) {
    a = i;
    b = j;
  }

  // devuelve true si o es igual al objeto llamante
  boolean equals(Test o) {
    if(o.a == a && o.b == b) return true;
    else return false;
  }
}

class PassOb {
  public static void main(String args[]) {
    Test ob1 = new Test(100, 22);
    Test ob2 = new Test(100, 22);
    Test ob3 = new Test(-1, -1);

    System.out.println("ob1 == ob2: " + ob1.equals(ob2));
    System.out.println("ob1 == ob3: " + ob1.equals(ob3));
  }
}

Uno de los ejemplos más usuales es en constructores para hacer copias de objetos:

  Box(Box ob) {
    width = ob.width;
    height = ob.height;
    depth = ob.depth;
  }

Box mybox = new Box(10,20,15);
Box myclone = new Box(mybox);

3 Paso de argumentos

El paso de tipos simples a los métodos es siempre por valor.
Los objetos se pasan siempre por referencia.

P11/CallByValue.java

class Test {
  void meth(int i, int j) {
    i *= 2;
    j /= 2;
  }
}
class CallByValue {
  public static void main(String args[]) {
    Test ob = new Test();
    int a = 15, b = 20;
    System.out.println("a y b antes de la llamada:"+a+" "+b);
    ob.meth(a, b);
    System.out.println("a y b despues de la llamada:"+a+" "+b);
  }
}

class Test {
  int a, b;
  Test(int i, int j) {
    a = i;
    b = j;
  }
  // pasa un objecto
  void meth(Test o) {
    o.a *=  2;
    o.b /= 2;
  }
}

P12/CallByRef.java

class CallByRef {
  public static void main(String args[]) {
    Test ob = new Test(15, 20);
    System.out.println("ob.a y ob.b antes de la llamada: " +
                       ob.a + " " + ob.b);
    ob.meth(ob);
    System.out.println("ob.a y ob.b después de la llamada: " +
                       ob.a + " " + ob.b);
  }
}

4 Control de acceso

Los especificadores de acceso para variables de instancia y métodos son:

private: Sólo es accesible por miembros de la misma clase.
public: Accesible por miembros de cualquier clase.
protected: Está relacionado con la herencia.
Por defecto: si no se indica nada los miembros son públicos dentro de su mismo paquete

P13/AccessTest.java

class Test {
  int a; // acceso por defecto
  public int b; // acceso publico
  private int c; // acceso privado
  void setc(int i) { // establece el valor de c
    c = i;
  }
  int getc() { // obtiene el valor de c
    return c;
  }
}

class AccessTest {
  public static void main(String args[]) {
    Test ob = new Test();

    // Esto es correcto, a y b pueden ser accedidas directamente
    ob.a = 10;
    ob.b = 20;

    // Esto no es correcto y generara un error de compilación
//  ob.c = 100; // Error!

    // Se debe acceder a c a través de sus métodos
    ob.setc(100); // OK

    System.out.println("a, b, y c: " + ob.a + " " +
                       ob.b + " " + ob.getc());
  }
}

5 Especificador static

Un miembro static puede ser usado sin crear ningún objeto de su clase.
Puede aplicarse a variables de instancia y métodos
- Las variables static son variables globales. Existe una sola copia de la variable para todos los objetos de su clase.
- Los métodos static
  - Sólo pueden llamar a métodos static
  - Sólo deben acceder a datos static
  - No pueden usar this o super
Una clase puede tener un bloque static que se ejecuta una sola vez cuando la clase se carga por primera vez.

P14/UseStatic.java

class UseStatic {
  static int a = 3;
  static int b;

  static void meth(int x) {
    System.out.println("x = " + x);
    System.out.println("a = " + a);
    System.out.println("b = " + b);
  }
  static {
    System.out.println("Bloque estático inicializado.");
    b = a * 4;
  }
  public static void main(String args[]) {
    meth(42);
  }
}

6 Especificador final con variables

Una variable final es una variable en la que no podemos modificar su contenido.

Las variables final deben inicializarse al declararlas.
Son similares al const de C/C++

Suele utilizar identificadores en mayúscula:

final int FILE_NEW = 1;
final int FILE_OPEN = 2;
final int FILE_SAVE = 3;
final int FILE_SAVEAS = 4;
final int FILE_QUIT = 5;

Existe una sola copia de ellas para todos los objetos de la clase.
Las variables final suelen ser también static.

7 Clase String

Es una clase muy usada, que sirve para almacenar cadenas de caracteres (incluso los literales).

Los objetos String no pueden modificar su contenido.
Los objetos StringBuffer si que pueden modificarse.
El operador + permite concatenar cadenas.
El método boolean equals(String objeto) compara si dos cadenas son iguales.
El método int length() obtiene la longitud de una cadena.
El método char charAt(int pos) obtiene el carácter que hay en la posición pos.

P15/StringDemo2.java

// Muestra la utilización de algunos metodo de la clase String
class StringDemo2 {
  public static void main(String args[]) {
    String strOb1 = "Primera cadena";
    String strOb2 = "Segunda cadena";
    String strOb3 = strOb1;
    System.out.println("La longitud de strOb1 es: " +
                       strOb1.length());
    System.out.println("El carácter de la posición 3 de strOb1 es: " +
                       strOb1.charAt(3));
    if(strOb1.equals(strOb2))
      System.out.println("strOb1 == strOb2");
    else
      System.out.println("strOb1 != strOb2");
    if(strOb1.equals(strOb3))
      System.out.println("strOb1 == strOb3");
    else
      System.out.println("strOb1 != strOb3");
  }
}

8 Argumentos de la línea de ordenes

P16/CommandLine.java

// Presenta todos los argumentos de la linea de ordenes
class CommandLine {
  public static void main(String args[]) {
    for(int i=0; i<args.length; i++)
      System.out.println("args[" + i + "]: " +
                          args[i]);
  }
}

Si ejecutamos este programa con:

kvm -classpath . CommandLine esto es una prueba 100 -1

obtendremos como salida:

args[0]: esto
args[1]: es
args[2]: una
args[3]: prueba
args[4]: 100
args[5]: -1

Siguiente: 7 Herencia Subir: Introducción a Java y Anterior: 5 Clases Índice General

Andres Cano Utrera 2006-09-23