HERENCIA

En java existe la herencia simple. Es decir, que en java una clase sólo puede tener una superclase directa de la cual puede heredar todos los métodos y datos.


Puede ser que exista una cadena de clases derivadas en que la clase X herede la clase Y y  la clase Y herede la clase Z, pero no podemos  escribir algo como:


class X extends Y , Z ....  // esto sería un error


 Un mecanismo como este de herencia múltiple en Java no existe. 


Tenemos aquí un ejemplo simple de herencia de clases para que les quede más claro.
Lo único que hace es imprimir tres mensajes de diferentes clases, una de ellas heredada.





import java.io.*; 
public class primero {


public static void main(String[]args)throws IOException
{
segundo objeto=new segundo();

System.out.println("Hola como estas");

objeto.mensaje();
objeto.sms();
}
}
-------------------------------------------------------------------------------------------------------------------------



public class segundo extends tercero {


public void sms()
{
System.out.println("En la clase segundo no se encuentra el método mensaje pero en la clase tercero si");
}
}

-------------------------------------------------------------------------------------------------------------------------



public class tercero {

pubhic void mensaje()
{
System.out.println("Muy bien");
}
}

try & catch

Hola ahora presentamos aquí un programa que hace uso de try & catch para que todos ustedes conozcan como es que funciona esta instrucción ya que el programa que presentamos sobre el método de inserción hace uso de esta y nos gustaría que les quedara claro que es lo que hace.

Bien como ya sabemos en java pueden existir ocasiones en que nuestro programa falle, en java a estos errores se le llaman excepciones y para poder manejar excepciones utilizamos el try & catch para el manejo de ellas dentro del programa lo que esta hace es intentar que es lo que try significa en español.

Entre las llaves de try se escribe el código que hará que funcione nuestro programa. Pero para capturar la excepción que este código pueda generar necesitaremos otra instrucción llamada catch (capturar). Entre las llaves de catch vamos a escribir el código que queramos para tratar el error.

Ejemplo:

En este programa se pide que el usuario digite un número entero pero si el usuario digita un número decimal o una letra va a provocar un error de ejecución el cual trataremos mostrando en la pantalla el mensaje de error que hallamos manejado para ello.

import java.io.*; 

public class demo {

public static BufferedReader entrada = new BufferedReader(new inputStreamReader(System.in));

  public static int x;

public static void main(String[] args)

{

  System.out.println("inicio de programa");

  metodox();

  System.out.println("final del programa");

}

public static void metodox() 

{

  try

  { 

 System.out.println("digite un entero");

  x = Integer.parseInt(entrada.readLine());

  System.out.println("valor de x es "+x);

  }

  catch(Exception e)

  {

  System.out.println("no es entero");

  }

}

}

MÉTODO DE INSERCIÓN DESCENDENTE

El método de inserción descendente hace prácticamente lo mismo solo que al revés en este caso también se compara el elemento K+1 solo que en lugar de recorrer el elemento mayor comparado del lado derecho se manda del lado izquierdo y así sucesivamente se van comparando todos los números hasta que quedan ordenados de izquierda a derecha pero en este caso de mayor a menor y esta es la forma de distinguir el método de inserción descendente del método de inserción ascendente.

Ejemplo:

Elementos:   5   7   2   5   1   9

Elementos ordenados:   9   7   5   5   2   1

MÉTODO DE INSERCIÓN ASCENDENTE

Bueno como ya se explico arriba, el método de inserción se refiere a la comparación del elemento K+1 con todos los demás elementos ya ordenados y en este caso se detiene cuando encuentra un elemento menor y así sucesivamente todos los elementos mayores se van desplazando una posición a la derecha y el elemento menor toma la posición del elemento K+1 cuando este es recorrido, y este proceso se convierte en una secuencia la cual se detiene hasta tener ordenados todos los elementos comparados, dejándolos de izquierda a derecha ordenados de menor a mayor y así es como funciona y como se distingue el método de inserción ascendente.

Ejemplo:

Elementos:   5   8   3   9   4  2   1

Elementos  ordenados:  1   2   3   4   5   8   9

CLASE ORDENAMIENTO

public class Ordenamiento extends ArregloUni
{

public void baraja()
{
int i,j,aux;
for(i=1;i<=n-1;i++)
{
aux=a[i];
j=i-1;
while(a[j]>aux && j>0)
{
a[j+1]=a[j];
j--;
}


if(a[j]>aux)
{
a[j+1]=a[j];
a[j]=aux;
}
else
a[j+1]=aux;
}
}


public void baraja2()
{
int i,j,aux;
for(i=1;i<=n-1;i++)
{
aux=a[i];
j=i-1;
while(a[j]<aux && j>0)
{
a[j+1]=a[j];
j--;
}


if(a[j]<aux)
{
a[j+1]=a[j];
a[j]=aux;
}
else
a[j+1]=aux;
}
}





}

CLASE ArregloUni

public class ArregloUni{
protected static int MAX=20;
protected int n;
protected int []a=new int[MAX];


public int cantidad(){
return n;
}


public void ingreso(){
int i,cant;


do{
System.out.print("Cuantos elementos : ");
cant=Leer.datoInt();
} while(cant<1 || cant>MAX);
for(i=0;cant>i;i++){
System.out.print("elemento "+i+":");
a[i]=Leer.datoInt();
}
n=cant;
}


public void reporte(){
int i;


if(n>0){
for(i=0;n>i;i++) System.out.print(a[i]+"\t");
System.out.println("\n");
}
else System.out.println("Esta Vacio");
}






}

CLASE LEER

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class leer{
public static String dato(){
String sdato = "";
try{

InputStreamReader isr = new InputStreamReader(System.in);
BufferedReader flujoE = new BufferedReader(isr);

sdato = flujoE.readLine();
}
catch(IOException e){
System.err.println("Error: " + e.getMessage());
}
return sdato;
}
public static int datoInt(){
try{
return Integer.parseInt(dato());
}
catch(NumberFormatException e){


        System.out.println("Esta mal introduce un número entero");
        
return Integer.parseInt(dato());

}
}


}

CLASE DemoOrdenamiento

import java.io.*;
import java.util.Scanner;
public class DemoOrdenamiento
{ public static void main(String []args)
{
Ordenamiento datos=new Ordenamiento();
int sw,opcion;


datos.ingreso();
sw=1;
do{


System.out.println("0. Salir");
System.out.println("1. Inserción(menor a mayor)");
System.out.println("2. Inserción(mayor a menor)");
System.out.println("cualquier número distinto al menú te regresará al mismo");
System.out.print("Opcion a elegir");
opcion=leer.datoInt();

switch(opcion)
{
case 0: sw=0;break;
case 1: datos.baraja();break;
case 2: datos.baraja2();break;
}
if(opcion==1)
{
System.out.println("Arreglo despues de ordenar");
datos.reporte();
}


if(opcion==2)
{
System.out.println("Arreglo despues de ordenar");
datos.reporte();
}
}while(sw==1);


}}

VENTAJAS Y DESVENTAJAS

Principal ventaja:

El propósito principal es el facilitar las búsquedas de los miembros del conjunto ordenado.

Desventaja:

En realidad no existe una desventaja si no mas bien todo depende de el método que el usuario decida utilizar.

MÉTODO DE INSERCIÓN

El método de inserción se refiere a un método de ordenamiento el cual se define de la siguiente manera.

El ordenamiento por inserción (insertion sort en inglés) es una manera muy napural de ordenar para un ser humano, y puede usarse fácilmente para ordenar un mazo de cartas numeradas en forma arbitraria.

Inicialmente se tiene un solo elemento, que obviamente es un conjunto ordenado. Después, cuando hay k elementos ordenados de menor a mayor, se toma el elemento k+1 y se compara con todos los elementos ya ordenados, deteniéndose cuando se encuentra un elemento menor (todos los elementos mayores han sido desplazados una posición a la derecha). En este punto se inserta el elemento k+1 debiendo desplazarse los demás elementos.