Contenido 6

PROGRAMACIÓN .
NET - I
SEMANA 6
Programación orientada
a objetos en .NET
Todos los derechos de autor son de la exclusiva propiedad de IACC o de los otorgantes de sus licencias. No está
permitido copiar, reproducir, reeditar, descargar, publicar, emitir, difundir, poner a disposición del público ni 1
ESTE
utilizarDOCUMENTO
los contenidos paraCONTIENE LAdeSEMANA
fines comerciales 6
ninguna clase.
2
ESTE DOCUMENTO CONTIENE LA SEMANA 6
ÍNDICE
PROGRAMACIÓN ORIENTADA A OBJETOS EN .NET ............................................................................ 4

OBJETIVOS ESPECÍFICOS ........................................................................................................................... 4
INTRODUCCIÓN ...................................................................................................................................... 4
1. PROGRAMACIÓN ORIENTADA A OBJETOS........................................................................................... 5
1.1. HERENCIA ............................................................................................................................ 5
1.2. POLIMORFISMO .................................................................................................................. 7
1.3. ENCAPSULAMIENTO ............................................................................................................ 8
1.4. ABSTRACCIÓN...................................................................................................................... 9
2. LIBRERÍAS DE CLASES DE .NET ............................................................................................................ 9
2.1. DESCRIPCIÓN DE LAS CLASES DEL SISTEMA ........................................................................ 9
2.2. CLASIFICACIÓN DE CLASES ................................................................................................ 10
2.3. ORGANIZACIÓN LÓGICA .................................................................................................... 12
3. CICLO DE VIDA DE UN OBJETO ......................................................................................................... 12
4. MÉTODOS Y PROPIEDADES ............................................................................................................. 12
4.1. USO .................................................................................................................................... 12
4.2. FUNCIÓN ........................................................................................................................... 13
5. CONSTRUCTORES Y DESTRUCTORES................................................................................................. 14
5.1. USO .................................................................................................................................... 15
5.2. FUNCIONAMIENTO............................................................................................................ 15
COMENTARIO FINAL.......................................................................................................................... 17
REFERENCIAS........................................................................................................................................ 18
3
PROGRAMACIÓN ORIENTADA A OBJETOS EN .NET
OBJETIVOS ESPECÍFICOS
 Utilizar los mecanismos de herencia y encapsulamiento de la programación orientada a
objetos en Visual Basic .NET.
 Reconocer las librerías de clases en Microsoft. NET.
 Analizar el uso y funcionamiento de los constructores y destructores en Microsoft. NET.
INTRODUCCIÓN
Esta semana se estudiará el paradigma de la programación orientada a objetos, sus conceptos,
funcionamiento y uso principal. Entre los términos básicos incluidos están objeto, clase, herencia,
polimorfismo y abstracción; todo framework en la actualidad que permite este tipo de desarrollo
maneja estos términos y características, donde por medio de la herencia se pueden ahorrar
recursos tanto en el momento del desarrollo como cuando el sistema está en marcha.
Profundizando más en el ámbito de .NET Framework, se hablará de sus librerías de clases, el ciclo
de vida de un objeto y cuáles son los métodos que son utilizados en cada una de sus etapas, como
también se analizará la presencia de constructores y destructores dentro del .NET Framework, sus
usos y funciones principales en el desarrollo de aplicaciones.
4
1. PROGRAMACIÓN ORIENTADA A OBJETOS
Es un paradigma que permite desarrollar aplicaciones haciendo uso de componentes de software,
también llamados objetos de software. Se fundamenta en el modelo de objeto, siendo un objeto
la instancia de una clase. En otras palabras, esta última posee los atributos y métodos que
caracterizan al objeto que realiza su llamado. Una de las características principales de la
programación orientada a objetos (en adelante, POO) es que permite la reutilización de código
para varias implementaciones y/o desarrollos. Los principales términos manejados en POO son los
siguientes:
Un objeto es una entidad que contiene características (atributos), comportamientos (métodos) y

es accedido por medio de su instancia. De tal forma, un objeto es la instancia de una clase. La
manera de crear una instancia de una clase se puede ver aquí:
Dim Variable As New Clase()
Donde la variable es asignada a la referencia de la instancia clase.
Una clase tiene todas las características de un objeto, es decir, sus propiedades y
comportamiento. Cuando se instancia una clase, se leen todas las definiciones y se crea un objeto
a través de esta.
Un atributo permite definir la estructura del objeto, ayuda a diferenciarlo de otros objetos. La
manera como se define es a través de un identificador y un tipo, indicando los valores que puede
almacenar. Estos valores definen el estado del objeto.
Un método es la implementación de un código que representa un proceso o función que realiza un

objeto. Los métodos determinan el comportamiento del objeto.
1.1. HERENCIA
Es una propiedad que tienen los objetos que permite que sean construidos a partir de otros o
recibiendo de un módulo superior los atributos o funciones. Permite expandir la funcionalidad de
las clases que existen para el cumplimiento de sus necesidades y la sustitucion de métodos que no
las cumplan. Las clases definen parámetros y métodos para los objetos que se basan en ellas.
Cuando una clase es heredada se llama clase base y la que hereda de ella se llama clase derivada.
A su vez, todas las clases heredan de manera implícita de la clase Object, lo que permite la
jerarquía de clases .NET.
Un ejemplo simple de herencia sería: un triángulo y un cuadrado son figuras; por lo cual se puede
decir que estos heredan de la clase Figura. Con la palabra clave Inherits genera la herencia de los
miembros públicos de la clase referenciada en Visual Basic .NET.
5
Se muestra aquí un ejemplo de declaración de dos clases, una clase base y la otra derivada.
Class ClaseBase
Sub Metodo1()
MsgBox("El primer método de la base base.")
End Sub
Overridable Sub Metodo2()
MsgBox("El segundo método de la base base.")
End Sub
End Class
Class Clase2
Inherits Clase1 ' aquí se hace la referencia a la clase base
Overrides Sub Metodo2()
MsgBox("El método derivado.")
End Sub
End Class
Protected Sub ProbarHerencia()

Dim Probar1 As New ClaseBase
Dim Probar2 As New Clase2
Probar1.Metodo1() ' De esta manera se llaman los métodos que se
heredan, tanto de la ClaseBase como de Clase2.
Probar1.Metodo2()
Probar2.Metodo1()
Probar2.Metodo2()
End Sub
Otro ejemplo: se crea la clase Administrador que herede de la clase Trabajador; se crea una
propiedad que se llama Sueldo.
Public Class Administrador
Inherits Trabajador
Private varSueldo As Single
Property Sueldo() As Single
Get
Sueldo = varSueldo
End Get
Set(ByVal Value As Single)
varSueldo = Value
End Set
End Property
6
End Class
Para declarar clases base se usan las siguientes palabras clave:
MustInherit: crea una clase que solo sirva para la implementación de herencia. Su sintaxis es:
MustInherit Class NombreClase
End Class
NotInheritable: con esta instrucción solo se pueden crear clases que creen objetos, pero no
heredar. La sintaxis:
NotInheritable Class NombreClase
End Class
Para la declaración de propiedades o métodos en una clase derivada:
Overridable: crea un método o propiedad que pueda ser sobrescrita en una clase derivada.
Overrides: permite sobrescribir un método o propiedad que anteriormente fue definido como
Overridable.
NotOverridable: no permite sobrescribir una clase derivada, la definición es realizada en el

método o propiedad de la clase base.
MustOverride: la propiedad o método serán sobrescritos obligatoriamente dentro de la clase

derivada.
1.2. POLIMORFISMO
Es la propiedad que permite a un elemento tomar diferentes formas. Dicho de otro modo, es el
uso de distintos tipos en una misma función o componente. Brinda la posibilidad de declarar
múltiples clases para que realicen diferentes funciones, con métodos o propiedades y
asignándoles nombres similares; lo anterior es de gran utilidad, pues permite distinguir elementos
que poseen nombres iguales. Visual Basic .NET usa la herencia para lograr el polimorfismo
mediante la definición de métodos en una clase base y luego reemplazándolos con nuevas
implementaciones en clases derivadas. La posibilidad que ofrece el polimorfismo es el uso de
elementos con el mismo nombre, sin importar el tipo de objeto que esté utilizando.
7
Ejemplo:
Se crea la clase CrearTrabajador, donde suponemos que de igual manera hereda de la clase base
Trabajador creada con Overridable, y se sobrescribe en la clase Administrador para calcular el
sueldo con horas extras:
Public Class Administrador

Inherits Trabajador
Public Overrides Sub CrearTrabajador (ByVal Codigo As Integer, _

ByVal Nombre As String, ByVal HorasExtras As Single)
Sueldo = varSueldo + (((varSueldo/30)/8) * HorasExtras)
MyBase.CrearTrabajador(Codigo,Nombre,Sueldo)
End Sub
End Class
En el caso siguiente se define el método VerSueldo, donde se crea al trabajador y se muestra su

sueldo.
Sub VerSueldo(ByVal vTrabajador As Trabajador, ByVal Codigo As Integer, _

ByVal Nombre As String, ByVal Sueldo As Single)
vTrabajador.CrearTrabajador(Codigo,Nombre,Sueldo)
MsgBox(Nombre & ", su sueldo es: " & Sueldo)
End Sub
Sub Probar () ‘Aquí Polimorfismo

Dim objTrabajador As New Trabajador
Dim objAdministrador As New Administrador
objTrabajador.CrearTrabajador(800, "Pedro Pérez", 1000)
objAdministrador.Sueldo=1000
objAdministrador.HorasExtras=5
objAdministrador.CrearTrabajador (800, " Pedro Pérez ", 1000)
End Sub
El resultado será:
Pedro Pérez, su sueldo es: 1000,00
Pedro Pérez, su sueldo es: 1020,83
1.3. ENCAPSULAMIENTO
Es el ocultamiento de los datos miembros de un objeto. De esta forma, solo puede cambiar a
través de operaciones previamente definidas. Permite que los métodos y los atributos estén
8
dentro del mismo código de la clase y, además, que sea controlado el acceso a un grupo de
elementos asociados. La forma común de encapsulamiento de elementos es a través de las clases.
El encapsulamiento agiliza también el cambio de implementación posterior, permitiendo el
ocultamiento de los detalles de implementación de los objetos.
1.4. ABSTRACCIÓN
Define las principales características de un objeto. Cada objeto funciona como un modelo
abstracto que realiza el trabajo, informando y modificando el estado, además de comunicarse con
otros objetos sin divulgar cómo se implementan dichas características. Las clases abstractas se
caracterizan porque de ellas no es posible crear instancias. Una clase derivada de una abstracta
puede implementar interfaces. Son de utilidad para la creación de componentes, debido a que
permiten definir un nivel no variable de funcionalidad para algunos métodos y no realizar la
implementación de otros hasta que sea requerida una implementación de la clase.
Las clases abstractas se definen con la instrucción MustInherit, para los métodos que no sean
variables pueden codificarse en una clase base, para el caso de los que se necesiten implementar
se debe usar el modificador MustOverride.
A continuación, se muestra un ejemplo de definición de clases abstractas, en este caso se define la

clase PagarServicios:
Public MustInherit Class PagarServicios

Sub New()
...
End sub
Public MustOverride Sub Telefono
Public MustOverride Sub Gas (MontoGas as Integer)
Public MustOverride Function Electricidad (MontoElec as Integer) as
Long
End Class
En ese ejemplo, se declaró una clase abstracta con la implementación de un método y tres no
implementados.
2. LIBRERÍAS DE CLASES DE .NET

Estas brindan acceso a las funcionalidades de las aplicaciones. Es la columna vertebral del
framework, debido a que posee todas las funciones de compilación, componentes y controles de
este. Según el proceso que se necesite ejecutar en un momento determinado, son usados los
diferentes espacios de nombres.
2.1. DESCRIPCIÓN DE LAS CLASES DEL SISTEMA
9
Como ya se ha estudiado anteriormente, las clases determinan todos los métodos, eventos o
propiedades; definen el valor que es guardado en el estado del objeto. Entre las características
que posee .NET framework en tiempo de ejecución les proporciona a las clases:
Característica Descripción
Abstract Esta propiedad indica que no es permitido crear
una instancia de la clase definida. Para poder
utilizarla, de ella debe derivar otra clase.
Inherits Determina que las instancias de la clase son
aptas para su utilización donde se especifique la
clase base. Las clases derivadas pueden
implementar todos los métodos que le ofrece
su clase base.
Implements Permite conocer las interfaces que utiliza la
clase, brindando las implementaciones de
miembros de la interfaz.
Sealed Indica que no se puede derivar otra clase de
este tipo.
Exported o not exported Permite conocer si la clase se encuentra o no
visible fuera del ensamblado donde fue
definida.
2.2. CLASIFICACIÓN DE CLASES

La biblioteca de clases de .NET se divide a partir de la funcionalidad que realizan sus espacios de
nombres. Entre ellos los más usados son:
Espacios de nombres básicos:
System.Collections: permite definir colecciones de objetos (matrices, listas, colas, tablas hash).
System.Collecions.Generic: permite definir colecciones genéricas, permitiendo con esto la

flexibilidad de tipos de datos.
System.IO: permite la escritura y lectura en archivos de manera sincrónica y asincrónica.
Espacios de nombres para datos:
System.Data: contiene clases de la infraestructura ADO.NET, con las que se crean componentes
para la administración de los datos de diversos orígenes.
System.Data.Common: describe colecciones de clases que son usadas para tener acceso al origen
de datos.
System.Xml: las clases contenidas permiten el procesamiento de código XML.
10
System.Data.OleDb: permite la conexión a orígenes de datos OLE DB.
System.Data.SqlClient: permiten la conexión a orígenes de datos SQL Server, ejecución de

comandos y la lectura de resultados.
Espacios de nombres para la web:
System.Web.UI: facilita la creación de formularios Web Forms.
System.Web.UI.HtmlControls: permite la creación de controles HTML, para ser incluidos en

formularios Web Forms.
System.Web.Services: permite la creación y uso de servicios web XML.
Espacios de nombres de aplicaciones para Windows:
System.Windows.Forms: permite la creación de aplicaciones en tipos Windows, posee la clase

Form y diversos controles, los cuales podrían ser incluidos en el desarrollo de los formularios.
System.Windows: facilita la creación de aplicaciones en Windows Presentation Foundation.
System.Windows.Controls: permite crear controles de Windows Presentation Foundation.
Espacios de nombres de seguridad:
System.Security: brinda el sistema de seguridad de Common Language Runtime.
System.Net.Security: permite la configuración de redes seguras entre hosts.
System.Web.Security: su uso permite la implementación de seguridad de ASP.NET en aplicaciones

en ambiente web.
 Para ampliar este contenido se recomienda visitar la página

oficial de Microsoft:
https://goo.gl/m4HRRi
11
2.3. ORGANIZACIÓN LÓGICA
Los espacios de nombres son la organización lógica de las bibliotecas de clases y son generados de
manera independiente de la organización de los ensamblados. Los espacios de nombres se
extienden de diferentes ensamblados. Con respecto a la elección del nombre para los espacios de
nombres en .NET, estos deben indicar la función que suministran los tipos que se encuentran
incluidos en el espacio de nombre al que pertenecen. El formato del nombre para los espacios de
nombres es el siguiente:
<compañía>.(<Producto>|<Tecnologia>)[.<característica>][.<espacionombre>]
3. CICLO DE VIDA DE UN OBJETO

Como se ha estudiado anteriormente, un objeto es una instancia de clase creado con la instrucción
New. Algunas veces, cuando se crea un objeto es necesario inicializarlo, debido a que existen
objetos nativos del sistema que lo requieren. El proceso de inicialización es realizado por los
constructores. Posteriormente, el CLR se encarga de la liberar los recursos del sistema a través de
los procesos llamados destructores. El CLR determina la liberación de los objetos cuando los
recursos son pocos.
El Sub New inicializa el objeto definido, el que es usado solo al momento de crear la clase.
El Sub Finalize es el procedimiento que destruye o libera los recursos del sistema y solo es usado
en casos específicos, cuando los objetos no se liberan de manera implícita. Permite ser llamado
solo desde la clase a la cual pertenece. Para la ejecución explicita de liberación de recursos
también es usada la interfaz Disposable, ayudando así al Garbage Collector de .NET o colector de
elementos.
4. MÉTODOS Y PROPIEDADES
La realización de acciones que ejecuta el objeto está controlada por los métodos. Por otro lado, las
propiedades permiten controlar la manera como los valores son establecidos y devueltos.
4.1. USO
Métodos
Son bloques de código que poseen un conjunto de instrucciones. Cuando una aplicación está
corriendo permiten que sean ejecutadas esas instrucciones al llamar al método. El punto de inicio
para cada aplicación en .NET es el método Main, el que es llamado a través del Common Language
Runtime (CLR). En Visual Basic .NET existen dos maneras de declarar los métodos; una es a través
12
de Sub, donde esta instrucción no devuelve un valor, y otra mediante la instrucción Function, que
sí devuelve un valor.
La manera de definir un método es la siguiente:
Public Sub NombreMetodo(ByVal parámetro(s) As Tipo)
End Sub
En este caso, el método es público, es decir, puede llamarse en cualquier parte de la aplicación.
Se produce una sobrecarga de métodos cuando una clase tiene dos o más métodos, llamados de la
misma manera y con firmas distintas. La sobrecarga es usada cuando un objeto tiene nombres de
procedimientos iguales pero con distintos tipos de datos.
Ejemplo de sobrecarga:
Overloads Sub SobreCarga(ByVal VariableChar As Char)

...
End Sub
Propiedades
Las propiedades son los atributos o características del objeto. Para definir las propiedades de una
clase se debe agregar las palabras claves Get y Set respectivamente, como se muestra en el
siguiente ejemplo:
Public Property TuEstatura() As String

Get
Return Me.Estatura
End Get
Set(ByVal Valor As String)
Me.Estatura = Valor
End Set
End Property
Get retorna la Estatura y Set usa el parámetro Valor para establecer la estatura.
4.2. FUNCIÓN
Método
Los métodos son las acciones que realiza o puede realizar el objeto, es decir, son un conjunto de
instrucciones que serán puestas en funcionamiento en el momento en que la aplicación se
encuentre en tiempo de ejecución. Por ejemplo:
13
Function Mayor(ByVal x As Integer, ByVal y As Integer)As Integer
If x > y Then
Return x
Else
Return y
End Function
Se define un método Function, el cual retornará el valor X o Y, dependiendo de cuál de los dos sea
el mayor.
Propiedades
Poseen procedimientos Get y Set, que permiten un mejor control en la manera como se
establecen o devuelven los datos. Las propiedades no especifican la dirección de memoria donde
se almacenan los objetos. Contienen descriptores de acceso, los que detallan las instrucciones que
serán procesadas al momento de lectura y escritura de los valores.
En el ejemplo siguiente se guarda el Rut y Nombre completo de los usuarios:
Dim Rut, NombreApellido As String

Property Datos() As String
Get
If NombreApellido = "" Then
Return Rut
Else
Return Rut & " " & NombreApellido
End If
End Get
Set(ByVal Valor As String)
Dim espacio As Integer = Valor.IndexOf(" ")
If espacio < 0 Then
Rut = espacio
NombreApellido = ""
Else
Rut = Valor.Substring(0, espacio)
NombreApellido = Valor.Substring(espacio + 1)
End If
End Set
End Property
El procedimiento Get realiza la unión de ambos datos y retorna la propiedad Datos, la que
contiene tanto el Rut como NombreApellido;
5. CONSTRUCTORES Y DESTRUCTORES
Como sus nombres lo indican, se encargan del control de la construcción y destrucción de los
objetos.
14
5.1. USO
Constructor
Corresponde a un conjunto de instructores similar a un método, y entre sus características

principales están:
 En Visual Basic .NET se usa la instrucción Sub New para la definición de los constructores.
 En su declaración no se especifica el tipo, debido a que el constructor crea un tipo.
Los constructores se encargan de la inicialización de un objeto en una clase; dicho de otro modo,
es la manera en que un objeto toma sus valores iniciales al realizar la instanciación de la clase. Son
utilizados en la creación de tablas de clases y en la implementación de polimorfismo.
Destructor
Es un conjunto de funciones para la liberación de recursos que se ejecutan de manera automática

durante la ejecución de una aplicación, por lo que no necesitan ser llamadas de forma explícita en
el desarrollo.
5.2. FUNCIONAMIENTO
Constructor
Cuando es usado un constructor el compilador puede determinar qué objeto responde a ciertos
eventos. Al definir una clase derivada, en la primera línea se debe realizar una llamada al
constructor perteneciente a la clase base, siempre y cuando el constructor necesite parámetros.
La sentencia Sub New para crear el constructor y entre paréntesis la o las variables que se
necesitarán.
La instrucción Sub New acepta argumentos cuando se llama a un constructor que incluye
parámetros, y su sintaxis es la siguiente:
Sub New (ByVal Constructor As String)
Ejemplo de un constructor llamado Valor:
Public Sub New(ByVal Valor As String)
If Valor <> "" Then
ValorExterno = Valor
EndIf
End Sub
15
La sobrecarga de constructores se da cuando tiene más de un parámetro, y su sintaxis es la
siguiente:
Sub New (ByVal Constructor1 As Integer, Constructor2 As Integer)
If Constructor1 > Constructor2 then
MsgBox("El Constructor 1 es mayor ")
Else
MsgBox("El Constructor 2 es mayor ")
End Sub
En dicho constructor con sobrecarga se evaluaron los valores de cada uno de los constructores
definidos.
Destructores
Sus funciones principales son la liberación de memoria y/o recursos de la plataforma que el objeto
haya utilizado durante la ejecución, al igual que la remoción de las relaciones con otros objetos
durante el tiempo de ejecución. El Garbage Collector de .NET es el encargado de realizar la
liberación de espacios utilizados por los objetos; a pesar de que la manera como es realizada la
liberación es de gran ayuda para el desarrollador, existen casos (cuando se realizan referencias a
objetos nativos, por ejemplo: conexión a bases de datos) donde este debe especificar qué se debe
ejecutar en la liberación.
Un ejemplo de un destructor es el uso del método Close(), al haber realizado la llamada de la clase
SqlConnection. El CLR realiza el llamado del método Finalize y, de este modo, permite liberar la
memoria. Este método se encarga de limpiar y guardar información referente al estado, cierre de
archivos y las conexiones a base de datos. Se muestra aquí un ejemplo de la declaración de una
clase base del destructor Finalize:
Sub Finalize()
MyBase.Finalize()
End Sub
Otro ejemplo con las palabras claves Protected Overrides sería:
Protected Overrides Sub Finalize()

MsgBox("Mi Nombre es: " & Nombre)
Nombre = Nothing ' se libera la referencia pero
Apellido = Nothing ' no es necesario hacerlo
End Sub
16
COMENTARIO FINAL
El desarrollo de aplicaciones haciendo uso del paradigma de programación orientada a objetos
(POO) es una de las bondades de mayor relevancia en Visual Basic .NET Framework, pues permite
desarrollar de una manera mucho más ordenada y comprensible al momento de necesitar leer el
código fuente, hacer uso eficiente de los recursos y/o infraestructura, y reutilizar el código que es
la base en este paradigma de programación. La herencia es la base fundamental de la POO, debido
a que de ella se deriva todo lo que un objeto podrá hacer o no. En este sentido, .NET pone a
disposición una gran cantidad de clases distribuidas en los diferentes espacios de nombres que se
encuentran en la biblioteca de clases del framework.
Los espacios de nombres permiten hacer uso de las virtudes del framework debido a que muchas
de las funcionalidades necesarias para el desarrollo de aplicaciones se encuentran ya
contempladas, desde la construcción de un formulario para el ingreso de datos hasta el control y/o
seguridad de red y acceso a los sistemas que se desarrollan en este. El manejo de constructores y
destructores de objetos permite que el desarrollador solo se preocupe del control de otros
aspectos en el ciclo de vida del sistema.
17
REFERENCIAS
Microsoft Developer Network (2007). Programación orientada a objetos en Visual Basic.
Recuperado de: https://goo.gl/w4NkOK
18
PARA REFERENCIAR ESTE DOCUMENTO, CONSIDERE:
IACC (2016). Programación orientada a objetos en .NET. Programación .NET - I. Semana 6.
19
20

Contenido 6

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Contenido 6

Cargado por

Copyright:

Formatos disponibles

PROGRAMACIÓN .

PROGRAMACIÓN ORIENTADA A OBJETOS EN .NET ............................................................................ 4

Un objeto es una entidad que contiene características (atributos), comportamientos (métodos) y

Dim Variable As New Clase()

Donde la variable es asignada a la referencia de la instancia clase.

Un método es la implementación de un código que representa un proceso o función que realiza un

Protected Sub ProbarHerencia()

Public Class Administrador

Private varSueldo As Single

Property Sueldo() As Single

Set(ByVal Value As Single)

Para declarar clases base se usan las siguientes palabras clave:

MustInherit Class NombreClase

NotInheritable Class NombreClase

Para la declaración de propiedades o métodos en una clase derivada:

NotOverridable: no permite sobrescribir una clase derivada, la definición es realizada en el

MustOverride: la propiedad o método serán sobrescritos obligatoriamente dentro de la clase

Public Class Administrador

Public Overrides Sub CrearTrabajador (ByVal Codigo As Integer, _

En el caso siguiente se define el método VerSueldo, donde se crea al trabajador y se muestra su

Sub VerSueldo(ByVal vTrabajador As Trabajador, ByVal Codigo As Integer, _

Sub Probar () ‘Aquí Polimorfismo

Pedro Pérez, su sueldo es: 1000,00

Pedro Pérez, su sueldo es: 1020,83

A continuación, se muestra un ejemplo de definición de clases abstractas, en este caso se define la

Public MustInherit Class PagarServicios

2. LIBRERÍAS DE CLASES DE .NET

2.1. DESCRIPCIÓN DE LAS CLASES DEL SISTEMA

2.2. CLASIFICACIÓN DE CLASES

Espacios de nombres básicos:

System.Collecions.Generic: permite definir colecciones genéricas, permitiendo con esto la

System.IO: permite la escritura y lectura en archivos de manera sincrónica y asincrónica.

Espacios de nombres para datos:

System.Xml: las clases contenidas permiten el procesamiento de código XML.

System.Data.SqlClient: permiten la conexión a orígenes de datos SQL Server, ejecución de

Espacios de nombres para la web:

System.Web.UI: facilita la creación de formularios Web Forms.

System.Web.UI.HtmlControls: permite la creación de controles HTML, para ser incluidos en

System.Web.Services: permite la creación y uso de servicios web XML.

Espacios de nombres de aplicaciones para Windows:

System.Windows.Forms: permite la creación de aplicaciones en tipos Windows, posee la clase

System.Windows: facilita la creación de aplicaciones en Windows Presentation Foundation.

System.Windows.Controls: permite crear controles de Windows Presentation Foundation.

Espacios de nombres de seguridad:

System.Security: brinda el sistema de seguridad de Common Language Runtime.

System.Net.Security: permite la configuración de redes seguras entre hosts.

System.Web.Security: su uso permite la implementación de seguridad de ASP.NET en aplicaciones

 Para ampliar este contenido se recomienda visitar la página

3. CICLO DE VIDA DE UN OBJETO

La manera de definir un método es la siguiente:

Public Sub NombreMetodo(ByVal parámetro(s) As Tipo)

Overloads Sub SobreCarga(ByVal VariableChar As Char)

Public Property TuEstatura() As String

En el ejemplo siguiente se guarda el Rut y Nombre completo de los usuarios:

Dim Rut, NombreApellido As String

Corresponde a un conjunto de instructores similar a un método, y entre sus características

Es un conjunto de funciones para la liberación de recursos que se ejecutan de manera automática

Sub New (ByVal Constructor As String)

Ejemplo de un constructor llamado Valor:

Public Sub New(ByVal Valor As String)

If Valor <> "" Then

Sub New (ByVal Constructor1 As Integer, Constructor2 As Integer)

If Constructor1 > Constructor2 then