Programación en Java: Conceptos básicos de programación y estructura de un programa en Java

Programa (o Algoritmo): Serie de operaciones detalladas y no ambiguas, a ejecutar paso a paso, y que conducen a la resolución de un problema.

Hay diversas formas de realizar un algoritmo. Simplemente hay que definirlo de forma no ambigua.

Dato: Información que procesa un algoritmo (y por tanto un futuro programa).

Tipo de dato: Tipo de información que se maneja. Es un concepto muy importante y que hay que ir teniendo muy claro al desarrollar programas.

Cuando se trabaja con un dato, hay que saber si dicho dato es un número entero, un número real, un carácter, una frase (una lista de caracteres), un valor lógico, etc... ya que el ordenador usa distintas formas para guardar distintos tipos de datos.

Variable: Es un elemento que contiene un dato y su valor puede variar a lo largo del programa. Internamente en el ordenador es una zona de memoria reservada donde se guarda un dato de determinado tipo y cuyo valor cambia a lo largo de la ejecución.

Atributos:

• Nombre o identificador: Lo que la designa
• Tipo de dato: El tipo de información que puede manejar esa variable.

Se utilizarán para recoger datos, para manejar datos internos variables y para devolver datos.

Constantes: Elemento de valor invariable y de un tipo determinado. También se les denomina Literales. Al igual que una variable internamente en el ordenado ocupa una región de memoria pero su contenido no varía, esto permite un uso más eficiente en determinadas circunstancias.

Ejemplos:

• Entera: -3 , 5, 17
• Real: 6x10⁸ (se verá como 6e8), 5.34
• Carácter : 'A'
• Cadena de caracteres (String): “Hola”

Expresiones: Combinaciones de variables, constantes símbolos de operación, paréntesis y nombres de funciones especiales.

Ejemplo:

m(n+5) –cos(p)

Veamos la estructura de un programa en Java con un nuevo ejemplo ligeramente más amplio que el primero.

import java.util.Scanner;

public class Hola2 {

   public static void main (String args[]) {

      // Declaración de variables

      String nombre;

      Scanner sc= new Scanner(System.in);

      // Código

      System.out.print("Dime tu nombre: ");

      nombre=sc.nextLine();

      System.out.println(nombre+", Welcome to the Java World");

      System.out.println("Nos vemos");

   }

}

Antes de explicar las distintas líneas veamos unos aspectos generales:

• Cada sentencia acaba en ; ya que es el indicador de fin de sentencia. Puedo escribir una sentencia en varias líneas como hicimos en el ejemplo de GUI ya que lo que marca el final es el ;
• Las llaves {} marcan inicio y fin de bloque. Cuando hay una serie de comandos o sentencias que queremos meter dentro de un bloque los meteremos entre estos símbolos.
• La identación o tabulación es esencial en el mundo de la programación. Sirve para entender que comandos están dentro de que bloques de forma clara.

Los elementos que nos encontramos a lo largo de cualquier programa son:

• Palabras reservadas: Son palabras que pertenecen al lenguaje Java y por tanto no pueden ser usadas por nosotros para nombrar variables. La lista completa es:
  abstract default if private this
  boolean do implements protected throw
  break double import public throws
  byte else instanceof return transient
  case extends int short try
  catch final interface static void
  char finally long strictfp volatile
  class float native super while
  const for new switch
  continue goto package synchronized
• Identificadores: Son palabras que crea el programador para dar diferentes nombres a elementos como las variables, las clases, funciones, etc... Hay algunas limitaciones para poner nombres:
  • Se usan sólo letras, números, y los símbolos _ y $
  • No puede, por tanto, contener espacios.
  • No puede empezar por número.
  • Se distingue entre mayúsculas y minúsculas .
  • No se pueden usar palabras reservadas (class, import, etc...)

De cara a la claridad de programación, vamos además a usar algunas reglas en cuanto a la creación de nombres de identificadores: Las clases siempre empezarán por mayúsculas y las variables por minúsculas. Si una clase o variable es una palabra compuesta, las siguientes palabras se escribirán comenzándolas en mayúscula: Clase SistemaOperativo, variable datoTransferido.
• Comentarios: Son líneas de código que no afecta al funcionamiento del programa. No se compilan. Por tanto son usadas para aclarar ciertas partes del código que tienen un funcionamiento especial o para documentar de forma técnica el programa. Existen tres tiops de comentarios en java:
  • Comentario de línea: Comienza donde se escriba // hasta el fin de la línea.
  • Comentario multilínea: Comienza con /* y acaba con */ en la misma línea o en otra.
  • Comentario de documentación: el SDK de Java incorpora un programa denominado javadoc que facilita la creación de documentación técnica y cuyo funcionamiento veremos en otra asignatura. Los comentarios detectados por javadoc comienzan por /** y acaban por */.
• Constantes o literales: Datos explícitos como 3, “hola”, '$' ó -78.23

Teniendo en cuenta estos puntos anteriores vamos a explicar de forma aproximada el funcionamiento del programa anterior:

Importación

Lo primero que encontramos en un programa en Java son las líneas de importación. En estas líneas se indican los paquetes (packages) donde existen clases de Java que podemos necesitar y ya están programados. Una clase podemos verla como un contenedor. Por tanto todos los comandos de Java (salvo las instrucciones más básicas) aparecerán dentro de clases que a su vez se guardan en pquetes.

En este caso se importa la clase Scanner que vamos a usar para pedir datos al usuario. Esa clase se encuentra en el paquete util que a su vez está en el paquete genérico java. Ese es el significado de java.util.Scanner.

Puede haber varias líneas de importación para usar varias clases, pero en el caso de usar diversas clases que están en un paquete puede usarse el comodín *. Es decir, si en un programa tenemos que importar clases de esta manera:

import java.io.File;

import java.io.IOException;

import java.io.BufferedReader;

import java.io.InputStream;

import java.io.IOException;

podría ser más cómodo escribirlo en una única línea así:

import java.io.*;

Ese * indica “todas las clases del paquete io que está en java”. Los puristas dicen que es mejor escribir sólo las clases que se van a usar por claridad, pero realmente no se pierde eficiencia y sí tiempo escribiendo.

La clase principal.

public class Hola2 {

}

Tras la zona de importación en el archivo viene la clase principal. Como ya se comentó una clase la veremos por el momento como un contenedor de elementos y ya veremos definiciones más precisas y correctas. Nos quedamos con la idea de que todo el código que vamos a meter hay que hacerlo dentro de la clase.

Una clase comienza por la palabra class y a continuación se le da el nombre deseado. Ya comentamos también que por claridad y estandarización vamos a nombrar las clases comenzando por letra mayúscula.

Todo lo que va dentro de la clase se mete entre llaves.

En un archivo se pueden meter varias clases pero por ahora meteremos sólo una que sirva para contener nuestros programas. Además el archivo ha de tener el mismo nombre que dicha clase (conservando mayúsculas y minúsculas) y precediendo a la palabra class irá le modificador public que indica que “cualquiera” puede acceder a la clase. Entenderemos mejor esto último en el tema de orientación a objetos.

Programa principal (función principal).

public static void main (String args[]) {

}

Un apartado denominado por la palabra reservada main (principal) y precedido por las palabras reservadas public, static y void es el bloque donde meteremos las sentencias ejecutables que conformarán nuestro programa al menos al principio.

A este apartado se le denominará también función o método principal o función o método main.

En general una función o método es una zona del programa que contiene comandos ejecutables y que puede ser invocada desde otras partes del programa o sistema. Crearemos más adelante otros métodos distintos del principal.

El elemento especificado entre paréntesis (String args[]) no lo tendremos en cuenta al menos por el momento.

Cuando se construye un programa Java hay que indicar las variables que se van a usar y el tipo de dato que son. Realmente se puede hacer en cualquier parte de la función pero por claridad conviene separar la zona de declaración de variables (se puede poner al principio) del resto del código.

Vamos a ver dos grandes bloques de variables, por un lado las básicas que simplemente hay que declarar su nombre y el tipo de dato que contendrán:

String nombre; //Variable que guarda una cadena de caracteres

int numero; // Variable que guarda un valor entero

y los objetos o variables referenciadas que, sin entrar en detalle, son “variables” para las cuales hay que reservar memoria y por tanto se declaran e inicializan en la misma línea.

Scanner sc = new Scanner(System.in);

aunque podría hacerse en líneas distintas (una de declaración y otra de reserva de memoria):

Scanner sc;

sc = new Scanner(System.in);

En este caso se inicializa la variable sc que es el objeto que representa al teclado (System.in) y va a servir para pedirle datos al usuario.

La diferencia entre las simples y las referenciadas es que las simples básicamente manejan un valor único y las referenciadas son complejas en cuanto a que pueden guardar varios valores e incluso contener código ejecutable asociado a la variable (son los denominados objetos).

Finalmente describimos brevemente cada línea de código:

System.out.print("Dime tu nombre: ");

Muestra una frase en pantalla pero no pasa a la línea siguiente.

nombre=sc.nextLine();

Se queda esperando a que el usuario introduzca una cadena de caracteres y una vez que el usuario pulsa enter introduce el dato en la variable nombre.

System.out.println(nombre+", Welcome to de Java World");

Muestra en pantalla el contenido de la variable nombre seguido del texto , Welcome to de Java World sin las comillas. La operación + con cadenas de caracteres se denomina concatenación (coloca una cadena detrás de otra). Además una vez que termina de escribir pasa a la línea siguiente.

System.out.println("Nos vemos");

Muestra otra frase en pantalla y pasa a la línea siguiente.

Nota: si leéis algún documento en la que se explique una versión de Java anterior a la 1.5 la introducción de datos se realizaba con otro objeto de la siguiente manera:

BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

nombre=br.readLine();

Además había que hacer el denominado control de excepciones que veremos más adelante pero que aumenta la complejidad de la entrada de datos.