Interfaz de Programación de Aplicaciones (Application Programming Interface) también conocido como Bibliotecas de Clases de Java proporciona a los programadores un conjunto de clases e interfaces agrupadas en paquetes, que permiten efectuar toda clase de tareas necesarias dentro de un programa.
Bibliografía consultada:
Como programar en Java, Deitel & Deitel, pág. 8, Séptima Edición 2008, Editorial Pearson Education.
La zona de un programa en la que una variable/método/clase está activa se denomina, normalmente, ámbito o alcance (scope). Por ejemplo, en el siguiente diagrama ilustramos el hecho de que una variable local puede utilizarse sólo a partir del punto en el que es declarada y hasta el final del bloque de la variable. Recordando que un bloque de una variable se establece por el par de llaves más cercanas que encierran la declaración de la variable.
La codificación del diagrama anterior se muestra en el siguiente código. Observa que el programa marca el error de compilación: cannot find symbol – variable c. La variable c no puede ser utilizada fuera de su ámbito.
/**
* Ilustra el concepto de ámbito de una variable.
*
* @author Raúl Oramas Bustillos
* @version 2010
*/
public class AmbitoVariable
{
/**
* Método main. Inicia la aplicación Java
*/
public static void main( String[] args )
{
int a = 1;
for( int b = 0; b < 3; b++ )
{
int c = 1;
for( int d = 0; d < 3; d++ ) {
if( c < 3 ) c++;
}
System.out.print( c );
System.out.println( b );
}
a = c; //Error c está fuera del ámbito
} //fin del método main
} //Fin de la clase AmbitoVariable
Conjunto de pasos o procedimientos ordenados necesarios para resolver un problema. Para hallar la solución de un cierto problema, puede haber multitud de algoritmos que, siendo todos correctos, requieran diferente esfuerzo, tiempo de cálculo o datos intermedios. Los algoritmos, cuando se codifican en un lenguaje de programación, se convierten en programas.
Una clase abstracta es aquella que posee al menos un método abstracto. Un método abstracto es aquél que está declarado, pero que no posee implementación alguna (es decir no tiene cuerpo). Está incompleto. Debido a esta carencia, es imposible declarar objetos de una clase abstracta. ¿Para qué sirve entonces una clase abstracta? Una clase abstracta sirve para establecer un marco de trabajo que deben cumplir todas las clases que hereden de ella. Las clases que heredan de ella sí deben dotar de una implementación a los métodos abstractos del padre. Si no lo hacen, automáticamente se convierten también en abstractas. También es posible definir una clase abstracta sin que posea métodos abstractos.
Las clases y métodos abstractos llevan la palabra clave abstract. Es importante que tengas en cuenta que no pueden llevar el modificador abstract:
los constructores
los métodos estáticos
los métodos privados
Ejemplo 1.
La clase abstracta Mascota declara un método abstracto hablar que deberá ser redefinido por las subclases Gato, Perro y Pato. Observa que la clase Mascota solo se está utilizando para declarar el método hablar, de modo que las clases hijas la puedan usar.
/**
* Abstract class Mascota - Representa una mascota
*/
public abstract class Mascota
{
/**
* Método abstracto hablar para las mascotas
*/
abstract public void hablar();
} //fin de la clase Mascota
/**
* La clase Gato que hereda de la clase Mascota.
*/
public class Gato extends Mascota
{
/**
* Implementación del método hablar
*/
public void hablar() {
System.out.println( "Meow" );
} // fin del método hablar
} // fin de la clase Gato
/**
* La clase Perro que hereda de la clase Mascota.
*/
public class Perro extends Mascota
{
/**
* Implementación del método hablar
*/
public void hablar() {
System.out.println( "Woof" );
} // fin del método hablar
} // fin de la clase Perro
/**
* La clase Pato que hereda de la clase Mascota.
*/
public class Pato extends Mascota
{
/**
* Implementación del método hablar
*/
public void hablar() {
System.out.println( "Quack" );
} // fin del método hablar
} // fin de la clase Pato
/**
* Clase controladora para los objetos Gato, Perro, Pato.
*
*/
public class Granja
{
/**
* Método principal de la aplicación
*/
public static void main( String[] args )
{
Mascota[] misMascotas = new Mascota[4];
misMascotas[0] = new Pato();
misMascotas[1] = new Perro();
misMascotas[2] = new Gato();
misMascotas[3] = new Pato();
for( int i = 0; i < misMascotas.length; i++ )
misMascotas[i].hablar();
} //fin del método main
} //fin de la clase Granja
Ejemplo 2.
La clase abstracta Producto incluye un método abstracto imprimirDatos. Observa el uso de la palabra clave abstract antes del nombre de la clase a fin de informar al compilador de Java que la clase incluye un método abstracto, o más. En virtud de que la clase abstracta no define todos sus métodos no se pueden crear instancias de la clase Producto.
/**
* Abstract class Producto - Representa el producto de una tienda
*
*/
public abstract class Producto
{
// variables de instancia
protected double precioVenta;
protected double costoFabrica;
protected String nombreProducto;
/**
* Constructor para Producto
*
* @param nombre El nombre del producto
* @param precioVenta El precio de venta del producto
* @param costoFabrica El costo de fábrica del producto
*/
public Producto( String nombre, double precio, double costo )
{
nombreProducto = nombre;
precioVenta = precio;
costoFabrica = costo;
} // fin del constructor Producto
/**
* Método abstracto para imprimirDatos
*/
public abstract String imprimirDatos();
} // fin de la clase Producto
Observa que las clases Libro y DVD que extienden de la clase abstracta Producto e implementan el método abstracto imprimirDatos.
/**
* Clase Libro que hereda de la clase Producto.
*/
public class Libro extends Producto
{
/**
* Constructor para los objetos de la clase Libro
* @param titulo El título del libro
* @param precio El precio de venta del libro
* @param costo El costo de fábrica del libro
*/
public Libro( String titulo, double precio, double costo )
{
super( titulo, precio, costo );
}
/**
* Imprime los datos asociados con el libro
*
* @return los datos del libro en un String
*/
public String imprimirDatos()
{
return "Libro: " + nombreProducto + "\tPrecio: $" + precioVenta;
} // fin del método imprimirDatos
} // fin de la clase Libro
/**
* Clase Libro que hereda de la clase Producto.
*/
public class DVD extends Producto
{
/**
* Constructor para los objetos de la clase DVD
* @param titulo El título del DVD
* @param precio El precio de venta del DVD
* @param costo El costo de fábrica del DVD
*/
public DVD( String titulo, double precio, double costo )
{
super( titulo, precio, costo );
}
/**
* Imprime los datos asociados con el DVD
*
* @return los datos del DVD en un String
*/
public String imprimirDatos()
{
return "DVD: " + nombreProducto + "\tPrecio: $" + precioVenta;
} //fin del método imprimirDatos
} //fin de la clase DVD
/**
* Clase controladora para los objetos de DVD y Libros.
*/
public class PruebaProducto
{
/**
* Método principal de la aplicación
*/
public static void main( String[] args )
{
Libro miLibro = new Libro( "Biblioteca del programador", 54.95, 39.95 );
DVD miDVD = new DVD( "Curso multimedia de Java", 29.95, 19.95 );
System.out.println( "Los datos de mis productos." );
System.out.println( miLibro.imprimirDatos() );
System.out.println( miDVD.imprimirDatos() );
} //fin del método main
} //fin de la clase PruebaProducto
