Blog del sitio: Tecnológico

Página: ()  1 ...  11  12  13  14  15  16  17  18  19  20  21  22  23  24  25  26  27  28 ...130   ()
Imagen de Miguel Angel Cano Dakin
de Miguel Angel Cano Dakin - domingo, 7 de septiembre de 2014, 11:49
Todo el mundo

Fecha:  01/09/2014                            Hora: 10:30

escritura y explicacion del profesor escritura y explicacion del estudiante

Para imprimer el dato que esta guardado en el objeto Fraccionario del Denominador
System.out .print(x.getDato.getDem());
El procedimiento anterior esta mal, porque este solo puede buscar objetos de tipo Objet y por tal motivo va a mostrar un error.
public class Nodo {
private Objet dato;
private Nodo sig;
public Objet getDato{
retur dato;
}}
Como getDatio es un metodo de tipo objet solo puede usar metodos de tipo objet.
Entonces la manera de mostrar el dato que nesesitamos es usando un casting de la siguiente forma:
System.out.print((Fracionario)(x.set.Dato).getDem);
Mediante este casting hacemos que el metodo de tipo Objet pueda usar el metodo de tipo Fraccionario.
La otra forma de hacerlo es:
Fraccionario f;
f=(Fraccionario)x.getDato();
System.out.print(f.getDem());
Otra forma de hacerlo para evitar hacer los casting es mediante las clases genericas:
public class Nodo <T>{
private T dato;
private Nodo sig;
public T getDato(){
retur dato;
}}
En este caso se agregan a las clase <> y en medio T que seria lo que representa el objeto, se cambia el atributo de dato y el metodo.
Y despues solo escribimos el codigo para imprimir el dato:
Nodo<Fraccionario> x=null;
x=new Nodo<>(new Fraccionario(1,3));
Si hay otro objeto de otra clase lo unico que se hace es cambiar el nombre de esta forma:
Nodo<estudiante>estudiante=null
si se quiere que el dato sea de tipo Objet
Nodo y=null;
la variable y se convierte de tipo objet

 

Hay que tener en cuenta que cuando los Nodos estan referenciando un objeto de otra clase distinta las formas de usar el objeto es con castings o usando clases genericas;
las clases genericas lo que hacen es que cuando se esta tratando de usar un metodo de otra clase, supone que el dato es de la clase que se esta tratando de usar y de esa forma no ha incompativilidad entre las clases a la que pertenese el objeto.
los metodos solo pueden usar metodos de las mismas clases, por ejemplo si un metodo de la clase Nodo intenta usar un metodo de otra clase, se va a presentar un error a menos que se utilize un casting o por medio de las clases genericas.

Lo que aprendi fue a como usar metodos de otras clases mediante la aplicacion e implementacion de castings y clases genericas..

 
Imagen de Luis Enrique Ayin Arias
de Luis Enrique Ayin Arias - domingo, 7 de septiembre de 2014, 11:01
Todo el mundo

22-08-2014

 

ESTRUCTURA ESTATICAS

  • arreglos
  • no cambia el espacio de memoria asignado
  • lista de datos contiguos
  • acceso rapido
  • acceso directo atra vez de indices
  • uso con cantidad de datos exactos o pocos

ESTRUCTURA DINAMICA

  • clases autoreferenciadas(nodos)
  • cambia de espacio de memoria asignado
  • lista de datos dispersos
  • acceso menos rapido
  • no hay acceso directo 
  • uso con volumen considerado de datos con operaciones de insercion y eliminacion

 

LISTAS ENLAZADAS :

Estructura de datos dinámica y lineal formada por un conjunto de nodos.

  • Uso y aplicaciones de forma general
  • Siempre hay una variable de referencia al primer nodo
  • Cada nodo esta compuesto por un atributo dato y una referencia al siguiente nodo.
  • En ultimo nodo el valor del atributo siguiente es “null” esto indica el final de la lista.

 

 

[ Modificado: domingo, 7 de septiembre de 2014, 11:01 ]
 
Imagen de Mauricio Jose Porras Gutierrez
de Mauricio Jose Porras Gutierrez - viernes, 5 de septiembre de 2014, 11:50
Todo el mundo

system.out.printl(x.getDato().getDen());
x.{getDato...setDato...getSig...setSig()} getDato().{equals()...toString()}
System.out.println(((fraccionario)(x.getDato())).getDen();
CLASE GENERICA
public class Nodo<T>
private T dato;
pirvate Nodo sig;
...
...
public T getDato(){
return dato;
}
...
}
Nodo <Fraccionario> x=null;
x=new Nodo<>(new Fraccionario(1,2));
...
...
Nodo<Estudiante>estudiantes=null;
Nodo<Integer>numeros= null;
Nodo y = null;
<Object>

System.out.println(x.getDato().getDen());
Fraccionario f=x.getDato();
System.out.println(f.getDen());

 

 
Imagen de Aldair De Jesus Blanco Segura
de Aldair De Jesus Blanco Segura - viernes, 5 de septiembre de 2014, 11:50
Todo el mundo

25/08/2014

en este clase vimos un abrebocas de lo que veremos en LISTAS ENLAZABLES, el profesor nosdio y nos hablo sobre las listas enlazadas!
vimos unas cuantas listas enlables , pero en la que mas nos dirigimos fue ala lista llamada NODO la cual me sorprendio mucho ya que la utilizaba con mucha frecuencia y no savia que era un NODO

 
Todo el mundo

http://kike2014.over-blog.com/preview/d5cb9e4a88176804ee41f86f29c82b3e6c0dc639

[ Modificado: lunes, 8 de septiembre de 2014, 01:07 ]
 
Todo el mundo

 

 

 

[ Modificado: martes, 2 de septiembre de 2014, 20:05 ]
 
Imagen de NEIFER ENRIQUE TORRES MARRUGO_12217002
de NEIFER ENRIQUE TORRES MARRUGO_12217002 - jueves, 28 de agosto de 2014, 22:12
Todo el mundo

25/08/2014

Public class nodo{

                Private int dato;

                Private nodo siguiente;

Public nodo (int dato){

                This.dato = dato;

                Siguiente = null;

 

 

Public class principal{

                Public static void main ( string [] org){

                                Nodo x = null;

                               X= new nodo(7);

 

 

LISTAS ENLAZADAS

 

 

Public class nodo{

                Private faccionario dato;

                Private nodo siguiente;

Public nodo (fraccionario dato){

                This.dato = dato;

                Siguiente null;

Public class principal{

                Public static void main ( string [] org){

                               Nodo x null;

                               X = new nodo ( new fraccionario());      

 

Public nodo {

Private object dato;

Private nodo siguiente;

Public nodo(object dato){

                This.dato =dato;

Siguiente = null;

 

}

 

Public class principal

                Public static void main( string [] org){

                               Nodo x = null;

                               X = new nodo (new estudiante());

                               Nodo y = null;

Nodo z = null;

Z = new nodo (7);

 
Imagen de Roberto de Jesús Morrinson Romero
de Roberto de Jesús Morrinson Romero - jueves, 28 de agosto de 2014, 20:02
Todo el mundo

 

 

 

 

Fe de erratas: el nombre correcto del modificador de acceso es public (con p minúscula).

 

 

 

 

[ Modificado: domingo, 31 de agosto de 2014, 19:37 ]
 
Imagen de Miguel Angel Cano Dakin
de Miguel Angel Cano Dakin - jueves, 28 de agosto de 2014, 16:44
Todo el mundo

Fecha: 25/08/2014                 Hora: 10:30 Am

Escritura e investigacion del profesor Escritura e investigacion del estudiante

Para la representacion codificada de la imagen anterior se empiesa haciendo la clase nodo y despues la clase prinsipal. de la siguiente forma:
public class Nodo{
private int dato;
private Nodo siguiente;
----------------
}
public class Prinsipal{
public static void main (String [] arg){
Nodo x=new;
x=new Nodo(7);
------
-----
}}

En este el codigo en la clase Nodo cambia ya que este esta referenciando objetos de clases fracionario. como se ve a continuacion:
public class Nodo{
private Fraccionario dato;
private Nodo siguiente;
public Nodo (Fraccionario dato){
this.dato=dato;
sig=null;
}
----------------
}
public class Prinsipal{
public static void main(String[] arg){
Nodo x=new;
x=new Nodo(new Fraccionario());
}}

La clase Nodo cambia en este caso, ya que en ese caso se tienen que referenciar objetos de otra clase, en este caso la clase Estudiante, y para que se de esto se aplica el uso de la clase object la cual puede referenciar objetos de cualquier clase.
public class Nodo{
private Object dato;
private Nodo siguiente;
public Nodo(Object dato){
this.dato=dato;
siguiente=new;
}}
public class Prinsipal{
public static void main(String [] arg){
Nodo x=new;
x=new Nodo(new Estudiante);
Nodo y=new;
y=new Nodo(new Fraccionario);
Nodo z=new;
z=new Nodo(7);
}}

 

hay que tener en cuenta que las listas enlasadas trabajan con la aplicacion de nodos que tienen variables propias y estos nodos pueden referenciar a variables y objetos de diferentes clases, con la aplicacion de los metodos y variables indicadas.
por ejemplo Object que es una clase que puede referenciar a cualquier objeto no importa que sea de una clase diferente, y esto ayuda a que los Nodos pueden referenciar objetos de diferentes clases.
equal es un metodo de la clase objet, el cual permite poder comparar los objetos, ademas objet permite almacenar la direccion de cualquier objeto.

Lo que aprendi fue a verificar y orientar las listas enlazadas y los Nodos y la forma de aplicar los metodos y la clase Objet en este y de esta forma aprender el manejo de los objetos.

 

 
Imagen de DAMASO SALGADO CASSIANI
de DAMASO SALGADO CASSIANI - jueves, 28 de agosto de 2014, 16:42
Todo el mundo

Escritura y explicacion del profesor

A continuacion veran ejemplos de listas enlazadas:

Parte 1:

public clas Nodo{

private int dato;

private nodo sig;

 

public Nodo(int dato){

this.dato=dato;

sig=null;

}

}

 

public class principal{

public static void main(String[] arg){

Nodo x=null;

x=new Nodo(7);

}

}

 

parte 2:

 

 

public class Nodo{

private Fraccionario dato;

private Nodo sig;

public Nodo(Fraccionario dato){

this.dato=dato;

sig=null;

}

}

 

public class principal{

public static void main(String[] arg){

Nodo x=null;

x=new Nodo(new Fraccionario());

}

 

Parte 3:

 

public class Nodo{

private Object dato;

private Nodo sig;

 

public Nodo(Object dato){

this.dato=dato;

sig=null;

}

}

 

public class Principal{

public static void main(String[] arg){

Nodo x=null();

x=new Nodo(new estudiante());

 

 

 

 

 

 

 

 

 

 ESCRITURA Y EXPLICACION DEL ESTUDIANTE

 

Lo que hicimos en esta entrada al blog fue tres ejercicios sencillos para ir entrando en el tema de listas enlazadas en la primera parte creamos una clase nodo la cual nos va a tener declarada la direccion(sig) de los nodos y el dato. a dicha clase le creamos sus contructores. luego de esto creamos la clase principal en la creamos el objeto(x) que se encarga de recorrer los nodos como pueden ver,  en la parte 2 y 3 hacemos lo mismo la unica diferencia en esta es que como pueden ver en los nodos no guardamos datos en si, si no que ponemos un objeto que guarda la direccion de la clase y por eso pueden ver que a diferencia de la parte uno donde dijimos: x=new Nodo(7); en la parte dos o tres pusimos x=new Nodo(new Fraccionario()); o x=new Nodo(new estudiante()); como pusimos en la parte 3 de este blog.

¿Que aprendi?

Con este tema pudimos empezar a practicar y ganar experiencia a la hora de utilizar o implementar listas enlazada lo que nos permite ganar confianza con este tema.

 

 

 

 
Página: ()  1 ...  11  12  13  14  15  16  17  18  19  20  21  22  23  24  25  26  27  28 ...130   ()