UNIDAD 3.

PARÁMETROS Y CONDICIONALES
 DESARROLLO

PARÁMETROS

En programación, cuando se habla de parámetros o argumentos; hay que indicar que los métodos
implementados en una aplicación, se les puede pasar uno o varios parámetros de diferentes tipos
de datos. Los parámetros permiten intercambiar información con los métodos y hacen que el
método tenga un comportamiento distinto, en la lógica para la cual fue programado; dependiendo
de los valores que se le pasa al parámetro. Es decir, los parámetros sirven de insumo o entrada para
la ejecución del método (Nadal, 2021).

A continuación se describe la sintaxis en Java para pasarle parámetros a un método. Después del
nombre del método, entre los paréntesis; se pasan uno o varios parámetros, indicando de qué tipo
de dato es el parámetro y el nombre del parámetro. Si al método se le pasan varios parámetros,
estos se separan con el carácter coma.

public tipo_de_dato nombreMetodo(tipo_de_dato parametro_1, tipo_de_dato parametro_2){

//implementación del método.

}

Ejemplo:

public String saludoMayorEdad(String nom, int e){

//implementación del método.

}

Para el caso del ejemplo anterior, al método saludoMayorEdad se le deben pasar dos atributos; un
atributo de tipo String y un atributo de tipo entero, así: saludoMayorEdad (“María”, 8); no se
le pueden pasar atributos con valores de otro tipo de datos, porque mostraría error.

CONDICIONALES

Una de las estructuras de control más utilizas en programación son los condicionales. Los
condicionales devuelven un valor booleano de verdadero o falso, y permiten ejecutar varias
instrucciones o líneas de código, si se cumple una condición. Dentro de los condicionales se
utilizan: el if, if else, if else if y switch case (Flórez, 2012). Al trabajar con condicionales, es
importante conocer los siguientes operadores de comparación y operadores lógicos para utilizarlos
en la implementación de las condiciones.
Operadores Lógicos:

 Negación (NOT): !
 AND: &&
 OR: ||

Operadores de Comparación:

 Mayor: >
 Menor: <
 Igual: ==
 Mayor Igual: >=
 Menor Igual: <=
 Diferente: !=

A continuación se describen las diferentes estructuras o bloques de condicionales que se pueden

utilizar en la implantación de un método o aplicación.

Estructura del condicional if:

if (condición){
//implementación del código.
}

Ejemplo:

if(edad >= 18){

//implementación del código.
}

Estructura del condicional if else:

if (condición){
//implementación del código.
}else{
//implementación del código.
}

Ejemplo:

if(edad >= 18){

//implementación del código.
}else{
//implementación del código.
}
Estructura del condicional if else if

if(condición){
//implementación del código.
}else{
if(condición){

}else{
//implementación del código.
}
}

Ejemplo:

if(getEdad() >= 18 && getSexo().equalsIgnoreCase("Femenino")){

//implementación del código.
}else{
if(getEdad() >= 18 && getSexo().equalsIgnoreCase("Masculino")){
//implementación del código.
}else{
//implementación del código.
}
}

Estructura del condicional switch case

int operacion = opcion.getSelectedIndex();

switch (opcion){
case 0:
//implementación del código.
case 1:
//implementación del código.
case 2:
//implementación del código.
}
IMPLEMENTACIÓN DEL EJERCICIO PROPUESTO

Siguiendo uno de los ejercicios propuestos en las actividades de la Guía de la Unidad 3; se define
el siguiente problema para poner en práctica el concepto de parámetros y condicionales. Se
requiere diseñar una aplicación que muestre un saludo personalizado a una persona; esto teniendo
en cuenta el nombre, el sexo y la edad de la persona como atributos de la aplicación. La aplicación
debe mostrar al usuario un mensaje de bienvenida e indicar conforme a su edad, si es mayor o
menor de edad (Ver Figura 1).

Figura 1. Mensaje que se le muestra al usuario

Para la solución del problema, primeramente se crea el proyecto en el IDE NetBeans y se crean
tres clases para la implementación de la aplicación. La forma de cómo se crea un nuevo proyecto
y se agregan las clases del proyecto, se explica en la guía complementaria de la Unidad 2.

Para la solución, primero se crea la clase principal Main; la cual se crea por defecto con el nuevo
proyecto, pero es opcional su creación. Después de creado el proyecto y teniendo creada la primera
clase del proyecto (Main); se procede a crear la segunda clase de nombre SaludoPersona, la cual
implementará la lógica para la solución del problema planteado; que en este caso es mostrar un
mensaje al usuario, pero haciendo uso parámetros y estructuras condicionales.

Finalmente, se crea la tercera clase del proyecto de nombre VentanaSaludo; en la cual se tendrá
la vista para pedir los valores de los atributos y mostrar el mensaje al usuarui. Esta clase será un
formulario JFrame. A continuación se procede a implementar el código fuente de las tres clases,
en los ficheros creados para solucionar el problema plateado: Main.java, SaludoPersona.java y
VentanaSaludo.java (Ver Figura 2).

Figura 2. Archivos del Proyecto

Implementación de la clase SaludoPersona en el fichero SaludoPersona.java

public class SaludoPersona {

//Se declaran los atributos de la clase SaludoPersona; los cuales son necesarios para
//solucionar el problema planteado y enviar el saludo al usuario.
private String nombre;
private String sexo;
private int edad;

//Se implementa el método constructor de la clase SaludoPersona para asignar los valores
//iniciales que tendrán los atributos de la clase.
public void SaludoPersona(){
nombre = "";
sexo = "";
edad = 0;
}

//Se declaran los métodos modificadores (set) para asignar desde otra clase, valores a los
//atributos; los cuales fueron declarados como privados y no se puede acceder a ellos desde
//otra clase. Entonces se utilizan los métodos modificadores, que fueron declarados como
//públicos, para que a través de ellos se puedan modificar los valores a los atributos.
public void setNombre(String nom){
nombre = nom;
}
public void setSexo(String s){
sexo = s;
}
public void setEdad(int e){
edad = e;
}

//Se declaran los métodos selectores (get) para obtener desde otra clase, los valores asignados
//a los atributos.
public String getNombre(){
return nombre;
}
public String getSexo(){
return sexo;
}
public int getEdad(){
return edad;
}
//Se implementa el método que envía el mensaje al usuario, indicando su nombre, la edad y
//diciendo si es mayor o menor de edad. Al método saludoMayorEdad, se le pasan dos
//parámetros. Un parámetro de nombre nom, que es de tipo String y otro parámetro de
//nombre e, que es de tipo entero. Cuando se llame al método saludoMayorEdad, se le deben
//pasar los dos parámetros, uno con el nombre del usuario y otro con la edad. El método
//retorna un dato de tipo String que contiene el mensaje.
public String saludoMayorEdad(String nom, int e){
String saludo = "";
//Para personalizar el saludo, se define un condicional if else, que determina si el usuario es
//mayor de 18 años. En caso que sea mayor, muestra el mensaje diciendo que es mayor; de lo
//contrario le envía el mensaje diciéndole que es menor. Para la condición se utiliza el
//parámetro de tipo entero del método (e) y el operador de comparación mayor igual (>=).
if(e >= 18){
saludo = (""+nom+" tiene "+e+" años, es mayor de edad");
}else{
saludo = (""+nom+" tiene "+e+" años, es menor de edad");
}
return saludo;
}

//Se implementa el método que muestra al usuario un mensaje de bienvenida personalizado.

//Para enviar el saludo se utiliza un condicional if else if. El método retorna un dato de tipo
//String que contiene el mensaje; dependiendo de la condición que se cumpla.
public String saludoPersonal(){
String saludo = "";
if(getEdad() >= 18 && getSexo().equalsIgnoreCase("Femenino")){
saludo = ("Cordial saludo señora "+getNombre()+" bienvenida, un gusto saludarla");
}else{
if(getEdad() >= 18 && getSexo().equalsIgnoreCase("Masculino")){
saludo = ("Cordial saludo señor "+getNombre()+" bienvenido, un gusto saludarlo");
}else{
saludo = ("Cordial saludo joven "+getNombre());
}
}
return saludo;
}
}
Implementación de la clase Main en el fichero Main.java

public class Main {

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
//En la clase Main se crea un objeto llamado ventana; de la clase VentanaSaludo, es decir,
//se crea una instancia de la clase VentanaSaludo.
//Cundo se ejecute la clase Main, se visualizará la ventana o formulario de la aplicación.
VentanaSaludo ventana = new VentanaSaludo ();
ventana.setVisible(true);
ventana.setLocationRelativeTo(null);
}
}

Implementación de la clase VentanaSaludo en el fichero VentanaSaludo.java

Para la implementación de la clase VentanaSaludo, se crea una clase JFrame o formulario para
realizar el diseño y la implementación del código que tendrá la vista del proyecto; es decir, la
ventana en donde se pide al usuario, los valores que se asignan a los atributos y en donde se muestra
el saludo al usuario.

En el diseño del formulario, se utilizan 4 tipos de controles de la librería Swing: etiquetas de texto
(JLabel); campos de texto (JTextField), una lista desplegable (JComboBox) y botones (JButton).
Todos los controles se arrastran desde la paleta de controles para realizar el diseño del formulario,
como se observa en la Figura 3.

Figura 3. Controles utilizados en el diseño del formulario

En el díselo se utilizan 3 etiquetas de texto (JLabel), a las cuales no se les asigna un nombre de
variable, se les deja el nombre que asigna por defecto la herramienta NetBeans. Igualmente se
asignan 2 campos de texto (JTextField), una lista desplegable (JComboBox) y un botón (JButton).
A los campos de texto, el botón y la lista desplegable, se les asigna un nombre de variable, a través
de cual se pueda hacer referencia a ellos.

Antes de pasar a la implementación del código; asociado al evento del único botón del formulario;
se indican los nombres de variables que se le asignaron a los 2 campos de texto (JTextField), a la
lista desplegable (JComboBox) y al botón (JButton) del formulario.

Al primer campo de texto se le asigna el nombre de variable nombre, a la lista desplegable se le

llama sexo y el segundo campo de texto se le asigna el nombre de edad. Al botón, se le asigna el
nombre de variable botonMensaje. Con los nombres descritos anteriormente, se hará referencia a
los diferentes controles del formulario, en la implementación del código de la clase
VentanaSaludo.

Nota: para implementar o programar el evento del botón, se hace doble clic sobre el botón en el
diseño del formulario.

public class VentanaSaludo extends javax.swing.JFrame {

//Se crea una instancia de la clase SaludoPersona; es decir, se crea el objeto de nombre obj; a
//través de cual, se accede a los métodos públicos implementados en la clase SaludoPersona.
SaludoPersona obj = new SaludoPersona();

public VentanaSaludo() {
initComponents();
}

@SuppressWarnings("unchecked")

//Se implementa un método para limpiar todos los campos de texto, después de que se
//muestre el mensaje.
private void limpiar(){
nombre.setText("");
edad.setText("");
nombre.grabFocus();
}
//Se implementa el código para el evento del botón que muestra el mensaje al usuario.
//Para implementar el evento del botón; se ubican en el diseño del formulario, y se hace doble
//clic sobre el botón.
private void botonMensajeActionPerformed(java.awt.event.ActionEvent evt) {
//Se declara una variable de tipo String llamada nom, a esa variable se le asigna la información
//que digita el usuario en el primer campo de texto llamado nombre, es decir, se obtiene lo que
//digita el usuario en ese campo de texto y se le asigna a la variable nom.
String non = nombre.getText();
//Luego, se asigna el valor digitado en el primer capo de texto (nombre), al atributo nombre; el
//cual fue declarado en la clase SaludoPersona. Esta asignación se realiza a través del método
//modificador del atributo llamado setNombre(non). Se accede al método modificador del
//atributo, a través del objeto obj, que se creó en la clase VentanaSaludo. Así, se asignan
//valores a los atributos de la clase SaludoPersona, utilizando los métodos modificadores.
obj.setNombre(non);
//Se obtiene la opción seleccionada en la lista desplegable (JComboBox), llamada sexo; y se
//asigna a la variable s.
//Luego, a través del método modificador setSexo(s); se le asigna un valor al atributo sexo
//de la clase SaludoPersona.
String s = (String) sexo.getSelectedItem();
obj.setSexo(s);
//Se asigna el dato digitado en el segundo campo de texto llamado edad, a la variable e.
//Como la variable e, es de tipo entero; se hace la conversión de String a entero, utilizando
//la clase Integer y el método parseInt.
//Luego, a través del método modificador setEdad(e); se le asigna un valor al atributo edad
//de la clase SaludoPersona.
int e = Integer.parseInt(edad.getText());
obj.setEdad(e);
//Finalmente, utilizando la clase JOptionPane y el método showMessageDialog; se muestra
//en una ventana emergente, el mensaje de saludo al usuario. Para esto, se utilizan los métodos
//saludoPersonal y saludoMayorEdad; los cuales fueron implementados en la clase
//SaludoPersona.
JOptionPane.showMessageDialog(null, ""+obj.saludoPersonal()+"\n \n"+
obj.saludoMayorEdad(obj.getNombre(), obj.getEdad()));
limpiar();
}
}
 EJERCICIOS/ACTIVIDADES

Una empresa que se dedica a la venta de casas, requiere implementar una aplicación que calcule
el valor a pagar por la cuota inicial de na casa y el valor de la cuota mensual que debe pagar el
cliente durante los meses que se le financia la deuda de la casa. Es importante mencionar que los
clientes pueden pagar una cuota inicial baja, si sus ingresos no son muy altos.

Para los usuarios que ganen menos de dos millones mensuales, solo tendrán que pagar de cuota
inicial el 2% del precio de venta de la casa y el resto se pagara en cuotas mensuales, durante diez
años. Los clientes que ganen más de dos millones de pesos mensuales, pagaran de cuota inicial del
8% del precio de venta de la casa y el resto se pagara en cuotas mensuales, durante ocho años.

El gobierno ofrece a los compradores, un subsidio de vivienda del 10% del precio de venta de la
casa para aquellos compradores que tengan un ingreso mensual inferior a un millón de pesos;
siempre que la casa a adquirir supere los 20 millones de pesos.

BIBLIOGRAFÍA

NADAL, M. Curso de programación Java. 1. ed. Madrid: Difusora Larousse - Anaya

Multimedia, 2021. 456 p. Disponible en:
https://ezproxyucor.unicordoba.edu.co:2086/es/ereader/unicordoba/215497?page=42.
Consultado en: 22 Oct 2022

FLÓREZ FERNÁNDEZ, H. A. Programación orientada a objetos usando java. ed. Bogotá: Ecoe
Ediciones, 2012. 418 p. Disponible en:
https://ezproxyucor.unicordoba.edu.co:2086/es/ereader/unicordoba/69236?page=25. Consultado
en: 22 Oct 2022