Vous êtes sur la page 1sur 37

ESCUELA SUPERIOR POLITECNICA DE CHIMBORAZO

FIE
ESCUELA DE INGENIERIA EN ELECTRONICA EN CONTROL
Y REDES INDUSTRIALES

LENGUAJES DE PROGRAMACION II

NOMBRE: KEIMER ALEXANDER SAPATANGA PEA


CODIGO:867
PROFESOR: ING.FERNANDO MEJIA
CURSO:TERCERO B
Vectores

1) Crea un array de 10 posiciones de nmeros con valores pedidos por teclado.


Muestra por consola el indice y el valor al que corresponde. Haz dos mtodos,
uno para rellenar valores y otro para mostrar.
import javax.swing.JOptionPane;
public class arrayApp {

public static void main(String[] args) {

//Esto es opcional
final int TAMANIO=10;

int num[]=new int[TAMANIO];

//Invocamos las funciones


rellenarArray(num);

mostrarArray(num);
}

public static void rellenarArray(int lista[]){


for(int i=0;i<lista.length;i++){
String texto=JOptionPane.showInputDialog("Introduce un nmero");
lista[i]=Integer.parseInt(texto);
}
}

public static void mostrarArray(int lista[]){


for(int i=0;i<lista.length;i++){
System.out.println("En el indice "+i+" esta el valor "+lista[i]);
}
}
}
2) Crea un array de nmeros donde le indicamos por teclado el tamao del array,
rellenaremos el array con nmeros aleatorios entre 0 y 9, al final muestra por
pantalla el valor de cada posicin y la suma de todos los valores. Haz un mtodo
para rellenar el array (que tenga como parmetros los nmeros entre los que tenga
que generar), para mostrar el contenido y la suma del array y un mtodo privado
para generar nmero aleatorio (lo puedes usar para otros ejercicios).

import javax.swing.JOptionPane;
public class arrayNumAleatoriosApp {

public static void main(String[] args) {

//Indicamos el tamao
String texto=JOptionPane.showInputDialog("Introduce un tamao");
int num[]=new int[Integer.parseInt(texto)];

//Invocamos las funciones


rellenarNumAleatorioArray(num, 0, 9);

mostrarArray(num);
}

public static void rellenarNumAleatorioArray(int lista[], int a, int b){


for(int i=0;i<lista.length;i++){
//Generamos un nmero entre los parametros pasados
lista[i]=((int)Math.floor(Math.random()*(a-b)+b));
}
}

public static void mostrarArray(int lista[]){


for(int i=0;i<lista.length;i++){
System.out.println("En el indice "+i+" esta el valor "+lista[i]);
}
}
}

3) Crea un array de nmeros de un tamao pasado por teclado, el array


contendr nmeros aleatorios primos entre los nmeros deseados, por
ltimo nos indica cual es el mayor de todos.

import javax.swing.JOptionPane;

public class Ejercicio_DiscoDurodeRoer_Arrays_3 {

public static void main(String[] args) {

//Indicamos el tamao
String texto=JOptionPane.showInputDialog("Introduce un tamao");
int num[]=new int[Integer.parseInt(texto)];
//Invocamos las funciones
rellenarNumPrimosAleatorioArray(num, 1, 100);

mostrarArray(num);

//Saco el primo mayor


int primoMayor=mayor(num);
System.out.println("El primo ms grande es el "+primoMayor);
}

public static void rellenarNumPrimosAleatorioArray(int lista[], int a, int b){

int i=0;

//Usamos mejor un while, ya que solo aumentara cuando genere un primo


while(i<lista.length){
int num=((int)Math.floor(Math.random()*(a-b)+b));
if (esPrimo(num)){
lista[i]=num;
i++;
}
}
}
private static boolean esPrimo (int num){

//Un numero negativo, el 0 y el 1, son directamente no primos.


if (num<=1){
return false;
}else{

//declaracion
int prueba;
int contador=0;
//Hacemos la raiz cuadrada y lo usamos para dividir el numero original
prueba=(int)Math.sqrt(num);
//Bucle que cuenta los numeros divisibles, podemos hacerlo con while
for (;prueba>1;prueba--){
if (num%prueba==0){
contador+=1;
}
}
return contador < 1;
}
}

public static void mostrarArray(int lista[]){


for(int i=0;i<lista.length;i++){
System.out.println("En el indice "+i+" esta el valor "+lista[i]);
}
}

public static int mayor(int lista[]){


int mayor=0;
for(int i=0;i<lista.length;i++){
if(lista[i]>mayor){
mayor=lista[i];
}
}

return mayor;
}

4) Crea un array de nmeros de 100 posiciones, que contendr los nmeros del 1 al
100. Obtn la suma de todos ellos y la media.

public class SumaMediaArrayApp {

public static void main(String[] args) {


//Creo un array
int[] numeros=new int[100];

//Declaro las variables necesarias


int suma=0;
double media;

//Recorro el array, asigno nmeros y sumo


for(int i=0;i<numeros.length;i++){
numeros[i]=i+1;
suma+=numeros[i];
}

//Calculo la media y muestro la suma y la meda


System.out.println("La suma es "+suma);

media=(double)suma/numeros.length;

System.out.println("La media es "+media);

}
5) Crea un array de caracteres que contenga de la A a la Z (solo las
maysculas). Despus, ve pidiendo posiciones del array por teclado y si la
posicion es correcta, se aadira a una cadena que se mostrara al final, se
dejar de insertar cuando se introduzca un -1.

import java.util.Scanner;

public class FormaPalabrasApp {

public static void main(String[] args) {

//restamos La posicion mayor Z a la posicion menor (sumamos 1 para que no se quede un


espacio de menos)
char abecedario[]=new char[('Z'-'A')+1];

//creamos el abecedario
for(int i='A', indice=0;i<='Z';i++, indice++){
abecedario[indice]=(char)i;
}

Scanner sn=new Scanner(System.in);

//Pedimos un numero, que sern posiciones del array


System.out.println("inserte un numero entre 0 y "+(abecedario.length-1)+". -1 para
acabar");
int num=sn.nextInt();

String cadena="";

while(num!=-1){

//Comprobamos que el nmero es correcto


if(num>=0 && num<abecedario.length){

cadena+=abecedario[num];
System.out.println("Inserte un numero entre 0 y "+(abecedario.length-1)+". -1 para
acabar");
}else{
System.out.println("Numero no valido inserte un numero entre 0 y
"+(abecedario.length-1)+". -1 para acabar");
}

num=sn.nextInt(); //lo pedimos de nuevo

//Resultado final
System.out.println("La cadena resultante es "+cadena);
}

}
MATRICES

Dadas dos matrices A y B intercambiar los minimos de A con los maximos de B


import java.util.Scanner;
public class JavaMatrizMetod1 {

Scanner Leer = new Scanner(System.in);

public static void llenar (int M [] [], int f, int c)


{
Scanner Leer = new Scanner(System.in);
for (int i = 1 ; i <= f ; i++)
{
for (int j = 1 ; j <= c ; j++)
{
System.out.print ("Inserte pos[" + i + "][" + j + "]: ");
M [i] [j] = Leer.nextInt();
}
}
}
public static void mostrar (int M [] [], int f, int c)
{
for (int i = 1 ; i <= f ; i++)
{
System.out.println ();
for (int j = 1 ; j <= c ; j++)
{
System.out.print ("[" + M [i] [j] + "]");
}
}
}
public static int menor (int M [] [], int f, int c)
{
int men = M [1] [1];
for (int i = 1 ; i <= f ; i++)
{
for (int j = 1 ; j <= c ; j++)
{
if (M [i] [j] < men)
men = M [i] [j];
}
}
return (men);
}
public static int maximo (int M [] [], int f, int c)
{
int max = M [1] [1];
for (int i = 1 ; i <= f ; i++)
{
for (int j = 1 ; j <= c ; j++)
{
if (M [i] [j] < max)
max = M [i] [j];
}
}
return (max);
}
public static void intercambiar (int A [] [], int fa, int ca, int B [] [], int fb, int cb)
{
int min_a = menor (A, fa, ca);
int max_b = maximo (B, fb, cb);
//para cambiar los minimos de A con los maximos de B
for (int i = 1 ; i <= fa ; i++)
{
for (int j = 1 ; j <= ca ; j++)
{
if (A [i] [j] == min_a)
A [i] [j] = max_b;
}
}
//para intercambiar los maximos de con los minimos de A
for (int i = 1 ; i <= fb ; i++)
{
for (int j = 1 ; j <= cb ; j++)
{
if (B [i] [j] == max_b)
B [i] [j] = min_a;
}
}
}
public static void main (String args [])
{
Scanner Leer = new Scanner(System.in);
int A [] [] = new int [20] [20];
int B [] [] = new int [20] [20];
System.out.print ("Insert filas de A: ");
int fa = Leer.nextInt();
System.out.print ("Insert columnas de A: ");
int ca = Leer.nextInt();
System.out.print ("Insert filas de B: ");
int fb = Leer.nextInt();
System.out.print ("Insert columnas de B: ");
int cb = Leer.nextInt();
//lectura de matrices
System.out.println ("nINSERTANDO DATOS EN MATRIZ A: n");
llenar (A, fa, ca);
System.out.println ("nINSERTANDO DATOS EN MATRIZ B: n");
llenar (B, fb, cb);
System.out.println ("nMATRICES ORIGINALMENTE INSERTADAS: ");
mostrar (A, fa, ca);
System.out.println ();
mostrar (B, fb, cb);
System.out.println ();
//intercambiando elementos
intercambiar (A, fa, ca, B, fb, cb);
System.out.println ("nMATRICES DESPUES DEL INTERCAMBIO:");
mostrar (A, fa, ca);
System.out.println ();
mostrar (B, fb, cb);
}
}
2) Dada una matriz cuadrada invertir su diagonal principal

import java.util.Scanner;
public class JavaMatrizMetod2 {

public static void llenar (int M [] [], int d)


{
Scanner Leer = new Scanner(System.in);
for (int i = 1 ; i <= d ; i++)
{
for (int j = 1 ; j <= d ; j++)
{
System.out.print("Inserte pos[" + i + "][" + j + "]: ");
M [i] [j] = Leer.nextInt();
}
}
}
public static void mostrar (int M [] [], int d)
{
for (int i = 1 ; i <= d ; i++)
{
System.out.println ();
for (int j = 1 ; j <= d ; j++)
{
System.out.print("[" + M [i] [j] + "]");
}
}
}
public static void invierte (int M [] [], int d)
{
int fin = d;
for (int i = 1 ; i <= d / 2 ; i++)
{
int aux = M [i] [i];
M [i] [i] = M [d] [d];
M [d] [d] = aux;
fin--;
}
}
public static void main (String args [])
{
Scanner Leer = new Scanner(System.in);
int M [] [] = new int [20] [20];
System.out.print("Inserte dimen. de la matriz cuadrada: ");
int d = Leer.nextInt();
llenar (M, d);
System.out.print("nMATRIZ ORIGINAL: ");
mostrar (M, d);
System.out.print("nnMATRIZ CON LA DIAGONAL PRINCIPAL INVERTIDA: ");
invierte (M, d);
mostrar (M, d);
}

}
3) Dada una matriz cuadrada invertir su diagonal secundaria

import java.util.Scanner;
public class JavaMatrizMetod3 {

public static void llenar (int M [] [], int d)


{
Scanner Leer = new Scanner(System.in);
for (int i = 1 ; i <= d ; i++)
{
for (int j = 1 ; j <= d ; j++)
{
System.out.print ("Inserte pos[" + i + "][" + j + "]: ");
M [i] [j] = Leer.nextInt();
}
}
}
public static void mostrar (int M [] [], int d)
{
for (int i = 1 ; i <= d ; i++)
{
System.out.println ();
for (int j = 1 ; j <= d ; j++)
{
System.out.print ("[" + M [i] [j] + "]");
}
}
}
public static void invierte (int M [] [], int d)
{
int fin = d;
for (int i = 1 ; i <= d / 2 ; i++)
{
int aux = M [i] [d];
M [i] [d] = M [d] [i];
M [d] [i] = aux;
fin--;
}
}
public static void main (String args [])
{
Scanner Leer = new Scanner(System.in);
int M [] [] = new int [20] [20];
System.out.print ("Inserte dimen. de la matriz cuadrada: ");
int d = Leer.nextInt();
llenar (M, d);
System.out.print ("nMATRIZ ORIGINAL: ");
mostrar (M, d);
System.out.print ("nnMATRIZ CON LA DIAGONAL SECUNDARIA INVERTIDA: ");
invierte (M, d);
mostrar (M, d);
}

}
4) Dada dos matrices de diferentes tamaos R y S mostrar los elementos comunes de
R en S
import java.util.Scanner;

public class JavaMatrizMetod4 {

public static void llenar (int M [] [], int f, int c)


{
Scanner Leer = new Scanner(System.in);
for (int i = 1 ; i <= f ; i++)
{
for (int j = 1 ; j <= c ; j++)
{
System.out.print ("Inserte pos[" + i + "][" + j + "]: ");
M [i] [j] = Leer.nextInt();
}
}
}
public static void mostrar (int M [] [], int f, int c)
{
for (int i = 1 ; i <= f ; i++)
{
System.out.println ();
for (int j = 1 ; j <= c ; j++)
{
System.out.print ("[" + M [i] [j] + "]");
}
}
}
public static void comunes (int R [] [], int fr, int cr, int S [] [], int fs, int cs)
{
System.out.print ("nnLos elementos comunes de R en S son: ");
for (int i = 1 ; i <= fr ; i++)
{
for (int j = 1 ; j <= cr ; j++)
{
for (int k = 1 ; k <= fs ; k++)
{
for (int l = 1 ; l <= cs ; l++)
{
if (R [i] [j] == S [k] [l])
System.out.print ("[" + R [i] [j] + "]");
}
}
}
}
}
public static void main (String args [])
{
Scanner Leer = new Scanner(System.in);
int R [] [] = new int [20] [20];
int S [] [] = new int [20] [20];
System.out.print ("Inserte filas de R: ");
int fr = Leer.nextInt();
System.out.print ("Inserte columnas de R: ");
int cr = Leer.nextInt();
System.out.print ("Inserte filas de S: ");
int fs = Leer.nextInt();
System.out.print ("Inserte columnas de S: ");
int cs = Leer.nextInt();

System.out.print ("nLLENANDO MATRIZ R: n");


llenar (R, fr, cr);
System.out.print ("nLLENANDO MATRIZ S: n");
llenar (S, fs, cs);
System.out.print ("nLA MATRICES R : ");
mostrar (R, fr, cr);
System.out.print ("nLA MATRICES S : ");
mostrar (S, fs, cs);
comunes (R, fr, cr, S, fs, cs);
}
}
5) Dada una matriz intercambiar los elementos de la primera columna con la ultima columna

import java.util.Scanner;
public class JavaMatrizMetod5 {

public static void llenar (int M [] [], int f, int c)


{
Scanner Leer = new Scanner(System.in);
for (int i = 1 ; i <= f ; i++)
{
for (int j = 1 ; j <= c ; j++)
{
System.out.print ("Inserte pos[" + i + "][" + j + "]: ");
M [i] [j] = Leer.nextInt();
}
}
}
public static void mostrar (int M [] [], int f, int c)
{
for (int i = 1 ; i <= f ; i++)
{
System.out.println ();
for (int j = 1 ; j <= c ; j++)
{
System.out.print ("[" + M [i] [j] + "]");
}
}
}
public static void intercambiar (int M [] [], int f, int c)
{
for (int i = 1 ; i <= f ; i++)
{
int aux = M [i] [1];
M [i] [1] = M [i] 1;
M [i] 1 = aux;
}
}
public static void main (String args [])
{
Scanner Leer = new Scanner(System.in);
int M [] [] = new int [20] [20];
System.out.print ("Inserte filas de la matriz: ");
int f = Leer.nextInt();
System.out.print ("Inserte columnas de la matriz: ");
int c = Leer.nextInt();
System.out.print ("nLLENANDO MATRIZ : n");
llenar (M, f, c);
System.out.print ("nLA MATRIZ ORIGINAL : ");
mostrar (M, f, c);
System.out.print ("nnLA MATRICES INTERCAMBIADA : ");
intercambiar (M, f, c);
mostrar (M, f, c);
}
}

HERENCIA
1) Disponemos de una clase Persona con los atributos nif y nombre

//Clase Persona. Clase Base


public class Persona {
private String nif;
private String nombre;
public String getNif() {
return nif;
}
public void setNif(String nif) {
this.nif = nif;
}
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
}

2) Vamos a aadir a la clase Persona un mtodo leer() para introducir por teclado los
valores a los atributos de la clase.

public class Persona {


private String nif;
private String nombre;
public String getNif() {
return nif;
}
public void setNif(String nif) {
this.nif = nif;
}
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
public void leer(){
Scanner sc = new Scanner(System.in);
System.out.print("Nif: ");
nif = sc.nextLine();
System.out.print("Nombre: ");
nombre = sc.nextLine();
}
}

3) Clase Rectangulo

public class Rectangulo extends Poligono{

private double lado1;


private double lado2;

public Rectangulo() {
}
public Rectangulo(double lado1, double lado2) {
super(2);
this.lado1 = lado1;
this.lado2 = lado2;
}

public double getLado1() {


return lado1;
}

public void setLado1(double lado1) {


this.lado1 = lado1;
}

public double getLado2() {


return lado2;
}

public void setLado2(double lado2) {


this.lado2 = lado2;
}

//Implementacin del mtodo abstracto area()


//heredado de la clase Polgono
@Override
public double area(){
return lado1 * lado2;
}
}

4) La clase base es la clase Empleado. Esta clase contiene:


Un atributo privado nombre de tipo String que heredan el resto de clases.
Un constructor por defecto.
Un constructor con parmetros que inicializa el nombre con el String que recibe.
Mtodo set y get para el atributo nombre.
Un mtodo toString() que devuelve el String: "Empleado " + nombre.
El resto de clases solo deben sobrescribir el mtodo toString() en cada una de ellas
y declarar el constructor adecuado de forma que cuando la ejecucin de las siguientes
instrucciones:

Empleado E1 = new Empleado("Rafa");


Directivo D1 = new Directivo("Mario");
Operario OP1 = new Operario("Alfonso");
Oficial OF1 = new Oficial("Luis");
Tecnico T1 = new Tecnico("Pablo");
System.out.println(E1);
System.out.println(D1);
System.out.println(OP1);
System.out.println(OF1);
System.out.println(T1);
Den como resultado:
Empleado Rafa
Empleado Mario -> Directivo
Empleado Alfonso -> Operario
Empleado Luis -> Operario -> Oficial
Empleado Pablo -> Operario -> Tecnico

//Clase Empleado. Clase Base de la jerarqua


public class Empleado {
private String nombre;

//constructor por defecto


public Empleado() {
}

//constructor con un parmetro


public Empleado(String nombre) {
this.nombre = nombre;
System.out.println("Constructor de Empleado " + nombre);
}

//mtodos get y set


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

//mtodo toString()
//devuelve un String formado por la palabra Empleado y el nombre de
empleado
@Override
public String toString() {
return "Empleado " + nombre;
}
}
//Clase Operario. Clase derivada de la clase Empleado
public class Operario extends Empleado{

//constructor con un parmetro


public Operario(String nombre) {
super(nombre);
System.out.println("Constructor de Operario");
}

//constructor por defecto


public Operario() {
}

//modificacin del mtodo toString() para mostrar el mensaje adecuado


@Override
public String toString() {
return super.toString() + " -> Operario";
}
}

//Clase Oficial. Clase derivada de la clase Operario


public class Oficial extends Operario{

public Oficial() {
}

public Oficial(String nombre) {


super(nombre);
System.out.println("Constructor de Oficial");
}

@Override
public String toString() {
return super.toString() + " -> Oficial";
}
}

//Clase Directivo. Clase derivada de la clase Empleado


public class Directivo extends Empleado{

public Directivo() {
}

public Directivo(String nombre) {


super(nombre);
System.out.println("Constructor de Directivo");
}

@Override
public String toString() {
return super.toString() + " -> Directivo";
}
}

//Clase Tecnico. Clase derivada de la clase Operario


public class Tecnico extends Operario{

public Tecnico() {
}

public Tecnico(String nombre) {


super(nombre);
System.out.println("Constructor de Tecnico");
}

@Override
public String toString() {
return super.toString() + " -> Tecnico";
}
}

5) Clase padre base alumno

public class Alumno {


public String getNombre() {
return nombre;
} public class Alumno {

public String getNombre() {


return nombre;
}

public String getClases() {


return clases;
}

public String getGrado() {


return grado;
}

public String getGrupo() {


return grupo;
}

public void setNombre(String nombre) {


this.nombre = nombre;
}

public void setClases(String clases) {


this.clases = clases;
}

public void setGrado(String grado) {


this.grado = grado;
}

public void setGrupo(String grupo) {


this.grupo = grupo;
}
private String nombre;
private String clases;
private String grado;
private String grupo;

protected void ir_a_clase(){

protected void estudiar(){

}
}

public String getClases() {


return clases;
}

public String getGrado() {


return grado;
}

public String getGrupo() {


return grupo;
}

public void setNombre(String nombre) {


this.nombre = nombre;
}

public void setClases(String clases) {


this.clases = clases;
}

public void setGrado(String grado) {


this.grado = grado;
}

public void setGrupo(String grupo) {


this.grupo = grupo;
}
private String nombre;
private String clases;
private String grado;
private String grupo;

protected void ir_a_clase(){

protected void estudiar(){

}
}
//clase hija alumno//

public class Regular extends Alumno{

public Regular(){

protected void pagar_inscripcion(){

protected void matricularse(){

}
}

POLIMORFISMO
1) Crear la clase animal

2) public interface IAnimal {


3)
4) int valor=5;
5)
6) /**
7) * Mtodo Comunicarse, sera implementado por las clases
concretas
8) * que hereden de la clase Animal
9) */
10) public void comunicarse();
11)
12) }
13) public abstract class Animal implements IAnimal {
14)
15) private String nombre;
16)
17) /**
18) * Constructor de la clase Animal
19) * @param nombre
20) */
21) public Animal (String nombre){
22) this.nombre=nombre;
23) System.out.println("Constructor Animal, " +
24) "nombre del animal : "+this.nombre);
25) }
26)
27) /**
28) * Retorna el valor de nombre
29) * @return
30) */
31) public String getNombre(){
32) return nombre;
33) }
34)
35)
36) /**
37) * Metodo Abstracto tipoAnimal, la implementacin depende
38) * de las clases concretas que extiendan la clase Animal
39) */
40) public abstract void tipoAnimal();

41) }
42) ublic class Gato extends Animal{
43)
44) /**
45) * Constructor explicito clase Gato
46) * @param nombre
47) */
48) public Gato(String nombre) {
49) super(nombre);//envia el parametro a el constructor de la
clase padre
50) System.out.println("Constructor Gato, nombre : "+nombre);
51) }
52)
53) public void tipoAnimal() {
54) System.out.println("Tipo Animal : Es un Gato");
55) }
56)
57) public void comunicarse(){
58) System.out.println("Metodo comunicarse : El gato mau-
lla... Miau Miau");
59) }
60) }
61) public class Test {
62) public static void main (String[] arg){
63)
64) /**Creamos anim, un objeto Perro de tipo Animal*/
65) Animal anim= new Perro("goliath") ;
66) anim.tipoAnimal();
67) anim.comunicarse();
68) System.out.println();
69)
70) /**Creamos perro, un objeto Perro de tipo Perro*/
71) Perro perro=new Perro("hercules");
72) perro.tipoAnimal();
73) System.out.println();
74)
75) /**Creamos animalPolimorfico, un objeto perro de tipo Ani-
mal
76) * asignamos una referencia ya existente*/
77) Animal animalPolimorfico=perro;
78) animalPolimorfico.tipoAnimal();
79) System.out.println();
80)
81) /**reasignamos la referencia del objeto anim a el objeto
perro
82) * esto es valido ya que ambos son de tipo Perro*/
83) perro=(Perro) anim;
84) perro.tipoAnimal();
85) System.out.println();
86)
87) /**Creamos gat, un objeto Gato de tipo Animal*/
88) Animal gat=new Gato("pichi");
89) gat.tipoAnimal();
90) gat.comunicarse();
91) System.out.println();
92)
93) /**Creamos cat, un objeto Gato de tipo IAnimal
94) * Para esto aplicamos polimorfismo usando la Interface*/
95) IAnimal cat = new Gato("pitufa");
96) cat.comunicarse();
97)
98) System.out.println("\nConstante en la interfaz Animal :
"+IAnimal.valor);
99) }
100) }
101) Animal animales[]= { new Perro("simon"),new Pe-
rro("paco"),new Gato("mimi")};
102) for(Animal a : animales){
103) a.tipoAnimal();
104) }
105) System.out.println();

2) polimorfismo msica

package POLIMORFISMO;

public class Musica {

// No importa el tipo de Instrumento,


// seguir funcionando debido a Polimorfismo:
static void afinar(Instrumento i) {
// ...
i.tocar();
}

static void afinarTodo(Instrumento[] e) {

for (int i = 0; i < e.length; i++) {


afinar(e[i]);
}
}
public static void main(String[] args) {
Instrumento[] orquesta = new Instrumento[5];
int i = 0;
// Up-casting al asignarse el Arreglo
orquesta[i++] = new Guitarra();
orquesta[i++] = new Piano();
orquesta[i++] = new Saxofon();
orquesta[i++] = new Guzla();
orquesta[i++] = new Ukelele();
afinarTodo(orquesta);
}
}
package POLIMORFISMO;

import java.util.*;
public class Instrumento {

public void tocar() {


System.out.println("Instrumento.tocar()");
}

public String tipo() {


return "Instrumento";
}

public void afinar() {


}
}

class Guitarra extends Instrumento {

public void tocar() {


System.out.println("Guitarra.tocar()");
}

public String tipo() {


return "Guitarra";
}

public void afinar() {


}
}

class Piano extends Instrumento {

public void tocar() {


System.out.println("Piano.tocar()");
}

public String tipo() {


return "Piano";
}

public void afinar() {


}
}

class Saxofon extends Instrumento {

public void tocar() {


System.out.println("Saxofon.tocar()");
}

public String tipo() {


return "Saxofon";
}

public void afinar() {


}
}

// Un tipo de Guitarra
class Guzla extends Guitarra {
public void tocar() {
System.out.println("Guzla.tocar()");
}

public void afinar() {


System.out.println("Guzla.afinar()");
}
}

// Un tipo de Guitarra
class Ukelele extends Guitarra {

public void tocar() {


System.out.println("Ukelele.tocar()");
}

public String tipo() {


return "Ukelele";
}
}

3) REALIZAR CON POLIMORFISMO LAS ACTIVIDADES QUE CUMPLE CADA MIEMBRO DE LA SELECCIN
ESPAOLA DE FUTBOL PARA ELLO VAMOS UTILIZAR CLASES Y ATRIBUTOS.

CADA UNO DE LOS MIEMBROS COMO FUTBOLISTA Y DEMAS SON UNA CLASE DIFERENTE LA CUAL DEBE
SER CREADA Y ENESAS CLASES PONDREMOS LOS DIFRENTES METODOS

public abstract class SeleccionFutbol {

protected int id;

protected String nombre;

protected String apellidos;

protected int edad;

// constructores, getter y setter

public void viajar() {

System.out.println("Viajar (Clase Padre)");

public void concentrarse() {

System.out.println("Concentrarse (Clase Padre)");

}
// IMPORTANTE -> METODO ABSTRACTO => no se implementa en la clase abstracta pero si en
la clases hijas

public abstract void entrenamiento();

public void partidoFutbol() {

System.out.println("Asiste al Partido de Ftbol (Clase Padre)");

public class Futbolista extends SeleccionFutbol {

private int dorsal;

private String demarcacion;

// constructor, getter y setter

@keimer

public void entrenamiento() {

System.out.println("Realiza un entrenamiento (Clase Futbolista)");

@keimer

public void partidoFutbol() {

System.out.println("Juega un Partido (Clase Futbolista)");

public void entrevista() {

System.out.println("Da una Entrevista");

public class Entrenador extends SeleccionFutbol {

private int idFederacion;

// constructor, getter y setter


@keimer

public void entrenamiento() {

System.out.println("Dirige un entrenamiento (Clase Entrenador)");

@keimer

public void partidoFutbol() {

System.out.println("Dirige un Partido (Clase Entrenador)");

public void planificarEntrenamiento() {

System.out.println("Planificar un Entrenamiento");

public class Masajista extends SeleccionFutbol {

private String titulacion;

private int aniosExperiencia;

// constructor, getter y setter

@keimer

public void entrenamiento() {

System.out.println("Da asistencia en el entrenamiento (Clase Masajista)");

public void darMasaje() {

System.out.println("Da un Masaje");

public class Main {


// ArrayList de objetos SeleccionFutbol. Idenpendientemente de la clase hija a la que pertenezca
el objeto

public static ArrayList<SeleccionFutbol> integrantes = new ArrayList<SeleccionFutbol>();

public static void main(String[] args) {

SeleccionFutbol delBosque = new Entrenador(1, "Vicente", "Del Bosque", 60, 28489);

SeleccionFutbol iniesta = new Futbolista(2, "Andres", "Iniesta", 29, 6, "Interior


Derecho");

SeleccionFutbol raulMartinez = new Masajista(3, "Ral", "Martinez", 41, "Licenciado en


Fisioterapia", 18);

integrantes.add(delBosque);

integrantes.add(iniesta);

integrantes.add(raulMartinez);

// CONCENTRACION

System.out.println("Todos los integrantes comienzan una concentracion. (Todos


ejecutan el mismo mtodo)");

for (SeleccionFutbol integrante : integrantes) {

System.out.print(integrante.getNombre() + " " + integrante.getApellidos() + " -


> ");

integrante.concentrarse();

// VIAJE

System.out.println("nTodos los integrantes viajan para jugar un partido. (Todos


ejecutan el mismo mtodo)");

for (SeleccionFutbol integrante : integrantes) {

System.out.print(integrante.getNombre() + " " + integrante.getApellidos() + " -


> ");

integrante.viajar();

}
// ENTRENAMIENTO

System.out.println("nEntrenamiento: Todos los integrantes tienen su funcin en un entrenamiento


(Especializacin)");

for (SeleccionFutbol integrante : integrantes) {

System.out.print(integrante.getNombre() + " " + integrante.getApellidos() + " -> ");

integrante.entrenamiento();

// PARTIDO DE FUTBOL

System.out.println("nPartido de Ftbol: Todos los integrantes tienen su funcin en un partido


(Especializacin)");

for (SeleccionFutbol integrante : integrantes) {

System.out.print(integrante.getNombre() + " " + integrante.getApellidos() + " -> ");

integrante.partidoFutbol();

// PLANIFICAR ENTRENAMIENTO

System.out.println("nPlanificar Entrenamiento: Solo el entrenador tiene el mtodo para planificar un


entrenamiento:");

System.out.print(delBosque.getNombre() + " " + delBosque.getApellidos() + " -> ");

((Entrenador) delBosque).planificarEntrenamiento();

// ENTREVISTA

System.out.println("nEntrevista: Solo el futbolista tiene el mtodo para dar una entrevista:");

System.out.print(iniesta.getNombre() + " " + iniesta.getApellidos() + " -> ");

((Futbolista) iniesta).entrevista();

// MASAJE

System.out.println("nMasaje: Solo el masajista tiene el mtodo para dar un masaje:");

System.out.print(raulMartinez.getNombre() + " " + raulMartinez.getApellidos() + " -> ");

((Masajista) raulMartinez).darMasaje();

4) polimorfismo clase persona


//Cdigo de la clase Persona ejemplo aprenderaprogramar.com
public class Persona {
private String nombre; private String apellidos; private int edad;
public Persona() { nombre = ""; apellidos = ""; edad = 0; }
public Persona (String nombre, String apellidos, int edad) {
this.nombre = nombre; this.apellidos = apellidos; this.edad = edad; }
public String getNombre() { return nombre; }
public String getApellidos () { return apellidos; }
public int getEdad() { return edad; }
} //Cierre de la clase
public class Profesor extends Persona { //Ejemplo aprenderaprogramar.com
private String IdProfesor;
public Profesor () { super();
IdProfesor = "Unknown";}
public Profesor (String nombre, String apellidos, int edad) {
super(nombre, apellidos, edad);
IdProfesor = "Unknown"; }
public void setIdProfesor (String IdProfesor) { this.IdProfesor = IdProfesor; }
public String getIdProfesor () { return IdProfesor; }

import java.util.Calendar; //Ejemplo aprenderaprogramar.com


public class ProfesorInterino extends Profesor {
private Calendar FechaComienzoInterinidad;
public ProfesorInterino(Calendar fechaComienzaInterinidad) {
super();
FechaComienzoInterinidad = fechaComienzaInterinidad; }
public ProfesorInterino (String nombre, String apellidos, int edad, Calendar fechaComienza-
Interinidad) {
super(nombre, apellidos, edad);
FechaComienzoInterinidad = fechaComienzaInterinidad; }
public Calendar getFechaComienzoInterinidad () { return FechaComienzoInterinidad; }
public void mostrarDatos() { System.out.println("Datos ProfesorInterino. Comienzo interini-
dad: " +
FechaComienzoInterinidad.getTime().toString() ); }
} //Cierre de la clase
import java.util.ArrayList; //Ejemplo aprenderaprogramar.com
public class ListinProfesores{
private ArrayList <Profesor> listinProfesores;
//Constructor
public ListinProfesores () {
listinProfesores = new ArrayList <Profesor> (); }
//Mtodos
public void addProfesor (Profesor profesor) {
listinProfesores.add(profesor); } // Cierre mtodo addProfesor
public void listar() {
System.out.println ("Se procede a mostrar los datos de los profesores existentes en el lis-
tn");
for (Profesor tmp: listinProfesores) { //Uso de for extendido
tmp.mostrarDatos(); }
} //Cierre mtodo
} //Cierre de la clase
import java.util.Calendar; //Ejemplo aprenderaprogramar.com
public class TestHerencia4 {
public static void main (String [ ] Args) {
Profesor profesor1 = new Profesor ("Juan", "Hernndez Garca", 33);
profesor1.setIdProfesor("Prof 22-387-11");
Calendar fecha1 = Calendar.getInstance();
fecha1.set(2019,10,22); //Los meses van de 0 a 11, luego 10 representa noviembre
ProfesorInterino interino1 = new ProfesorInterino("Jos Luis", "Morales Prez", 54, fe-
cha1);
ListinProfesores listin1 = new ListinProfesores ();
listin1.addProfesor(profesor1);
listin1.addProfesor(interino1);
listin1.listar(); } //Cierre del main
} //Cierre de la clase

5)polimorfismo con la clase figuras

public abstract class figura {

protected String nombre;


protected int color;
protected int grosorBorde;

public String getNombre(){


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

public int getColor(){


return this.color;
}

public void setColor(int c){


this.color=c;
}

public int getGrosorBorde(){


return this.grosorBorde;
}

public void setGrosorBorde(int g){


this.grosorBorde=g;
}

public abstract void dibujar();


}

Las siguientes clases en el nivel de la jerarqua podran quedar muy parecidas


a stas:

public abstract class figura2D extends figura {


public abstract int calcularArea();

public abstract int calcularPerimetro();


}

public abstract class figura3D extends figura {

public abstract int calcularVolumen();


}