En este volumen os voy a explicar qué son los argumentos en Java y cómo se usan, también hablaremos de los constructores y de los principales operadores que nos podemos encontrar en Java.
Este artículo será más práctico que los anteriores que tenía sólo teoría, debemos ir poco a poco ya que sino programaremos sin saber qué es cada cosa, y al principio podremos «sobrevivir» pero cuando luego las cosas no salen…ahí está el problema.
Este va a ser de los últimos artículos de teoría pura y dura (necesitaremos uno más para hablar de los bucles) y a partir de aquí estaremos con ejemplos y con ejercicios diversos usando todo lo que hemos aprendido.
Argumentos
Representan un dato de un tipo determinado, declarado dentro de los paréntesis en el encabezamiento de un método, y alojado en la memoria.
- Contiene un valor.
- Se representa por un nombre.
Ejemplo de declaración de argumentos
public tipo_retornado nombreDelMetodo1 (tipo1 nombre1,
tipo2 nombre2)
{
…
}
Ejemplo de programa con datos
Cálculo de la media de tres notas.
La clase tendrá:
- Tres atributos enteros (las tres notas)
- Método para cambiar las notas: – Tres parámetros enteros (nuevos valores de las notas). – No retorna nada
- Método para hallar la media entera: retorna la media
- Método para hallar la media real: retorna la media
Este es el diagrama de clases que podría estar asociado a los requerimientos de el problema que se plantea:
Implementación
[java]public class Notas
{
//Atributos de la clase
private int nota1, nota2, nota3;
/** Pone los valores de las tres notas */
public void ponNotas (int n1, int n2, int n3)
{
nota1=n1;
nota2=n2;
nota3=n3;
}
/** Calcula la media real */
public double media()
{
return (nota1+nota2+nota3)/3.0;
}
/** Calcula la media entera */
public int mediaEntera()
{
return (nota1+nota2+nota3)/3;
}
}[/java]
Comentarios sobre el ejemplo:
- Argumentos de un método: datos que el método necesita.
- Valor de retorno de un método: respuesta.
- Operador de asignación : «=».
- Operador de suma: «+».
- Uso de paréntesis.
- Expresiones reales y enteras: conversiones automáticas.
¡Probad el cálculo como (nota1+nota2+nota3)*(1/3)!
Uso de un constructor
El ejemplo pone de manifiesto la necesidad de dar valor a los atributos
- Hemos creado ponNotas para ello
- Es una necesidad frecuente
El constructor:
- Es un método especial, usado al crear el objeto (con new) para dar valor a los atributos
- Sintaxis: método de nombre igual a la clase y en el que no se pone lo que retorna:
- Ventaja: al crear el objeto, el constructor nos obliga a poner las notas.
Operadores y expresiones
Las expresiones permiten transformar datos para obtener un resultado. Se construyen con operadores y operandos.
Operandos:
- Constantes literales.
- Datos simples (atributos, variables, o argumentos de tipos simples).
- Funciones (métodos que retornan un valor de un tipo simple).
Operadores más usuales:
Indican la operación a realizar en una expresión
- Dependen del tipo de dato
- Tienen unas reglas de precedencia
- El paréntesis altera la precedencia
Operadores aritméticos: operan con números, y dan como resultado números del mismo tipo.
Operadores relacionales: comparan dos números o caracteres y dan un resultado lógico.
Operadores lógicos: operan con valores lógicos y dan otro valor lógico.
Operador de asignación simple: copia un valor en una variable (=)
Otros operadores de asignación: opera con los operandos izquierdo y derecho y copia el resultado en el izquierdo.
Operador de concatenación: retorna la concatenación del operando izquierdo (String) con la conversión a String del operando derecho (+).
Ejemplo de uso de Operadores
Cálculo de valores resistivos en paralelo.
Diseño de la clase:
- Atributos: las resistencias
- Constructor que les da valor inicial
- Un método que devuelve la resistencia equivalente
[java]public class Resistencias
{
private double r1, r2, r3; //Kohms
/** Constructor*/
public Resistencias(double res1, double res2, double res3)
{
r1=res1;
r2=res2;
r3=res3;
}
/** Calcula la resistencia equivalente a 3 resistencias en paralelo */
public double calculaResEquiv()
{ // Kohms
return 1/((1/r1)+(1/r2)+(1/r3));
}
}[/java]
Ejemplo: uso desde un programa principal (main).
Ahora podemos hacer una clase que usa un objeto de la clase anterior, para poder usar su operación:
[java]public class ResistenciasEnParalelo
{
public static void main(String[] args)
{
double r1=3.5; // Kohms
double r2=5.6; // Kohms
double r3=8.3; // Kohms
double reff; // Kohms
Resistencias res=new Resistencias(r1,r2,r3);
// alternativamente se podría hacer
// Resistencias res= new Resistencias(3.5,5.6,8.3);
reff=res.calculaResEquiv();
System.out.println
(«Resist. en paralelo: «+r1+»,»+r2+»,»+r3);
System.out.println(«Resistencia efectiva = «+reff);
}
}[/java]
Observaciones del ejemplo
- Creación de un objeto de la clase Resistencias: declaración+new.
- Creación de variables locales.
- Diferencias entre crear una variable y un objeto.
- Uso de un método.
- Concatenación.
Conversión de tipos
Compatibilidad de tipos: Java es un lenguaje con tipificación estricta..
- Los números son compatibles hacia «arriba» (promoción automática de tipos): es decir, el tipo destino tiene mayor cabida que el origen
- No son compatibles cosas de distinta naturaleza (p.e., números con char o boolean)
- También hay conversión automática al almacenar un literal en un byte o short (pero no en expresiones no literales).
Conversiones explicitas de tipos (cast)
Sintaxis
(tipo) exp
Hay que usarlas con precaución, porque hay truncamiento de la parte fraccionaria, y/o operación módulo. Por ejemplo:
[java]int i;
double d=3.4;
i= (int) d; // valor=3
byte b;
int j=1000;
b=(byte) j; // valor=-24[/java]
Hasta aquí finalizamos por hoy, el próximo artículo tratará sobre los distintos tipos de bucles en Java y luego nos pondremos a hacer ejercicios que es donde más se aprende.
