Java

Java es un lenguaje de programación de propósito general orientado a objetos diseñado con la intención de generar un código donde el mismo código pueda ser utilizado en cualquier lugar.

James Gosling de Sun Microsystems guió el desarrollo de Java a finales de la década de 1990. Este lenguaje de programación está basado en clases, orientado a objetos y legible por el ser humano. Java es compilado e interpretado.

El compilador Java transforma el código fuente en código bytecode y luego el intérprete java produce código máquina que es ejecutado directamente por la máquina en la que se está ejecutando el programa java. Es fiable, distribuido y portátil. Podría utilizarse para desarrollar aplicaciones autónomas o aplicaciones basadas en la web.

Características

1. Compilado e interpretado: Al principio, el compilador Java traduce el código fuente a código bytecode. Entonces se produce un código de máquina que puede ser ejecutado directamente por la máquina, y el intérprete es responsable de hacerlo.
2. Plataforma independiente y portátil: Se puede mover de una máquina a otra, cualquier modificación en los sistemas operativos, recursos del sistema y procesador no puede afectar a los programas java. El código de byte generado por un compilador java puede ser empleado en cualquier máquina.
3. Orientado a objetos: Java es un lenguaje puramente orientado a objetos donde todo gira alrededor de las clases y los objetos.
4. Robusto y seguro: Java previene la amenaza de virus y el mal uso de los recursos. Consiste en un recolector de basura y emplea un manejo de excepciones para eliminar los errores y el riesgo de colisión.
5. Distribuido: También permite la creación de aplicaciones en la red y puede compartir datos y programas. Java también se puede utilizar para acceder a objetos remotos a través de Internet y permite que varios programadores trabajen en tándem desde diferentes ubicaciones remotas.
6. Multihilo e interactivo: Ayuda a programas con varios subprocesos en los que se pueden realizar varias tareas a la vez.
7. Dinámico y Extensible: Las nuevas clases, objetos, métodos y librerías están probablemente enlazadas dinámicamente en java. También puede soportar funciones escritas en lenguajes como C y C++.
8. Facilidad de desarrollo: La reutilización del código facilita el desarrollo.
9. Escalabilidad y rendimiento: La escalabilidad y el rendimiento pueden mejorarse aumentando el tiempo de arranque y minimizando el consumo de memoria en el entorno de tiempo de ejecución de Java.

Ejemplo Código Java

import java.util.Arrays;
import java.awt.Rectangle;

/**
 * A sample of a ploymorphic method.
 * @author scottm
 *
 */
public class CreateASet {
    
    public static void main(String[] args){
        String[] words = {"A", "B", "B", "D", "C", "A"};
        System.out.println( "original: " + Arrays.toString(words));
        System.out.println( "as a set: " + Arrays.toString(makeSet(words)));
        
        Rectangle[] rectList = {new Rectangle(), new Rectangle(), 
                    new Rectangle(0, 1, 2, 3), new Rectangle(0, 1, 2, 3)};
        System.out.println( "original: " + Arrays.toString(rectList));
        System.out.println( "as a set: " + Arrays.toString(makeSet(rectList)));     
        
        
        Object[] mixed = {"A", "C", "A", "B", new Rectangle(),
                new Rectangle(), "A", new Rectangle(0, 1, 2, 3), "D"};
        System.out.println( "original: " + Arrays.toString(mixed));
        System.out.println( "as a set: " + Arrays.toString(makeSet(mixed))); 
    }
    
    /**
     * An example of polymorphism in action. The method relies
     * on Java's inheritance requirement and polymorhphism to call
     * the correct equals method.
     * @param data != null, no elements of data are null
     * @return a Set (no duplicates) of the elements in data.
     */
    public static Object[] makeSet(Object[] data){
        assert data != null : "Failed precondition makeSet. parameter cannot be null";
        assert noNulls(data) : "Failed precondition makeSet. no elements of parameter can be null";
        Object[] result = new Object[data.length];
        int numUnique = 0;
        boolean found;
        int indexInResult;
        for(int i = 0; i < data.length; i++){
            // maybe should break this out into another method
            indexInResult = 0;
            found = false;
            while(!found && indexInResult < numUnique){
                found = data[i].equals(result[indexInResult]);
                indexInResult++;
            }
            if( ! found ){
                result[numUnique] = data[i];
                numUnique++;
            }
        }
        Object[] result2 = new Object[numUnique];
        System.arraycopy(result, 0, result2, 0, numUnique);
        return result2;
    }
    
    // pre: data != null
    // return true if all elements of data are non null,
    // false otherwise
    private static boolean noNulls(Object[] data){
        assert data != null : "Failed precondition makeSet. parameter cannot be null";
        boolean good = true;
        int i = 0;
        while( good && i < data.length ){
            good = data[i] != null;
            i++;
        }
        return good;        
    }
    
}