EXAMEN DE MEDIO CURSO

1.Que entiendes por entornos de desarrollo (IDE) y mencione alguno de ellos

Es un programa informático compuesto por un conjunto de herramientas de programación puede dedicarse a desarrollar un solo lenguaje de programación o varias de ellos ;un ide es una palabra que define un programa capaz de interpretar sintaxis básicas o avanzadas de lenguaje de programación.Como:

Netbeans ,Visual C++,Eclipse,JCreator,JDeveloper de Oracle.

2.Se pide crear clases y objetos de los siguientes datos:

a.(Juan,23,Sistemas)

b.(Luisa,21,Contabilidad)

3.Definir Wrappers y realizar un ejemplo

Son clases ya definidas en la API de java para envolver los datos primitivos y poder tratarlos como objetos,por cada primitivo existe una clase wrapper asociada. 

Ejemplo:

4.Definir tipos de variables y realizar un ejemplo

Variables de instancia.Son definidas dentro de la clase, pero fuera de cualquier método, y son solo inicializadas cuando la clase es instanciada. Las variables de instancia son los campos que pertenecen a cada objeto único.

Cada instancia de la clase perro se sabrá su nombre, color y su razar. Cada instancia puede tener sus propios valores únicos para sus 3 campos. 

Variables locales.Las variables locales son declaradas dentro de un método. Esto significa que la variable no solo se inicializa dentro del método, sino que también se declara dentro del método.

Variables de clase.Son propias únicamente de la clase y no de los objetos que puedan crear de la misma por lo tanto sus valores son compartidos por todos los objetos de la clase;van precedidas del modificador static.

5.Que consideraciones debe tenerse en una clase abstracta

No puede ser instanciada.

Puede contener a un método abstracto.

Ser super clase.

Todos sus métodos deben existir en sus clases hijas.

Un método abstracto debe ser redefinido en las subclases.

6.Que consideraciones debe tenerse en una interfaces

Sus atributos son públicos .

Una interfaces es totalmente abstracta,todos sus métodos son abstractos.

Una clase solo puede heredar de una superclase.

Una clase puede implementar muchas interfaces,por lo que las interfaces permiten herencia múltiple.

7.Cuando utilizamos static y final

Static.Para indicar que este atributo no pertenece a las instancias de la clase si no a la propia clase, esto quiere decir que si tenemos varias instancias de una misma clase, cada una de ellas no tendrán una copia propia de ese atributo, si no que todas estas instancias compartirán una misma copia del atributo, a los atributos definidos como static, se les suele llamar atributos de la clase.

De esta manera, para acceder a un atributo static, no necesitamos crear una instancia de la clase, ya que podemos acceder a ellos mediante el nombre de la clase

final.Cuando necesitamos que el valor de un atributo no cambie durante el transcurso de nuestro programa, debemos utilizar el modificador final.

8.Java realiza paso por valor o referencia explicar

Paso por valor ya que cuando un argumento se pasa a una función, la función recibe una copia del valor original. Por lo tanto, si la función modifica el parámetro, sólo la copia cambia y el valor original permanece intacto.

9.Mencione las formas de realizar polimorficos en las siguientes clase

class numero {

int n;

}

sobre carga de métodos

sobre escritura de métodos

variables polimorficas

CARPINTERIA:
Hacer un programa que registre y muestre los objetos que tiene una carpinteria
-hacer una superclase carpinteria().
-hacer dos subclases mesa() y silla() que hereden atributos de la superclase(carpinteria()).

aqui tenemos la clase padre :

// la superclase 
public abstract class carpinteria {
protected String tipMadera ;

public carpinteria ()
{this.tipMadera="caoba";
}
public carpinteria(String n)
{this.tipMadera=n;}
    public String getTipMadera() {
        return tipMadera;
    }
    
    public void setTipMadera(String tipMadera) {
        this.tipMadera = tipMadera;
    }
    
    public String tipo_de_madera ()
    {
     this.tipMadera="caoba";
   return (this.tipMadera);
    }
}

como vemos estos son las clase hijas que estar heredando atributos de la superclase:

public class mesa extends carpinteria{
  public String color;
  public int precio=40;
  

  public mesa ()
  {
   this.color="negro";
   
  }
    public String getColor() {
        return color;
    }

    public int getPrecio() {
        return precio;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public void setPrecio(int precio) {
        this.precio = precio;
    }
  
   public void  mostrar ()
  {System.out.println("la mesa es de color:"+this.color);
  System.out.println("su precio es precio :"+this.precio);
  }    
}

//subclase silla hereda de la clase padre(carpinteria)
public class silla extends carpinteria {
 private int precio;
 private String color;
 
 public silla ()
 {this.precio=14;
  this.color="rojo";
  //this.tipMadera="cedro";
 }
 
 public silla (String n,int p,String c)
 {
  this.precio=p;
  this.color=c;
 }

    public void setPrecio(int precio) {
        this.precio = precio;
    }

    public void setColor(String color) {
        this.color = color;
    }
    
    
   public int getprecio()
   {return this.precio;}
 
   public String getcolor()
   {return this.color;}
 
   public String tipo_de_madera()
   {
   this.tipMadera="tornillo";
   return this.tipMadera;
   }
 
   public void mostrar ()
   {
       System.out.println( "la silla es de color: "+this.color);
   }
   
   public void mostrar (String n)
   {
       System.out.println("la silla tiene color:"+this.color);
       System.out.println("tipo de madera:"+n);
   }
    public void mostrar (String n,int b)
   {int a=0;
   a=b;
       System.out.println("la silla tiene color:"+this.color);
       System.out.println("tipo de madera:"+n);
       System.out.println("tiene precio:"+b);
   }

}

aqui tenemos la clase principal:

//la clase principal
public class test_practica {
    public static void main(String [] args)
    {silla s1= new silla ();
     mesa m1= new mesa() {

      /*  @Override
        void ingresar() {
            throw new UnsupportedOperationException("Not supported yet."); //To change body of generated methods, choose Tools | Templates.
        }*/
    };
        System.out.println("*********datos de la silla***********");
     s1.mostrar();
        System.out.println("+++++++++++++++++++++metodos sobrecargado");
     s1.mostrar("bolaina");
     s1.mostrar("capirona",25);
        System.out.println("++++++++++++++++metodo sabreescrito: ");
        System.out.println("tipo de madera: "+s1.tipo_de_madera());
    System.out.println("*********datos de la mesa***********");
    m1.mostrar();
    }
}

al compilarlo nos saldra esto:

run:
*********datos de la silla***********
la silla es de color: rojo
+++++++++++++++++++++metodos sobrecargado
la silla tiene color:rojo
tipo de madera:bolaina
la silla tiene color:rojo
tipo de madera:capirona
tiene precio:25
++++++++++++++++metodo sabreescrito: 
tipo de madera: tornillo
*********datos de la mesa***********
la mesa es de color:negro
su precio es precio :40
BUILD SUCCESSFUL (total time: 2 seconds)

EXAMEN PARCIAL INTERNADO

PRIMER EXAMEN PARCIAL INTERNADO 

public abstract class InternadoPersona {
    String nombre;
    String Apellido;
    String numCuartos;

    public InternadoPersona() {
    }

    public InternadoPersona(String nombre, String Apellido, String numCuartos) {
        this.nombre = nombre;
        this.Apellido = Apellido;
        this.numCuartos = numCuartos;
    }
    

    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;
    }

    public String getNumCuartos() {
        return numCuartos;
    }

    public void setNumCuartos(String numCuartos) {
        this.numCuartos = numCuartos;
    }
    
}
 
nueva clase

public final class InternadoAlumno extends InternadoPersona {

    private String pabellon;

    public InternadoAlumno() {
        this.ingresarDatos();
        this.mostrarDatos();
    }

    public void ingresarDatos() {
        Scanner sc = new Scanner(System.in);
        System.out.println("ingresa nombre del pabellon");
        pabellon = sc.next();
        System.out.println("ingrese nombre del alumno");
        nombre = sc.next();
        System.out.println("ingrese el apellido de la alumno");
        Apellido = sc.next();
        System.out.println("ingrese el numero de cuarto");
        numCuartos = sc.next();

    }

    public void mostrarDatos() {
        System.out.println("nombre: " + this.getNombre());
        System.out.println("apellidos: " + this.getApellido());
        System.out.println(" Numero de cuarto " + this.getNumCuartos());
    }
}

nueva clase

public final class Cuartos extends InternadoPersona {

    int cantCuarto;

    public Cuartos() {
        this.ingresarDAto();
        this.mostrarDato();
    }

    public void ingresarDAto() {
        Scanner sc = new Scanner(System.in);
        System.out.println("ingresa nombre: ");
        nombre=sc.next();
        System.out.println("ingresar apellido");
        Apellido=sc.next();
        
    }

    public void mostrarDato() {
        System.out.println("nombre: "+this.nombre);
        System.out.println("apellido: "+this.Apellido);
        System.out.println("numero de cuarto"+this.numCuartos);
       

    }
}


nueva clase


public final class Pabellones extends InternadoPersona {
    String nombrePabellon;

    public Pabellones() {
        this.ingresarDato();
        this.mostrarDato();
    }

  
    public  void ingresarDato (){
        Scanner sc=new Scanner(System.in);
        System.out.println("ingresar nombre;");
        nombre=sc.next();
        System.out.println("ingresa apellido");
        Apellido=sc.next();
        System.out.println("ingrese numero de cuarto");
        numCuartos=sc.next();
    }
    public void mostrarDato(){
        System.out.println("nombre: "+this.nombre);
        System.out.println("apellido: "+this.Apellido);
        System.out.println("numero de cuato: "+this.numCuartos);
    }
}

clase principal

import java.util.ArrayList;
import java.util.Iterator;
import java.util.Scanner;


public class MainInternado {

    InternadoAlumno aa = new InternadoAlumno();
    Pabellones p = new Pabellones();

    public void Mennu() {
        int opc = 0;
        Scanner sp = new Scanner(System.in);
        do {
            System.out.println("****************************************");

            System.out.println("(1) Ingresar                            ");
            System.out.println("(2) Mostrar                             ");
            System.out.println("(3) Salir                               ");
            System.out.println("****************************************");
            System.out.println("Elija una opcion: ");
            opc = sp.nextInt();

            switch (opc) {
                case 1:
                    System.out.println("nombre del pabellon");
                    String pabellon = sp.next();
                    System.out.println("imgresa nombre del alumno");
                    String nombre = sp.next();
                    System.out.println("imgrese apellido del alumno");
                    String apellido = sp.next();
                    System.out.println("ingrese dni del alumno");
                    String dni = sp.next();

                    break;

                case 2:
                    System.out.println("mostrar");
                    aa.mostrarDatos();
                    break;
            }
        } while (opc != 3);
    }

    public static void main(String[] args) {
        InternadoAlumno aa = new InternadoAlumno();
        Pabellones p = new Pabellones();

        ArrayList lista = new ArrayList();

        ingresar(lista);
        mostrar(lista);

    }

    static void ingresar(ArrayList lista) {
       
        System.out.println("LSTA DE INTERNADOS");
        lista.add("Maria Angola");
        lista.add("elefantes");
        lista.add("Sheraton");
    }

    static void mostrar(ArrayList lista) {
        Iterator i = lista.iterator();
        while (i.hasNext()) {
            System.out.println(i.next());
        }
    }

}

EXAMEN PARCIAL CARPINTERIA

 Primero creo mi clase Carpintería



package carpinteria;

public abstract class Carpinteriaa {

    String nombre_carpinteria;
    String maderas_que_vende;

    public Carpinteriaa() {

    }

    public Carpinteriaa(String nc, String m) {
        this.nombre_carpinteria = nc;
        this.maderas_que_vende = m;
    }

    public String getNombre_carpinteria() {
        return nombre_carpinteria;
    }

    public void setNombre_carpinteria(String nombre_carpinteria) {
        this.nombre_carpinteria = nombre_carpinteria;
    }

    public String getMaderas_que_vende() {
        return maderas_que_vende;
    }

    public void setMaderas_que_vende(String maderas_que_vende) {
        this.maderas_que_vende = maderas_que_vende;
    }

    public void horarios_de_atencion() {
        System.out.println("Los horarios de atencion son:");
        System.out.println("En las mañanas ");
        System.out.println("En las tardes son:");
    }

    abstract void saludo();

    abstract void mostrar();

}

Luego mi creare una  clase Persona quien heredara una carpintería


package carpinteria;

import java.util.Scanner;

public class Persona extends Carpinteriaa {

    public Persona() {

    }

    //atributos heredados

    public Persona(String nc, String m) {
        super(nc, m);
    }

    //sobre carga

    public String materiales_carpinteria(String silla) {
        System.out.println("Sillas");
        return silla;
    }

    public String materiales_carpinteria(String sillas, String mesas) {
        System.out.println("Sillas y mesas");
        return sillas + mesas;

    }

    public String materiales_carpinteria(String sillas, String mesas, String carpetas) {
        System.out.println("Sillas ,mesas y carpetas");
        return sillas + mesas + carpetas;
    }

    //sobre escritura 
    //le aumento los datos a y b para las horas de atencion

    public void horarios_de_atencion(int a, int b) {
        Scanner sc = new Scanner(System.in);
        System.out.println("Los horarios de atencion son:");
        System.out.println("En las mañanas");
        System.out.println("De:");
        a = sc.nextInt();
        System.out.println("A");
        b = sc.nextInt();
        System.out.println("En las tardes son:");
        System.out.println("De:");
        a = sc.nextInt();
        System.out.println("A:");
        b = sc.nextInt();

    }

    //metodo abstracto

    void saludo() {
        System.out.println("Bienvenidos a la Carpinteria:" + " " + this.nombre_carpinteria);
    }
    //metodo abstracto

    void mostrar() {
        System.out.println("EL nombre de la tienda:" + " " + this.nombre_carpinteria);
        System.out.println("Lo que mas vende la carpinteria es:" + " " + this.maderas_que_vende);

    }

}



Y por ultimo creare mi Tienda_Principal donde instanciare mi clase 

package carpinteria;

import java.util.ArrayList;
import java.util.Scanner;


public class Tienda_Principal1 {
    public static void main(String[] args) {
        //variables polimorficas
        ArrayList maderas;
        maderas=new ArrayList();
      
        Persona p=new Persona("LA CASA DE MADERAS ","sillas");
        p.saludo();
        System.out.println("La Carpinteria contiene:");
        p.materiales_carpinteria("*sillas");
        p.materiales_carpinteria("*sillas", "Mesas");
        p.materiales_carpinteria("*sillas", "Mesas","Carpetas");
        System.out.println("La carpinteria te ofrecen muebles de las maderas:");
        maderas.add("*Tornillo");
        maderas.add("*Cedros");
        maderas.add("*Caoba");
        maderas.add("*Madera");
        for (int i = 0; i < maderas.size(); i++) {
            System.out.println(""+maderas.get(i));
            
        }
       
        p.mostrar();
    
        p.horarios_de_atencion(2,3);
         System.out.println("Esperamos su visita");
    }
   
}

INTERFACES I

En Java una interface es una clase abstracta pura, es decir una clase donde todos los métodos son abstractos (no se implementa ninguno). Permite al diseñador de clases establecer la forma de una clase (nombres de métodos, listas de argumentos y tipos de retorno). Una interface puede  también contener datos miembro, pero estos son siempre static y final. Una interface sirve para establecer un 'protocolo' entre clases.  Para crear una interface, se utiliza la palabra clave interface enlugar de class. La interface puede definirse public o sin modificador de acceso, y tiene el mismo significado que para las clases. Todos los métodos que declara una interface son siempre

public.  

Para indicar que una clase implementa los métodos de una interface se utiliza la palabra clave implements. El compilador se encargará de verificar que la clase efectivamente declare e implemente todos los métodos de la interface. Una clase puede implementar más de una interface. 

Una interfaz en Java es una colección de métodos abstractos y  propiedades. En ellas se especifica qué se debe hacer pero no su implementación. Serán las clases que implementen estas interfaces las que describan la lógica del comportamiento de los métodos.

EJEMPLO INTERFACES

public class Persona implements Comparable {

    public int dni, edad;

    public Persona(int d, int e) {
        this.dni = d;
        this.edad = e;
    }
    public int compareTo(Persona o) {
        int resultado = 0;
        if (this.edad < o.edad) {
            resultado = -1;

        } else {
            if (this.edad > o.edad) {
                resultado = 1;

            } else {
                if (this.dni < o.dni) {
                    resultado = -1;

                } else {
                    if (this.dni > o.dni) {
                        resultado = 1;

                    } else {
                        resultado = 0;
                    }
                }
            return resultado;
            }
            
        }
        return 0;
    }
}

MAIN PERSONA

public class MainPersona {

    
    public static void main(String[] args) {
        Persona p1=new Persona(47628559, 35);
        Persona p2=new Persona(26538649, 30);
        if (p1.compareTo(p2)<0) {
            System.out.println("LA PRIMERA PERSONA ES MENOR");
            
        }else{
            if (p2.compareTo(p2)>0) {
                System.out.println("LA PRIMERA PERSONA ES MAYOR");
                
            }else{
                System.out.println("LA  PRIMERA PERSONA ES IGUAL A LA SEGUNDA PERSONA");
            }
        }
    }
    
}

Ventajas

 El uso de interfaces proporciona las siguientes ventajas: Organizar la programación. Obligar a que ciertas clases utilicen los mismos métodos(nombres y parámetros). Establecer relaciones entre clases que no estén relacionadas.

 Declaración 

 Para declarar una interfaz se utiliza la sentencia interface, de la misma manera que se usa la sentencia class:

VARIABLES POLIMORFICAS

VARIABLES POLIMORFICAS

En Java las palabras que contienen objetos son variables polimorficas .En Java, una variable polimórfica es una variable que contiene un objeto y se refiere al hecho de que una misma variable puede contener objetos de diferentes tipos del tipo declarado o de cualquier subtipo del tipo declarado por eso se llama polimórfica que literalmente significa: muchas formas.

• ArrayList 

Un arrayList declarado así puede contener objetos de cualquier tipo.
De forma general un ArrayList en Java se crea de la siguiente forma:
ArrayList nombreArray = new ArrayList();

Ejemplo:

• LinkedList

Es una lista enlazada de Recipientes (nodos) donde cada uno contiene elementos (objetos, otras listas, etc) y uno o dos punteros hacia posiciones de memoria que apuntan al anterior o siguiente nodo.

Útil cuando se quiere insertar o eliminar elementos al principio o al final de la lista. A diferencia del ArrayList ,no permite acceder a un elemento en concreto de la lista directamente sin recorrer antes los anteriores.

Ejemplo:

POLIMORFISMO I

POLIMORFISMO

El polimorfismo en una característica y un de los cuatro pilares junto con abstracción,encapsulamiento y herencia de la POO .
Se refiere hacer los mismo pero en distintas clases ,para entender mejor un breve ejemplo.

Ejemplo:

Nos creamos una clase Animal

Luego una clase León que heredara la clase Animal y donde veremos que tiene el mismo método de la clase animal pero en su propia clase

Luego aremos una clase Vaca que heredara Animal y donde veremos que tiene el mismo método de la clase animal pero en su propia clase

Luego nos crearemos nuestra clase Animal_Principal para que nos corra los métodos

GESTIÓN DE EXPRESIONES EN JAVA

GESTIÓN DE EXCEPCIONES EN JAVA

Puede producirse errores en tiempo de ejecución de un programa y por tanto Java necesita de un conjunto de palabras nuevas para tener en cuenta que cualquier código puede fallar o ser mal interpretado en tiempo de ejecución.

Vamos a ver dos de las palabras reservadas para tratamiento de excepciones:

• Try
• Catch

BLOQUE TRY

Try en inglés es el verbo intentar, así que todo el código que vaya dentro de esta sentencia será el código sobre el que se intentará capturar el error si se produce y una vez capturado hacer algo con él. Lo ideal es que no ocurra un error, pero en caso de que ocurra un bloque try nos permite estar preparados para capturarlo y tratarlo. Así un ejemplo sería:

try {      System.out.println(“bloque de código donde pudiera saltar un error es este”);        }

 BLOQUE CATCH

En este bloque definimos el conjunto de instrucciones necesarias o de tratamiento del problema capturado con el bloque try anterior. Es decir, cuando se produce un error o excepción en el código que se encuentra dentro de un bloque try, pasamos directamente a ejecutar el conjunto de sentencias que tengamos en el bloque catch. Esto no es exactamente así pero ya explicaremos más adelante todo el funcionamiento. De momento para una mejor comprensión vamos a considerar que esto es así.

catch (Exception e) {      System.out.println(“acá se pone el mensaje de error”); }

 Ejemplo:

HERENCIA I

HERENCIA EN PROGRAMACIÓN ORIENTADA A OBJETOS

La herencia consiste en hacer uso de los atributos o métodos de una clase dentro de otra como si le perteneciera a este mismo. Esto se podría dar en un caso muy exclusivo para poder ahorrar proceso y código a implementar.

Por ejemplo podría ser para una serie de empleados que ocupen diferentes cargos pero tienen atributos en común como el nombre, apellido, DNI, etc.

Lo cual sería conveniente usar la herencia juntando los datos en común en una misma clase y distribuir clases independientes para los demás datos de los empleados.

Por ejemplo en este esquema se muestra la clase padre que vendría ser Vehículo.

La Herencia es el mecanismo por el que se crean nuevos objetos definidos en términos de objetos ya existentes. Por ejemplo, si se tiene la clase Comida, se puede crear la subclase Juane, que es una especialización de Comida.

La palabra reservada extends se usa para generar una subclase (especialización) de un objeto. Una Juane es una subclase de Comida.

Cualquier cosa que contenga la definición de Comida será copiada a la clase Juane, además, en Juane se pueden definir sus propios métodos y variables de instancia. Se dice que Juane deriva o hereda de Comida.

Para ello realice un ejemplo:

Entonces para entender este caso primero crearemos una clase la cual heredaremos donde se encuentre el apellido y después otra clase donde asignemos el nombre de una persona.

Una vez hecho la primera clase del cual heredaremos, bueno en esta clase crearemos el nombre de la persona.

Como punto final en nuestra función principal, pasamos a usar la clase instanciando en nuestro main.

Para ello Instanciamos la Clase “Herencia” pasándole a su constructor el apellido de la persona lo cual internamente lo pasará a la clase superior “ClaseHeredada”.

luego le asignamos el nombre haciendo uso de su método setPersona y lo imprimimos mediante getPersona

Entonces finalizado esto se imprimirá:  Vladimir Chipana Ramos

Porque lo que hicimos fue juntar el nombre y el apellido utilizando herencia.

para entender mejor sobre herencia pueden visualizar este vídeo visiten a:

https://www.youtube.com/watch?v=LcrCsCuWW7g

aqui tenemos  un poco mas sobre lo que es herencia en POO:

Sobreescritura de Metodos

una clase al heredar de una superclase tiene derecho a re-difinir los metodos de la clase padre (es decir si dicho metodo no esta definido como final), osea que puede crear metodos con el mismo nombre de su superclase. Si tengo una clase padre que tiene un metodo Estudiar(), yo puedo crear en la clase hijo un metodo que tambien se llame Estudiar () pero implementandole caracteristicas
especificas para los objetos de la subclase.

veamos un ejemplo:

//la superclase (clase padre)
public class padre {
//metodo estudiar
public String Estudiar ()
{
 return "enfermeria";
}
    
}


//la subclase(clase hijo)
//esta heredando de la clase padre
public class hijo extends padre {
    
   //metodo Estudiar (propio de la clase hijo)
  public String Estudiar ()
  {
    return "sistemas";
  }
  
  public static void main (String [] args)
  {hijo h1=new hijo();
   h1.Estudiar();
   // muestra lo que retorna del metodo Estudiar de la clase hijo ("sistemas")
      System.out.println(h1.Estudiar());
  }
}

En el ejemplo vemos que una subclase puede elegir o no convenientemente usar el metodo de la superclase o si no crear su propio metodo que tenga el mismo nombre pero inplementando caracteristicas propias de la subclase es decir una clase hijo puede crear sus metodos independientemente de la clase padre.

Sobrecarga de Metodos

Los metodos sobrecargados se utilizan para reutilizar el nombre de un metodo pero con diferente argumento, en pocas palabra dentro de una clase se podria crear metodos con el mismo nombre pero con diferente argumentos; las carateristicas que pueden tener un metodo sobrecargado son:

- Los metodos sobrecargados deben ser con diferente argumento.

- Un metodo puede ser sobrecargado en la misma clase o en una subclase.

- Pueden retornar diferentes valores siempre y cuando sea diferente de void.

Veamos un ejemplo claro:hagamos un metodo sobrecargado en la clase Persona.java

//metodo CambiarDatos 
public void CambiarDatos (String n,String p)
{
  nacionalidad= n;
  profesion=p;
}

//sobrecarga metodo CambiarDatos
public void CambiarDatos (String n)
{
  nacionalidad= n;
}

Solución de la Segunda Pregunta del examen TP1

Clase Libro
package examen;

import java.util.Scanner;

public class Libro {

    String titulo ;
    Persona autor;
    String ISBN ;
    int paginas ;
    String edicion ;
    String editorial ;
    Lugar sitio;
    Fecha fecha;

    public Libro() {

    }

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

    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 getSitio() {
        return sitio;
    }

    public void setSitio(Lugar sitio) {
        this.sitio = sitio;
    }

    public Fecha getFecha() {
        return fecha;
    }

    public void setFecha(Fecha fecha) {
        this.fecha = fecha;
    }

    void leer(Persona p, Lugar l, Fecha f) {
        Scanner sc = new Scanner(System.in);
        System.out.println("La informacion del libro:");
        System.out.println("Ingrese titulo:");
        titulo = sc.nextLine();
        System.out.println("Ingrese nombre del autor,");
        p.nombre = sc.nextLine();
        System.out.println("Ingrese apellido del autor");
        p.apellido = sc.nextLine();
        System.out.println("Imgrese codigo:");
        ISBN = sc.nextLine();
       
        System.out.println("Paginas:");
        paginas = sc.nextInt();
        System.out.println("La edicion:");
        edicion = sc.nextLine();
        System.out.println("El editorial");
        editorial = sc.nextLine();
        System.out.println("Ingrese pais:");
        l.pais = sc.nextLine();
        System.out.println("Ingrese ciudad:");
        l.ciudad = sc.nextLine();
        System.out.println("Ingrese dia:");
        f.dia = sc.nextLine();
        System.out.println("Ingrese numero de dia:");
        f.numero_dia = sc.nextInt();
        System.out.println("Ingrese mes:");
        f.mes = sc.nextLine();
        System.out.println("Ingrese año");
        f.año = sc.nextInt();

    }

    void mostrar(Persona p, Lugar l, Fecha f) {
        System.out.println("Titulo:" + this.titulo + "," + this.edicion);
        System.out.println("Autor:" + p.nombre + p.apellido);
        System.out.println("ISBN:" + this.ISBN + ", " + this.editorial + "," + l.pais + l.ciudad + f.dia + f.numero_dia + f.mes + f.año);
        System.out.println("Paginas:" + this.paginas);
    }

}




Clase Persona

package examen;

public class Persona {

    String nombre;
    String apellido;

    public Persona() {

    }

    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 Lugar

package examen;

public class Lugar {

    String pais;
    String ciudad;

    public Lugar() {

    }

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

    public String getPais() {
        return pais;
    }

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

    public String getCiudad() {
        return ciudad;
    }

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

}


Clase Fecha

package examen;

public class Fecha {
    String dia;
    int numero_dia;
    String mes;
    int año;
public Fecha(){
    
}

    public Fecha(String dia, int numero_dia, String mes, int año) {
        this.dia = dia;
        this.numero_dia = numero_dia;
        this.mes = mes;
        this.año = año;
    }

    public String getDia() {
        return dia;
    }

    public void setDia(String dia) {
        this.dia = dia;
    }

    public int getNumero_dia() {
        return numero_dia;
    }

    public void setNumero_dia(int numero_dia) {
        this.numero_dia = numero_dia;
    }

    public String getMes() {
        return mes;
    }

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

    public int getAño() {
        return año;
    }

    public void setAño(int año) {
        this.año = año;
    }

}


Test_Libro

package examen;


public class TestLibro {
    public static void main(String[] args) {
        Persona p=new Persona();
        Lugar l=new Lugar();
        Fecha f=new Fecha();
        Libro l1=new Libro();
        l1.leer(p, l, f);
        l1.mostrar(p, l, f);
    }
 
}

pregunta 3 examen TP1

Desarrolla una clase CD con los siguientes atributos:
a.canciones: un array de objetos de clase canción.
b.contador la siguiente posición libre del array  canciones y los siguientes métodos:
c.CD():contructor predeterminado (crear array canciones).
d.numeroCanciones();devuelve el valor de contador de canciones.
e.dameCancion(int): devuelve la canción que se encuentra en la posición indicada 
f.grabaCancion(int Canción): cambia la canción de la posición indicada por la nueva canción
proporcionada.
g.agrea(Canción):agrega al final del array la canción proporcionada.
h.elimina(int)elimina la canción que se encuentra en la posición indicada.

SOLUCIÓN:

public class cancion {
    private String titulo;
    private String autor;

    public cancion() {
    }

    public cancion(String titulo, String autor) {
        this.titulo = titulo;
        this.autor = autor;
    }

    public String getTitulo() {
        return titulo;
    }

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

    public String getAutor() {
        return autor;
    }

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


    public String verCancion() {
        return "cancion{" + "titulo=" + titulo + ", autor=" + autor + '}';
    }
    
   
}
//clase CD:
public class cd {

    private ArrayList canciones;
    private int indice = 0, tamanio = 30;
    
    public cd() {
        this.canciones = new ArrayList(tamanio);
    }
    
    public void agregar(cancion c) {
        if (canciones.size() <= tamanio) {
            canciones.add(c);
        } else {
            System.out.println("cd lleno");
        }
    }

    //mostrar

    public cancion getCancion(int i) {
        return (cancion)canciones.get(i);
        
    }
    
    public int numeroCanciones() {
        return canciones.size();
    }
    //modificar: 
    public void modificar(String buscar_titulo,cancion c) {
       int estado=0;
       
        for (int i = 0; i < numeroCanciones(); i++) {
            if(buscar_titulo.equals(getCancion(i).getTitulo())){
                estado=1;
                canciones.set(i, c);
            }
        }
        if(estado==0){
            System.out.println("cancion no encontrada");
        }
    }
    //eliminar
    public void eliminar(String buscar_titulo) {
       int estado=0;
       
        for (int i = 0; i < numeroCanciones(); i++) {
            if(buscar_titulo.equals(getCancion(i).getTitulo())){
                estado=1;
                canciones.remove(i);
            }
        }
        if(estado==0){
            System.out.println("cancion no encontrada");
        }
    }
    
}
//Main CD:

public class Maincd {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        
        cancion c1=new cancion("ffv", "cvcvx");
        cancion c2=new cancion("f", "vx");
        cancion c3=new cancion("ffvvv", "vcvx");
        
        cd d1=new cd();
        d1.agregar(c1);
        d1.agregar(c3);
        d1.agregar(c2);
        
        for (int i = 0; i < d1.numeroCanciones(); i++) {
            System.out.println(d1.getCancion(i).verCancion());
        }
        
        cancion c4=new cancion("u", "u");
        String buscar="f";
        d1.modificar(buscar, c4);
        
        for (int i = 0; i < d1.numeroCanciones(); i++) {
            System.out.println(d1.getCancion(i).verCancion());
        }

        String buscar_elinar="u";
        d1.eliminar(buscar_elinar);
        
        for (int i = 0; i < d1.numeroCanciones(); i++) {
            System.out.println(d1.getCancion(i).verCancion());
        }
        
    }
    
}

CLASE LEER

import java.io.*;

public class Leer 
{

 public String getString()
 {
  InputStreamReader isr = new InputStreamReader(System.in); 
  BufferedReader br = new BufferedReader (isr);
  String s="";
  try
  {
   s = br.readLine();
  }
  catch(Exception ex)
  {
   System.out.println(ex.getMessage());
  }
  return s;
 }

 public int getInt()  
 {
  String s;
  int valInt=0;
  s=this.getString();
  try
  {
   valInt = Integer.parseInt(s);
  }
  catch(Exception ex)
  {
   System.out.println(ex.getMessage());
   
  }
  return valInt;
 }
 public double getDouble()
 {
   String s;
  double aDub=0.0;
  s=this.getString();
   try
   {
    aDub = Double.parseDouble(s);
   }
   catch(Exception ex)
  {
   System.out.println(ex.getMessage());
  }
   return aDub;
    }
 public char getChar()
 {
  String s;
  s="";
    try
    {
     s = this.getString();
    }
    catch(Exception ex)
  {
   System.out.println(ex.getMessage());
  }
   return s.charAt(0);
    }
    public char getCharMay()  
 {
    String s;
    s="";
    try
    {
     s = this.getString();
    }
    catch(Exception ex)
    {
     System.out.println(ex.getMessage());
     
    }
    s = s.toUpperCase();
    return s.charAt(0);
    }
   
    public String getTextMay()  
 {
    String s;
    s="";
    try
    {
     s = this.getString();
    }
    catch(Exception ex)
    {
     System.out.println(ex.getMessage());
     
    }
    s = s.toUpperCase();
    return s;
    }
}

Primer examen resuleto del TP1(primera pregunta)

package examen;

public class Cuenta {
    //los afritubos de la class Cuenta

    float numero_de_cuenta = 100000;//numero asignado ala cuenta
    float DNI;
    float saldo_actual;
    float interes_anual;
//Constructo por defecto
    public Cuenta() {

    }
//Constructor con DNI , saldo_actual r 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;
        numero_de_cuenta++;//Para que el munero de cuenta se muestre asignando el siguiente numero al numero asignado
    }
//Accedentes y mutadores para el numero de cuenta no habra no
    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;
    }
// actualizar saldo (el interes anual dividido entre 365 aplicado al saldo actual)
    public double actualizar_saldo() {
        double saldo_total;
        saldo_total = this.saldo_actual - (this.saldo_actual * this.interes_anual) / 36500;
        return saldo_total;
    }
//Ingresar cantidad en la cuenta
    public double ingresar(double monto_ingresar) {
        double monto = 0;

        monto = actualizar_saldo() + monto_ingresar;

        return monto;
    }
//Cantidad a retirar de la cuenta
    public double retirar(double monto_retirar) {
        double monto = 0;

        monto = actualizar_saldo() - monto_retirar;

        return monto;
    }
//Metodo mostrar
    void mostrar(double x, double y) {
        System.out.println("Su dni es: " + this.DNI);
        System.out.println("Su interes:" + this.interes_anual);
        System.out.println("Numero de cuenta:" + this.numero_de_cuenta);
        System.out.println("Saldo actual:" + this.saldo_actual);
        System.out.println("Saldo actualizado" + this.actualizar_saldo());
        System.out.println("Saldo ingresado:" + this.ingresar(x));
        System.out.println("Saldo retirado:" + this.retirar(y));

    }
}

 CLASE MAIN

package examen;


public class Cuenta_principal {
      public static void main(String[] args) {
        Cuenta c1=new Cuenta(2014,500,34);
        c1.mostrar(100,100);
        c1.ingresar(100);
     
    }

}

Lenguaje de programación orientado a objetos

LENGUAJE DE PROGRAMACION ORIENTADA A OBJETOS 

DEFINICION DE LENGUAJE POO:

Antes de establecer los elementos del lenguaje, es necesario tener presentes los conceptos básicos de la programación orientada a objetos porque la sintaxis y el formato de Java están plenamente apegados a ellos.

Para empezar, todo parte del hecho de que el desarrollo de la programación de computadoras entró en crisis en los años 60 y 70 del s. XX porque las aplicaciones a menudo hacían cosas raras. Un caso es el del Centro de Cómputo Noruego en Oslo en el que desarrollaban simuladores de vuelo; sucedía, cuando los ejecutaban, que las naves colisionaban. Un análisis del problema probó que la aplicación confundía las características entre uno y otro objeto simulado; es decir, que la cantidad de combustible, la posición en el espacio o la velocidad de una nave eran atribuidas a otra. Se concluyó que esto se debía al modo como programaban y que los lenguajes de entonces eran incapaces de resolver el problema. Ante esto, los expertos del Centro Noruego desarrollaron Simula 67 que fue el primer lenguaje orientado a objetos.

Así que la POO es una manera de diseñar y desarrollar software que trata de imitar la realidad tomando algunos conceptos esenciales de ella; el primero de éstos es, precisamente, el de objeto, cuyos rasgos son la identidad, el estado y el comportamiento. No debemos dejarnos intimidar por estas expresiones, son muy simples:

·         La identidad es el nombre que distingue a un objeto de otro.

·         El estado son las características que lo describen.

·         El comportamiento es lo que puede hacer.

Se debe tener presente que los objetos, sean reales o su proyección en software, se abstraen en clases. Por ejemplo: de la clase perro pueden existir dos objetos Fido y Firuláis (esta es su identidad). Fido es un san bernardo enorme, pinto, de 5 años de edad; mientras que Firuláis es un labrador, negro, de 3 años (este es su estado). Ambos perros ladran, merodean, juguetean, comen y duermen (este es su comportamiento).

Si nos pidieran que hiciéramos un programa orientado a objetos que simulara lo anterior haríamos la clase Perro que tendría las variables raza, color y edad, y los métodos ladrar(), merodear(), juguetear(), comer() y dormir(). Firuláis y Fido son los identificadores que podríamos usar en una aplicación que pretenda mostrar dos objetos de la clase Perro.

FUNDAMENTOS

La POO es una técnica para desarrollar soluciones computacionales utilizando componentes de software (objetos desoftware).

Objeto: Componente o código de software que contiene en sí mismo tanto sus características (campos) como sus comportamientos (métodos); se accede a través de su interfaz o signatura.

Campo: Es una característica de un objeto, que ayuda a definir su estructura y permite diferenciarlo de otros objetos. Se define con un identificador y un tipo, el cual indica los valores que puede almacenar. El conjunto de valores de los campos definen el estado del objeto.

Método: Es la implementación de un algoritmo que representa una operación o función que un objeto realiza. El conjunto de los métodos de un objeto determinan el comportamiento del objeto.

La POO es un paradigma de la programación de computadores; esto hace referencia al conjunto de teorías, estándares, modelos y métodos que permiten organizar el conocimiento, proporcionando un medio bien definido para visualizar el dominio del problema e implementar en un lenguaje de programación la solución a ese problema.

Una ventaja de la POO frente al paradigma algorítmico es la facilidad que brinda a través de sus herramientas, de concebir, analizar, modelar, diseñar e implementar el mundo real de manera fiel a como se presenta en la realidad; el paso que hay desde la concepción y asimilación del problema hasta la implementación del mismo es un proceso que se hace de manera casi natural. Esto porque el mundo está lleno de objetos reales, los cuales se pueden representar como tales en una solución computarizada.

Modularidad

Proceso de crear partes de un todo que se integran perfectamente entre sí para que funcionen por un objetivo general, y a las cuales se les pueden agregar más componentes que se acoplen perfectamente al todo, o extraerle componentes sin afectar su funcionamiento. En el caso que se requiera actualizar un módulo, no hay necesidad de hacer cambios en otras partes del todo. Un ejemplo clásico es un conjunto de módulos que, al integrarlos conforman un armario, el cual puede agregarle más funcionalidad si se le agregan más módulos, o al contrario. También se puede cambiar su finalidad si se acomodan esos módulos para darle otro objetivo: volverlo una mesa.

Esto ayuda a la descomposición de problemas en subproblemas, es decir,  a la solución de problemas por composición de soluciones a subproblemas.

Reutilización

Capacidad de usar un mismo código para varias implementaciones o necesidades (desarrollos); para esto se debe tener en cuenta:

• Polimorfismo: Esta propiedad indica que un elemento puede tomar distintas formas. Podemos definirlo como el uso de varios tipos en un mismo componente o función. Por ejemplo, una función que sume dos operandos, la cual maneja, o dos números o dos cadenas, para retornar un total de una suma o de una concatenación. También se denomina subsumption (más delante de detalla este concepto).

• Genericidad: Usar algoritmos genéricos para resolver varias situaciones, como acceso a varios motores de bases de datos de forma transparente, como el PEAR de PHP. Consiste en parametrizar una función con varios tipos de datos donde ella misma en su cuerpo decida cómo operar, como la ut0110.4gl.

• Operaciones Relacionadas: Todas las operaciones de un módulo deben estar dentro de él, como parte de su cuerpo ...

• Caja negra: Saber qué entra y qué sale (la interfaz del módulo: signatura) y no cómo lo hace (su implementación), como la co0020.4gl.

• Sobrecarga: Modalidad de herencia que permite usar el mismo módulo para diferentes implementaciones de una operación, es decir, usando diferente signatura: una función que pueda recibir un parámetro, o dos, o ninguno; pero opera correctamente con cualquiera de ellos con que se lo invoque, está sobrecargada; por ejemplo, la función saludar(), cuando va sin parámetros retorna la cadena “Hola”, cuando se invoque con un nombre, (saludar(var_nombre)), retorna “Hola var_nombre”, y así sucesivamente. Esto debe manejarse por código dentro de la función.

La reutilización es la principal característica de la POO, la cual se logra mediante:

•  Encapsulación de información: Ocultamiento de información, datos o funciones especiales a los usuarios. En el caso de la programación, el encapsulamiento es lo que permite que tanto la estructura (campos) como el comportamiento (métodos) se encuentren dentro del mismo cuerpo de código de la clase con la que se crean los objetos. Dentro de la clase se deben agrupar tanto la información o datos de los campos como las operaciones o métodos o funciones que operan sobre esta información

• Herencia: Propiedad que permite a los objetos ser construidos a partir de otros; es recibir de un módulo superior sus características, tales como atributos o funciones (campos y métodos o comportamientos), para usarlos en el módulo actual. Heredar es compartir atributos

• Sobre escritura ( override ): Posibilidad de heredar un método de un módulo y cambiarle el comportamiento en el heredero, con la opción de poder usar el original, si se desea.

• Métodos unidos a los objetos: los métodos de un objeto son inseparables y siempre formarán parte de su cuerpo, como un todo.

• Noción de self : unicidad de los objetos; son únicos y no se repiten, aunque sean de la misma clase. Así como se puede definir varias variables del tipo INT cada una de las cuales es única, se puede crear o instanciar varios objetos de una misma clase.

Ejemplos:

Lenguajes imperativos:

• BASIC
• C
• C++
• Java
• C#
• Perl
• unerg

Híbridos:

• Lisp
• Scheme
• Ocaml
• Standard ML
• ML
• Scala 

Lenguajes Funcionales:

Puros:

• Haskell
• Miranda

Lenguajes orientados a objeto

•  C++
•  Objective C
• Java
• Smalltalk
• Eiffel
•  Java
•  Actionscript
• COBOL
• Perl
• C#
•  Visual Basic.NET
• PHP
• Lexico (en castellano)
• Ruby
• Python
• OCAML
• Object Pascal
• CLIPS
• Visual .net

VENTAJAS

Los lenguajes orientados a objetos presentan las siguientes ventajas:

· Agiliza el desarrollo de software
· Facilita el trabajo en equipo
· Facilita el mantenimiento del software
· Fomenta la reutilización y extensión del código.
· Permite crear sistemas más complejos.
· Relacionar el sistema al mundo real.
· Facilita la creación de programas visuales.
· Construcción de prototipos

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. Una de las desventajas de la programación orientada a objetos es que cuando se heredan clases a partir de clases existentes se heredan de forma implícita todos los miembros de dicha clase aun cuando no todos se necesiten, lo que produce aplicaciones muy grandes que no siempre encajan en los sistemas con los que se disponga.