jueves, 14 de octubre de 2010

HERENCIA SUPER

package HERENCIASUPER;

public class Prueba {

    public static void main(String[] args) {
      Persona p=new Persona("persona",27);
      Estudiante e=new Estudiante("estudiante",27,30);
      Profesor pr = new Profesor("profesor",30,20);
      p.Visualizar();
      e.Visualizar();
      pr.Visualizar();
    }
}
**********************************************************************************
package HERENCIASUPER;

public class Profesor extends Persona {
int salario;
public Profesor(String Nombre,int edad,int salario){
    super(Nombre,edad);
    this.salario=salario;
}
    void Visualizar(){
    System.out.println("hola "+
            Nombre+" tu edad es "+
            edad+" años "+" tu salario "+salario);
}
}
**********************************************************************************
package HERENCIASUPER;

public class Persona {
protected String Nombre;
protected int edad;

public Persona(String Nombre,int edad){
this.Nombre=Nombre;
this.edad=edad;
}
void Visualizar(){
    System.out.println("hola "+
            Nombre+" tu edad es "+
            edad+" años");
}
}
**********************************************************************************
package HERENCIASUPER;

public class Estudiante extends Persona {
    int id;
    public Estudiante(String Nombre,int edad, int id){
        super(Nombre,edad);
        this.id=id;
    }
    @Override
    void Visualizar(){
    System.out.println("hola "+
            Nombre+" tu edad es "+
            edad+" años "+" tu id es "+id);
}
}
**********************************************************************************

CALCULANDO MATRICES

package MATRICES;

import javax.swing.JOptionPane;

public class MATRICES {

    static int fil;
    static int col;
    static int mat[][];

    public static void main(String[] args) {
        JOptionPane.showMessageDialog(null, "calcule matrices");
        fil = 1;
        col = 2;
        mat = new int[fil][col];
        JOptionPane.showMessageDialog(null, "calcular datos");
        mat_llenar_matriz(mat, fil, col);
        mat_mostrar_matriz(mat, fil, col);
        mat_suma_fila(mat, fil, col);
        mat_suma_col(mat, fil, col);
    }
////////////////////////////////////////////////////////////////////////////////

    public static void mat_llenar_matriz(int[][] M, int f, int c) {
        JOptionPane.showMessageDialog(null, "Matriz de:" + f + "filas" + c + "columnas");
        for (int i = 0; i < f; i++) {
            for (int j = 0; j < c; j++) {
                M[i][j] = Integer.parseInt(JOptionPane.showInputDialog(null,
                        "ingrese valor : " + "[" + i + "]" + "[" + j + "]"));

               System.out.println();
                    System.out.println("*_ 1 _*** Añadir a Pila *****");
                    System.out.println();
            }
        }
    }
////////////////////////////////////////////////////////////////////////////////

    public static void mat_mostrar_matriz(int[][] M, int f, int c) {
        for (int i = 0; i < f; i++) {
            for (int j = 0; j < c; j++) {
                System.out.println("--" + M[i][j]);

            }
        }
    }
////////////////////////////////////////////////////////////////////////////////

    public static void mat_suma_fila(int[][] M, int f, int c) {
        int sf[];
        sf = new int[f];
        for (int i = 0; i < f; i++) {
            for (int j = 0; j < c; j++) {
                sf[i] = sf[i] + M[i][j];
            }          //mostrar el vector suma fila
            for (int j = 0; j < f; j++) {
                System.out.println("la suma de la fila es :" + j + ": " + sf[j]);
            }
        }
    }
////////////////////////////////////////////////////////////////////////////////

    public static void mat_suma_col(int[][] M, int f, int c) {
        int sc[];
        sc = new int[c];
        for (int i = 0; i < f; i++) {
            for (int j = 0; j < c; j++) {
                sc[j] = sc[j] + M[i][j];
            }
        }      //mostra el vecotr de la suma columna
        for (int j = 0; j < c; j++) {
            System.out.println("la suma de la comluma  " + j + ": " + sc[j]);
        }
    }
}
////////////////////////////////////////////////////////////////////////////////

POLIMORFISMO

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

CONTADOR DE PALABRAS

package PROYECTOS;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;

public class STRINGOBJETOS {

    private static BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in));

    public static void main(String[] args) throws IOException,
            NumberFormatException {
        short eleccion;
        String cadena = null;
        do {
            System.out.println("ELIGE UNA OPCIÓN: ");
            System.out.println("================== ");
            System.out.println("1.- Inicializar cadena String: ");
            System.out.println("2.- Convertimos el String a array de caracteres primitivo");
            System.out.println("3.- Buscar cadena en la cadena String: ");
            System.out.println("4.- Comparaciones: ");
            System.out.println("5.- Salir: ");
            eleccion = Short.parseShort(stdin.readLine());
            switch (eleccion) {

                case 1:
                    System.out.println("Introduce una cadena de caracteres: ");
                    cadena = new String(stdin.readLine());
                    System.out.println("La longitud de tu cadena " + cadena + " es de " + cadena.length() + " caracteres");
                    System.out.println("El segundo caracter de la cadena: " + cadena + " es " + cadena.charAt(1));
                    System.out.println("Los caracteres de la cadena " + cadena + " de la posicion 1 a la 4 son " + cadena.substring(0, 3));
                    System.out.println("La cadena de caracteres " + cadena + " en mayúsculas es " + cadena.toUpperCase());
                    break;
                case 2:
                    char[] vectorcadena = cadena.toCharArray();
                    for (int i = 0; i < vectorcadena.length; i++) {
                        System.out.println("La posicion: " + i + " contiene " + vectorcadena[i]);
                    }
                    break;
                case 3:
                    System.out.println("Introduce la cadena a buscar en la cadena: " + cadena);
                    String cadBus = new String(stdin.readLine());
                    System.out.println("la cadena " + cadBus + " aparece en la posición " + cadena.indexOf(cadBus));
                    break;
                case 4:
                    String cadena2 = new String("juantxu");
                    if (cadena.compareTo(cadena2) == 0) {
                        System.out.println("La cadena " + cadena + " es igual a la cadena2 " + cadena2);
                    } else {
                        System.out.println("La cadena " + cadena + " es distinta a la cadena2 " + cadena2);
                    }
                    break;
            }
        } while (eleccion != 5);
    }
}

RANDOM ARRAY

package PROYECTOS;
import java.util.*;
import java.io.*;
public class RANDOMARRAY {

    private static BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in));

    public static void main(String[] args) throws IOException,
            NumberFormatException {
        Random aleatorios = new Random();
        int[] rand = new int[3];
        int[] num_usu = new int[3];
        int[] num_aci = new int[3];
        int cont = 0;
        for (int i = 0; i < 3; i++) {
            System.out.println("Introduce el valor para el " + i + "º numero");
            num_usu[i] = Integer.parseInt(stdin.readLine());
        }
        System.out.println("Los 3 numeros de la primitiva son: ");
        System.out.println("===================================");
        for (int i = 0; i < 3; i++) {
            rand[i] = aleatorios.nextInt(10);
            System.out.println(rand[i]);
        }
        System.out.println("Haciertos ");
        System.out.println("===========");
        for (int i = 0; i < 3; i++) {
            if (rand[i] == num_usu[i]) {
                cont = cont + 1;
                num_aci[i] = cont;
            }
        }
        for (int i = 0; i < 3; i++) {
            System.out.println("El numero " + num_usu[i] + " se repite " + num_aci[i] + " veces");
        }
    }
}

RANDOM

package PROYECTOS;

import java.lang.*;
import java.util.*;

public class RANDOM {

    public static void main(String[] args) {
        Random aleatorios = new Random(2);
        System.out.println("Diez nº aleatorios: ");
        System.out.println("====================");
        for (int i = 0; i < 10; ++i) {
            System.out.println(aleatorios.nextInt());
        }
    }
}

FECHA Y HORA

package FECHAYHORA;

import java.util.Calendar;
import java.util.Timer;
import java.util.TimerTask;
import java.text.DateFormat;

public class Fecha {
    DateFormat df;
    public Fecha() {
        df = DateFormat.getDateTimeInstance(DateFormat.MEDIUM, DateFormat.MEDIUM);
        Timer timer = new Timer();
        timer.schedule(new DoTick(), 0, 1000); // do it every second
    }
    class DoTick extends TimerTask {
        public void run() {
            Calendar c = df.getCalendar();
            System.out.println(df.format(c.getTime()));

            c.add(Calendar.SECOND, 1);
            df.setCalendar(c);
        }
    }

    public static void main(String[] args) {
        Fecha t = new Fecha();
    }
}

HASHTABLES

package HASHTABLES;
import java.util.*;
public class Direccion {

    public static void main(String[] args) {

Hashtable direccion  = new Hashtable();

Integer ocho = new Integer(8000);
direccion.put("calle","Primavera");
direccion.put("numero", ocho);
direccion.put("colonia"," La Silla ");
direccion.put("ciudad"," Monterrey ");
direccion.put("estado"," Nuevo Leon ");
direccion.put("pais","Mexico");

        String miciudad  = (String) direccion.get("ciudad");
        String miestado  = (String) direccion.get("estado");
String micalle = (String) direccion.get("calle");
Integer minumero = (Integer) direccion.get("numero");

System.out.println("Direccion : " + micalle + " " + minumero);
System.out.println("Lugar: " + miciudad + "," + miestado);
    }
}

HERENCIA MULTIPLE

package HERENCIAMULTIPLE;
public class Cardiologo {

    static void r(PuedeCurar x) { x.curar(); }
    static void s(PuedeConsultar x) { x.consultar(); }
    static void t(PuedeRecetar x) { x.recetar(); }
    static void u(Cirujano x) { x.operar(); }

   public static void main(String[] args) {
Medico m = new Medico();
r(m);
s(m);
t(m);
u(m);
    }
}
**********************************************************************************

package HERENCIAMULTIPLE;

class Medico extends Cirujano
        implements PuedeCurar, PuedeConsultar, PuedeRecetar {

    public void curar() {
        System.out.println("Medico.curar()");
    }

    public void consultar() {
        System.out.println("Medico.consultar()");
    }

    public void recetar() {
        System.out.println("Medico.recetar()");
    }
}
**********************************************************************************
package HERENCIAMULTIPLE;

interface PuedeCurar {
    void curar();
}

interface PuedeConsultar {
    void consultar();
}

interface PuedeRecetar {
    void recetar();
}

class Cirujano {

    public void operar() {
        System.out.println("Cirujano.operar()");
    }
}
**********************************************************************************

LANZAMIENTO DE DADO

package array;
import javax.swing.JOptionPane;
import javax.swing.JTextArea;
public class DADO {
  
    public static void main(String[] args) {
      {
      int frecuencia[] = new int[ 7 ];
      // tirar un dado 6000 veces; usar el valor del dado como índice de frecuencia
      for ( int tiro = 1; tiro <= 600; tiro++ )
         ++frecuencia[ 1 + ( int ) ( Math.random() * 6 ) ];
      String salida = "Cara\tFrecuencia";
         // anexar frecuencias al String salida
      for ( int cara = 1; cara < frecuencia.length; cara++ )
          salida += "\n" + cara + "\t" + frecuencia[ cara ];
      JTextArea areaSalida = new JTextArea();
      areaSalida.setText( salida );
      JOptionPane.showMessageDialog( null, areaSalida,"Tirar un dado 6000 veces", JOptionPane.INFORMATION_MESSAGE );
      System.exit( 0 );
   } // fin de main
 }} // fin de la clase TirarDado

CONVERTIR DECIMAL A BINARIO N1

package array;
// traer paquetes de java
import java.io.*;
import javax.swing.*;

public class DECIMALABINARIO {
    //el metodo main inicia

    public static void main(String arg[]) throws IOException {
        String NumADividir;
        String Resultado = "";
        int bin[] = new int[100];
        int size = 100,
        posStart = -1;
        int x = 0, temp;
        NumADividir = JOptionPane.showInputDialog("Número entero a convertir ? ");
        // verifica que la cadena no sea mayor a 8 caracteres
        if (NumADividir.length() <= 8) { // inicializa vector
            for (x = 0; x < size; x++) {
                bin[x] = -1;
            }
            temp = Integer.parseInt(NumADividir);
            bin[0] = temp % 2;
            // toma los binarios
            for (x = 1; x < size; x++) {
                temp /= 2;
                bin[x] = temp % 2;
            }
            // recorta para no tomar los ceros excedentes
            for (x = size - 1; x >= 0; x--) {
                if (bin[x] == 1) {
                    posStart = x;
                }
            }
            // forma la cadena final
            for (x = posStart; x >= 0; x--) {
                Resultado = Resultado + Integer.toString(bin[x]);
            }
            JOptionPane.showMessageDialog(null, "Binario: " + Resultado, "Resultados", JOptionPane.PLAIN_MESSAGE);
        } else {
            JOptionPane.showMessageDialog(null, "La cantidad contiene más de 8 digitos", "Error !!!!", JOptionPane.PLAIN_MESSAGE);
        }
        System.exit(0);
//terminar aplicacion de la ventana
    } //fin del metodo main} // fin de la clase
}

CONVERTIR DECIMAL A BINARIO

package array;
// traer paquetes de java
import java.io.*;
import javax.swing.*;

public class DECIMALBINARIO {
    //el metodo main inicia

    public static void main(String arg[]) throws IOException {
        int bin1, bin2, bin3, bin4, bin5, bin6, bin7, bin8;
        int mod1, mod2, mod3, mod4, mod5, mod6, mod7, mod8;
        String NumADividir;

        NumADividir = JOptionPane.showInputDialog("Dame el numero entero a convertir");

        int NumADividir1 = Integer.parseInt(NumADividir);


        bin1 = NumADividir1 / 2;
        mod1 = NumADividir1 % 2;

        bin2 = bin1 / 2;
        mod2 = bin1 % 2;

        bin3 = bin2 / 2;
        mod3 = bin2 % 2;

        bin4 = bin3 / 2;
        mod4 = bin3 % 2;

        bin5 = bin4 / 2;
        mod5 = bin4 % 2;

        bin6 = bin5 / 2;
        mod6 = bin5 % 2;

        bin7 = bin6 / 2;
        mod7 = bin6 % 2;

        bin8 = bin7 / 2;
        mod8 = bin7 % 2;

        JOptionPane.showMessageDialog(null, "El numero en sistema binario es :" + mod8 + mod7 + mod6 + mod5 + mod4 + mod3 + mod2 + mod1,
                "Resultados", JOptionPane.PLAIN_MESSAGE);

        System.exit(0); //terminar aplicacion de la ventana

    }//fin del metodo main
} // fin de la clase suma

ENTEROS PARES EN ARRAY

package array;

import javax.swing.JOptionPane;
import javax.swing.JTextArea;

public class ENTEROSPARESARRAY {

    public static void main(String[] args) {
     // Inicialización de un arreglo con los enteros pares del 2 al 20.
      final int LONGITUD_ARREGLO = 10;    // constante
      int arreglo[];                    // referencia a un arreglo int

      arreglo = new int[ LONGITUD_ARREGLO ];  // crear el arreglo

      // calcular el valor para cada elemento del arreglo
      for ( int contador = 0; contador < arreglo.length; contador++ )
         arreglo[ contador ] = 2+2  * contador;
      String salida = "Índice\tValor\n";
         for ( int contador = 0; contador < arreglo.length; contador++ )
         salida += contador + "\t" + arreglo[ contador ] + "\n";
      JTextArea areaSalida = new JTextArea();
      areaSalida.setText( salida );

      JOptionPane.showMessageDialog( null, areaSalida,
         "Inicialización con enteros pares del 2 al 20",
         JOptionPane.INFORMATION_MESSAGE );
      System.exit( 0 );
   } // fin de main
} // fin de la clase InicArreglo

SENTENCIAS FOR::::WHILE:::::DO-WHILE

package array;

public class FORWHILED0WHILE {

    public static void main(String[] args) {
        int x = 0;
        int y = 5;
        salida("Primer iterador WHILE");
        while (x < y) {
            salida("x es " + x++);
        }
        salida("Segundo iterador FOR");
        for (int i = 0; i < 10; ++i) {
            salida("i es " + i);
        }
        salida("Tercer iterador DO");
        do {
            salida("x es " + x--);
        } while (x > 0);

        System.exit(0);
    }

    public static void salida(String cadena) {
        System.out.println(cadena);
    }
}

HISTOGRAMA

package array;

import javax.swing.JOptionPane;
import javax.swing.JTextArea;

public class HISTOGRAMA {

    public static void main(String[] args) {
      int arreglo[] = { 19, 3, 15, 7, 11, 9, 13, 5, 17, 1 };
      String salida = "Elemento\tValor\tHistograma";
       // para cada elemento del arreglo, mostrar una barra en el histograma
      for ( int contador = 0; contador < arreglo.length; contador++ ) {
         salida += "\n" + contador + "\t" + arreglo[ contador ] + "\t";
         // imprimir barra de asteriscos
         for ( int estrellas = 0; estrellas < arreglo[ contador ]; estrellas++ ){
            salida += "*";
         }
      } // fin de instrucción for externa
      JTextArea areaSalida = new JTextArea();
      areaSalida.setText(salida);
      JOptionPane.showMessageDialog( null, areaSalida,
         "Programa para imprimir histogramas", JOptionPane.INFORMATION_MESSAGE );
      System.exit( 0 );
   } // fin de main
}

SENTENCIA IF ELSE

package array;

public class IFELSE {

    public static void main(String[] args) {
       // Uso de if.
 int x = 5;
 int y = 7;
 comparar(x,y);
 comparar(7,5);
 comparar(5,5);
 System.exit(0);
    }
    public static void salida ( String cadena ) {
 System.out.println(cadena);
    }
    public static void comparar(int entero1, int entero2) {
 if (entero1 > entero2)
     salida("El primer argumento es menor");
 else
     if(entero1 < entero2)
  salida ("El primer argumento es mayor.");
 else
     salida("Los dos argumentos son iguales");
    }
}

SUMA ARREGLO

package array;

public class SUMAENARRAY {

    public static void main(String[] args) {
        // Sumar el total de los valores de los elementos de un arreglo.
        int arreglo[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        int total = 0;
        // sumar el valor de cada elemento al total
        for (int contador = 0; contador < arreglo.length; contador++) {
            total += arreglo[contador];
            System.out.println(arreglo[contador]+"-->"+total);
        }
           System.exit(0);
    } // fin de main
} // fin de la clase SumarArreglo

SUMA DE NUMEROS

package array;

import javax.swing.JOptionPane;

public class SUMANUMEROS {

    public static void main(String[] args) {
         String strNumero1;
      String strNumero2;
      int intNumero1;
      int intNumero2;
      int suma;
      strNumero1 = JOptionPane.showInputDialog( "Ingrese el entero 1" );
      strNumero2 = JOptionPane.showInputDialog( "Ingrese el entero 2" );
      intNumero1 = Integer.parseInt( strNumero1 );
      intNumero2 = Integer.parseInt( strNumero2 );

      suma = intNumero1 + intNumero2;

      JOptionPane.showMessageDialog(
         null, "La suma es " + suma, "Resultado,",
         JOptionPane.PLAIN_MESSAGE );
     System.exit( 0 );
  }
    }

SWITCH

package array;

public class SWITCH {

    public static void main(String[] args) {
        int x = 1;
        int tope = 10;

        salida("valor x: " + x);
        salida("valor tope: " + tope);
        while (x < tope) {
            evaluar(x++);
        }
        System.exit(0);
    }
    public static void salida(String cadena) {
        System.out.println(cadena);
    }

    public static void evaluar(int numero) {
        switch (numero) {
            case 1:
                salida("Uno");
                break;
            case 2:
                salida("Dos");
                break;
            case 3:
                salida("Tres");
                break;
            case 4:
                salida("Cuatro");
                break;
            case 5:
            case 6:
                salida("Cinco o seis");
                break;
            default:
                salida("Otro numero");
                break;
        }
    }
}

RAÍZ CUADRADA

package array;

import javax.swing.JOptionPane;
import javax.swing.JTextArea;

public class RAIZCUADRADA {

    private static void log(String s) {
        System.out.println(s);
        JTextArea areaSalida = new JTextArea();
        areaSalida.setText(s);
        JOptionPane.showMessageDialog(null, areaSalida, "Programa de votación de estudiantes", JOptionPane.INFORMATION_MESSAGE);
    }

    public static void main(String[] args) {
        // sqrt(x) devuelve la raíz cuadrada.
        for (int i = 0; i < 10; i++) {
        log("La raíz cuadrada de " + i + " es " + Math.sqrt(i));
        }
        int num1;
        String num = JOptionPane.showInputDialog("ingrese numeron");
        num1 = Integer.parseInt(num);
        log("La raíz cuadrada de " + num1 + " es " + Math.sqrt(num1));
    }
}

VECTOR

package VECTOR;

import java.util.Vector;
*********************************************************************************
class Clip {
}

class Lapiz {
}

class Pluma {
}

class Silla {
}

class SillaReclinable {
}

public class ClaseOficina {

    public static void main(String[] args) {

        // Un arreglo de Clips
        Clip[] c = new Clip[5];

        // Un objeto de Lapiz
        Lapiz l = new Lapiz();

        // Un arreglo de Plumas
        Pluma[] p = new Pluma[7];

        // Un arreglo de Sillas
        Silla[] s = {
            new Silla(), new Silla(), new Silla()
        };

        // Un Objeto Tipo String
        String deptF = new String("Finanzas");
        String deptV = new String("Ventas");

        // Definir Dos Vectores
        Vector ciudad1 = new Vector(3);
        Vector ciudad2 = new Vector(4, 5);

        //Iniciar asignación de Objetos a Vectores
        //Un Vector puede tomar cualquier tipo de Objeto
        ciudad1.add(deptF);
        ciudad1.add(c);
        ciudad1.add(l);

        ciudad2.add(deptV);
        ciudad2.add(c);
        ciudad2.add(l);
        System.out.println("Vector ciudad1 tiene " + ciudad1.size()
                + " elementos y una capacidad de " + ciudad1.capacity());
        System.out.println("Vector ciudad2 tiene " + ciudad2.size()
                + " elementos y una capacidad de " + ciudad2.capacity());

        // Asignar otros valores para ver incremento de capacidad
        ciudad1.add(p);
        ciudad1.add(s);

        ciudad2.add(p);
        ciudad2.add(s);

        System.out.println("Después de agregar otros elementos: ");
        System.out.println("Vector ciudad1 tiene " + ciudad1.size()
                + " elementos y una capacidad de " + ciudad1.capacity());
        System.out.println("Vector ciudad2 tiene " + ciudad2.size()
                + " elementos y una capacidad de " + ciudad2.capacity());

        String deptExtraido = (String) ciudad1.elementAt(0);
        Silla[] sillaExtraida = (Silla[]) ciudad1.elementAt(4);
        System.out.println("El departamento de " + deptExtraido
                + " en la ciudad1 tiene " + sillaExtraida.length + " sillas");

        SillaReclinable[] sr = new SillaReclinable[12];
        ciudad2.insertElementAt(sr, 4);

        deptExtraido = (String) ciudad2.elementAt(0);

        // La siguiente extracción generaría un error
        // porque este elemento del Vector ya no es una Clase Silla
        // sillaExtraida = (Silla[]) ciudad2.elementAt(4);

        SillaReclinable[] sillaRecExtraida = (SillaReclinable[]) ciudad2.elementAt(4);
        System.out.println("El departamento de " + deptExtraido
                + " en la ciudad2 tiene " + sillaRecExtraida.length + " sillas");
    }
}
*********************************************************************************

HERENCIA


package HERENCIA;
public class AppPoligono {
    public static void main(String[] args) {
     Rectangulo rec=new Rectangulo();
     Triangulo tri=new Triangulo();
     rec.setValores(4, 6);
     tri.setValores(4,6);
     System.out.println("rectangulo\n"+rec.area()+"\n"+"triangulo \n"+tri.area());
    }
}
package HERENCIA;
public class Poligono {
protected int base,altura;
public Poligono(){
    }
public void setValores(int a,int b){
    base=a;
    altura=b;
    }}
package HERENCIA;
public class Rectangulo extends Poligono{
public int area(){
    return (base *altura);
}
}
package HERENCIA;
public class Triangulo extends Poligono {
public int area(){
    return(base*altura/2);
}
}

ENCAPSULAMIENTO


package ENCAPSULAMIENTO;
public class MiClase {
    private int tipo;
    public void setTipo(int t) {
        tipo = t;
    }
    public int getTipo() {
        return tipo;
    }
}
package ENCAPSULAMIENTO;
public class AccesoDirecto {
public static void main(String[] args) {
MiClase mc = new MiClase();
mc.setTipo(5);
System.out.println("El tipo es:" + mc.getTipo());
}
}

lunes, 22 de marzo de 2010

CODIGO-LISTAS


public class Lista {
private Object info;
private Lista cola;

/**
* Constructor para una lista de un solo elemento.
* @param i La información.
*/

public Lista(Object i){
info = i;
cola = null;
}

/**
* Constructor para una lista de más de un elemento.
* @param i La información
* @param c La lista cola
*/
public Lista(Object i, Lista c){
info = i;
cola = c;
}

/**
* Obtiene la cola de la lista.
* @return Cola de la lista.
*/
public Lista obtCola(){
return cola;
}
/**
* Obtiene la información de la lista.
* @return La información.
*/

public Object obtInfo(){
return info;
}

/**
* Obtiene la información del "n"-esimo nodo.
* @param n La posición del nodo.
* @return La información del nodo.
*/
public Object obtInfo(int n){
if(n == 0){
return info;
}
if(cola != null){
return cola.obtInfo(n - 1);
}
return null;
}
/**
* Busca la información "i" en la lista retornando la sublista cuya cabeza contiene
* la información. Si no la encuentra retorna null.
* @param i La información a buscar.
* @return La sublista cuya cabeza tiene la información, retorna null sino la
* encuentra.
*/
public Lista buscar(Object i){
if(info.equals(i)){
return this;
}
if(cola != null){
return cola.buscar(i);
}
return null;
}
/**
* Cuenta en numero de nodos de la lista.
* @return El numero de nodos de la lista.
*/
public int contar(){
if(cola == null){
return 1;
}
return 1 + cola.contar();
}
/**
* Convierte a cadena la lista. Por ejemplo, para imprimirla.
*/
public String toString(){
String cad = "(";
cad += info;
if(cola != null){
cad += "," + cola;
}
cad += ")";
return cad;
}
/**
* Adiciona la Lista "l" al final de la lista.
* @param l Lista que se va a adicionar.
*/
public void adicionar(Lista l){
if(cola == null){
cola = l;
}
else{
cola.adicionar(l);
}
}
/**
* Inserta la Lista "l" después de la cabeza.
* @param l La Lista a insertar.
*/
public void insertar(Lista l){
if(cola == null){
cola = l;
}
else{
l.adicionar(cola);
cola = l;
}
}
/**
* Inserta la lista "l" después de la posición "n". Si no existe la posición la
* inserta al final.
* @param n Posición a insertar.
* @param l La Lista que se va a insertar.
*/
public void insertar(int n, Lista l){
if(n == 1){
insertar(l);
}
else{
if(cola != null){
cola.insertar(n - 1, l);
}
else {
cola = l;
}
}
}
/**
* Elimina el nodo después de la cabeza retornándolo.
* @return El nodo final.
*/
public Lista eliminar(){
Lista c = cola;
if(cola != null){
cola = cola.cola;
c.cola = null;
}
return c;
}
/**
* Elimina el "n"-esimo nodo de la Lista retornándolo.
* @param n La posición del nodo.
* @return El nodo que se elimina.
*/
public Lista eliminar(int n){
if(n == 2){
return eliminar();
}
if(cola != null){
return cola.eliminar(n - 1);
}
return null;
}
/**
* Elimina la cabeza de la sublista "l" retornándola.
* @param l La sublista cuya cabeza se eliminará.
* @return La cabeza.
*/
public Lista eliminar(Lista l){
if(cola == null){
return null;
}
if(cola.equals(l)){
return eliminar();
}
return cola.eliminar(l);
}
/**
* Saca una copia de la sublista de la cola.
* @return La sublista.
*/
public Lista subLista(){
if(cola != null){
return new Lista(cola.info, cola.subLista());
}
return null;
}
/**
* Hace una copia de la sublista que va desde la posición  "n" hasta la "m".
* @param n Posición inicial
* @param m Posición final
* @return La sublista
*/
public Lista subLista(int n, int m){
return subLista(n, m, 1);
}
private Lista subLista(int n, int m, int i){
if(i >= n && i < m){
if(cola != null){
return new Lista(info, cola.subLista(n, m, i + 1));
}
return new Lista(info);
}
if(cola != null){
return cola.subLista(n, m, i + 1);
}
return null;
}
} // class Lista