Hola de nuevo, ahora que sabemos como crear una clase, vamos a ver que podemos escribir dentro de ella para poder generar aplicaciones.

Dentro de una clase podemos incluir lo que llamaremos miembros de clase y estos son:

    • Campos. Un campo es una variable que se utiliza para almacenar un valor. Si yo quiero calcular x+3, creo una variable x pudiéndole asignar infinitos valores, pero lo importante no es poder asignarle infinitos valores, es que puede almacenar un valor, al nombre x le adjudicamos una relación con un valor.
    • Métodos. Los métodos son el código real, lo que tiene que hacer un objeto cuando lo instanciamos. En la clase vehículo que creamos, había varios métodos, ARRANCAR, PARAR y AVANZAR. Dentro de los métodos escribiremos el código necesario para hacer lo que queremos hacer.
    • Propiedades. Las propiedades a mi parecer han sido un gran invento, son campos con métodos!! que cosas tiene esto de la programación!, pues si, son campos de cara al usuario, es decir almacenan valores pero en realidad son métodos porque dentro de las propiedades podemos incluir más código. Los llaman Smart Fields (Campos inteligentes)!! y pueden ser de lectura y escritura o lectura.
    • Constantes. Es un campo con un valor fijo, invariable, de solo lectura, ya que no podemos cambiarlo. ¿Para que se utilizan? pues por ejemplo para almacenar el número pi, el número e, un texto que se repite mil veces y es siempre el mismo, pues para eso.
    • Eventos. Un evento se produce cuando pasa algo, por ejemplo click de ratón. Si le asignamos un evento a un botón, cuando hagamos click sobre él (cuando pulsamos), este correrá código de un método asociado, por ejemplo cambiar de color el botón. En el lenguaje “der waki”, cuando pulses el botón, cambiar de color botón.

Hay más miembros de clase, pero creo que con estos es suficiente para aprender.

Existen además elementos muy importantes en programación que son los modificadores de acceso. A todos los miembros de clase hay que especificarle lo visibles o accesibles que deben ser vistos desde fuera o desde la misma clase. Por ejemplo supongamos que mi casa es una clase, yo que soy el propietario, (vivo en la clase) puedo abrir la puerta, llamar al timbre, cocinar, limpiar, etc. pero un alguien que intente usar mi casa, no podría hacerlo porque no tiene los medios para hacerlo, lo más que le permitiría sería dejar una carta en el buzón o llamar al timbre. Pues como solo quiero que haga eso, los métodos de dejar carta en el buzón y llamar al timbre, pues estos métodos los haría públicos, mientras que los de cocinar o limpiar los haría privados.

¿Captada la idea? pues hay cuatro modificadores (en C#):

    • public. Esto quiere decir que el miembro de clase, es accesible desde fuera de la clase que lo ha definido y de la jerarquía de clases derivadas o heredadas. Vamos, que si instanciamos un casa nueva como la mía por ejemplo, el usuario de esa clase solo podrá usar los métodos que creamos como públicos.
    • protected. El miembro de clase no es visible desde fuera pero si desde las clases derivadas. Nuestro ejemplo, clase vehículo y camión. El método ARRANCAR podría ser protected, ya que al derivar la clase camión de vehículo, este método podría ser usado por el camión aunque el método en si pertenece a vehículo.
    • private. Los miembros de clase con este modificador solo son accesibles desde la propia clase, las clases derivadas no pueden acceder a ellos.
    • internal. Los miembros de clase internos solo son accesibles desde la compilación es un híbrido entre protected y public, dependiendo donde esté el código.

En VB.NET son Public, Protected, Private y Friend.

Damos paso a un ejemplo de una clase con una propiedad, un campo y un método. Por cierto, se me olvidaba, no lo puse en la anterior entrega para no liarnos, todas las clases tiene un método inicial con el mismo nombre que la clase (por algún sitio tenía que empezar la clase, ¿no?)

En C#

using System;
using System.Drawing;
using System.Windows.Forms;
namespace MyNameSpace
{
    public class MyClass: Form
    {
        public MyClass()
        {
               // lo primero que hace la clase cuando es instanciado como objeto,
               // es el código contenido aquí. El nombre es igual que la clase
        }          

        // aquí incluyo los campos
        int variable_1 = 3;
        const double s = 3.1415926535; // número pi           

        // aquí incluyo las propiedades. Para las propiedades, habrá un capítulo entero
        private string variable_privada_propiedad;
        public string Propiedad_1
        {
            get { return variable_privada_propiedad ; }
            set { variable_privada_propiedad  = value; }
        }          

        // aquí los métodos
        protected void CargarMenuPrincipal()
        {
            // el código para cargar el menú principal, estaría contenido aquí
        }
    }
}

en  VB.NET


Imports System
Imports System.Drawing
Imports System.Windows.Forms
Namespace MyNameSpace
    Public Class [MyClass]
        Inherits Form     

        Public Sub New()
            ' lo primero que hace la clase cuando es instanciado como objeto,
             ' es el código contenido aquí. el nombre es igual que la clase
        End Sub 

        ' aquí incluyo los campos
        Private variable_1 As Integer = 3
        Const s As Double = 3.1415926535 ' número pi

        ' aquí incluyo las propiedades. Para las propiedades, habrá un capítulo entero
        Private variable_privada_propiedad As String
        Public Property Propiedad_1() As String
            Get
                Return variable_privada_propiedad
            End Get
            Set(value As String)
                variable_privada_propiedad = value
            End Set
        End Property 

        ' aquí los métodos
        Protected Sub CargarMenuPrincipal()
            ' el código para cargar el menú principal, estaría contenido aquí
        End Sub

    End Class
End Namespace

Analicemos el código. Lo primero importamos espacios de nombres (using e Imports), después nuestro espacio de nombres, todas las clases que creemos dentro de este espacio de nombres, podrán ser instanciadas a través de este.

Nombre de la clase con modificador público. Ahora vemos en C# dos puntos y Form y para VB Inherits Form, pues esto es como realmente se hereda una clase de otra, nuestra clase hereda de la clase Form que proviene del espacio de nombres System.Windows.Forms, de modo que nuestra clase tendrá el aspecto de un formulario de Windows. La herencia solo puede ser usada una sola vez, es decir, una clase solo se puede ser derivada de otra, pero no de 3 o cuatro clases, para hacer algo parecido, tenemos otros elementos.

Después aparece el constructor de la clase, que es el código que primero se ejecutará.

Pasamos a los campos. Primero tenemos un campo del tipo número entero (int e Integer) al cual le hemos dado por primera vez el valor de 3. Como es variable en cualquier momento podemos darle cualquier valor; como es privado, solo puede ser visto desde la clase.

Ahora creamos un valor constante (de solo lectura) de tipo numérico doble (double y Double) y le asignamos el número pi con 10 decimales.

Ahora creamos una propiedad que como ya he dicho, dedicaré un capítulo a este miembro de clase y por último un método protected simple con el pretendemos cargar el menú principal de nuestra aplicación. (Para C# un método se inicia con void y llaves {} y en VB mediante Sub y End Sub.)

Ya está, poco a poco va creciendo nuestra clase y le vamos dando forma. El desarrollo de software es arquitectura por tanto antes de empezar a escribir código hay muchos elementos comunes y fijos que siempre aparecen en las clases, pero hay otros que debemos y tenemos que meditar, planificar, diseñar, etc. antes de plasmarlos en una clase como líneas de código.

Antes de despedirme he dejado caer los tipos int y double, pues hay muchos más. Al declarar una variable como un tipo concreto, le estamos diciendo que guarde en memoria un objeto concreto con unas características concretas, por ejemplo, cuando hemos guardado en la variable variable_1 el valor 3 como un valor entero, estamos diciéndole al sistema que el valor que voy a guardar en un futuro, no va a sobrepasar los 32 bit en binario (ala!!!) y sin embargo para el valor de pi, he visto que es necesario su utilización como valor double que utiliza valor en coma flotante con 64 bit en binario (otra vez alaaaaa!!!!!)¿pero que es esto? tranquiiiilos! todo llega.

Espero no haberos aburrido!!

Saludos “der Waki”

Anuncios

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión /  Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión /  Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión /  Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión /  Cambiar )

w

Conectando a %s