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.