Fecha y hora actual: Jueves 17 Ene 2019 04:47
Í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.14 - Clases, datos - Java

Responder al Tema

Índice del Foro > Visual Basic .NET > Curso VB .NET - Tema 1.14 - Clases, datos - Java

Autor Mensaje
Tesis
Administrador


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

Mensaje Publicado: Viernes 23 Ene 2009 13:53

Título del mensaje: Curso VB .NET - Tema 1.14 - Clases, datos - Java

Responder citando

Curso de programación VB .NET - Tema 1.14 - Clases, datos - Java

1. Clases.
1.1 Objetivos del tema.
Se han explicado los conceptos imprescindibles de una clase, métodos y propiedades, ahora tenemos que aplicarlos en este caso en Java.

1.2 Introducción.
Las clases son el molde a partir del cual obtenemos el objeto en nuestro programa, y el objeto es en realidad el que tiene el protagonismo de la acción, la clase es solo el molde.

Vamos a ver como aplicar los conceptos vistos con anterioridad en Java.

1.3 Crear la clase.
Elegimos File > New Project y seleccionamos Java application de consola.



Esto nos dejará la pantalla como sigue, pero con algunas líneas más de comentarios que se han quitado

Código:
package ejemplos;
 public class Main
 {
   public static void main(String[] args)
  {
  }
 }


Después hemos de añadir la clase, File > New File y seleccionamos Java Class, y después en la ventana siguiente indicamos el nombre de la clase.



La podemos dejar con el nombre que tiene, o cambiarlo, nosotros la llamaremos ejemplo.

Código:
package ejemplos;
 public class Ejemplo
 {
 }


Y ahora a utilizarla.

1.4 El objeto.
Primero creemos el objeto.
Nuestra clase ahora es así.

Código:
package ejemplos;
 public class Ejemplo
 {
 }


Ahora creamos un objeto de esa clase, en el Main.

Código:
Ejemplo Objeto;


Si ahora escribimos en nuestro programa

Código:
Objeto.


Si vemos la imagen, ese es el resultado, nos índica que es una clase, pero solo vemos los métodos estándar de todas las clases.



1.5 Los datos.
En Java, los datos que usemos como propiedades, se denominan variables miembro.

Hemos comentado que eran de dos tipos

    Internos
    Externos


Veamos como definir los datos internos en la clase, es decir los que no se ven en el exterior, variables.

Código:
package ejemplos;
 public class Ejemplo
 {
   private int Dato;
 }


Si ahora escribimos en nuestro programa, en el Main.

Código:
Ejemplo Objeto;
Objeto.


Si vemos la imagen, ese es el resultado, son los métodos estándar de cualquier objeto.



Exactamente lo mismo que antes, como los datos son internos, private, no se ven fuera de la clase.

Ahora externos, o sea, propiedades.

Código:
package ejemplos;
 public class Ejemplo
 {
   int Dato;
 }


Si ahora escribimos en nuestro programa
Código:

Ejemplo Objeto;
Objeto.


Si vemos la imagen, ese es el resultado, son los métodos estándar de cualquier objeto, pero ahora aparece nuestra propiedad, o variable, el dato externo.



En Java, cuando una variable no se indica que se considera privada, por defecto se considera pública, por lo que hay que tener presente cuando declaramos una variable que si no deseamos que sea utilizada fuera de la clase, hay que acompañarla de la palabra private.

Código:
private int Dato;


1.6 Creemos un objeto.
El siguiente paso es crear un objeto de esta clase, aunque ya lo hemos hecho, pero de forma más avanzada.

Código:
Ejemplo Objeto;


Observar que esa es la sintaxis utilizada anteriormente, y no generaba errores, pues no se había hecho uso del objeto, pero cuando hay que avanzar en su uso, no es suficiente declarar, si no que hay que inicializar el mismo.

Código:
Ejemplo Objeto = new Ejemplo();


O bien, declarar y después inicializar más adelante.

Código:
Ejemplo Objeto;
.. / ..
Objeto = new Ejemplo();


Y ahora asignemos algo al dato externo para probarlo.

Código:
package ejemplos;
 public class Main
 {
   public static void main(String[] args)
   {
     Ejemplo Objeto;
     Objeto = new Ejemplo();
     Objeto.Dato = "Contenido de la propiedad";
     System.out.println(Objeto.Dato);
   }
 }


Este sería el resultado.

Código:
init:
deps-jar:
compile:
run:
Contenido de la propiedad
BUILD SUCCESSFUL (total time: 0 seconds)


1.7 Inicializar el objeto.
Para poder utilizar el objeto que hemos creado, éste ha de inicializarse, para ello se utiliza el constructor de la clase.

Tiene el mismo nombre que la clase, al contrario que en otros lenguajes que va precedido de la palabra New, en Java su característica o identificativo es el coincidir en el nombre con el de la clase.

Código:
public class Ejemplo
{
   // Constructor de la clase
   public Ejemplo()
   {
   }
} // fin de la clase


Existe también la posibilidad de escribir una parte de inicialización de código que solo se ejecuta la primera vez que se usa la clase, y que sirve para poder inicializar en esa zona las variables que sea necesario.

Código:
static
{
  System.out.println("Creación static");
  System.out.println("Solo una vez");
}


Si colocamos el ejemplo anterior en una clase y creamos dos objetos de la misma, podremos comprobar que el texto solo aparece una vez, no dos, para comprobarlo ejecutamos el siguiente ejemplo.

Código:
package ejemplos;
 public class Main
 {
   public static void main(String[] args)
   {
      Ejemplo Objeto;
      Ejemplo OtroObjeto = new Ejemplo();
      Objeto = new Ejemplo();
      Objeto.Dato = "Contenido de la propiedad";
      System.out.println(Objeto.Dato);
   }
 }


Y el resultado es el que sigue:

Código:
init:
deps-jar:
Compiling 1 source file to
compile:
run:
Creación static
Solo una vez
Contenido de la propiedad
BUILD SUCCESSFUL (total time: 0 seconds)


La misión del constructor no es solo la de asumir los valores que se reciben en el momento de crear el objeto, si no que también se puede hacer en ese momento el control de los mismos.

Código:
package ejemplos;
 public class Ejemplo
 {
   private String DatoInterno;
   private int OtroInterno;
   String DatoExterno = "Valor por defecto";
   public Ejemplo(String dato) // constructor
   {
     if (dato != "")
     {
       DatoExterno = dato;
     }
    } 
  }


En el ejemplo se obliga a que el dato recibido sea distinto de nulo para asignarlo a la variable de la clase.

La declaración del constructor como public sin argumentos permite la creación de objetos sin la utilización de datos, esto no siempre puede ser práctico o cómodo.

Si en lugar de declarar el constructor como public lo declaramos como private, se impide que se generen instancias de un objeto sin que estos tengan los valores que se reclamen como adecuados en la sobrecarga correspondiente.

Código:
// Constructor de la clase private, impide que se haga sin argumentos.
private Ejemplo()
{
}


Con esta declaración, la ejecución de estas dos líneas de código no es posible.

Código:
Ejemplo OtroObjeto = new Ejemplo();
Objeto = new Ejemplo();


En este ejemplo al declarar como private el constructor anterior, la declaración de un objeto de ésta clase obliga a que lleve los dos datos que se piden en la definición del ejemplo anterior.

Código:
public Ejemplo("Algún valor") // constructor


Explicado de otra forma, así se impide que un objeto se cree sin pasar por el control del constructor correspondiente, ya que al declararse como private, éste queda bloqueado, anulado o como deseemos decirlo, y siempre se ejecuta el declarado por nosotros como public.

1.8 Cómo gestionar las propiedades, los datos.
Disponemos de un dato, una propiedad que el usuario puede utilizar, y a nosotros nos permite obtener datos para el funcionamiento del objeto.

Podemos gestionar la obtención de datos de varias formas, podemos:

    Obtener datos en la creación del objeto
    Asignar controladamente los datos
    Asignar sin control previo los datos


1.8.1 Obtener datos en la creación del objeto.
Los objetos tienen propiedades, en Java variables miembro, por lo tanto vamos a añadir dos propiedades a la clase.

Cuando se crea una instancia de un objeto, se ejecuta de forma predeterminada el constructor, en Java es el método que tiene el mismo nombre que la clase, tema a parte es que lo hayamos escrito o no.

En ese método nosotros podemos reclamar la inclusión de aquellos datos que creamos oportunos, y en ese mismo momento validarlos.

Cuando se crea una instancia de un objeto, se ejecuta de forma predeterminada el constructor de la clase, tema a parte es que lo hayamos escrito o no.

En ese método nosotros podemos reclamar la inclusión de aquellos datos que creamos oportunos, y en ese mismo momento validarlos.

Código:
package ejemplos;
public class Ejemplo
{
   private String DatoInterno;
   private int OtroInterno;
   String DatoExterno;
   public Ejemplo(String dato) // constructor
   {
     DatoExterno = dato;
   }
}


Si añadimos el constructor a la clase, tal como esta en el ejemplo superior, en el programa habrá que hacer el siguiente cambio,

Código:
Objeto = new Ejemplo("Contenido de la propiedad");


para evitar el error de sintaxis que podemos observar en la imagen, ya que no se ha introducido el valor que solicitamos en el constructor.



Probemos ahora el programa modificado, el programa principal es el que sigue:

Código:
package ejemplos;
public class Main
{
 public static void main(String[] args)
 {
   Ejemplo Objeto;
   Objeto = new Ejemplo("Contenido de la propiedad");
   System.out.println(Objeto.DatoExterno);
 }
}


Ahora si que funciona, y este sería el resultado.

Código:
init:
deps-jar:
Compiling 1 source file to
compile:
run:
Contenido de la propiedad
BUILD SUCCESSFUL (total time: 0 seconds)


Fijémonos en que a la propiedad DatoExterno le hemos asignado el valor obtenido en el constructor.

Además no se ha realizado ningún control sobre ese dato.

Es conveniente que la propiedad esté inicializada a un valor por defecto para evitar posibles problemas de valores incorrectos o inadecuados.

Código:
String DatoExterno = "Valor por defecto";


De la misma forma que se ha recogido los datos sin control, se hubiera podido escribir lo siguiente:

Código:
public Ejemplo(String dato) // constructor
{
 if (dato != "")
 {
   DatoExterno = dato;
 }
}


Es decir controlar que el dato no sea nulo.

De tal forma que si hubiera escrito en el principal

Código:
Objeto = new Ejemplo("");


El resultado de la ejecución hubiera sido:

Código:
init:
deps-jar:
Compiling 1 source file to compile:
run:
Valor por defecto
BUILD SUCCESSFUL (total time: 0 seconds)


1.8.2 Asignar controladamente los datos.
En Java la asignación de datos de forma controlada se realiza a través de un método que escribimos al efecto.

De esa forma a la variable interna que representa a la propiedad le asignamos el dato a través de la ejecución del código escrito en el interior del método.

Al igual que en el caso anterior, conviene que para evitar los casos de datos inadecuados la variable esté inicializada a un valor conveniente.

Código:
private String DatoInterno = "Valor por defecto";


Visto por otro lado, el dato que representa en si una propiedad, está compuesto por dos elementos, o de dos partes:

    La propiedad que es la parte visible.
    La variable interna de la clase, que está oculta.


La captura de los datos es como sigue:

Código:
public void Propiedad(String dato )
{
  if (dato > 0)
  {
    DatoInterno = dato;
  }
} // fin del método


Analicemos la sintaxis de la línea.

Código:
public void Propiedad(String dato )


Public indica que es un elemento visible fuera de la clase.

Void que no tiene que devolver datos, es un método que usamos para una propiedad.

Lo demás ya es el nombre del método para la propiedad y el valor recibido con su tipo.

En el interior se coloca el código adecuado al control que deseamos realizar.

En su utilización hemos de tener presente que el método lo que hace es asignar internamente el dato a una variable, si es que el dato es correcto.

Código:
private String DatoInterno;


Y para cargar los datos en la misma, escribimos éste código:

Código:
public void Dato1(String dato )
{
  if (dato > 0)
  {
    DatoInterno = dato;
  }
} // fin del método


Este código que está integrado en la clase, permite controlar el valor que se asigna a la propiedad, variable miembro, y si no es adecuado rechazarlo, recordemos la conveniencia de inicializar la variable.

1.8.3 Asignar sin control previo los datos.
La asignación sin control de los datos puede realizarse tanto en la propiedad, como en la variable.

En el método podemos observar que hemos eliminado el código de validación, y que solo queda la asignación:

Código:
DatoInterno = dato;


La propiedad quedaría pues, de esta forma:

Código:
public void Dato1(String dato )
{
  DatoInterno = dato;
}


La otra posibilidad es la de declarar como variable pública la variable miembro, la propiedad, el dato a utilizar y el usuario puede asignar valores de forma libre.

Código:
public String DatoExterno = "Valor por defecto"; // público


Para posteriormente hacer uso de ella, pero sin la posibilidad de efectuar el control del valor de la misma.

Código:
// Le asignamos valores a la propiedad pública
Objeto.DatoExterno = "Valor en el programa"; // Público


Con todo lo mencionado anteriormente la clase del ejemplo quedará como figura a continuación.

Código:
package ejemplos;
public class Ejemplo
{
  private String DatoInterno = "Valor por defecto Dato Interno";
  String DatoExterno = "Valor por defecto Dato Externo";
  String Propiedad = "Valor de la propiedad por defecto";
  static
  {
    System.out.println("Creación static");
    System.out.println("Solo una vez");
  }
  public void MetodoPropiedad(String dato)
  {
    if (dato != "")
    {
      DatoInterno = dato;
    }
  } // fin del método

  public String MetodoPropiedad()
  {
    return DatoInterno;
  } // fin del método
  public Ejemplo(String dato) // constructor
  {
    if (dato != "")
    {
      DatoExterno = dato;
    }
  }
}


Con éste programa

Código:
package ejemplos;
public class Main
{
  public static void main(String[] args)
  {
    Ejemplo Objeto;
    Objeto = new Ejemplo("");
    System.out.println(Objeto.DatoExterno);
    Objeto.Propiedad = "Valor nuevo" ;
    System.out.println(Objeto.Propiedad);
    System.out.println(Objeto.MetodoPropiedad());
    Objeto.MetodoPropiedad("Nuevo valor de la propiedad.");
    System.out.println(Objeto.MetodoPropiedad());
  }
}


La ejecución quedaría como sigue:

Código:
init:
deps-jar:
Compiling 1 source file to
compile:
run:
Creación static
Solo una vez
Valor por defecto Dato Externo
Valor nuevo
Valor por defecto Dato Interno
Nuevo valor
BUILD SUCCESSFUL (total time: 0 seconds)


1.9 Aclaración.
Si repasamos lo visto anteriormente, comprobaremos que lo que estamos viendo en realidad es otra de las formas de uso de los procedimientos y funciones, visto en temas anteriores.

A la posibilidad de tener escrito varias veces el mismo método, se le llama sobrecarga, y si analizamos el diseño de las versiones del mismo método, comprobaremos que en realidad son distintas, ya que en realidad no está contemplado que un método se escriba dos veces, si es idéntico, no tiene sentido.

Código:
public void MetodoPropiedad(String dato)
{
  if (dato != "")
  {
    DatoInterno = dato;
  }
} // fin del método

public String MetodoPropiedad()
{
  return DatoInterno;
} // fin del método


En el primer caso, no se devuelve ningún dato, se captura solo,

Código:
DatoInterno = dato;


en el segundo se devuelve el contenido de DatoInterno,

Código:
return DatoInterno;


1.10 Propiedades solo lectura.
Si deseamos utilizar o disponer de la posibilidad de que solo pueda leerse el valor de una propiedad, variable miembro, con escribir únicamente el método con el formato de función es suficiente.

Para ello utilizamos la siguiente sintaxis.

Código:
public String MetodoPropiedad()
{
  return DatoInterno;
} // fin del método



El que tenga o no sentido dependerá de las circunstancias, pero la forma de conseguirlo es esta.

1.11 Propiedades solo escritura.
Se trata del caso contrario, permitir que solo pueda asignarse datos pero no su visualización, para ello utilizamos la otra opción de las vistas anteriormente, con o sin validación.

Código:
public void MetodoPropiedad(String dato)
{
  if (dato != "")
  {
    DatoInterno = dato;
  }
} // fin del método


El que tenga o no sentido dependerá de las circunstancias, pero la forma de conseguirlo es esta.

1.12 Utilizar los datos, las propiedades.
El uso de la propiedad es como en el resto de casos en los que utilizamos una variable, con las restricciones expuestas de lectura y escritura, pero no hay cambios, se pueden usar como una variable más.

Precauciones a tomar, tener presente que los cambios en una propiedad, afectan al objeto del cual depende, y si tenemos varios objetos de la misma clase, estar seguros sobre cual hacemos los cambios, o cual es el que estamos utilizando.

1.13 Conclusiones.
Hemos visto el uso de los datos en una clase, propiedades, variables públicas, sus condiciones de uso y la forma de controlar los datos.

Lo principal es tener presente que es muy útil, imprescindible podríamos decir, declarar las variables inicializadas a valores que sean prácticos para el uso por defecto del objeto.

Pero, además exigir en el método constructor, la inserción de los datos que sean necesarios para la inicialización del objeto.

1.14 Ejercicios propuestos.
1º Crear una clase en la que dispongamos de:
    Una variable privada,
    Una variable pública.
    Una propiedad y su variable interna.
    Una propiedad solo lectura, y su variable interna.
    Una propiedad solo asignación, y su variable interna.

2º A la clase anterior asignar datos a las variables en su declaración.
    Modificar los contenidos de esas variables a través de sus propiedades, realizando un control en función del tipo de dato a introducir.
    Visualizar los contenidos antes y después de los cambios.

3º Añadir a la clase anterior el constructor, de forma que se pueda cargar los valores iniciales de las propiedades en el mismo.

1.15 Solución a los ejercicios propuestos.
1º Crear una clase en la que dispongamos de:
    Una variable privada,
    Una variable pública.
    Una propiedad y su variable interna.
    Una propiedad solo lectura, y su variable interna.
    Una propiedad solo asignación, y su variable interna.


Código:
package ejemplos;
public class Ejemplo
{
  private String DatoInterno;
  private String SoloLeer;
  private String SoloEscribir;
  String DatoExterno ;
  public String SoloLectura()
  {
    return SoloLeer;
  } // fin del método
  public void SoloEscritura(String dato)
  {
    if (dato != "")
    {
      SoloEscribir = dato;
    }
  } // fin del método
}


2º A la clase anterior asignar datos a las variables en su declaración.
    Modificar los contenidos de esas variables a través de sus propiedades, realizando un control en función del tipo de dato a introducir.
    Visualizar los contenidos antes y después de los cambios.


Código:
package ejemplos;
public class Ejemplo
{
  private String DatoInterno = "Variable interna privada";
  private String SoloLeer = "Variable solo se puede leer";
  private String SoloEscribir = "Solo se puede escribir";
  String DatoExterno = "Variable pública.";
  static
  {
    System.out.println("Creación del objeto");
    System.out.println("Solo la primera vez");
  }
  public void MetodoPropiedad(String dato)
  {
    if (dato != "") // Control del dato
    {
      DatoInterno = dato;
    }
  } // fin del método
  public String MetodoPropiedad()
  {
    return DatoInterno;
  } // fin del método
  public String SoloLectura()
  {
    return SoloLeer;
  } // fin del método
  public void SoloEscritura(String dato)
  {
    if (dato != "") // Control del dato
    {
      SoloEscribir = dato;
    }
  } // fin del método
}


Código:
package ejemplos;
public class Main
{
  public static void main(String[] args)
  {
    Ejemplo Objeto;
    Objeto = new Ejemplo("");
    System.out.println(Objeto.DatoExterno);
    System.out.println(Objeto.MetodoPropiedad());
    Objeto.MetodoPropiedad("Nuevo valor de la propiedad.");
    System.out.println(Objeto.MetodoPropiedad());
    Objeto.SoloLectura();
    System.out.println(Objeto.SoloLectura());
  }
}


3º Añadir a la clase anterior el constructor, de forma que se pueda cargar los valores iniciales de las propiedades en el mismo.

Código:
package ejemplos;
public class Ejemplo
{
  private String DatoInterno = "Variable interna privada";
  private String SoloLeer = "Variable solo se puede leer";
  private String SoloEscribir = "Solo se puede escribir";
  String DatoExterno = "Variable pública.";
  String Propiedad = "Valor de la propiedad por defecto";
  static
  {
    System.out.println("Creación del objeto");
    System.out.println("Solo la primera vez");
  }
  public void MetodoPropiedad(String dato)
  {
    if (dato != "")
    {
      DatoInterno = dato;
    }
  } // fin del método
  public String MetodoPropiedad()
  {
    return DatoInterno;
  } // fin del método
  public String SoloLectura()
  {
    return SoloLeer;
  } // fin del método
  public void SoloEscritura(String dato)
  {
    if (dato != "")
    {
      SoloEscribir = dato;
    }
  } // fin del método
  // Constructor de la clase
  public Ejemplo(String DatInt, String SolLee, String SolEsc) // constructor
  {
    if (DatInt != "")
    {
      DatoInterno = DatInt;
    }
    if (SolLee != "")
    {
      SoloLeer = SolLee;
    }
    if (SolEsc != "")
    {
      SoloEscribir= SolEsc;
    }
  }
}


Código:
package ejemplos;
public class Main
{
  public static void main(String[] args)
  {
    Ejemplo Objeto;
    Objeto = new Ejemplo("Inicial alor interno",
    "Inicial Solo lectura",
    "Inicial Solo escritura");
    System.out.println(Objeto.DatoExterno);
    System.out.println(Objeto.MetodoPropiedad());
    Objeto.MetodoPropiedad("Nuevo valor de la propiedad.");
    System.out.println(Objeto.MetodoPropiedad());
    System.out.println(Objeto.SoloLectura());
    System.out.println(Objeto.Propiedad);
    // System.out.println(Objeto.SoloEscritura()); no permite su utilización
  }
}


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

Dudas al instanciar clases heredadas

MMCA Java 0 Viernes 26 Ene 2018 21:34 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,