desarrollo de software-1
TRANSCRIPT
Aldea: Aldea Universitaria: “Alberto Carnevalli“El Tigre, Estado Anzoátegui
PNF en Ingeniería en SistemasDesarrollo de Software
Elaborado por:Thays SulbaránCI: 10.065.870Omar QuijadaCI: 11.422.440Juan MariñoCI: 18454612
El Tigre, Enero del 2012
INTRODUCCIÓN
La programación orientada a objeto, no es difícil de aprender. La idea principal
es que la información se organiza en términos de objetos. En el caso de
JavaScript viene con una biblioteca incorporada de objetos.
Por ejemplo, una ventana es un objeto. Cada vez que nos referimos a uno de
los objetos por defecto de JavaScript comenzaré con una mayúscula (Window).
Instancias específicas (una ventana en particular) estarán en minúsculas.
El propósito de este trabajo es explicar cómo crear o generar objetos a partir de
una clase, ya que la clase en sí, es el molde del cual se pueden crear objetos
o instancias.
Los objetos que creemos van a tener unas variables asociadas, las cuales
pueden ser públicas o privadas.
Los lenguajes de programación son poco más que una lista de acciones a
realizar sobre un conjunto de datos en una determinada secuencia.
Cuando se crea un software, se sigue una secuencia u orden, de esta manera
modelizamos nuestro programa. Si en algún momento se modifica la estructura
de los datos, el programa cambia.
CREACIÓN Y CONTROL DE LAS PROPIEDADES DE UN OBJETO
Operador new
La utilidad del operador new, que precisamente es crear objetos y cuya
sintaxis es:
new <nombreTipo>(<parametros>)
Este operador crea un nuevo objeto del tipo cuyo nombre se le indica y llama
durante su proceso de creación al constructor del mismo apropiado según los
valores que se le pasen en <parametros>, devolviendo una referencia al objeto
recién creado. Hay que resaltar el hecho de que new no devuelve el propio
objeto creado, sino una referencia a la dirección de memoria dinámica donde
en realidad se ha creado.
El antes comentado constructor de un objeto no es más que un método
definido en la definición de su tipo que tiene el mismo nombre que la clase a la
que pertenece el objeto y no tiene valor de retorno. Como new siempre
devuelve una referencia a la dirección de memoria donde se cree el objeto y
los constructores sólo pueden usarse como operandos de new, no tiene
sentido que un constructor devuelva objetos, por lo que no tiene sentido incluir
en su definición un campo <tipoDevuelto> y el compilador considera erróneo
hacerlo (aunque se indique void)
El constructor recibe ese nombre debido a que su código suele usarse precisamente
para construir el objeto, para inicializar sus miembros. Por ejemplo, a nuestra clase de
ejemplo Persona le podríamos añadir un constructor dejándola así:
class Persona
{
string Nombre; // Campo de cada objeto Persona que almacena su nombre
int Edad; // Campo de cada objeto Persona que almacena su edad
string NIF; // Campo de cada objeto Persona que almacena su NIF
void Cumpleaños() // Incrementa en uno la edad del objeto Persona
{
Edad++;
}
Persona (string nombre, int edad, string nif) // Constructor
{
Nombre = nombre;
Edad = edad;
NIF = nif;
}
}
Como se ve en el código, el constructor toma como parámetros los valores con
los que deseemos inicializar el objeto a crear. Gracias a él, podemos crear un
objeto Persona de nombre José, de 22 años de edad y NIF 12344321-A así:
new Persona("José", 22, "12344321-A")
La forma en que se pasan parámetros al constructor consiste en indicar los
valores que se ha de dar a cada uno de los parámetros indicados en la
definición del mismo separándolos por comas. Obviamente, si un parámetro se
definió como de tipo string habrá que pasarle una cadena, si se definió de tipo
int habrá que pasarle un entero y, en general, a todo parámetro habrá que
pasarle un valor de su mismo tipo (o de alguno convertible al mismo),
produciéndose un error al compilar si no se hace así.
En realidad un objeto puede tener múltiples constructores, aunque para
diferenciar a unos de otros es obligatorio que se diferencien en el número u
orden de los parámetros que aceptan, ya que el nombre de todos ellos ha de
coincidir con el nombre de la clase de la que son miembros. De ese modo,
cuando creemos el objeto el compilador podrá inteligentemente determinar cuál
de los constructores ha de ejecutarse en función de los valores que le pasemos
al new.
Una vez creado un objeto lo más normal es almacenar la dirección devuelta
por new en una variable del tipo apropiado para el objeto creado. El siguiente
ejemplo -que como es lógico irá dentro de la definición de algún método-
muestra cómo crear una variable de tipo Persona llamada p y cómo almacenar
en ella la dirección del objeto que devolvería la anterior aplicación del operador
new:
Persona p; // Creamos variable p
p = new Persona("Jose", 22, "12344321-A");
// Almacenamos en p el objeto creado con new
A partir de este momento la variable p contendrá una referencia a un objeto
de clase Persona que representará a una persona llamada José de 22 años y
NIF 12344321-A. O lo que prácticamente es lo mismo y suele ser la forma
comúnmente usada para decirlo: la variable p representa a una persona
llamada José de 22 años y NIF 12344321-A.
Como lo más normal suele ser crear variables donde almacenar referencias a objetos
que creemos, las instrucciones anteriores pueden compactarse en una sola así:
Persona p = new Persona("José", 22, "12344321-A");
De hecho, una sintaxis más general para la definición de variables es la siguiente:
<tipoDato> <nombreVariable> = <valorInicial>;
La parte = <valorInicial> de esta sintaxis es en realidad opcional, y si no se
incluye la variable declarada pasará a almacenar una referencia nula
(contendrá el literal null).
Constructor por defecto
No es obligatorio definir un constructor para cada clase, y en caso de que no
definamos ninguno el compilador creará uno por nosotros sin parámetros ni
instrucciones. Es decir, como si se hubiese definido de esta forma:
<nombreTipo>(){}
Gracias a este constructor introducido automáticamente por el compilador, si
Coche es una clase en cuya definición no se ha incluido ningún constructor,
siempre será posible crear uno nuevo usando el operador new así:
Coche c = new Coche(); //Crea coche c llamando al constructor por defecto de
Coche
Hay que tener en cuenta una cosa: el constructor por defecto es sólo incluido
por el compilador si no hemos definido ningún otro constructor. Por tanto, si
tenemos una clase en la que hayamos definido algún constructor con
parámetros pero ninguno sin parámetros no será válido crear objetos de la
misma llamando al constructor sin parámetros, pues el compilador no lo habrá
definido automáticamente. Por ejemplo, con la última versión de la clase de
ejemplo Persona es inválido hacer:
Persona p = new Persona(); // ERROR:
// El único constructor de Persona
// toma 3 parámetros
Referencia al objeto actual con this
Dentro del código de cualquier método de un objeto siempre es posible
hacer referencia al propio objeto usando la palabra reservada this. Esto puede
venir bien a la hora de escribir constructores de objetos debido a que permite
que los nombres que demos a los parámetros del constructor puedan coincidir
nombres de los campos del objeto sin que haya ningún problema. Por ejemplo,
el constructor de la clase Persona escrito anteriormente se puede rescribir así
usando this:
Persona (string Nombre, int Edad, string NIF)
{
this.Nombre = Nombre;
this.Edad = Edad;
this.NIF = NIF;
}
Es decir, dentro de un método con parámetros cuyos nombres coincidan con
campos, se da preferencia a los parámetros y para hacer referencia a los
campos hay que prefijarlos con el this tal y como se muestra en el ejemplo.
El ejemplo anterior puede que no resulte muy interesante debido a que para
evitar tener que usar this podría haberse escrito el constructor tal y como se
mostró en la primera versión del mismo: dando nombres que empiecen en
minúscula a los parámetros y nombres que empiecen con mayúsculas a los
campos. De hecho, ese es el convenio que Microsoft recomienda usar. Sin
embargo, como más adelante se verá sí que puede ser útil this cuando los
campos a inicializar a sean privados, ya que el convenio de escritura de
identificadores para campos privados recomendado por Microsoft coincide con
el usado para dar identificadores a parámetros (obviamente otra solución sería
dar cualquier otro nombre a los parámetros del constructor o los campos
afectados, aunque así el código perdería algo legibilidad)
Un uso más frecuente de this en C# es el de permitir realizar llamadas a un
método de un objeto desde código ubicado en métodos del mismo objeto. Es
decir, en C# siempre es necesario que cuando llamemos a algún método de un
objeto precedamos al operador de alguna expresión que indique cuál es el
objeto a cuyo método se desea llamar, y si éste método pertenece al mismo
objeto que hace la llamada la única forma de conseguir indicarlo en C# es
usando this.
Finalmente, una tercera utilidad de this es permitir escribir métodos que
puedan devolver como objeto el propio objeto sobre el que el método es
aplicado. Para ello bastaría usar una instrucción return this; al indicar el objeto
a devolver.
Propiedades de los objetos
Los objetos tienen propiedades que los describen. Algunas de las propiedades
de un objeto Window es su nombre, las palabras en su barra de estado, la URL
del documento dentro de la ventana y el documento de la ventana en sí mismo
que incluye las palabras imágenes y enlaces dentro de la ventana.
En JavaScript tiene un objeto Ventana por defecto que es donde se ubican
todas las cosas llamada window. Una de las propiedades de una ventana son
las palabras en su barra de estado. Para saber que palabras están presentes
en la barra de estado se realiza lo siguiente:
var estado = window.status;
Esto dice: "Encuéntrame la propiedad estado del objeto Ventana llamada
windows y cárguelo en la variable estado". Además de leer cuales son estas
palabras, puede también cambiarlas. La forma de establecer las propiedades
de un objeto es:
window.status = "La vida es bella!";
Realice un programa JavaScript que al pasar el mouse sobre un enlace
describa, sobre la barra de estado, de que se trata dicho enlace
Veamos el siguiente código:
<a href="#" onMouseOver="window.status='Actualiza la Base de Datos';return
true;">
Actualizar
</a>
Esto dice, "Cuando el mouse se mueva sobre este enlace, cambie la barra de
estado". Si lo mira detenidamente advertirá un "return true" dentro de la
cláusula onMouseOver. Si no pusiera esto, el navegador haría lo que
normalmente hace cuando mueve el cursor sobre un enlace, mostrará la URL
descripta en href y lo pondrá en la barra de estado, reemplazando el texto que
Ud. puso en la barra de estado.
Poniendo return true en onMouseOver, le impide al navegador que haga esto.
No obstante se puede usar "return false" dentro de onClick para impedir al
navegador que cargue la URL especificada.
<a href="#" onClick="return false;">este enlace no hace nada!</a>
Porque se pone return false en un onClick y return true en un onMouseOver
es uno de los misterios de la vida que mejor es dejarlo como misterio.
Métodos que tienen los objetos
Además de las propiedades, los objetos también tienen métodos. Los métodos
son las acciones que se pueden aplicar a un objeto. Por ejemplo, Windows
sabe como abrir una ventana: window.open("URL,""name,""features"). Esto
le dice a JavaScript que use los métodos open del objeto Window para abrir
una nueva ventana.
Por lo tanto, como en ejemplo de arriba, un método de un objeto se llama del
mismo modo que se accede a una propiedad: el nombre del objeto, un punto y
el nombre del método.
La principal diferencia es que los métodos están siempre seguidos por
paréntesis que contienen los parámetros de los métodos. Aún si el método no
tiene parámetros, necesita los paréntesis. Por ejemplo, para poner algo en
itálica:
var italic_hippy = hippy_monkey.italics();
Si las tiras de caracteres son realmente objetos e italics() es un método del
objeto String. Hemos visto varios otros ejemplos de métodos para ventanas.
La caja de dialogo, alerta y prompt son realmente métodos del objeto
Windows. Si llama:
window.alert("Viva la naturaleza!!");
Obtendrá una caja de alerta donde podrá leer "Viva la naturaleza!!", esto es
porque Window es el objeto de más bajo nivel. Esto significa que
open("URL","name,""features") hace la misma cosa que
window.open("URL,""name,""features").
No veremos todos los métodos del objeto Window aquí, solo dos más focus y
blur. El método focus mueve una ventana que está detrás de otra ventana al
frente.
El método blur hace la inversa, mueve una ventana por detrás de otra.
Desafortunadamente estos métodos pueden que no funcionen correctamente
en su navegador, por lo tanto deberá asegurarse de esto.
El código dentro de onClick:
onClick="window.blur();return false;"
Window.blur() le dice al navegador que envíe esta ventana a la parte de atrás.
Es hermoso pero parece medio tonto hacerlo con la ventana principal. Para
usar focus y blur de una forma más útil deberá conocer como llamar métodos
sobre otras ventanas.
Comunicándose entre ventanas
Si bien no tiene sentido blur o focus con la ventana principal, puede querer
manejar el comportamiento de otra ventana. Para comunicarse con una
ventana usando JavaScript, necesita una referencia a dicha ventana. Veamos
este ejemplo y luego veamos la explicación.
<p><a href="#" onClick="window.open('ventana_referencia.html','wind_ref',
'height=400,width=400,menubar');">Obteniendo y usando una ventana</a>.
Esto abre una pequeña ventana.
Hay unas pocas líneas claves en este JavaScript. Primero, abrimos una nueva
ventana y obtenemos una referencia a ella:
var new_window =
window.open("hello.html","html_name","width=200,height=200");
Esto abre una pequeña ventana y asigna una variable new_window para
referirse a ella. Del mismo modo que las variables pueden contener número o
tiras, las variables también pueden contener referencias a objetos (en este
caso un objeto Ventana).
Ahora la variable new_window se comportará como el objeto por defecto
Window. Puede usar métodos con ella. La siguiente línea muestra un ejemplo
de llamar un método sobre new_window: new_window.blur().
Ahora un poco de truco, es como window.blur() desde la última página. Estas
dos líneas aparecen en el encabezado HTML de la página.
Ver código fuente de la página si quiere ver todas las cosas. Como he
mencionado , tienda a poner el código JavaScript en el encabezado HTML de
las páginas HTML. De este modo puedo encontrarlo cuando lo busco. Estas
líneas de JavaScript podrían haber estado en el cuerpo.
Ahora, moviéndonos al cuerpo vemos dos enlaces que moverán la nueva
ventana hacia delante o hacia atrás:
<a href="#" onMouseOver="new_window.focus();">Bring it forward</a>
<a href="#" onMouseOver="new_window.blur();">Put it backward</a>
Modelo de Objeto de Documento
(DOM)
Hasta ahora hemos aprendido que JavaScript incluye objetos por defecto como
Windows. Hemos aprendido que los objetos tienen propiedades que los
describen y métodos que describen qué es lo que saben hacer y como lo
hacen. Ahora es tiempo de profundizar un poco estos conocimientos.
Una cosa buena sobre objetos es que las propiedades de un objeto pueden ser
también objetos. Por ejemplo, las ventanas tienen una propiedad llamada
documento que se refiere al documento real HTML en la ventana. Este
propiedad documento es en sí misma un objeto que tiene propiedades y
métodos que le son propios. Hemos visto un ejemplo de esto cuando hablamos
sobre intercambio de imágenes. Volviendo a la última lección, aprendimos que
puede intercambiar imágenes como esto:
<a href="#" onMouseOver=
"window.document.the_image.src='button_d.gif';">
change</a>
Esta larga tira, window.document.the_image.src='button_d.gif', se traduce
en: "Encuentre la propiedad de la ventana del documento, encuentre la
propiedad del documento the_image, encuentre la propiedad src de the_image
y establézcala a button_d.gif". ¿Demasiado palabrerío, no?. Todo funciona
porque son objetos, documento dentro de windows es un objeto y las imágenes
dentro de los documentos también son objetos.
Parece como demasiado detalle, pero realmente no es muy complicado y por
otro lado parece bastante lógico. El DOM de JavaScript, describe una pequeña
jerarquía de objetos, aquí está:
La caja superior del diagrama representa a la ventana de su navegador.
Siguiendo la línea desde esa caja y hacia abajo, veremos 7 cajas
interconectadas. Estas son las propiedades de la ventana (window) del
navegador. La sexta caja, "document", representa los contenidos de su
ventana. Si sigue la pequeña línea desde la caja documento verá que se
conecta a seis cajas más. Estas son las propiedades del objeto documento.
Note que la cuarta caja son imágenes "images". Esta es la lista de todas las
imágenes de su página Web. Debido a que las imágenes son propiedades del
"document", que a su vez es una propiedad de "window", el modo preciso de
describir una imagen para JavaScript es decir que mire en la "window", que
encuentre el "document" de la ventana y en el documento buscar la imagen.
Las propiedades del objeto documento lo veremos en breve.
Sin embargo, antes de que le pueda extraer todo su potencial de este objeto,
debería conocer como manejar los conceptos del DOM en otras ventanas.
Jerarquía de objetos en un documento
JavaScript organiza todos los elementos de una página en una jerarquía. Cada
elemento se ve como un objeto. Cada objeto puede tener ciertas propiedades y
métodos. Con la ayuda de JavaScript puede fácilmente manejar los objetos.
Para esto es muy importante comprender la jerarquía de los objetos. Veamos
una página:
Tenemos dos imágenes, un enlace y un formulario con dos campos de texto y
un botón. Desde el punto de vista de JavaScript la ventana del navegador es el
objeto-ventana. Éste objeto contiene ciertos elementos como la barra de
estado. Dentro de una ventana se puede cargar un documento HTML. Ésta
página es un objeto-documento, esto significa que el objeto-documento
representa el documento HTML. El objeto-documento es un objeto muy
importante en JavaScript, se usa una y otra vez. Las propiedades del objeto
documento son por ejemplo el color de fondo de la página. Pero lo más
importante es que todos los objetos son propiedades del objeto documento. Un
objeto HTML es, por ejemplo, un enlace o un formulario. Veamos lo siguientes
objetos mostrados como jerarquías:
Lo que queremos es poder obtener información sobre los distintos objetos y
manejarlos. Para esto tenemos que conocer como acceder a los diferentes
objetos. Puede ver los nombres de los objetos en la jerarquía. Si ahora quisiera
saber como referirse a la primer imagen de la página HTML tiene que observar
la jerarquía. Comenzando desde la parte superior. El primer objeto se llama
documento.
La primer imagen se representa por medio de images. Esto significa que
podemos acceder a este objeto a través de JavaScript por medio de
document.images. Si por ejemplo quisiera saber lo que el usuario ingresó en el
primer elemento del primer formulario, nuevamente siguiendo la jerarquía sería:
document.forms[0].elements[0]
Pero, ¿cómo podemos saber el valor ingresado? Lo primero que tendría que
hacer es referirse a las propiedades que tiene el elemento. Una de ellas nos
ayuda a nosotros a responder la pregunta anterior. La propiedad es: value, por
lo tanto podríamos hacer:
nombre=document.forms[0].elements[0].value;
Una cosa que tenemos que tener en claro es que se puede también manejar
por medio de los nombres de cada uno de los elementos de la página. Por
ejemplo veamos el siguiente trozo de HTML.
<form name="primero">
Ingrese su nombre:<br>
<input type="text" name="text1">
<input type="button" name="button1" value="Test Input"
onClick="test1(this.form)">
<P>
Ingrese su dirección de correo:<br>
<input type="text" name="correo">
<input type="button" name="button2" value="Test Input"
onClick="test2(this.form)">
</body>
Para referirnos al valor del correo ingresado lo podemos hacer por medio de:
document.primero.correo.value
Relacionándonos con otras ventanas
Como ya hemos visto, para intercambiar una imagen la llevamos a cabo con:
window.document.la_imagen.src="button_d.gif";
Esto funciona diciéndole a JavaScript que mire en una ventana, encuentre su
documento y luego que busque una cosa llamada la_imagen dentro del
documento. Una vez que JavaScript ubica la imagen, puede cambiar su src a
cualquier GIF que queramos.
A veces es útil tener un enlace en una ventana que cambie la imagen en otra
ventana. Imagínese una muestra de diapositivas en la cual una ventana
muestra las imágenes y otra pequeña ventana que contiene las imágenes
reducidas de cada diapositiva. Presionando sobre las reducidas en la pequeña
ventana, cambia la imagen de la imagen grande.
Para dar una idea sobre lo que estoy hablando ejecute diapo_menu1_0.html,
analice su código luego bosqueje el porqué de su comportamiento.
Hasta este momento únicamente se ha visto la posibilidad de dibujar cajas y
esferas de forma dinámica sin que sus dimensiones se tengan en cuenta pero
a partir de ahora los objetos se van a crear con unas dimensiones
determinadas.
Este apartado pretende ser una introducción a la creación de objetos de modo
que se conozcan los distintos tipos de objetos que se pueden crear y el
proceso general de creación de los mismos.
Tipos de objetos
Si bien 3D Studio está diseñado para el dibujo en tres dimensiones, también
permite la creación de objetos en dos dimensiones que normalmente sirven
como base para la creación de objetos 3D. Por tanto, se pueden dividir los
objetos en dos grandes grupos:
Geometrías: objetos 3D.
Formas: objetos 2D.
Geometrías
Se denominan geometrías a los objetos en 3D. Dentro de este grupo se
pueden encontrar desde objetos simples como esferas o cajas a objetos más
complejos como pueden ser los sistemas de partículas. En función del tipo de
geometría se agrupan en:
Primitivas estándar: son objetos 3D sencillos (cajas, esferas...) que se
crean sin más que asignar valores a una serie de parámetros que los
definen.
Primitivas extendidas: son objetos 3D similares a los anteriores pero
más elaborados (cápsulas, bidones...). También se crean asignando
valores a los parámetros que los definen.
Objetos de composición: son objetos que se crean a partir de otros
objetos. Algunos ejemplos son:
o Objetos booleanos: combinan la geometría de dos objetos
mediante las operaciones unión, intersección y diferencia.
o Objetos FusForma: permiten incrustar una forma spline en una
malla geométrica.
o Objetos solevados: se crean a partir de una forma que sirve como
recorrido y formas que establecen las secciones transversales a
lo largo del mismo.
Sistemas de partículas: son objetos animados que simulan aerosol,
nieve, ventisca y grupos similares de objetos pequeños.
Cuadrículas de corr.: son superficies 2D sencillas listas para modelar o
reparar mallas existentes.
Objetos NURBS: son superficies generadas analíticamente, adecuadas
para modelar superficies con curvas complicadas.
Objetos dinámicos: objetos diseñados para uso en simulaciones
dinámicas.
Formas
Las formas son curvas spline o NURBS. Aunque se trata de objetos en 2D
pueden encontrarse tanto en un espacio en 2D, como es el caso de
rectángulos o círculos, como en espacio 3D, como es el caso de la hélice.
Los dos tipos de formas que se pueden crear son:
Spline: formas 2D sencillas (líneas, círculos, rectángulo, etc.).
Curvas NURBS: permiten la creación de superficies complejas.
Método de creación de objetos
Aunque la creación de cada tipo de objeto difiere, en todos los casos el
comienzo del proceso es similar y algunas características comunes. Es por ello
que los aspectos que explicamos a continuación se puedan aplicar a la mayoría
de los objetos.
No existe un único modo de crear un objeto, ya que hay muchos caminos para
ello. El método que presentamos a continuación no tiene por qué ser el más
adecuado, pero va a servir para conocer todas las opciones que se presentan a
la hora de crear un objeto simple.
1. Hacer clic sobre la solapa Crear del Panel de comandos.
2. Hacer clic sobre el botón correspondiente a la categoría que contiene el
objeto que se quiere crear. De izquierda a derecha: Geometrías,
Formas, Luces, Cámaras, Ayudantes, Efectos especiales y
Sistemas.
3. Cada una de estas categorías presenta a su vez varias subcategorías,
seleccionar aquella que contenga el objeto a crear de la lista
desplegable que se presenta bajo los iconos, tal y como muestra la
siguiente imagen.
4. Una vez seleccionada la subcategoría los objetos que contiene se
muestran dentro de la persiana Tipo de objeto, si no está abierta hacer
clic sobre su nombre.
5. Hacer clic sobre el nombre del objeto que se quiere crear. Observar que
el botón toma un color anaranjado lo que indica la operación que se está
realizando.
6. Al seleccionar el objeto se muestran nuevas persianas en el Panel
Crear que permitirán establecer las características del nuevo objeto.
7. En función del objeto seleccionado, la persiana Método de creación
muestra distintas opciones a partir de las cuales crear el objeto. Activar
la que se precise.
8. Si el visor en el cual se quiere dibujar el objeto no es el actual hacer clic
sobre él y situar a continuación el puntero en la posición donde se quiere
situar el nuevo objeto.
9. Pulsar el botón del ratón y, sin soltarlo, arrastrarlo hasta que el objeto
tome las dimensiones adecuadas. Soltar en ese momento el botón del
ratón.
10.Si el objeto necesita más parámetros (por ejemplo, en el caso de la caja
se define primero la base y luego la altura) arrastrar el ratón de nuevo
para definir el siguiente parámetro y hacer clic sobre la posición
adecuada. Repetir el proceso si se necesita otro parámetro.
11.Cuando el objeto ya esté creado se presenta seleccionado y sus
dimensiones se muestran en la persiana Parámetros. Se podrán ajustar
las dimensiones del objeto modificando cada uno de estos parámetros.
La siguiente imagen muestra el aspecto de esta persiana tras generar
una esfera.
12.En la persiana Nombre y color asignar un nombre al objeto y modificar
su color. Aunque este paso es opcional si que es recomendable, el
cambio de color hará que se visualicen mejor o peor los objetos en
pantalla y el asignarle un nombre permitirá reconocer al objeto por él.
Para cambiar el nombre simplemente hay que sustituir el que se
presenta en el cuadro de texto. Para cambiar el color hacer clic sobre el
cuadro que muestra el color del objeto y seleccionar en el cuadro de
diálogo que se presenta el color que se precise sin más que hacer clic
sobre él.
Se pueden emplear tanto la paleta de 3D Studio como la de AutoCAD, si
se utiliza la de 3D Studio y se quiere asignar un color distinto al de la
paleta se pueden personalizar hasta 16 colores: seleccionar uno de los
cuadros situado en la parte inferior, hacer clic sobre el botón Añadir
colores personalizados, en el cuadro que se muestra seleccionar el
color adecuado y hacer clic en el botón Añadir color, finalmente cerrar
el cuadro y repetir el proceso para personalizar otros colores.
13.El objeto ya está creado pero el botón correspondiente al mismo sigue
activo, en color naranja, lo que indica que se puede crear otro objeto
similar. Si se quiere finalizar el proceso activar otra opción, pulsar la
tecla ESC o bien el botón derecho del ratón sobre el visor.
Persiana Entradas de teclado
Esta es la única persiana del panel Crear que no se ha utilizado. Presenta
prácticamente las mismas opciones que la persiana Parámetros y lo que
permite es indicar los parámetros exactos del objeto antes de crearlo.
Para la creación de una caja los pasos a seguir son:
1. Poner como actual el visor en el cual dibujar la caja.
2. En el Panel Crear hacer clic sobre el botón Caja.
3. En la persiana Método de creación seleccionar la opción Caja.
4. Abrir la persiana Entradas de teclado haciendo clic en su nombre. La
siguiente imagen muestra su aspecto.
5. Introducir los parámetros correspondientes al objeto que se quiere crear:
las tres primeras casillas indican la posición del objeto y el resto las
dimensiones del mismo.
6. Una vez indicados los parámetros hacer clic sobre el botón Crear.
La tendencia es que un mayor número de lenguajes de programación adopten
la programación orientada a objetos como paradigma para modelizar los
sistemas. La programación orientada a objetos es un tema de gran interés,
pues es muy utilizada y cada vez resulta más esencial para poder desarrollar
en casi cualquier lenguaje moderno.
CONCLUSIÓN
La programación orientada a objetos es una metodología de programación
avanzada y bastante extendida, en la que los sistemas se modelan creando
clases, que son un conjunto de datos y funcionalidades. Las clases son
definiciones, a partir de las que se crean objetos. Los objetos son ejemplares
de una clase determinada y como tal, disponen de los datos y funcionalidades
definidos en la clase.
Cabe destacar que dentro de un método, las variables hacen referencia al
objeto sobre el que invocamos el método. En la invocación se está llamando al
método que se introduce sobre el objeto. Cuando se está ejecutando ese
método, se vuelca el valor que recibe por parámetro en el atributo contenido.
En ese caso, se hace referencia al atributo contenido del objeto, que es sobre
el que se invocaba el método.