Fecha y hora actual: Jueves 17 Ene 2019 04:13
Índice del Foro

Foros de programación informática, diseño gráfico y Web

En esta comunidad intentaremos dar soporte de programación a todos los niveles, desde principiantes a profesionales de la informática, desarrollo de programas, programación web y mucho más.

Curso VB .NET - Tema 1.28 - Datos, Java

Responder al Tema

Índice del Foro > Visual Basic .NET > Curso VB .NET - Tema 1.28 - Datos, Java

Autor Mensaje
Tesis
Administrador


Registrado: 04 Mar 2007
Mensajes: 3200
Ubicación: Valencia - España

Mensaje Publicado: Martes 16 Jun 2009 09:15

Título del mensaje: Curso VB .NET - Tema 1.28 - Datos, Java

Responder citando

Curso de programación en .NET - Tema 1.28 - Datos, Java.


1. Datos, Java.
1.1 Objetivos del tema.

Veamos los datos ahora desde el punto de vista de Java.
Entrar en los tipos de usuario, en Java se agrupan bajo una clase.

1.2 Introducción.
Hecha la introducción a nivel general en el tema anterior, ahora tenemos que profundizar sobre los datos en Java, los tipos básicos están ya comentados a principio del curso, toca ahora ampliar el uso de los mismos y de sus estructuras, formas de almacenamiento y su acceso desde Java.

1.3 Tipos de datos.
Ya hemos mencionado en un sin fin de ocasiones que arrancamos de dos tipos básicos, y que estos después se amplían en cada uno de los lenguajes de programación existentes.

En los datos numéricos, en función del lenguaje utilizado, encontraremos una mayor o menor gama de variaciones, pero básicamente serán de dos tipos, los que tienen decimales, -single, double, real -, y los que no admiten decimales, integer.
Código:

                                 Bytes    Máximo                   Mínimo
Byte números                         1    255                       0
Booleano                             2    True                      False
Integer rangos                       2    32,767                    -32,768
Long Entero largo                    4    2,147,483,647             -2,147,483,648
Single precisión números (positivos) 4    3.402823E+38              1.401298E-45
Single precisión números(negativos)  4    -1.401298E-45             -3.402823E+38
Double precisión números(positivos)  8    1.797693134862315D+308    4.940656458412465D-324
Double precisión números (negativos) 8    -4.940656458412465D-324   -1.797693134862315D+308

Pero esto es lo que podríamos llamar tipos de datos estándar o del lenguaje.

1.4 Declaración.
Los datos a lo largo de un programa pueden cambiar o permanecer inalterables.

Si cambian, o puede ser que cambien, la utilización del mismo se hará mediante el uso de variables.
Si el dato va permanecer inalterable a lo largo del programa, podemos utilizar una constante.
Las constantes y las variables han de declararse antes de utilizarse.

La declaración de una constante es como sigue:
Código:
final static double PI = 3,1416


Para declarar constantes se utiliza el calificador final y/o static

Una vez declarada una constante, por definición no se le puede asignar otro valor. Por ello, cuando se declara una
constante debe ser iniciada con un valor.

Las variables se pueden declarar en cualquier bloque de código, dentro de llaves.
La declaración es siempre indicando primero el tipo de la variable y después el nombre.
Código:
int precio_venta_publico;


Podrá o no inicializarse.
Código:
int precio_venta_publico = 0;

Delante del tipo de la variable, también se puede indicar el ámbito de disponibilidad de la misma, indicando delante public o private.
Código:
private int precio_venta_publico = 0;


En caso de declarar un objeto en lugar de una variable, podemos hacer
Código:
Clase Objeto;


En cuyo caso el objeto queda con un valor nulo.
O bien podemos declarar e inicializar el objeto directamente.
Hay que tener presente que la inicialización dependerá siempre de cómo esté diseñada la clase.
Código:
Clase Objeto = new Clase (50,60);


1.5 Conversión de tipos.
En algunos casos, es necesario convertir una variable de un tipo en otro. Por ejemplo, puede que se necesite pasar una variable int a un método que acepte solamente variables float. Este proceso se denomina conversión de tipo.

Para convertir el tipo de una variable, basta escribir el tipo de destino entre paréntesis inmediatamente delante del identificador de la variable. El siguiente ejemplo muestra cómo el valor devuelto por un método, de tipo int, puede convertirse en float:
Código:
float f = (float) returnInt();


Debe tenerse cuidado cuando se conviertan tipos, ya que es posible que se produzca una pérdida de información.
Por ejemplo, cuando se convierte una variable long de 64 bits en una variable int de 32 bits, el compilador omite los 32 bits de orden superior de la variable long.

Si, en el momento de realizar la conversión de tipo, el valor de la variable long ocupase más de 32 bits, en el proceso de conversión se asignaría un valor incorrecto a la variable int.
La regla general es que el tipo convertido debe tener como mínimo un tamaño igual al tipo original.

1.6 Nombres, estructuras.
Con la riqueza del castellano, no tiene sentido complicarse la vida a la hora de asignar el nombre a una variable, por lo tanto, no utilicemos las palabras propias del lenguaje, y no se pueden utilizar los símbolos especiales como los operadores, etc.

Palabras cortas y si deseamos dos las unimos con el guión bajo.
Código:
int precio_venta_publico = 0;


Pero mejor ...
Código:
int pre_vta_pub = 0;


1.7 Tipos de estructuras.
En un programa los datos pueden tener distintas formas.

  • Constante. Un dato que permanece invariable a lo largo del programa.
  • Variable. Un dato que cambia de valor a lo largo del programa.
  • Array. Es una estructura estática de datos, una agrupación de datos, del mismo tipo, los cuales es posible referenciar con un único nombre y diferenciarlos a través de un índice.
  • Colecciones. Es una estructura dinámica de datos, similar a un array. Collections.
  • Listas. Existe una clase especializada en su gestión, List.


1.8 Ambito de las variables.
En términos generales las variables se consideran locales y globales, o públicas y privadas, después aparece las características de cada lenguaje de programación.

En Java las variables se consideran privadas o locales, y se definen dentro de un método, por lo que al finalizar el método desaparece la variable, se destruye.

Código:
double dato1, dato2, resultado;


Se pueden declarar a nivel de la clase, acompañadas de la palabra public.
Código:
public class Clase {
public double dat1 = 1000;


Y entonces podrá ser utilizada por el objeto que se cree de dicha clase.
Código:
.. / ..
Objeto Clase = new Clase();
Objeto.dat1 = 23;
.. / ..


Se pueden declarar a nivel de la clase, acompañadas de la palabra private.
Código:
public class Clase {
private double dat1 = 1000;


Se pueden declarar dentro de una sentencia If, y al finalizar ésta sentencia finaliza su posibilidad de usarse.
Código:
if (condición)
{
  int variable = 5;
  instrucción;
  ... / ...
  instrucción;
}


En general se pueden declarar dentro de un bloque de código, entendiendo por bloque lo comprendido entre que se abre y se cierran las llaves "{ }"

1.9 Tipos de usuario.
En Java, no existen los tipos de usuario, pues en realidad todos los tipos de datos que existen son definiciones de datos que pertenecen a una clase que los gestiona.
Sin embargo en programación la existencia del tipo de datos definido por el usuario es imprescindible.

Pero siguiendo con la filosofía que Java aplica en el lenguaje, en realidad lo que Java te índica es que todo está relacionado con objetos, por lo que la solución al tipo de usuario es clara, crear un objeto.
Veamos como crear un objeto equivalente al ejemplo anterior.

Este es el código de la clase, como se puede observar no hay código, solo datos, y no hay métodos.
Código:
package tema_28;
public class ClaseTipoUsuario
{
  public java.lang.String Marca;
  public int Pulgadas ;
  public java.lang.String Resolucion ;
  public java.lang.String Velocidad ;
 
  public ClaseTipoUsuario()
  {
  }
}


Y en el programa su utilización queda como sigue:
Código:
package tema_28;
public class Main
{
  public static void main(String[] args)
  {
    ClaseTipoUsuario Monitor = new ClaseTipoUsuario( );
    Monitor.Marca ="Marca del monitor";
    Monitor.Resolucion ="1024 x 768";
    Monitor.Velocidad = "160 Hz Vert., 70 kHz. Horiz.";
    Monitor.Pulgadas =17;
    System.out.println( Monitor.Marca);
    System.out.println( Monitor.Pulgadas);
    System.out.println( Monitor.Resolucion);
    System.out.println( Monitor.Velocidad);
  }
}


1.10 Tipos de usuario anidados.
Pero habitualmente en las estructuras de datos es normal que un tipo de usuario albergue a otros tipos de usuario, o que los tipos se aniden unos a otros.

Un tipo anidado se puede resolver creando una clase que contenga aquellos datos que nos interesen
Código:
package tema_28;
public class ClaseTipoUsuarioAnidada
{
  public double compras;
  public double ventas;
  public double devoluciones;
  public double abonos;
 
  public ClaseTipoUsuarioAnidada()
  {
  }
}


Y en la clase principal se hereda la estructura de ésta clase.
Código:
package tema_28;
public class ClaseTipoUsuario extends ClaseTipoUsuarioAnidada
{
  public int Codigo;
  public java.lang.String nombre ;
  public java.lang.String domic ;
 
  public ClaseTipoUsuario()
  {
  }
}


Para luego en el main desarrollar el siguiente código:
Código:
ClaseTipoUsuario Cliente = new ClaseTipoUsuario( );
Cliente.Codigo = 5;
Cliente.domic = "Rue del Percebe";
Cliente.nombre = "Mortadelo";
Cliente.compras = 123;
Cliente.ventas = 234;
Cliente.abonos = 345;
Cliente.devoluciones = 456;
System.out.println( Cliente.Codigo);
System.out.println( Cliente.nombre);
System.out.println( Cliente.compras);
System.out.println( Cliente.devoluciones);


Siendo válida la estructura anterior, podemos mejorarla cambiando la definición de la misma.
Código:
package tema_28;
public class ClaseTipoUsuario
{
  public ClaseTipoUsuarioAnidada Importes = new ClaseTipoUsuarioAnidada();
  public int Codigo;
  public java.lang.String nombre ;
  public java.lang.String domic ;
 
  public ClaseTipoUsuario()
  {
  }
}


Quedando su utilización como sigue.
Código:
ClaseTipoUsuario Cliente = new ClaseTipoUsuario( );
Cliente.Codigo = 5;
Cliente.domic = "Rue del Percebe";
Cliente.nombre = "Mortadelo";
Cliente.Importes.compras = 123;
Cliente.Importes.ventas = 234;
Cliente.Importes.abonos = 345;
Cliente.Importes.devoluciones = 456;
System.out.println( Cliente.Codigo);
System.out.println( Cliente.nombre);
System.out.println( Cliente.Importes.compras);
System.out.println( Cliente.Importes.devoluciones);


Revisemos los ejemplos y veamos que el cambio estriba en que en lugar de heredar la clase
Código:
public class ClaseTipoUsuario extends ClaseTipoUsuarioAnidada {


que es lo que se ha hecho en la primera versión, lo que se hace es declarar un objeto en la clase de tipo de usuario llamado Importes del tipo, de la clase, ClaseTipoUsuarioAnidada.
Código:
public ClaseTipoUsuarioAnidada Importes = new ClaseTipoUsuarioAnidada();


El utilizar un sistema u otro, depende de muchas cosas, es cuestión de gustos y de necesidades en las estructuras a utilizar.
Pero éste no es su uso principal.

Una de las más interesantes es declarar una estructura en forma de array, se verán próximamente, ya que por ejemplo nos podría interesar que dichos datos.
Código:
public double compras;
public double ventas;
public double devoluciones;
public double abonos;


hagan referencia a los datos de todo un año, y para ello su utilización podemos enfocarla como sigue.
Código:
package tema_26;
public class ClaseVentasMes
{
  public double compras=0;
  public double ventas=0;
  public double devoluciones=0;
  public double abonos=0;
}


La clase ClaseVentasMes sería la estructura de datos de un mes del año, sería una estructura básica.
Código:
public class ClaseCliente
{
  int Codigo;
  java.lang.String nombre ;
  java.lang.String domic ;
  ClaseVentasMes VentasMes[] = new ClaseVentasMes[12];
  public ClaseCliente ()
  {
    int x;
    x=0;
    while (x < VentasMes.length)
    {
      VentasMes[x] = new ClaseVentasMes();
      ++x;
    }
  }
}


La clase ClaseCliente, sería la estructura de datos para un cliente, en la que definiríamos todos aquellos datos que necesitemos para el mismo, pero en ella haríamos referencia a la clase ClaseVentasMes
Código:
ClaseVentasMes VentasMes[] = new ClaseVentasMes[12];


creando una estructura en forma de array de doce elementos.

Aquí hay que tener presente, que para que no se produzca error en su inicialización, en la inicialización de ésta clase hemos de referenciar cada uno de los elementos del vector.
Código:
while (x < VentasMes.length)
{
  VentasMes[x] = new ClaseVentasMes();
  ++x;
}


Evidentemente además de cualquier otra actuación que podamos necesitar.
Finalizada la parte de definición, su utilización quedaría como sigue.
Código:
ClaseCliente Cliente = new ClaseCliente();


Y solo quedaría explotarla, que para probar puede ser suficiente lo siguiente:
Código:
package tema_28;
public class Main
{
  public static void main(String[] args)
  {
    ClaseCliente Cliente = new ClaseCliente();
    Cliente.Codigo= 5;
    Cliente.domic="Rue del Percebe";
    Cliente.nombre = "Mortadelo";
    Cliente.VentasMes[0].abonos = 1;
    Cliente.VentasMes[0].compras = 1;
    Cliente.VentasMes[0].devoluciones = 34;
    Cliente.VentasMes[1].abonos = 2;
    Cliente.VentasMes[1].compras = 2;
    Cliente.VentasMes[1].devoluciones = 345;
    System.out.println(Cliente.Codigo);
    System.out.println(Cliente.nombre);
    System.out.println(Cliente.VentasMes[0].abonos);
    System.out.println(Cliente.VentasMes[0].compras);
    System.out.println(Cliente.VentasMes[1].abonos);
    System.out.println(Cliente.VentasMes[1].compras);
  }
}


Y de ésta forma podemos acceder a estructuras de datos que pueden ir ganando en complejidad a medida que se necesite.

1.11 Ventajas.
No tiene sentido volver a comentar lo mismo, es un tema innegable, y se vienen utilizando desde hace mucho tiempo, y más a medida que los sistemas han ido mejorando en prestaciones y capacidades.
Código:
Cliente.VentasMes[0].abonos = 1;
Cliente.VentasMes[0].compras = 1;
Cliente.VentasMes[0].devoluciones = 34;


Esta clara la potencialidad del uso adecuado de dichas estructuras de datos, solo queda el uso de nuestra imaginación para sacarle el máximo partido.

1.12 Ejercicios propuestos.
1. Defina un tipo de usuario que le permita utilizar todos los datos relacionados con las características de un monitor.
2. Defina varios tipos de usuario de tal forma que le permita crear una estructura de datos anidada, es decir que al menos uno de los tipos de usuario esté en el interior de otro tipo o estructura.
Se trata traducir la solución de los ejercicios del tema anterior a Java.

1.13 Solución a los ejercicios propuestos.
1. Defina un tipo de usuario que le permita utilizar todos los datos relacionados con las características de un monitor.
Código:
public class ClaseTipoUsuario
{
  public java.lang.String Marca;
  public int Pulgadas ;
  public java.lang.String Resolucion ;
  public java.lang.String Velocidad ;
 
  public ClaseTipoUsuario()
  {
  }
}


2. Defina varios tipos de usuario de tal forma que le permita crear una estructura de datos anidada, es decir que al menos uno de los tipos de usuario esté en el interior de otro tipo o estructura.
Código:
package tema_28;
class Muebles
{
  public java.lang.String Color;
  public java.lang.String Construido ;
  public java.lang.String Uso ;
  public java.lang.String Fabricante;
 
  public Muebles()
  {
  }
}

class Sillas
{
  public Muebles Caracteristicas = new Muebles();
  public double Precio ;
  public double Cantidad ;
 
  public Sillas()
  {
  }
}

class Camas
{
  public Muebles Caracteristicas = new Muebles();
  public java.lang.String Medidas;
  public double Precio ;
  public double Cantidad ;
 
  public Camas()
  {
  }
}


Su uso en el main quedaría:
Código:
public class Main
{
  public static void main(String[] args)
  {
    Camas Cama = new Camas();
    Cama.Caracteristicas.Color="Marron";
    .. / ..
  }
}


La definición de las clases podría ser como se ha visto o bien:
Código:
class Sillas
{
  public Muebles Caracteristicas = new Muebles();
  public double Precio ;
  public double Cantidad ;
 
  public Sillas()
  {
  }
}




Autor del curso: Casiopea


Normas del foro
Aprende a postear correctamente usando las etiquetas
Volver arriba
Ver perfil del usuario Enviar mensaje privado
Responder al Tema
Mostrar mensajes anteriores:   
Ir a:  
Todas las horas están en GMT + 2 Horas

Temas relacionados

Tema Autor Foros Respuestas Publicado
El foro no contiene ningún mensaje nuevo

AYUDA CON LOGEO Y BASE DE DATOS

gonzaloramirez PHP 1 Domingo 28 Oct 2018 03:29 Ver último mensaje
El foro no contiene ningún mensaje nuevo

Base Datos Access Problemas Conexion/Reporte

ce_1187@hotmail.com Visual Basic .NET 0 Jueves 27 Sep 2018 22:31 Ver último mensaje
El foro no contiene ningún mensaje nuevo

Ayuda con TestNG Parametrico en java netbeans

baltigo Java 0 Sábado 30 Jun 2018 01:37 Ver último mensaje
El foro no contiene ningún mensaje nuevo

Cursos de programacion y base de datos

Alexweb ASP, ASP.NET 1 Jueves 31 May 2018 16:59 Ver último mensaje
El foro no contiene ningún mensaje nuevo

Publicar Aplicación web JAVA en tomcat

Irvin Java Web 1 Viernes 13 Oct 2017 17:54 Ver último mensaje
Panel de Control
No puede crear mensajes, No puede responder temas, No puede editar sus mensajes, No puede borrar sus mensajes, No puede votar en encuestas,