Unidad 2 / Escenario 3

Lectura fundamental

Estructura de un programa Java

Contenido

1 Estructura básica de un programa Java

2 Hola mundo

3 Uso de variables

4 Métodos

5 Resumen

Palabras clave: lenguaje de programación, programa, Java, métodos.

1. Estructura básica de un programa Java
En esta Lectura fundamental se presenta la estructura básica de un programa Java. Al inicio se
expone el primer programa completo del módulo: el tradicional “Hola Mundo!”, el cual, permite
introducir los elementos mínimos que forman el esqueleto de todo programa escrito en lenguaje Java.
Posteriormente, en la segunda parte, se desarrollan otros ejemplos en los que se hace uso de variables
e instrucciones de interacción con el usuario.

En la tercera parte se estudian los métodos, es decir, elementos del lenguaje Java que le ayudarán
a dividir las diferentes tareas del algoritmo y obtener programas sencillos, ordenados, claros, que
puede mantener y con menor propensión a los errores. Inicialmente, se señalan algunos métodos de
uso frecuente ya disponibles en librerías del kit de desarrollo Java, JDK. Luego, aprende a crear sus
propios métodos, de acuerdo con los requisitos del programa.

2. Hola mundo
Es una tradición en programación que el primer programa que se escribe cuando se está aprendiendo
es uno que muestra en la pantalla el mensaje “Hola mundo!”:

public class HolaMundo {

   public static void main(String[] args) {

        System.out.println(“Hola Mundo!”);

  }

A continuación, se describe cada una de las líneas que componen el programa:

public class HolaMundo:en esta línea se indica que el archivo contiene un programa Java
llamado HolaMundo. El nombre del programa debe coincidir con el nombre del archivo que lo
contiene. La palabra public indica que dicho programa puede ser accedido y, por tanto, ejecutado
por la máquina virtual de Java. En esta misma línea, se encuentra una llave cuya pareja está al final del
código. Esta pareja de llaves envuelve todo el código que corresponde al programa.

POLITÉCNICO
POLITÉCNICO GRANCOLOMBIANO
GRANCOLOMBIANO 2
public static void main(String[] args):

El main es un método(posteriormente se explicará en detalle) que contiene el algoritmo principal del

programa. Más adelante aprende que un algoritmo puede descomponerse en tareas pequeñas, cada
una de las cuales es en sí misma otro algoritmo. Estas tareas deben ser coordinadas por un algoritmo
principal que indica en qué orden son realizadas, de la misma manera en que un director de orquesta
logra que la unión de sonidos generados por cada instrumento formen una única y perfecta sinfonía.
Por ahora se dirá que, al ejecutar el programa, el intérprete buscará las instrucciones incluidas
dentro del main. La palabra public indica que el método puede ser ejecutado directamente por el
intérprete. Los términos static y String[] args obedecen a cuestiones del lenguaje que están
fuera del alcance de este curso. El término void será explicado en la segunda sección de esta lectura.
Al igual que lo ocurrido con el código que compone el programa, el código correspondiente al main se
encuentra circunscrito entre una pareja de llaves.

System.out.println(Hola Mundo!): como lo vio anteriormente, esta instrucción muestra en

la consola el mensaje “Hola Mundo!”

3. Uso de variables
Ya superado el Hola Mundo!, es momento de creaer programas capaces de interactuar con el usuario
y realizar cálculos matemáticos simples. El siguiente programa le pide al usuario dos valores de tipo
entero y muestra en consola su suma, diferencia, producto, cociente y residuo:

import java.util.Scanner;

public class Calculadora {

public static void main(String[] args) {

        Scanner entrada = new Scanner(System.in);

        System.out.println(«Ingrese dos números enteros:»);

        int a = entrada.nextInt();

POLITÉCNICO
POLITÉCNICO GRANCOLOMBIANO
GRANCOLOMBIANO 3
        int b = entrada.nextInt();

        System.out.println(“Suma: “ + (a + b));

        System.out.println(“Diferencia: “ + (a - b));

        System.out.println(“Producto: “ + (a * b));

        System.out.println(“Cociente: “ + (a / b));

        System.out.println(“Residuo: “ + (a % b));

  }

A continuación, se describen cada una de las líneas que componen el programa:

import java.util.Scanner:necesaria para poder interactuar con el usuario mediante el

objeto Scanner.

public class Calculadora:indica que el archivo corresponde al código fuente del

programa Calculadora.

public static void main(String[] args):indica el inicio del algoritmo principal del programa.

Scanner entrada = new Scanner(System.in): crea el objeto entrada de tipo

Scanner para solicitar información al usuario.

System.out.println(“Ingrese dos números enteros:”): indica al usuario cuál es la

información solicitada mediante un mensaje en la consola.

int a = entrada.nextInt(): declara la variable a y le asigna un valor ingresado por el

usuario a través del teclado. De igual forma ocurre con la variable b.

POLITÉCNICO
POLITÉCNICO GRANCOLOMBIANO
GRANCOLOMBIANO 4
System.out.println(“Suma: “ + (a + b)): calcula la suma de los valores ingresados por
el usuario y reporta el resultado. De igual forma ocurre con las operaciones de resta, multiplicación,
división y residuo.

Finalmente, mire cómo se vería en la consola el resultado del programa (el usuario ingresa los valores
20 y 6):

Ingrese dos números enteros:

20 6

Suma: 26

Diferencia: 14

Producto: 120

Cociente: 3

Residuo: 2

4. Métodos
Para motivar el uso de los métodos, considere el siguiente problema:

Juan es ingeniero civil y ha sido contratado para construir una cancha de fútbol en su universidad. El día
de mañana, él debe presentar una propuesta, por lo que se ha sentado a trabajar. Infortunadamente,
Juan nota que ha perdido algunos de sus apuntes sobre el proyecto: en particular, los correspondientes
al largo y ancho de la cancha. Sin embargo, el recuerda cuál era el perímetro y el área que calculó debía
tener la cancha.

Su tarea es escribir un programa que le permita a Juan recalcular el largo y el ancho de la cancha,
conociendo su perímetro y área.

Antes de construir el programa debe resolver el problema matemáticamente:

Tiene que ancho×largo =área y que 2×ancho+2×largo =perímetro.

Resolviendo el sistema de ecuaciones obtiene que:

POLITÉCNICO
POLITÉCNICO GRANCOLOMBIANO
GRANCOLOMBIANO 5
 perímetro-perímetro2-16xárea perímetro ⁺perímetro2-16xárea
ancho= y largo=
4 4

¿Puede escribir un programa que evalúe las fórmulas anteriores? Inténtelo antes de seguir con la lectura.

Es posible que la escritura del programa haya sido sencilla hasta la parte de evaluación de la raíz
cuadrada. ¿Cómo se calcula una raíz cuadrada en Java? De hecho, ¿sabe hacerlo en papel? La
evaluación de una raíz cuadrada es un proceso de varios pasos que puede ser descrito por un
algoritmo. Dicho algoritmo no será considerado en esta lectura por estar fuera del alcance del tema;
sin embargo, esto no es necesario. Para calcular la raíz cuadrada de cualquier número real positivo,
Java cuenta con el método Math.sqrt:

double x = Math.sqrt(z);

La instrucción anterior usa un algoritmo ya incluido en el JDK para calcular la raíz cuadrada de z y
almacena su valor en x. Las instrucciones que calculan el ancho y el largo de la cancha en el lenguaje
Java son entonces:

ancho = (perímetro - Math.sqrt(perímetro * perímetro - 16 * área)) / 4;

largo = (perímetro + Math.sqrt(perímetro * perímetro - 16 * área)) / 4;

Cómo mejorar...
Escriba el programa usando completamente las instrucciones ya provistas.

POLITÉCNICO
POLITÉCNICO GRANCOLOMBIANO
GRANCOLOMBIANO 6
sqrt es lo que se denomina un método. Un método es un fragmento de código que implementa
un algoritmo para resolver un problema particular, por ejemplo, calcular raíces cuadradas. sqrt se
encuentra en la clase Math disponible en el JDK (Oracle Inc., 2015). La tarea que resuelve un
método está especificada por sus entradas y salidas, como, por ejemplo, el valor al cual se desea
calcular la raíz cuadrada y su raíz cuadrada correspondiente.

Además de sqrt, Math incluye métodos para cálculos de diversas funciones matemáticas de uso
frecuente y constantes como π y e. Algunos otros ejemplos de estos métodos son:

• pow(a, b): recibe como entrada dos reales a y b, y calcula ab.

• sin(ang): recibe como entrada un ángulo ang medido en radianes y calcula la función seno en ang.

• abs(a): recibe como entrada un número a y calcula su valor absoluto.

• hypot(a, b): recibe como entrada dos reales a y b, y calcula la hipotenusa de un triángulo
rectángulo de catetos de longitud a y b.

• max(a, b): recibe como entrada dos números a y b, y calcula el mayor valor entre los dos.

Así como estos métodos tan útiles se encuentran disponibles en Math, existen muchas otras clases
con métodos útiles que irá aprendiendo en el transcurso del módulo. Por ahora, note que nextByte,
nextShort, nextInt, nextLong, nextFloat, nextDouble y nextBoolean de Scanner también son
métodos, y se hablarán de ellos más adelante.

4.1. Invocación de métodos

Cuando se usa un método para resolver una instancia particular del problema para el que fue diseñado
se dice que se hizo una invocación al método. Para invocar un método, debe escribir su nombre
seguido de paréntesis, y dentro de estos debe escribir los valores que definen la instancia del problema
en el orden indicado por la declaración del método. La invocación del método puede producir un
resultado que puede ser almacenado posteriormente en una variable, usado en el cálculo de alguna
fórmula o reportado directamente en pantalla empleando la instrucción System.print y similares.
A continuación se exponen algunos ejemplos de invocación de métodos:

POLITÉCNICO
POLITÉCNICO GRANCOLOMBIANO
GRANCOLOMBIANO 7
// Esta instrucción calcula el valor de 10 elevado a la 5.5, le suma 50000

// y almacena el resultado en la variable pot.

pot = Math.pow(10, 5.5) + 50000;

// Esta instrucción calcula el valor de 5.5 elevado a la 10 y muestra el

// resultado en la consola.

System.out.println(Math.pow(5.5, 10));

// Esta función calcula la longitud de la hipotenusa de un triángulo

// rectángulo de catetos de longitudes a + b y raíz cuadrada de 2.

hipotenusa = Math.hypot(Math.sqrt(2), a + b);

4.2. El método main

El método main contiene, como ya se mencionó anteriormente, el algoritmo principal del programa.
En el momento en que el intérprete inicia la ejecución del programa buscará dentro de su código
este método e iniciará su ejecución. Si este método no existe en el código fuente, quiere decir que el
código será usado por otro programa, pero que no es un programa por sí mismo.

El diseño de la gran mayoría de algoritmos (con excepción de aquellos que resuelven tareas triviales)
se simplifica considerablemente si el problema se descompone en subproblemas más pequeños (esto
se conoce como el principio de dividir y vencer). Cada uno de estos subproblemas es resuelto con
un algoritmo particular. El algoritmo que soluciona el problema inicial es entonces la agregación de
los algoritmos que resuelven cada uno de los subproblemas. Este algoritmo principal está contenido
en el main y consiste en la invocación coordinada de los métodos que resuelven cada uno de los
subproblemas y su correspondiente agregación.

Un método no será ejecutado a menos que sea invocado directamente por main, por un método invocado
por main o por algún método que sea parte de una cadena de invocaciones que inicie en main.

POLITÉCNICO
POLITÉCNICO GRANCOLOMBIANO
GRANCOLOMBIANO 8
 4.3. Creación de métodos

Además de los métodos incluidos en el lenguaje, es posible crear métodos de acuerdo con nuestras
necesidades. La sintaxis general para declarar y crear un método en Java es la siguiente:

static <tipo método> <nombre método>(<tipo_1> <var_1>, <tipo_2 var_2>, ...) {

       <código que realiza los cálculos>

       return <respuesta método>;

     

static:esta palabra inicia la declaración del método y permite a main acceder a él.

tipo método: es el tipo de dato del valor de salida del método. Note que cada método puede dar
como salida un único dato.

nombre método: el nombre que desee darle al método.

tipo_n: el tipo de dato de la n-ésima entrada del método.

var_n: el nombre de la n-ésima variable de entrada del método.

return:esta instrucción precede al valor que entregará el método como resultado. Al efectuar esta
instrucción la ejecución del método finaliza. En adelante, se dirá que el método retorna o devuelve su
valor de salida.

respuesta método: valor correspondiente a la salida del método. Es una expresión de tipo método:
una variable, un literal, una invocación a un método de idéntico tipo o un conjunto de operaciones.

A continuación se presenta, a manera de ejemplo, un programa que calcula el área y el perímetro de

un círculo a partir de su radio:

import java.util.Scanner;

public class Circulo {

POLITÉCNICO
POLITÉCNICO GRANCOLOMBIANO
GRANCOLOMBIANO 9
 public static void main(String[] args) {

        Scanner entrada = new Scanner(System.in);

        System.out.println(“Ingrese el radio del círculo:”);

        double radio = entrada.nextDouble();

        double area = calcularÁrea(radio);

        double perímetro = calcularPerímetro(radio);

        System.out.println(«Área: « + area);

        System.out.println(«Perímetro: « + perímetro);

  }

  static double calcularÁrea(double radio){

        double area = radio * radio * Math.PI;

        return area;

  }

  static double calcularPerímetro(double r){

        return 2 * r * Math.PI;

  }

Note que en este ejemplo no es necesario que la variable con que se invoca el método comparta su
nombre con la variable del método (calcular Perímetro), pero, aun así, es posible (calcular Área).

Al ejecutar el programa e ingresar como entrada el valor 1, se mostrará en la consola:

POLITÉCNICO
POLITÉCNICO GRANCOLOMBIANO
GRANCOLOMBIANO 10
Ingrese el radio del círculo:

Área: 3.141592653589793

Perímetro: 6.283185307179586

El siguiente programa muestra un método que, dados dos valores dinero y p, calcula el p % de dinero:

public class Porcentaje {

 public static void main(String[] args) {

    System.out.println(«El 10% de 5000 es: « + porcentaje(5000, 10));

    System.out.println(«El 150% de 5000 es: « + porcentaje(2000*2+1000, 100+50));

    double valor = 5000;

    double porciento = 30;

    System.out.println(«El 30% de 5000 es: « + porcentaje(valor, porciento));

 }

 static double porcentaje(double dinero, double p){

    return dinero * p / 100;

 }

Al ejecutar el programa se imprimirá en la consola:

El 10% de 5000 es: 500.0

El 150% de 5000 es: 7500.0

El 30% de 5000 es: 1500.0

Note que los métodos que conforman un programa deben estar dentro de las llaves que encierran el
programa (las llaves que suceden public class <Nombre_programa>). Adicionalmente, pueden
aparecer en cualquier orden y no puede existir un método en el interior de otro.

POLITÉCNICO
POLITÉCNICO GRANCOLOMBIANO
GRANCOLOMBIANO 11
 4.4. Métodos sin valores de entrada y/o valores de salida

Dependiendo de la tarea que realicen, algunos métodos podrían no requerir valores de entrada. Un
claro ejemplo de esto son los métodos de lectura de Scanner (e.g. nextInt()). La razón por la cual
estos métodos no requieren valores de entrada es porque usan datos provenientes de otras fuentes
(p. ej. el teclado, el mouse, un archivo). Para crear un método sin entradas simplemente debe dejarse
vacío el espacio entre los paréntesis en su declaración.

A continuación se expone un ejemplo muy sencillo que siempre da como resultado el mismo valor
y, por tanto, no requiere valores de entrada para calcular su salida (note que este método solamente
tiene sentido como ejemplo. No es útil en una aplicación real):

// Este método siempre retorna 100

static int cien() {

  return 100;   

De igual forma, también es posible crear métodos que no retornan un resultado. En general, estos
métodos tienen como función escribir datos en archivos, bases de datos o mostrarlas en la consola.
Para crear un método sin salida debe usarse la palabra void como su tipo. También es posible usar la
instrucción return para finalizar tempranamente la ejecución de la función.

// Este método dibuja una avioneta

  static void dibujarAvioneta() {

  System.out.println(«____________________|____________________»);

  System.out.println(«            \\  |   |  /»);

  System.out.println(“             `.#####.’”);

  System.out.println(“              /`#_#’\\”);

  System.out.println(“            O’   O   `O”);      

POLITÉCNICO
POLITÉCNICO GRANCOLOMBIANO
GRANCOLOMBIANO 12
En consola se verá así:           

____________________|____________________

              \  |   |  /

               `.#####.›

                /`#_#›\

              O›   O   `O

5. Resumen
La estructura básica de un programa Java es la siguiente:

public class <Nombre programa> {

   public static void main(String[] args) {

<Código>

  }

<Métodos adicionales>

Donde <Nombre programa> corresponde al nombre que desee darle al programa, <Código> es
la implementación del algoritmo principal y <Métodos adicionales> es un conjunto de cero o
más métodos que complementan el código contenido en main.

Frecuentemente, es de gran ayuda descomponer un problema en subproblemas más sencillos, cuyas

soluciones agregadas darán solución al problema original. Un método es la implementación de un
algoritmo que resuelve uno de estos subproblemas. El método main es el encargado de invocar y
combinar los resultados de los demás métodos para obtener la solución del problema. Este método es
ejecutado por el intérprete tan pronto se inicia la ejecución del programa.

POLITÉCNICO
POLITÉCNICO GRANCOLOMBIANO
GRANCOLOMBIANO 13
La invocación de un método es su llamado por parte de otro método, proveyéndole valores a sus
variables de entrada. Al obtener el valor que se espera calcule, un método devuelve o retorna a quien le
invoca dicho valor. Esto se logra mediante la instrucción return.

La sintaxis básica para definir un método es la siguiente:

static <tipo método> <nombre método>(<tipo_1> <var_1>, <tipo_2 var_2>,

...) {

       <código que realiza los cálculos>

       return <respuesta método>;

Es posible para un método tener cero variables de entrada, caso en el cual obtiene información de
otra fuente (p. ej., un archivo, el teclado). De igual forma, es factible que un método no devuelva un
resultado a quien lo invoca (p. ej., escribe el resultado en consola o en un archivo). Un método sin valor
de salida debe ser de tipo void.

La clase Math contiene un gran número de métodos que implementan funciones matemáticas de uso
frecuente (raíces cuadradas y cúbicas, potencias, logaritmos, funciones trigonométricas, máximos y
mínimos, valor absoluto, entre muchas otras).

POLITÉCNICO
POLITÉCNICO GRANCOLOMBIANO
GRANCOLOMBIANO 14
Referencias
Oracle Inc. (2015). Beyond Basic Arithmetic. The Java ™ Tutorials. Oracle Inc. Recuperado de

https://docs.oracle.com/javase/tutorial/java/data/beyondmath.html

POLITÉCNICO
POLITÉCNICO GRANCOLOMBIANO
GRANCOLOMBIANO 15
 INFORMACIÓN TÉCNICA

Módulo: Programación de Computadores

Unidad 2: Herramientas de desarrollo, modelado y
especificación de problemas
Escenario 3: Estructura de un programa Java

Autor: Edwin Andrés Niño Velásquez

Asesor Pedagógico: Jeiner Velandia

Diseñador Gráfico: Kelly Yohana Valencia Forero
Asistente: Ginna Quiroga

Este material pertenece al Politécnico Grancolombiano.

Prohibida su reproducción total o parcial.

POLITÉCNICO GRANCOLOMBIANO 16