Fecha y hora actual: Jueves 17 Ene 2019 04:12
Í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.18 - Clases, fases - VB Studio 2005

Responder al Tema

Índice del Foro > Visual Basic .NET > Curso VB .NET - Tema 1.18 - Clases, fases - VB Studio 2005

Autor Mensaje
Tesis
Administrador


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

Mensaje Publicado: Miércoles 25 Mar 2009 20:34

Título del mensaje: Curso VB .NET - Tema 1.18 - Clases, fases - VB Studio 2005

Responder citando

Curso de programación en .NET - Tema 1.18 - Clases, fases - VB Studio 2005


1. Clases, VB fases en su ejecución.

1.1 Objetivos del tema.
Ver las distintas fases por las que pasa un objeto en Visual Basic, desde que se realiza la instancia del mismo en su clase hasta, que finaliza la existencia del mismo.

1.2 Introducción.
Es importante tener presente en que momento, cuando y como se van desarrollando las distintas etapas de la vida de un objeto, de esa forma no estaremos consumiendo recursos del sistema de forma innecesaria.

Un objeto es igual que un ser vivo, nace, crece y desaparece, lo que hay que hacer es ajustar esos pasos a las necesidades de nuestro programa.

  • Inicialización
  • Ejecución
  • Finalización


1.3 Iniciar la clase, crear una instancia.
Cuando se crea un objeto a partir de una clase, el primer paso es instanciar ese objeto, con una u otra sintaxis, se dispone de un constructor, un método especializado, que se ejecuta de forma automática al crearse el objeto de la clase en cuestión.

Ese método en Visual se denomina “new”.

Código:
Public Class Clase
   Public UnDato As Integer
   ' Constructor sin captura de datos
   Public Sub New()
   End Sub
      
   Public Sub New(ByVal AlgunDato As Integer)
      UnDato = AlgunDato
   End Sub
End Class


En esa fase disponemos de la posibilidad de reclamar datos necesarios para la correcta ejecución de la clase, y es donde debemos o podemos realizar el control de los mismos.

Código:
Public Class Clase
   Public UnDato As Integer
   ' Constructor sin captura de datos
   Public Sub New()
   End Sub

   ' Constructor que obliga a introducir un dato en la inicialización
   Public Sub New(ByVal AlgunDato As Integer)
      UnDato = AlgunDato
   End Sub
End Class


También podemos optar por no reclamar ninguna información y arrancar con los datos de nuestra clase inicializados a los valores que nosotros consideremos oportunos.

Código:
Public Class Clase
   Public UnDato As Integer = 10
   ' Constructor sin captura de datos
   Public Sub New()
   End Sub
End Class


Cualquiera de las dos soluciones es correcta, cual utilizar vendrá marcado por las circunstancias en las que se tenga que utilizar el objeto.

Código:
Public Class Clase
   Public UnDato As Integer
   ' Constructor sin captura de datos
   Public Sub New()
   End Sub

   ' Constructor que obliga a introducir un dato en la inicialización
   Public Sub New(ByVal AlgunDato As Integer)
      UnDato = AlgunDato
   End Sub
End Class


1.4 Proteger nuestra clase.
Se trata de bloquear el constructor sin argumentos convirtiéndolo en private.
En muchas ocasiones es imprescindible, sobre todo cuando deseamos exigir datos en la inicialización de la misma, y no deseamos que se inicie una copia de nuestra clase de forma accidental.

Código:
Public Class Clase
   Public UnDato As Integer
   ' Constructor sin captura de datos
   Private Sub New()
   End Sub
   
   ' Constructor que obliga a introducir un dato en la inicialización
   Public Sub New(ByVal AlgunDato As Integer)
      UnDato = AlgunDato
   End Sub
End Class


De esa forma no es visible y no se puede utilizar, y es imposible que se use accidentalmente.
Normalmente es muy habitual que necesitemos varios escenarios posibles en el inicio de un objeto, por lo que la solicitud de datos en el constructor se puede volver algo complicada.

En las clases existe el concepto de sobrecarga, esto significa poder escribir varias versiones de un mismo método, - más adelante se expondrá el tema - , ese es el camino más adecuado para poder solventar el problema de los distintos escenarios posibles en el inicio de una clase para los objetos que se derivan de ella.

En el siguiente ejemplo, podemos observar como se han escrito varias versiones del constructor en el cual se ha declarado distintas versiones de la misma variable, String, Integer, aunque no tiene porque cambiar el nombre de la variable.

Código:
Public Class Clase
   Public UnDato As Integer
   ' Constructor sin captura de datos
   Private Sub New()
   End Sub

   ' Constructor que obliga a introducir un dato en la inicialización
   Public Sub New(ByVal AlgunDato As Integer)
      UnDato = AlgunDato
   End Sub

   ' Constructor que obliga a introducir un dato en la inicialización
   Public Sub New(ByVal AlgunDato As String)
   End Sub
End Class


Pero también se puede crear con distintas variables en cada uno de ellos.

Código:
Public Class Clase
   Public UnDato As Integer
   ' Constructor sin captura de datos
   Private Sub New()
   End Sub

   ' Constructor que obliga a introducir un dato en la inicialización
   Public Sub New(ByVal AlgunDato As Integer)
      UnDato = AlgunDato
   End Sub

   ' Constructor que obliga a introducir un dato en la inicialización
   Public Sub New(ByVal AlgunDato As Integer, ByVal OtroDato as Integer)
   End Sub
End Class


Podemos observar como en este ejemplo se mantiene el nombre de la variable, pero se añade una nueva en la segunda versión del mismo.

1.5 Ejecución de la clase.
La clase no se ejecuta, se ejecuta una instancia de la misma, en el objeto que de ella se crea.
El punto de inicio es el constructor de la misma.

Código:
' Constructor que obliga a introducir un dato en la inicialización
Public Sub New(ByVal AlgunDato As Integer)
End Sub


La ejecución del objeto, se iniciará en una fase inicial cuando se declara y se inicializa el mismo, y en segundas fases cuando se reclama la ejecución de cualquiera de sus métodos.

La finalización de la ejecución de cualquiera de sus métodos no implica que deje de ser utilizado el objeto y que éste deje de consumir recursos.

La ejecución permanecerá activa hasta que se ejecute una asignación de “nothing” o “null”, al objeto que de ella se deriva, o bien hasta que desaparezca el mismo de la memoria por finalizar el procedimiento o programa que lo reclama, o bien finalicemos la misma con el método de finalización previsto en el lenguaje.

Tengamos presente que mientras no se ejecute una de estas acciones, el objeto estará consumiendo recursos del sistema.

1.6 Finalización de la clase.
Finalize está protegido y, por lo tanto, sólo se puede obtener acceso a él a través de esta clase o de una clase derivada.

Este método se invoca de forma automática, después de que un objeto pase a ser inaccesible, salvo que haya sido excluido del proceso de finalización mediante una llamada a SuppressFinalize. Durante el cierre de un dominio de aplicación, se realiza una llamada automática a Finalize para los objetos que no están exentos de finalización, incluso para aquellos objetos que a los que aún se puede obtener acceso. Sólo se realiza una llamada a Finalize para una instancia especificada, a menos que el objeto vuelva a registrarse mediante un mecanismo como ReRegisterForFinalize y no se haya llamado posteriormente a GC.SuppressFinalize.

Todas las implementaciones de Finalize en un tipo derivado deben llamar a la correspondiente implementación de tipo base de Finalize. Este es el único caso en el que se permite al código de la aplicación llamar a Finalize.

La regla de oro a seguir es que no se debe poner ningún código que deba ser ejecutado en el método finalize().
Por ejemplo, si se necesita concluir la comunicación con un servidor cuando ya no se va a usar un objeto, no debe ponerse el código de desconexión en el método finalize, porque puede que nunca sea llamado.

Es responsabilidad del programador escribir métodos para realizar la limpieza que no involucre a la memoria ocupada por el objeto y ejecutarlos en el instante preciso.

Código:
Objeto = nothing


El método finalize y el recolector de memoria son útiles para liberar la memoria de la pila y debería restringirse su uso solamente a eso, y no depender de ellos para realizar ningún otro tipo de limpieza.

En la construcción de un objeto, se desplaza uno por el árbol de jerarquía, de herencia, desde la raíz del árbol hacia las ramas, y en la finalización, es al revés, los desplazamientos por la herencia debe ser desde las ramas hacia las superclases hasta llegar a la clase raíz.

1.7 Ejercicios propuestos.
1. Crear una clase en la que no se pida ningún requisito para crear un objeto con la misma.
2. Crear una clase en la que al iniciar una instancia de la clase se tenga que introducir un valor entero, y comprobar que su valor es mayor que cero y menor que diez.
3. Con la clase del ejercicio anterior, añadir una variable interna que se llame Dato, dicha variable será inicializada a cinco, y que tome el valor de la inicialización del objeto en caso de ser válido.
4. Con la clase del ejercicio anterior, añadir un método llamado finalizar, y colocar en el un texto que permita visualizar su ejecución. En el programa principal asignar al objeto una vez utilizado una línea que le asigne nothing, comprobar los mensajes utilizar los métodos que siguen para probar los distintos resultados.

1.8 Solución a los ejercicios propuestos.
1. Crear una clase en la que no se pida ningún requisito para crear un objeto con la misma.

Código:
Public Class Ejercicios
   Public Sub New()
   
   End Sub
End Class


2. Crear una clase en la que al iniciar una instancia de la clase se tenga que introducir un valor entero, y comprobar que su valor es mayor que cero y menor que diez.

La clase será:

Código:
Public Class Ejercicios
   Public Sub New()
   End Sub
   Public Sub New(ByVal Dato As Integer)
      Select Case Dato
         Case 1 To 9
         Case Else
            Console.WriteLine("El dato es incorrecto")
      End Select
   End Sub
End Class


En el programa principal.

Código:
Module Module1
   Sub Main()
      Dim Objeto As Ejercicios = New Ejercicios(20)
      Console.ReadLine()
   End Sub
End Module


El resultado será


3. Con la clase del ejercicio anterior, añadir una variable interna que se llame Dato, dicha variable será inicializada a cinco, y que tome el valor de la inicialización del objeto en caso de ser válido.

La clase será:

Código:
Public Class Ejercicios
   Dim Dato As Integer = 5
   Public Sub New()
   End Sub
   Public Sub New(ByVal UnValor As Integer)
      Select Case UnValor
         Case 1 To 9
            Dato = UnValor
            Console.WriteLine("El valor de dato es {0} ", Dato)
         Case Else
            Console.WriteLine("El valor de dato es {0} ", Dato)
            Console.WriteLine("El dato es incorrecto")
      End Select
   End Sub
End Class


El programa principal.

Código:
Module Module1
Sub Main()
   Dim Objeto As Ejercicios = New Ejercicios(20)
      Console.ReadLine()
   End Sub
End Module


El resultado será:


4. Con la clase del ejercicio anterior, añadir un método llamado finalizar, y colocar en el un texto que permita visualizar su ejecución. En el programa principal asignar al objeto una vez utilizado una línea que le asigne nothing.

Código:
Public Class Ejercicios
   Dim Dato As Integer = 5
   Public Sub New()
   End Sub
   Public Sub New(ByVal UnValor As Integer)
      Select Case UnValor
         Case 1 To 9
            Dato = UnValor
            Console.WriteLine("El valor de dato es {0} ", Dato)
         Case Else
            Console.WriteLine("El valor de dato es {0} ", Dato)
            Console.WriteLine("El dato es incorrecto")
      End Select
   End Sub

   Public Sub Finalizar()
      Console.WriteLine("Ejecución de finalize")
      Me.Finalize()
   End Sub
End Class


El programa principal sería:

Código:
Module Module1
   Sub Main()
      Dim Objeto As Ejercicios = New Ejercicios(20)
      Objeto = Nothing
      Objeto.Finalizar()
      Console.ReadLine()
   End Sub
End Module


El resultado sería erróneo al tener

Código:
Objeto = Nothing


Antes de la siguiente línea.

Código:
Objeto.Finalizar()


Sería correcto si estuviera:

Código:
Module Module1
   Sub Main()
      Dim Objeto As Ejercicios = New Ejercicios(20)
      Objeto.Finalizar()
      Objeto = Nothing
      Console.ReadLine()
   End Sub
End Module


Como figura en el ejemplo, teniendo en cuenta que hay cierta redundancia en el mismo.


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

Dudas al instanciar clases heredadas

MMCA Java 0 Viernes 26 Ene 2018 21:34 Ver último mensaje
El foro no contiene ningún mensaje nuevo

Clases

angeljonh C, C#, Visual C++ 2 Miércoles 30 Ago 2017 06:20 Ver último mensaje
El foro no contiene ningún mensaje nuevo

Curso de PHP-WordPress avanzado

wordpressadict PHP 1 Domingo 27 Nov 2016 19:59 Ver último mensaje
El foro no contiene ningún mensaje nuevo

Curso fundamentos de programación

Yaser Programación en general 0 Miércoles 18 May 2016 00:28 Ver último mensaje
El foro no contiene ningún mensaje nuevo

Curso de Desarrollo en Inteligencia Artificial

JL Iglesias Feria Programación de juegos o videojuegos 7 Miércoles 02 Dic 2015 18:20 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,