ARRAYLIST

Bueno ArrayList nos servirá para almacenar valores, podemos ingresar sin restrigciones de Tamaño. Tenemos los siguientes métodos:

• add() es un método para agregar.
• size() es un método para el tamaño del ArrayList. 
• get() es un método para mostrar. 
• set() es un método para modificar. 
• remove() es un método para eliminar.

 Bueno pasaremos a ver el siguiente ejemplo:

import java.util.ArrayList;


public class ArrayList_Ejem {

    
    public static void main(String[] args) {
      
        ArrayList lis= Lista_Nombres();
        for(int i=0;i < lis.size();i++){
            System.out.println(" "+lis.get(i));
        }
    
    }
    public static ArrayList Lista_Nombres(){
     ArrayList lista=new ArrayList();
    lista.add("Juan");
    lista.add('R');
    lista.add(1);
    lista.add(00.2);
        for (int i = 0; i < lista.size(); i++) {
            lista.get(i);
        }
        return lista;
    }
}

INTERFACE

INTERFACE

Es una super clase al igual que las clases abstractas pero en este caso
puede o no tener métodos abstractos y tiene una característica muy común que
cuando instancias una variable automáticamente esta sera una constante y ya
no sera necesario poner la palabra "final".

Al hablar de INTERFACE hablamos de "Herencia Múltiple" que quiere decir eso, que
al crear varias INTERFACE podemos heredar todos sus atributos y métodos que
contengan esas INTERFACE, pero para poder heredar sus atributos y métodos
necesitaremos una palabrita reservada de java que se llama "implements".

En conclusión :

• Puede o no contener métodos abstractos.
• Todas las variables instanciadas son constantes.
• Es Herencia Múltiple.
• Podemos heredar sus atributos y métodos mediante la palabra "implements."

Veamos el siguiente Ejemplo de INTERFACE:

interface Privada
{
    public String a="A";
    public abstract void AA();    
}

interface Publica
{
    public char y='Z';
    public abstract void CC();
}

interface Universidad
{
    public int x=10;
    public abstract void BB();
}

public class Interfeis implements Privada,Publica,Universidad
{
    @Override
    public void AA()
    {
        System.out.println(a);
        System.out.println("Privada");
    }
    
    @Override
    public void BB()
    {
        System.out.println(x);
        System.out.println("Universidad");
    }
    
    @Override
    public void CC()
    {
        System.out.println(y);
        System.out.println("Publicas");
    }
    
    public static void main(String[] args) 
    {
        Interfeis it=new Interfeis();
        it.AA();
        System.out.println("****************");
        it.BB();
        System.out.println("****************");
        it.CC();
    }
}

CLASES ABSTRACTAS

Es una de los principios de la programación Orientada a Objetos que sirve para modelar objetos de alto nivel, no contienen código, sino solo declaraciones. Todos sus métodos deben existir en sus clases hijas. Una clase abstracta no puede ser instanciada (Crear un objeto a partir de ella). 

Métodos abstractos
Estos métodos son parte de clases abstractas
Un método abstracto debe ser redefinido en las subclases.
Cada subclase puede definir el método de manera diferente.
Las clases abstractas pueden contener métodos que no son abstractos.



class c1 extends Padre
{
    @Override
    public String Estudio()
    {
        System.out.println("SISTEMAS");
        return "";
    }
}

class c2 extends Padre
{
    @Override
    public String Estudio()
    {
        System.out.println("CONTABILIDAD");
        return "";
    }
}

class c3 extends Padre
{
    @Override
    public String Estudio()
    {
        System.out.println("ADMINISTRACIÓN");
        return "";
    }
}

public abstract class Padre 
{
    public abstract String Estudio();
}

class man_Padre
{
    public static void main(String[] args) 
    {
        c1 hijo1=new c1();
        c2 hijo2=new c2();
        c3 hijo3=new c3();
        
        hijo1.Estudio();
        hijo2.Estudio();
        hijo3.Estudio();
    }
}

Examen Resuelto

Pregunta numero 1°

Clase Cuenta

package Pregunta1;

public class Cuenta {
    long numero_de_cuenta;
    float DNI;
    float saldo_actual;
    float interes_anual;

    public Cuenta(long numero_de_cuenta, float DNI, float saldo_actual, float interes_anual) {
        this.numero_de_cuenta = numero_de_cuenta;
        this.DNI = DNI;
        this.saldo_actual = saldo_actual;
        this.interes_anual = interes_anual;
    }

    public Cuenta(float DNI, float saldo_actual, float interes_anual) {
        this.DNI = DNI;
        this.saldo_actual = saldo_actual;
        this.interes_anual = interes_anual;
    }

    public long getNumero_de_cuenta() {
        return numero_de_cuenta;
    }

    public void setNumero_de_cuenta(long numero_de_cuenta) {
        this.numero_de_cuenta = numero_de_cuenta;
    }

    public float getDNI() {
        return DNI;
    }

    public void setDNI(float DNI) {
        this.DNI = DNI;
    }

    public float getSaldo_actual() {
        return saldo_actual;
    }

    public void setSaldo_actual(float saldo_actual) {
        this.saldo_actual = saldo_actual;
    }

    public float getInteres_anual() {
        return interes_anual;
    }

    public void setInteres_anual(float interes_anual) {
        this.interes_anual = interes_anual;
    }
    
    
    public float actualizarSaldo(){
        float saldo_nuevo;
        saldo_nuevo=this.saldo_actual+(this.saldo_actual*((this.interes_anual/100)/365));
        return saldo_nuevo;
    }
    
    public float ingresar(float cant_ingresada){
        float nuevo_monto;
        nuevo_monto=this.saldo_actual+cant_ingresada;
        return nuevo_monto;
    }
    
    public float retirar(float cant_retiro){
        float nuevo_monto=0;
        if(this.saldo_actual>=cant_retiro){
            nuevo_monto=this.saldo_actual-cant_retiro;
        }else{
            System.out.println("No hay saldo suficiente en su cuenta!!");
        }
         return nuevo_monto;
    } 
}

Clase Principal_Cuenta

package Pregunta1;
import java.util.Scanner;

public class Principal_Cuenta {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        Cuenta c1=new Cuenta(2105056, 73660590, 512, 25);
        System.out.println("Ingrese el monto que desea agregar a su cuenta: ");
        float monto=sc.nextFloat();
        System.out.println("El nuevo saldo en su cuenta es: "+c1.ingresar(monto)+" soles");
    }
}

Pregunta Numero 2°
Clase Fecha

package Pregunta2;

public class Fecha {
    String día_semana;
    int dia_mes;
    String mes;
    int anio;

    public Fecha(String día_semana, int dia_mes, String mes, int anio) {
        this.día_semana = día_semana;
        this.dia_mes = dia_mes;
        this.mes = mes;
        this.anio = anio;
    }

    public String getDía_semana() {
        return día_semana;
    }

    public void setDía_semana(String día_semana) {
        this.día_semana = día_semana;
    }

    public int getDia_mes() {
        return dia_mes;
    }

    public void setDia_mes(int dia_mes) {
        this.dia_mes = dia_mes;
    }

    public String getMes() {
        return mes;
    }

    public void setMes(String mes) {
        this.mes = mes;
    }

    public int getAnio() {
        return anio;
    }

    public void setAnio(int anio) {
        this.anio = anio;
    }

}

Clase Libro

package Pregunta2;
import java.util.*;

public class Libro {
    String titulo="Introduccion to Java Programing";
    Persona autor;
    String ISBN="0-13-031997-X";
    int paginas=784;
    String edicion="3a. Edicion";
    String editorial="Prentice-Hall";
    Lugar lugar;
    Fecha fecha_edicion;

    public Libro() {
    }

    public Libro(String titulo, Persona autor, String ISBN, int paginas, String edicion, String editorial, Lugar lugar, Fecha fecha_edicion) {
        this.titulo = titulo;
        this.autor = autor;
        this.ISBN = ISBN;
        this.paginas = paginas;
        this.edicion = edicion;
        this.editorial = editorial;
        this.lugar = lugar;
        this.fecha_edicion = fecha_edicion;
    }

    public String getTitulo() {
        return titulo;
    }

    public void setTitulo(String titulo) {
        this.titulo = titulo;
    }

    public Persona getAutor() {
        return autor;
    }

    public void setAutor(Persona autor) {
        this.autor = autor;
    }

    public String getISBN() {
        return ISBN;
    }

    public void setISBN(String ISBN) {
        this.ISBN = ISBN;
    }

    public int getPaginas() {
        return paginas;
    }

    public void setPaginas(int paginas) {
        this.paginas = paginas;
    }

    public String getEdicion() {
        return edicion;
    }

    public void setEdicion(String edicion) {
        this.edicion = edicion;
    }

    public String getEditorial() {
        return editorial;
    }

    public void setEditorial(String editorial) {
        this.editorial = editorial;
    }

    public Lugar getLugar() {
        return lugar;
    }

    public void setLugar(Lugar lugar) {
        this.lugar = lugar;
    }

    public Fecha getFecha_edicion() {
        return fecha_edicion;
    }

    public void setFecha_edicion(Fecha fecha_edicion) {
        this.fecha_edicion = fecha_edicion;
    }
    
    
    
    public void leer(Persona p, Lugar l, Fecha f){
        Scanner sc=new Scanner(System.in);
        System.out.println("INGRESE LOS DATOS DEL LIBRO");
        System.out.println("Titulo: ");
        this.titulo=sc.nextLine();
        System.out.println("Datos del autor ");
        System.out.println("Nombre: ");
        p.nombre=sc.nextLine();
        System.out.println("Apellido: ");
        p.apellido=sc.nextLine();
        System.out.println("ISBN del libro: ");
        this.ISBN=sc.nextLine();
        System.out.println("Paginas: ");
        this.paginas=sc.nextInt();
        System.out.println("Edicion: ");
        this.edicion=sc.nextLine();
        System.out.println("Editorial: ");
        this.editorial=sc.nextLine();
        System.out.println("Lugar ");
        System.out.println("Ciudad: ");
        l.ciudad=sc.nextLine();
        System.out.println("Pais: ");
        l.pais=sc.nextLine();
        System.out.println("Fecha de edicion ");
        System.out.println("Dia de la semana: ");
        f.día_semana=sc.nextLine();
        System.out.println("Dia del mes: ");
        f.dia_mes=sc.nextInt();
        System.out.println("Mes: ");
        f.mes=sc.nextLine();
        System.out.println("Año: ");
        f.anio=sc.nextInt();
    }
    
    public void mostrar_autor(){
        System.out.println(""+this.autor.nombre+", "+this.autor.apellido);
    }
    
    public void mostrar(Persona p,Lugar l, Fecha f){
        System.out.print("Titulo: "+this.titulo+" "+this.edicion);
        System.out.print("\nAutor: "+p.nombre+", "+p.apellido);
        System.out.print("\nISBN: "+this.ISBN+" "+this.editorial+", "+l.ciudad+" ("+l.pais+"), "+f.día_semana+" "+f.dia_mes+" de "+f.mes+" de "+f.anio);
        System.out.print("\n"+this.paginas+" páginas");
       
    }
}

Clase Lugar

package Pregunta2;

public class Lugar {
    String ciudad;
    String pais;

    public Lugar(String ciudad, String pais) {
        this.ciudad = ciudad;
        this.pais = pais;
    }

    public String getCiudad() {
        return ciudad;
    }

    public void setCiudad(String ciudad) {
        this.ciudad = ciudad;
    }

    public String getPais() {
        return pais;
    }

    public void setPais(String pais) {
        this.pais = pais;
    }   
}

Clase Persona

package Pregunta2;

public class Persona {
    String nombre;
    String apellido;

    public Persona(String nombre, String apellido) {
        this.nombre = nombre;
        this.apellido = apellido;
    }

    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    public String getApellido() {
        return apellido;
    }

    public void setApellido(String apellido) {
        this.apellido = apellido;
    }   
}

Clase Principal Libro

package Pregunta2;

public class Principal_Libro {
    public static void main(String[] args) {
        Fecha f1=new Fecha("viernes", 16, "noviembre", 2001);
        Lugar u1=new Lugar("New Jersey", "USA");
        Persona p1= new Persona("Liang","y.Daniel");
        Libro l1=new Libro();
       // l1.leer(p1, u1, f1);
        l1.mostrar(p1, u1, f1);
    }
}

Pregunta numero 3°
Clase Cancion

package Pregunta3;

public class Cancion {
    String nombre;
    int duracion;
    String autor;

    public Cancion(String nombre, int duracion, String autor) {
        this.nombre = nombre;
        this.duracion = duracion;
        this.autor = autor;
    }

    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    public int getDuracion() {
        return duracion;
    }

    public void setDuracion(int duracion) {
        this.duracion = duracion;
    }

    public String getAutor() {
        return autor;
    }

    public void setAutor(String autor) {
        this.autor = autor;
    }

    
    public void mostrar(){
        System.out.println("Nombre: "+this.nombre);
        System.out.println("Duracion: "+this.duracion);
        System.out.println("Autor: "+this.autor);
    }
}

Clase CD

package Pregunta3;

import java.util.ArrayList;

public class CD {

    int contador = 0;
    int tamaño_maximo = 20;
    ArrayList canciones;

    public CD() {
        canciones = new ArrayList(tamaño_maximo);
    }

    public int numeroCanciones() {
        return canciones.size();
    }

    public Cancion dameCancion(int i) {
        return (Cancion) canciones.get(i);
    }

    public void grabaCancion(int i, Cancion c) {
        canciones.set(i, c);
    }

    public void agrega(Cancion c) {
        canciones.add(c);
    }

    public void elimina(int i) {
        canciones.remove(i);
    }
   
    public void graba_Cancion(String nombre_cancion, Cancion c) {
        int estado = 0;
        for (int i = 0; i < this.numeroCanciones(); i++) {
            if (dameCancion(i).nombre.equals(nombre_cancion)) {
                estado = 1;
                grabaCancion(i, c);
            }
        }
        if (estado == 0) {
            System.out.println("Cancion no encontrada!!");
        }
    }

  
    
    public void eliminar_Cancion(String nombre_cancion, Cancion c) {
        int estado = 0;
        for (int i = 0; i < this.numeroCanciones(); i++) {
            if (dameCancion(i).equals(nombre_cancion)) {
                estado = 1;
                canciones.remove(c);
            }
        }

        if (estado == 0) {
            System.out.println("Cancion no encontrada");
        }
    }
}

Clase Principal CD

package Pregunta3;

import java.util.Scanner;

public class Principal_CD {
    
     public static void main(String[] args) {
        
        Cancion c1=new Cancion("Basta ya",3,"Olga Tañón");
        Cancion c2=new Cancion("Perdón",5,"Camila");
        Cancion c3=new Cancion("Aire soy",4,"Ximena y Miguel");
        
        CD cd= new CD();
        cd.agrega(c1);
        cd.agrega(c2);
        cd.agrega(c3);
        System.out.println("Número de canciones: "+cd.numeroCanciones());
         
        for(int i=0;i

La Clase Lectura (BufferStreamReader - BufferedReader)

CLASE LECTURA (FilterInputStream - BufferStreamReader)

LA CLASE LECTURA (InputStreamReader - BufferedReader)

Nota: Esta con todas sus restricciones.

import java.io.*;

public class Lectura 
{
    InputStreamReader conv= new InputStreamReader(System.in);                       
    BufferedReader entrada=new BufferedReader(conv);
    private boolean valor;
    
    public String Cadenas() throws IOException
    {
        String cad="";
        try{
        cad=entrada.readLine();
        }catch(IOException io)
              {
                  System.out.println("Error");
              }
        return cad;
    }
    
    public int Enteros() throws IOException
    {        
        int naturales=0;
        do{
            valor=false;
        try{
        naturales=Integer.parseInt(entrada.readLine());
        }catch(NumberFormatException nfe)
              {
                  System.out.println("Error ingrese un numero entero");
                  valor=true;
              }
        }while(valor);
        return naturales;
    }
    
    public float Flotantes() throws IOException
    {
        float reales= 0.0f;
        do{
            valor=false;
        try{
        reales=Float.parseFloat(entrada.readLine());
        }catch(NumberFormatException nfe)
              {
                  System.out.println("Error ingrese un numero decimal");
                  valor=true;
              }
        }while(valor);
        return reales;
    }
    
    public long Longs() throws IOException
    {
        long entegrandes= 0;
        do{
            valor=false;
        try{
        entegrandes=Long.parseLong(entrada.readLine());
        }catch(NumberFormatException nfe)
              {
                  System.out.println("Error ingrese un numero entero");
                  valor=true;
              }
        }while(valor);
        return entegrandes;
    }
    
    public double Doubles() throws IOException
    {
        double numlargos=0.0f;
        do{
            valor=false;
        try{
        numlargos=Double.parseDouble(entrada.readLine());
        }catch(NumberFormatException nfe)
              {
                  System.out.println("Error ingrese un numero decimal");
                  valor=true;
              }
        }while(valor);
        return numlargos;
    }        
}

ESTO ES LA CLASE MANEJO DE LECTURA

import java.io.IOException;

public class manLectures 
{
    //la palabra static sirve para poder verlos en un void main
    //si lo declaro en la clase sin static saldra error
    //es por eso la palabra static.
     
    public static void main(String[] args) throws IOException 
    {
        Lectura lec=new Lectura();
        String name,direccion,ape,cod;
        int a,b,c,suma;
        double sue;
        
        //si ingresan un numero decimal a un int
        //lo que va a ser es que vuelvan a ingresar 
        //un numero entero de tipo int, y eso solo es para
        //los numeros, pero para una cadena si puedes ingresar 
        //numeros y letras
        
        System.out.println("Ingrese su nombre: ");
        name=lec.Cadenas();
        System.out.println("Ingrese su Apellido: ");
        ape=lec.Cadenas();
        System.out.println("Ingrese su Dirección: ");
        direccion=lec.Cadenas();
        System.out.println("Ingrese su Codigo: ");
        cod=lec.Cadenas();
        
        System.out.println("Ingrese su primer numero");
        a=lec.Enteros();
        System.out.println("Ingrese su segundo numero");
        b=lec.Enteros();
        System.out.println("Ingrese su tercero numero");
        c=lec.Enteros();
        System.out.println("Ingrese su sueldo mensual");
        sue=lec.Doubles();
        
        System.out.println("**************************");
        System.out.println("Su Nombre: "+name);
        System.out.println("Su Apellido: "+ape);
        System.out.println("Su Direccion: "+direccion);
        System.out.println("Su Codigo: "+cod);
        suma=a+b+c;
        System.out.println("La suma es: "+suma);
        System.out.println("Su sueldo mensual es: "+sue);
    }    
}

LA SUCESIÓN DE FIBONACCI

También conocida como secuencia de Fibonacci o incorrectamente como serie de Fibonacci, esta en si es una sucesión matemática infinita.
Consta de una Serie de números naturales que se suman de a 2, a partir de 0 y 1.
Básicamente, la sucesión de Fibonacci se realiza sumando siempre los ultimos 2 numeros,
(Todos los números presentes en la sucesión se llaman números de fibonacci) de la siguiente manera:

0 , 1 , 1 , 2 , 3 , 5 , 8 , 13 , 21 , 34 , . . .

Siendo así: ( 0 + 1 = 1 ,   1 + 1 = 2,  1 + 2 = 3 , .... , 13 + 21 = 34 ... ) Así sucesivamente, hasta el infinito.

Aquí les dejamos el siguiente Video de como hacer una Sucesión de Fibonacci en Java.

PARADIGMAS DE PROGRAMACIÓN

Entendemos como paradigma a la creación y explicación de modelos en el caso de programación tenemos técnicas que con el paso del tiempo han creado distintos tipos de programaciones singulares por su forma de desarrollar aplicaciones, programas, etc. En este articulo conoceremos aquellos paradigmas:

1. Programación Imperativa

La programación Imperativa, en contraposición a la programación declarativa, es un paradigma de programación que describe la programación en términos del estado del programa y sentencias que cambian dicho estado. Los programas imperativos son un conjunto de instrucciones que le indican al computador cómo realizar una tarea.

La implementación de hardware de la mayoría de computadores es imperativa; prácticamente todo el hardware de los computadores está diseñado para ejecutar código de máquina, que es nativo al computador, escrito en una forma imperativa. Esto se debe a que el hardware de los computadores implementa el paradigma de las Máquinas de Turing. Desde esta perspectiva de bajo nivel, el estilo del programa está definido por los contenidos de la memoria, y las sentencias son instrucciones en el lenguaje de máquina nativo del computador (por ejemplo el lenguaje ensamblador).

Los lenguajes imperativos de alto nivel usan variables y sentencias más complejas, pero aún siguen el mismo paradigma. Las recetas y las listas de revisión de procesos, a pesar de no ser programas de computadora, son también conceptos familiares similares en estilo a la programación imperativa; donde ada paso es una instrucción.

Son aquellos cuyos valores son atómicos y están formados por elementos en un caso especial.

Dentro de esta se encuentra:

• La programación orientada a objetos: Está basada en el imperativo, pero encapsula elementos denominados objetos que incluyen tanto variables como funciones. Está representado por C++ o el Java, pero el más representativo sería el Smalltalk que está completamente orientado a objetos

• Programación dinámica: Está definida como el proceso de romper problemas en partes pequeñas para analizarlos y resolverlos de forma más óptima, busca resolver problemas en O(n) sin usar por tanto métodos recursivos. Este paradigma está más basado en el modo de realizar los algoritmos, por lo que se puede usar con cualquier lenguaje imperativo.

2. Programación Declarativa

La Programación Declarativa, en contraposición a la programación imperativa es un paradigma de programación que está basado en el desarrollo de programas especificando o "declarando" un conjunto de condiciones, proposiciones, afirmaciones, restricciones, ecuaciones o transformaciones que describen el problema y detallan su solución. La solución es obtenida mediante mecanismos internos de control, sin especificar exactamente cómo encontrarla (tan sólo se le indica a la computadora qué es lo que se desea obtener o qué es lo que se está buscando). No existen asignaciones destructivas, y las variables son utilizadas con transparencia referencial.

Dentro de esta se encuentra:

• Programación funcional: Basada en la definición los predicados y es de corte más matemático, está representado por Scheme (una variante de Lisp) o Haskell.

• Programación lógica: Basado en la definición de relaciones lógicas, está representado por Prolog.

• Programación con restricciones: Similar a la lógica usando ecuaciones. Casi todos los lenguajes son variantes del Prolog.

3. Programación Multiparadigma

Un lenguaje de programación Multiparadigma es el que soporta más de un paradigma de programación. Según lo describe Bjarne Stroustrup, permiten crear “programas usando más de un estilo de programación”.

El objetivo en el diseño de estos lenguajes es permitir a los programadores utilizar el mejor paradigma para cada trabajo, admitiendo que ninguno resuelve todos los problemas de la forma más fácil y eficiente posible.

Por ejemplo, lenguajes de programación como C++, Genie, Delphi, Visual Basic o PHP, combinan el paradigma imperativo con la orientación a objetos. Incluso existen lenguajes multiparadigma que permiten la mezcla de forma natural, como en el caso de Oz, que tiene subconjuntos (particularidad de los lenguajes lógicos), y otras características propias de lenguajes de programación funcional y de orientación a objetos. Otro ejemplo son los lenguajes como Scheme (paradigma funcional) o Prolog (paradigma lógico), que cuentan con estructuras repetitivas, propias del paradigma imperativo.

4. Lenguaje especifico de  Dominio

En desarrollo de software e ingeniería de dominio, un lenguaje específico del dominio (en inglés Domain Specific Language, DSL), es un lenguaje de programación o especificación dedicado a resolver un problema en particular, representar un problema específico y proveer una técnica para solucionar una situación particular. El concepto no es nuevo pero se ha vuelto más popular debido al aumento del uso de modelaje específico del dominio.1

Ejemplos de lenguajes específicos del lenguaje incluyen, Logo para niños, Verilog y VHSIC, R y S para estadísticas, Mata para programación matricial, Mathematica y Máxima para matemáticas, fórmulas de hojas de cálculo y macros, SQL para consultas a bases de datos relacionales, Yacc para crear parseadores, expresiones regulares para crear análisis léxico, Generic Eclipse Modeling System para crear lenguajes con el objetivo de diagramar, Csound un lenguaje para síntesis digital, y los lenguajes de entrada de GraphViz y GrGen, paquetes de software usados para graficar y reescribir gráficas.

Lo opuesto es:

• Un lenguaje de programación de propósito general, como por ejemplo C o Java.

• Un lenguaje de modelaje de propósito general como UML.

Crear un lenguaje específico del dominio (con software que lo soporte) vale la pena cuando permite que un tipo particular de problemas o soluciones puedan ser expresadas más claramente que con otros lenguajes existentes, y el tipo de problema en cuestión reaparece lo suficiente. La programación orientada a lenguajes considera la creación de lenguajes específicos para expresar problemas una parte estándar para el proceso de solucionar el problema.

INTRODUCCIÓN A LA PROGRAMACION ORIENTADO A OBJETOS

La Programación Orientada a Objetos (POO u OOP según sus siglas en inglés) es un paradigma de programación que usa objetos y sus interacciones para diseñar aplicaciones y programas de computadora. Está basado en varias técnicas, incluyendo herencia, modularidad, polimorfismo, y encapsulamiento. Su uso se popularizó a principios de la década de 1990. Actualmente son muchos los lenguajes de programación que soportan la orientación a objetos. Actualmente una de las áreas más candentes en la industria y en el ámbito académico es la orientación a objetos. La orientación a objetos promete mejoras de amplio alcance en la forma de diseño, desarrollo y mantenimiento del software ofreciendo una solución a largo plazo a los problemas y preocupaciones que han existido desde el comienzo en el desarrollo de software: la falta de portabilidad del código y reusabilidad, código que es difícil de modificar, ciclos de desarrollo largos y técnicas de codificación no intuitivas.

Objetos:

•   Herencia múltiple: suele ser común a la mayoría de los lenguajes OOP, aunque introduce un problema al existir la posibilidad de que el objeto sucesor herede el mismo atributo, aunque con distinto tipo y valor, de más de un predecesor.

•   Eficiencia: Los lenguajes de POO arrastraron en un principio la reputación de ser ineficaces. Esto se debía en gran medida a que los primeros lenguajes (como Smalltalk) eran interpretados y no compilados. La existencia de compiladores permite a los desarrolladores ganar rapidez.

•   Asignación de tipos: Los lenguajes orientados a objetos varían de forma sustancial la forma por la que se aproximan a la asignación de tipos. • Por asignación de tipos entendemos que cada variable sea identificada como perteneciente a una clase (asignación fuerte) o sea simplemente un objeto indeterminado (asignación débil).

•   Manejo de memoria: La POO son lenguajes que utilizan de manera intensiva la memoria de la computadora. Hay dos tipos de aproximación a la gestión de memoria. El sistema en tiempo de ejecución libera la memoria automáticamente a medida que los objetos dejan de utilizarse.

•   Encapsulamiento: consiste en separar aquellos atributos del objeto que deben ser conocidos por el resto, de aquellos necesarios para su funcionamiento propio.

•   Polimorfismo: Comportamientos diferentes, asociados a objetos de distintos, pueden compartir el mismo nombre, al llamarlos por ese nombre se utilizará el comportamiento correspondiente al objeto que se esté usando.

Ventajas y desventajas de programación orientada a objetos

Ventajas:

•   Uniformidad: ya que la representación de los objetos lleva a implicar tanto el análisis como el diseño y la codificación de los mismos.

•   Comprensión: tanto los datos que componen los objetos, como los procedimientos que los manipulan, están agrupados en clases, que corresponden con las estructuras de información que el programa trata.

•   Flexibilidad: al tener relacionados los procedimientos que manipulan los datos con los datos a tratar, cualquier cambio que se realice sobre ellos quedara reflejado automáticamente en cualquier lugar donde estos datos aparezcan.

•   Estabilidad: dado que permite un tratamiento diferenciado de aquellos objetos que permanecen constantes en el tiempo sobre aquellos que cambian con frecuencia permite aislar las partes del programa que permanecen inalterables en el tiempo.

Desventajas:

A pesar de que las ventajas de la programación orientada a objetos superan a las limitaciones de la misma, podemos encontrar algunas características no deseables en ésta. Limitaciones para el programador. No obstante que la tecnología orientada a objetos no es nueva, un gran porcentaje de programadores no están familiarizados con los conceptos de dicha tecnología. En otras palabras, la lógica de la programación estructurada sigue siendo predominante en la mayoría de los desarrolladores de software, después de haber revisado de forma breve los principios de la programación orientada a objetos, nos es claro que en ésta se requiere una lógica de pensamiento totalmente diferente a la lógica comúnmente utilizada para la programación estructurada. Tamaño excesivo en las aplicaciones resultantes. La gran mayoría de los equipos de cómputo cuentan con capacidades tanto de almacenamiento como de memoria lo suficientemente buena como para ejecutar la mayoría de las aplicaciones que puedan desarrollarse con la tecnología orientada a objetos, sin embargo existen casos en los que lo anterior no se cumple.

HISTORIA DE JAVA

La primera versión de Java empezó en 1991 y fue escrita en 18 meses en Sun Microsystems. De hecho, en ese momento, ni siquiera se llamó Java; se llamó Oak y se utilizó en Sun para uso interno. La idea original para Oak era crear un lenguaje orientado a objetos independiente de la plataforma. Por entonces, muchos programadores se limitaban a la programación del IBM PC, pero el entorno corporativo podía incluir toda clase de plataformas de programación, desde el PC hasta los grandes sistemas. Lo que había detrás de Oak era crear algo que se pudiera usar en todos los ordenadores ( y ahora que Java se ha hecho popular gracias a la red Internet, cada vez más corporaciones están adoptándolo para uso interno en lugar de C++, precisamente por esa razón). El lanzamiento original de Oak no fue especialmente fascinante; Sun Microsystems quería crear un lenguaje que se pudiera usar en electrónica. Oak pasó a llamarse Java en 1995, cuando se lanzó para el uso público y supuso un éxito casi inmediato. En ese momento, Java había adoptado un modelo que lo hizo perfecto para la red Internet, el modelo “bytecode”.

¿QUÉ ES JAVA?

Java es un lenguaje de programación de alto nivel con el que se pueden escribir tanto programas convencionales como para Internet.
Una de las ventajas significativas de Java sobre otros lenguajes de programación es que es independiente de la plataforma tanto en código fuente como en binario. Esto quiere decir que el código producido por el compilador Java puede transportarse a cualquier plataforma que tenga instalada una máquina virtual Java y ejecutarse.
Java incluye dos elementos: un compilador y un intérprete. El compilador produce un código de bytes que se almacena en un fichero para ser ejecutado por el intérprete Java denominado máquina virtual de Java.

COMPONENTES DE JAVA

JAVA DEVELOPMENT KIT (JDK):

Se trata de un conjunto de herramientas de desarrollo que permiten desarrollar programas en lenguaje Java. El JDK contiene:

• JAVAPATH: es un path completo del directorio donde está instalado el JDK.
• CLASSPATH: son las librerías o clases de usuario.
• PATH: variable donde se agrega la ubicación de JDK. 

      Los programas más importantes que se incluyen son:

• Appletviewer: es un visor de applet para generar sus vistas previas, ya que un applet carece de método main y no se puede ejecutar con el programa java.
• Javac: es el compilador de JAVA.
• java: es el intérprete de JAVA.
• javadoc: genera la documentación de las clases java de un programa.
• El JDK tiene el compilador que permite convertir código fuente en bytecode, es decir, el código "maquina" de la máquina virtual de Java (JVM).

JAVA RUNTIME ENVIRONMENT (JRE):

Es el conjunto de JVM, bibliotecas y demás componentes necesarios para que pueda ejecutarse un programa codificado en lenguaje Java. En pocas palabras el JRE es el que comunica el sistema operativo en Java en su conjunto.

JAVA VIRTUAL MACHINE (JVM - En Español "MAQUINA VIRTUAL DE JAVA"):

Es una de las piezas fundamentales de la plataforma Java, porque es el intérprete de Java. Ejecuta los “bytecodes” (ficheros compilados con extensión *.class) creados por el compilador de Java (javac.exe). Tiene numerosas opciones entre las que destaca la posibilidad de utilizar el denominado JIT (Just In Time Compiler), que puede mejorar entre 10 y 20 veces la velocidad de ejecución de un programa.

NOTA: Esas 3 componentes son necesarios para el funcionamiento de Java. Las puedes descargar en la página oficial de Java.

LA RAZÓN DE NUESTRO BLOG

La Razón por la cual decidimos escribir este blog ha sido para compartir nuestros conocimientos y aprender un poco más de lo que escribimos. Este blog nos hace ser más creativos. El blog nos da la libertad de publicar líneas y líneas sin restricción. Nos permite expresar libremente nuestros conocimientos, ser nosotros mismos compartiendo lo poco que sabemos para ayudar a otros. 

Ayúdanos con tus comentarios a formar mejores ideas que las plasmadas en un principio.