Java: De los metodos y del paso de parametros

Dentro de una clase de java se pueden tener un numero x de metodos que realicen alguna acción en especifico, algunos de ellos regresan algun valor, otros no, algunos reciben parametros y otros no, en este post hablaremos de estos tipos de metodos, primero es necesario hablar de la estructura basica del metodo.

El metodo esta compuesto como sigue:de esta manera un ejemplo de un metodo ya dentro de la clase seria el siguiente:
En este ejemplo el metodo1 no tiene ningun valor de retorno (void), y no esta recibiendo ningun parametro, cuando el metodo comienza a enviar o recibir parametros comenzamos con lo que es el paso de parametros. El paso de parametros se puede realizar en la misma clase o entre clases poniendo especial atención en el tipo de modificador de acceso en cada caso.

Supongamos que el metodo1 necesita recibir un valor de entero y asi mismo no es necesario que regrese ningun tipo de valor:

En este caso estamos recibien un valor en z para usarlo en nuestro metodo.

El otro caso es cuando necesitamos recibir un valor y regresar un valor de respuesta, el tipo de retorno que le asignemos a nuestro metodo debe ser del mismo tipo que retornemos dentro del cuerpo de metodo.

De esta manera se puede realizar un paso de parametros entre metodos de diversas clases o de la misma clase.

Felices trazos!

JAVA: Jerarquia Errores y Excepciones

JAVA: Array (Arreglos)

Los arreglos son estructuras de datos del mismo tipo.

Arreglos
int [] testScores; //declaración
testScores = new int [4] //construcción

Arreglos multidimencionales
int [][] rating = new int [3][]; //declaración y construcción
rating [0] = new int[2]; //ponemos otro arreglo en la posición 0 del arreglo

Declarar, construir e inicializar en una linea
int[] dots = {3,6,x,8}; //x debe ser un entero previamente declarado e inicializado
int [][]scores = {{5,2,4,7} , {9,2} , {3}};

Arreglo de objetos
Clase []cas = new Clase[3];
cas[0] = new Clase( );
Si la clase es una subclase que extiende de clase tambien se puede guardar en ese arreglo
ejemplo:
Car[ ]miscarros = {new Vocho( ), new Honda( ),new Ferrari( )};

Nota: Si el arreglo es declarado un tipo de interfaz, el arreglo de elementos puede referenciar a cualquier instancia de cualquier clase que implemente esa interfaz declarada.

Errores o Excepciones
NullPointerException .- cuando no existe la referencia a un objeto en el arreglo por lo cual el valor es null.
ArrayIndexoutofBounds Exception.- cuando tratas de accesar a una posición en un arreglo que no existe.

JAVA : Estructura de Datos abstracta llamada Pilas LIFO(Last in First out)

La idea de las pilas es muy sencilla, simplemente el nuevo objeto que ingresa es referido por final y enlaza al anterior que ocupada ese espacio.
Nuestro objeto Dato tendra la variable sig de tipo Dato y la variable x de tipo int, aunque realmente no importa el valor de x ya que no lo ordenara.
Ahora bien aqui estan los metodos, recuerda que es necesario tener la clase Dato con sus respectivas variables y metodos get/set, y tambien la clase Test Pilas donde vamos a estar en interacción con el usuario.

public class Pilas {
   private Dato finale;
   private Dato aux;   
   public void insertar(Dato dat){//metodo insertar
       if(finale==null){
          finale=dat;
          
       }else{
           dat.sig=finale;
           finale=dat;
       }   
   } 
   public Dato eliminar(){//metodo eliminar    
       if(finale==null){
           aux=null;
       }else{
        aux=finale;
        finale=aux.sig;            
       }
       return aux;
   }   
   public String imprimir(){//metodo imprimir
       String cad="";
       Dato aux=null;
       for(Dato p=finale;p!=null;aux=p,p=p.sig){           
           cad=cad+"\n"+p.getNum();          
       }
       return cad;
   }
}

JAVA : Estructura de Datos abstracta llamada Arbol. (Metodo Insertar y recorrido)

Los arboles son relativamente sencillos desde el punto de vista logico sin embargo todo comienza a ponerse interesante cuando pasas de los 15 valores. Nuestro objeto Dato debera contener un int x donde almacene el valor x (uh!), dos variables de tipo Dato( izq y der).
El funcionamiento del arbol es el siguiente: Este ingresa un objeto que tiene un valor x, ese valor x se posiciona en la variable raiz (que es tipo Dato ya que raiz hasta el momento era null) del arbol, posteriormente los demas objetos con valores x diferentes (mayores o menores) se iran acomodando de lado izq o der de nuestro objeto. (cada objeto tiene variable izq y der)
Los valores menores se iran a las variables izq y los valores mayores a la variable der.

Cada objeto a su vez tendra que realizar esta validación.Para insertar es necesario que nuestro metodo conozca si es mayor o menor, si es el primer objeto o si es uno de los ultimos de la rama.

Dato raiz;
   public void insertar(Dato dat){
       if(raiz==null){
          raiz=dat;
       }else{
           for(Dato p=raiz;p!=null;){
            if(dat.getNum()
             if(p.izq==null){
              p.izq=dat;
              break;
             }else
              p=p.izq;
            }else{
              if(p.der==null){
               p.der=dat;
               break;
              }else
               p=p.der;
            } 
            }
      }
    }

Cabe mencionar que estamos suponiendo que este metodo esta siendo insertado dentro de la clase(por eso que la variable raiz de tipo Dato la creamos fuera).
El metodo a su vez para eliminar tiene sus dificultades ya que si una rama contiene valores en sus variables izq o derecha esos valores no se pueden perder, sino que tienen que pasar a la rama anterior (el valor mayor) y el menor acomodarse en la rama izq libre del objeto anterior, asi mismo cuando deseamos eliminar el numero que esta en el objeto raiz.
Proximamente publicare el metodo eliminar, por lo mientras aqui esta el metodo recorrido, o impresion de los valores del arbol, este metodo utiliza la recursividad.

   public void recorrido(Dato p){
       if(p!=null){
            recorrido(p.izq);       
         System.out.println(p.getNum());
         recorrido(p.der);
        }
       }

JAVA: Estructura de Datos Abstracta llamada Cola
FIFO (First In, First Out)

La logica de este algoritmo es sencilla, comenzamos explicando la idea de lo que es una cola: cuando un objeto llega se le asigna la posiciòn inicio, los objetos siguentes en llegar (crearse), se asignaran al final de la cola y el primer objeto (inicio) referenciara a su vez al ultimo, o a el mismo, si solo existe el en la cola, de esta manera conforme llegan se van agregando a la cola.

Nuestra clase Dato cuenta con los siguientes atributos:
Dato sig e int x, sig de tipo Dato ya que guardara las referencias de los objetos de ese tipo e int de tipo entero por que almacenara el valor que insertemos a x. Basicamente con esto se construye la clase (metodos set y get de x) aunque se le pueden aumentar muchas mas cosas y ser utilizado de diversas maneras.
Para poder manejar el insertado de objetos de tipo Dato como sigue:

class ManejoDato{
Dato inicio;
public void insertar (Dato dat){
 if(inicio==null){
   inicio= dat;
   dat.sig= dat;
 }else{
   dat.sig = inicio.sig;
   inicio.sig = dat;
 }
}
public boolean eliminar(){
 if(inicio !=null){
   Dato p = inicio.sig;
    if(p==inicio){
      inicio=null;
    }else{
      for(p=inicio; p.sig!=inicio;p=p.sig);
      p.sig=inicio.sig;
      inicio=p;
    }
  return true;
 }else{
   return false;
 }
}
}

JAVA: Metodo de Inserción en 2 capas

La primer clase contiene nuestro modelo de negocios:

class Insercion{
private static int a[] ={5,3,2,4,1};
private int x=0,k=0, aux;
public void insercion1(){
for(int i=1;i aux = a[i];
k=i-1;
while (k>=0 && aux a[k+1]=a[k];
k--;
}
a[k+1]=aux;
}
}
public String getver(){
return (a[0]+" "+a[1]+" "+a[2]+" "+a[3]+" "+a[4]+" ");
}
}

Interfaz:

class TestInsercion{
public static void main (String args[]){
Insercion obj=new Insercion();
System.out.println(obj.getver());
obj.insercion1();
System.out.println(obj.getver());
System.out.println("Finalizando programa... ");
}
}

Estas clases cambia la posición de los valores de nuestro arreglo y los ordena, try it!!! Utilizando el logaritmo de inserción.