Está en la página 1de 11

Módulo: Programación

Programación Orientada a Objetos


Clases y Objetos en C#
Programación Clases y Objetos

Índice
1. ¿Qué es una clase?................................................................................... 4
2. ¿Cómo se define una clase? ..................................................................... 4
3. ¿Qué es un objeto? ................................................................................... 4
4. ¿Qué elementos puede contener una clase? ............................................ 4
5. ¿Qué es un constructor? ........................................................................... 4
6. ¿Cuántos constructores tiene una clase?.................................................. 4
7. Características de un constructor. ............................................................. 4
8. ¿Siempre existe el constructor vacío? ....................................................... 5
9. ¿Qué es un modificador de acceso? ......................................................... 5
10. ¿Cuáles son los modificadores de acceso más comunes? .................... 5
11. ¿Cuál es el modificador de acceso por defecto en C#? ......................... 5
12. Modificador de acceso private ................................................................ 5
13. Modificador de acceso public ................................................................. 5
14. Modificador de acceso protected............................................................ 5
15. Modificador de acceso static. Características. ....................................... 5
16. ¿Cómo se accede a los métodos estáticos de la clase? ........................ 5
17. ¿Cuáles son los tres pilares de la programación orientada a objetos? .. 6
18. ¿Qué es el encapsulamiento? ................................................................ 6
19. ¿Cómo conseguimos normalmente el encapsulamiento? ...................... 6
20. ¿Qué son las Propiedades en C#? ........................................................ 6
21. ¿Cómo se implementan las Propiedades? ............................................. 6
22. ¿Qué es herencia? ................................................................................. 7
23. ¿Cómo se denominan las respectivas clases que intervienen en la
herencia?.......................................................................................................... 7
24. ¿Qué ventajas obtenemos realizando herencia? ................................... 7
25. ¿Características de las clases derivadas? ............................................. 7
26. ¿Qué modificador de acceso deben tener en el padre los miembros que
se van a heredar? ............................................................................................ 7
27. ¿Cuál es la sintaxis que indica que una clase es heredada? ................. 7
28. Sintaxis de herencia en el constructor. ................................................... 7
29. ¿Qué es la herencia múltiple?, ¿Existe la herencia múltiple en C#? ...... 8
30. ¿Qué son métodos virtuales?................................................................. 8
31. ¿Cuál es la sintaxis para definir métodos virtuales? .............................. 8
32. ¿Qué es el polimorfismo?....................................................................... 8
33. ¿Qué es el espacio de nombres? ........................................................... 8
34. ¿Para qué sirve la cláusula using?......................................................... 8

Dpto. Informática Altair [ 2 / 11]


Programación Clases y Objetos

35. ¿Qué es un alias? .................................................................................. 9


36. ¿Qué clases de las BCL se pueden usar en un proyecto? .................... 9
37. ¿Qué es una excepción?........................................................................ 9
38. ¿Cómo se controlan excepciones? ........................................................ 9
39. Funcionamiento de la estructura try-catch-finally. .................................. 9
40. Algunas características de la cláusula finally. ....................................... 9
41. ¿En qué orden se deben colocar los bloques catch? ........................... 10
42. ¿Cuál es el catch más genérico y cómo funciona? .............................. 10
43. ¿En qué consiste lanzar una Excepción por código? ........................... 10
44. ¿Cómo se propagan las Excepciones? ................................................ 11
45. Diferencia entre pasar un parámetro por referencia o por valor. .......... 11
46. Característica de la asignación de objetos. .......................................... 11
47. ¿Cuál es la manera más correcta de declarar una variable de cadena
vacía? ............................................................................................................. 11

Dpto. Informática Altair [ 3 / 11]


Programación Clases y Objetos

Ev.4: Programación Orientada a Objetos

1. ¿Qué es una clase?


Es la definición de un tipo específico de datos (objetos). En esta definición se
concreta cómo se van a construir los objetos de ese tipo, cómo van a ser sus
campos (atributos) y su funcionalidad (sus métodos).

2. ¿Cómo se define una clase?


La sintaxis básica para definir una clase es la que a continuación se muestra:
public class <nombreClase>
{
<miembros> Veremos ejemplos
}

3. ¿Qué es un objeto?
Un objeto es la instancia de una clase, es decir, un elemento concreto del tipo
de la clase a la que pertenece.
Cada objeto tendrá sus características propias (atributos) y una forma de
operar con ellos (métodos). Tanto a los atributos como a los métodos se les
llama miembros de la clase.

4. ¿Qué elementos puede contener una clase?


Al menos el constructor que, si no aparece explícitamente, la clase tiene por
defecto el constructor vacío. Puede tener atributos, propiedades, constructores
y métodos. A estos elementos de la clase se les llama miembros de la clase

5. ¿Qué es un constructor?
Un constructor es un método de una clase que se utiliza para implementar
objetos de esa clase.

6. ¿Cuántos constructores tiene una clase?


Una clase siempre tiene al menos un constructor pero puede tener varios
(sobrecarga).

7. Características de un constructor.
Un constructor es un método con las siguientes características especiales:
 Tiene el mismo nombre que la clase a la que pertenece.
 No devuelve ningún valor. Construye un objeto.
 Normalmente será público para que se pueda utilizar.
 Normalmente se utiliza para inicializar los atributos de un objeto de esa
clase

Dpto. Informática Altair [ 4 / 11]


Programación Clases y Objetos

8. ¿Siempre existe el constructor vacío?


No siempre. En el caso de existir un constructor con parámetros, el constructor
vacío no existe, salvo que lo escribamos explícitamente.

9. ¿Qué es un modificador de acceso?


Es una cláusula que se pone delante del miembro al que queremos controlar,
para limitar quienes pueden acceder a dicho miembro.

10. ¿Cuáles son los modificadores de acceso más comunes?


public, private, protected, internal, protected internal, static.

11. ¿Cuál es el modificador de acceso por defecto en C#?


El modificador de acceso por defecto es private.

12. Modificador de acceso private


Se puede acceder a un miembro private sólo desde el código de la clase a la
que pertenece. Es lo considerado por defecto en punto Net.

13. Modificador de acceso public


Se puede acceder a un miembro public desde el código de cualquier parte del
proyecto.

14. Modificador de acceso protected


Sólo se puede acceder a un miembro protected desde el código de la clase a la
que pertenece o desde sus clases derivadas (hijas).

15. Modificador de acceso static. Características.


El modificador static se usa para definir miembros (datos o métodos) como
pertenecientes a una clase, en lugar de pertenecer a una instancia, es decir, a
un objeto de la clase.
La sintaxis de un método static es la siguiente:
<modific.acceso> static <tipo> NombreMétodo(. . .)
{
. . .
}

16. ¿Cómo se accede a los métodos estáticos de la clase?


Para acceder a métodos estáticos de las clases se antepone el nombre de la
clase en lugar de utilizar objetos.
<NombreDeLaClase>.NombreMétodo(. . .)

Dpto. Informática Altair [ 5 / 11]


Programación Clases y Objetos

17. ¿Cuáles son los tres pilares de la programación orientada a


objetos?
Los tres pilares de la programación orientada a objetos son:
Encapsulamiento Herencia y Polimorfismo.

18. ¿Qué es el encapsulamiento?


Podríamos definirlo como la capacidad que tienen los objetos de ocultar su
código y proteger sus datos, ofreciendo única y exclusivamente una interfaz
que garantiza que el uso del objeto es el adecuado.

19. ¿Cómo conseguimos normalmente el encapsulamiento?


Con los modificadores de acceso y las propiedades.

20. ¿Qué son las Propiedades en C#?


Las propiedades son miembros que ofrecen un mecanismo flexible para leer,
escribir o calcular los valores de campos privados.
Las propiedades se utilizan desde fuera como si fuesen campos (atributos)
públicos, aunque en realidad internamente son métodos especiales denominados
descriptores de acceso.
De este modo, se puede obtener acceso a los datos con facilidad, a la vez que se
controla la seguridad.

21. ¿Cómo se implementan las Propiedades?


public <tipo-del-campo> NombrePropiedad // ojo sin paréntesis
{
// Si quieres que se pueda leer (propiedad de lectura)
get{ <cuerpo-get> return valor; }

// Si quieres que se pueda actualizar (propiedad de escritura)


set{<campo> = value; }
}

Notas:
Como NombrePropiedad se suele poner el nombre del campo al que se refiere,
pero iniciándolo con Mayúscula. Ej: para campo edad, la propiedad Edad.
Tanto en el get como en el set puede haber otras instrucciones.

Ejemplo: Para una clase con un campo llamado nombre

public string Nombre


{
get { return nombre; }

set { nombre = value; }


}

Dpto. Informática Altair [ 6 / 11]


Programación Clases y Objetos

22. ¿Qué es herencia?


Es la posibilidad de definir nuevas clases a partir de clases ya definidas.
Permite que una clase adquiera los campos y métodos de otra clase, los
constructores no se heredan.

23. ¿Cómo se denominan las respectivas clases que intervienen


en la herencia?
A la clase de la que se parte, se le llama clase padre o clase base o
superclase.
A la clase que aprovecha la herencia se le llama clase hija o clase derivada.

24. ¿Qué ventajas obtenemos realizando herencia?


Garantiza la reutilización de código ya que en una clase hija no habrá que
reescribir lo que herede de su clase padre.
Además se estructuran los proyectos de manera más lógica e intuitiva.

25. ¿Características de las clases derivadas?


Puede heredar todos los miembros no privados de la clase padre excepto sus
constructores.
Una clase hija puede tener sus campos y métodos propios además de los
heredados.
Una clase hija puede modificar las propiedades y métodos heredados. A este
proceso se le llama virtualización.

26. ¿Qué modificador de acceso deben tener en el padre los


miembros que se van a heredar?
Para poder utilizar en la clase hija elementos de su clase padre, estos
elementos no deberán ser private sino, al menos, protected.

27. ¿Cuál es la sintaxis que indica que una clase es heredada?


class <nombreHija>:<nombrePadre>
{
<miembros exclusivos de la Hija>
}

28. Sintaxis de herencia en el constructor.


A la hora de escribir el constructor se coloca antes de la llave de apertura del
cuerpo del método, una llamada al constructor de la clase padre, de la forma:
: base(<parametrosBase>) NOTA: los parámetros de la llamada, sin el
tipo, son los que hemos denominado en la
clase hija.
A esta estructura se le llama inicializador base y se utiliza para indicar cómo
deseamos inicializar los atributos heredados.

Dpto. Informática Altair [ 7 / 11]


Programación Clases y Objetos

29. ¿Qué es la herencia múltiple?, ¿Existe la herencia múltiple


en C#?
La herencia múltiple se da cuando una clase hereda de más de una clase
padre. En C# no existe la herencia múltiple. Para conseguir el mismo efecto
se pueden usar clases abstractas e interfaces.

30. ¿Qué son métodos virtuales?


Son los métodos de una clase, cuya definición puede ser cambiada en sus
clases derivadas.

31. ¿Cuál es la sintaxis para definir métodos virtuales?


La sintaxis que se usa para definirlos es la siguiente:
En la clase padre se utiliza la palabra clave virtual:
public virtual <tipoDevuelto> <nombreMétodo>(<parámetros>)
{
<código>
}

En la clase hija se utiliza la palabra clave override:


public override <tipoDevuelto> <nombreMétodo>(<parámetros>)
{
<código>
}

Es importante tener en cuenta que los parámetros tienen que ser los mismos
en los dos métodos. En otro caso sería sobrecarga y no llevaría las clausulas
virtual ni override.

32. ¿Qué es el polimorfismo?


Es la posibilidad de asignar a variables de una clase, objetos del tipo de sus
hijas. En este caso, sólo se podrán usar miembros comunes a las dos y en el
caso de haber métodos virtuales se utilizarán automáticamente las versiones
de las clases hijas.

33. ¿Qué es el espacio de nombres?


Es la forma en la que se organizan las clases en .NET. Se trata de una
distribución parecida a un directorio respecto a los ficheros que contiene. El
directorio sería el Espacio de Nombres y los ficheros serían las clases.

34. ¿Para qué sirve la cláusula using?


Se utiliza para simplificar al programador el uso de clases de espacios de
nombres distintos al de nuestro proyecto. De ese modo, no necesitamos
referirnos a dicho espacio de nombre explícitamente cada vez que queramos
utilizar una de sus clases.

Dpto. Informática Altair [ 8 / 11]


Programación Clases y Objetos

Ejemplo: Si no usamos using System; podemos utilizar todas las clases


de este espacio de nombres, como Console, pero tendríamos que precederlas
de System. Es decir, tendríamos que escribir, por ejemplo:
System.Console.WriteLine()

35. ¿Qué es un alias?


Es un sobrenombre que se le asigna a un espacio de nombres o a cualquier
tipo para facilitar su uso al programador.
Sintaxis.
using <alias> = <nombreCompletoTipo>;
Ejemplo
using ENlistas = System.Collections.Generic;

36. ¿Qué clases de las BCL se pueden usar en un proyecto?


Todas. Independientemente de si se usa la clausura “using” o si se antepone el
nombre del espacio de nombres delante de la clase.

37. ¿Qué es una excepción?


Es un objeto de la clase System.Exeption que se construye y “lanza” cuando
se produce un error durante la ejecución del programa. Contiene toda la
información necesaria sobre el tipo concreto de error producido.

38. ¿Cómo se controlan excepciones?


Mediante las sentencias try-catch-finally

39. Funcionamiento de la estructura try-catch-finally.


El trozo de código susceptible de tener algún tipo de error de ejecución se
introduce dentro del bloque try.
Los sucesivos bloques catch tienen el código necesario para tratar el posible
error específico.
Cuando en una línea se produce un error de ejecución, el flujo salta hasta el
catch correspondiente a dicho error específico. Si no existiera un catch
específico del error producido, buscará un catch más genérico o un bloque
finally. Si no los encuentra, el programa colapsará.
El finally siempre se ejecutará. Suele utilizarse para lanzar un mensaje final, o
efectuar operaciones de limpieza de memoria, cierre de ficheros, etc.

40. Algunas características de la cláusula finally.


Se ejecutará se produzca o no se produzca error.
Se coloca siempre tras todos los catch.

Dpto. Informática Altair [ 9 / 11]


Programación Clases y Objetos

Es opcional salvo en el caso de que a un try no se le haya asociado ningún


catch. En este caso es obligatoria.

41. ¿En qué orden se deben colocar los bloques catch?


En primer lugar el más específico y en último el más genérico. Ejemplo:…
try
{
. . .
}
// Primero los catch específicos
catch (FormatException err)
{
. . .
}
catch (IndexOutOfRangeException err)
{
. . .
}
// Al final, si se ponen, los más genéricos
catch (Exception err)
{
. . .
}
catch
{
. . .
}
// Si se pone bloque filally (opcional) estará detrás del último catch
finally
{
. . .
}

42. ¿Cuál es el catch más genérico y cómo funciona?


El catch sin parámetros. Ejemplo:
catch
{
Console.WriteLine("¡¡Error desconocido!!");
}
Si se produce un tipo de excepción que no se captura con ninguno de los catch
específicos, entrará en este bloque de catch.

43. ¿En qué consiste lanzar una Excepción por código?


Consiste en construir un objeto Excepción del tipo que nos interese y lanzarla
mediante el método Throw. Ejemplo:
throw (new IndexOutOfRangeException());

throw (new Exception("Error de rango"));

El primero de estos dos ejemplos lo capturará el catch del tipo correspondiente


y el segundo el catch genérico.

Dpto. Informática Altair [ 10 / 11]


Programación Clases y Objetos

Como se ve en el segundo ejemplo, se puede personalizar el mensaje


asociado a la excepción.

44. ¿Cómo se propagan las Excepciones?


Si se hace una llamada a un método donde no se ha controlado una excepción
y ésta se produce, se propagará al lugar donde se realizó la llamada, y también
puede ser controlada ahí. Si no se hace, la aplicación colapsará.

Otras preguntas sobre POO

45. Diferencia entre pasar un parámetro por referencia o por


valor.
En el paso de un parámetro por valor pasamos una copia del valor por lo que
los cambios solo afectarán dentro del ámbito donde se trate el objeto pasado.
En el paso de un parámetro por referencia pasamos la referencia de memoria
correspondiente al objeto pasado, por lo que los cambios que realicemos sobre
el objeto, sí se conservarán.

46. Característica de la asignación de objetos.


La asignación de objetos siempre se realiza por referencia, es decir, los dos
apuntarán a la misma dirección de memoria, por lo que cualquier cambio en
uno de los objetos afectara al otro.
Ejemplo: Si tenemos Cuadrado c1= new Cuadrado(50);
Y luego hacemos Cuadrado c2 = c1;
Cualquier cambio que se haga en c1, se hará en c2 y viceversa.

47. ¿Cuál es la manera más correcta de declarar una variable de


cadena vacía?
En el caso de que indicar que una variable string x está vacía normalmente
usamos la expresión string x = "";. El inconveniente de hacerlo así es que al
usar comillas dobles, cada vez se creará un nuevo objeto de tipo string.
La forma más correcta de hacerlo es usando la propiedad String.Empty. De
esta forma solo tendríamos una instancia (String.Empty precisamente) para
todas las variables asignadas, además el uso de comillas dobles puede ser
interpretado de formas diferentes según el lenguaje de programación, pero si
usamos String.Empty el propio compilador se encarga de hacer la traducción
correspondiente al lenguaje que lo ejecute.

Dpto. Informática Altair [ 11 / 11]

También podría gustarte