Objetos \ Processing.
org
Tratamiento p5.js Processing.py Procesando para Android Procesando para Pi Fundación de procesamiento
Portada
Este tutorial es del libro Learning Processing de Daniel Shiffman, publicado por Morgan Kaufmann, © 2008
Elsevier Inc. Todos los derechos reservados. Si ve algún error o tiene comentarios, háganoslo saber .
Descargar
Donar
Exposición
Bibliotecas de Objetos
referencia
Daniel Shiffman
Herramientas Medio
Antes de comenzar a examinar los detalles de cómo funciona la programación orientada a objetos (OOP) en el
ambiente Tutoriales
procesamiento, comencemos una breve discusión conceptual de los "objetos" en sí mismos. Imagine que no está
Ejemplos Libros
programando en Processing, sino que está escribiendo un programa para su día, una lista de instrucciones, si lo
Descripción general
desea. Podría comenzar algo como:
Personas » Foro »
GitHub » Despierta.
Problemas » Wiki »
Preguntas Beber café (o té).
frecuentes » Twitter
Desayune: cereal, arándanos y leche de soya.
» Facebook » Medio
Viaja en el metro.
¿Qué está involucrado aquí? Específicamente, ¿qué cosas están involucradas? Primero, aunque puede no ser
inmediatamente evidente por cómo escribimos las instrucciones anteriores, lo principal es usted, un ser
humano, una persona. Exhibes ciertas propiedades. Te ves de cierta manera; tal vez tienes cabello castaño, usas
anteojos y pareces un poco nerd. También tiene la capacidad de hacer cosas, como despertarse
(presumiblemente, también puede dormir), comer o tomar el metro. Un objeto es como tú, una cosa que tiene
propiedades y puede hacer cosas.
Entonces, ¿cómo se relaciona esto con la programación? Las propiedades de un objeto son variables, y las cosas
que un objeto puede hacer son funciones. La programación orientada a objetos es la unión de todos los
fundamentos de la programación: datos y funcionalidad.
Vamos a mapear los datos y funciones para un objeto humano muy simple:
datos humanos
Altura.
Peso.
Género.
Color de los ojos.
Color de pelo.
Funciones humanas
Dormir.
Despierta.
Comer.
Viaja en alguna forma de transporte.
Ahora, antes de avanzar demasiado, debemos embarcarnos en una breve digresión metafísica. La estructura
anterior no es un ser humano en sí mismo; simplemente describe la idea, o el concepto, detrás de un ser
humano. Describe lo que es ser humano. Ser humano es tener altura, cabello, dormir, comer, etc. Esta es una
distinción crucial para la programación de objetos. Esta plantilla de ser humano se conoce como una clase . Una
clase es diferente de un objeto . Eres un objeto Soy un objeto Ese tipo en el metro es un objeto. Albert Einstein es
un objeto. Todos somos personas, instancias del mundo real de la idea de un ser humano.
https://processing.org/tutorials/objects/[5/11/2019 7:03:09 p. m.]
Objetos \ Processing.org
Piensa en un cortador de galletas. Un cortador de galletas hace galletas, pero no es una galleta en sí. El cortador
de galletas es la clase , las galletas son los objetos .
Usando un objeto
Antes de ver la escritura real de una clase en sí, veamos brevemente cómo usar objetos en nuestro programa
principal (es decir, setup () y draw () ) hace del mundo un lugar mejor.
Considere el pseudocódigo para un boceto simple que mueve un rectángulo horizontalmente a través de la
ventana (pensaremos en este rectángulo como un "automóvil").
Datos (variables globales) :
Color del coche.
Coche x ubicación.
Coche y ubicación.
Auto x velocidad.
Configuración :
Inicializa el color del auto.
Inicialice la ubicación del automóvil al punto de partida.
Inicializar la velocidad del automóvil.
Dibujar :
Rellenar fondo.
Exhiba el auto en el lugar con color.
Incremente la ubicación del automóvil por velocidad.
Para implementar el pseudocódigo anterior, definiremos variables globales en la parte superior del programa,
las inicializaremos en setup () y llamaremos a funciones para mover y mostrar el automóvil en draw (). Algo
como:
color c = color (0);
flotador x = 0;
flotador y = 100;
velocidad de flotación = 1;
configuración nula () {
tamaño (200.200);
}
sorteo vacío () {
fondo (255);
moverse();
monitor();
}
movimiento nulo () {
x = x + velocidad;
if (x> ancho) {
x = 0;
}
}
pantalla vacía () {
relleno (c);
rect (x, y, 30,10);
}
La programación orientada a objetos nos permite sacar todas las variables y funciones del programa principal y
almacenarlas dentro de un objeto de automóvil. Un objeto de automóvil sabrá acerca de sus datos: color ,
ubicación , velocidad . El objeto también sabrá acerca de las cosas que puede hacer , los métodos (funciones dentro
de un objeto): el automóvil puede conducir y puede mostrarse .
Usando un diseño orientado a objetos, el pseudocódigo mejora para parecerse a esto:
Datos (Variables globales) :
Objeto de coche.
Configuración :
https://processing.org/tutorials/objects/[5/11/2019 7:03:09 p. m.]
Objetos \ Processing.org
Inicializar objeto del automóvil.
Dibujar :
Rellenar fondo.
Mostrar objeto de automóvil.
Conducir objeto de automóvil.
Aviso: eliminamos todas las variables globales del primer ejemplo. En lugar de tener variables separadas para el
color del automóvil, la ubicación del automóvil y la velocidad del automóvil, ahora tenemos solo una variable:
¡una variable del automóvil! Y, en lugar de inicializar esas tres variables, inicializamos una cosa: el objeto Car.
¿A dónde fueron esas variables? Todavía existen, solo que ahora viven dentro del objeto Car (y se definirán en la
clase Car, a la que llegaremos en un momento).
Más allá del pseudocódigo, el cuerpo real del boceto podría verse así:
Car myCar;
configuración nula () {
myCar = auto nuevo ();
}
sorteo vacío () {
fondo (255);
myCar.drive ();
myCar.display ();
}
Vamos a entrar en detalles sobre el código anterior en un momento, pero antes de hacerlo, echemos un vistazo a
cómo se escribe la clase Car.
Escribiendo el cortador de galletas
El simple ejemplo de Car anterior muestra cómo el uso de objetos en Processing genera código limpio y legible.
El trabajo duro consiste en escribir la plantilla del objeto, es decir, la clase misma. Cuando aprende por primera
vez acerca de la programación orientada a objetos, a menudo es un ejercicio útil tomar un programa escrito sin
objetos y, sin cambiar la funcionalidad, reescribirlo usando objetos. Haremos exactamente esto con el ejemplo
del automóvil, recreando exactamente el mismo aspecto y comportamiento de una manera orientada a objetos.
Todas las clases deben incluir cuatro elementos: nombre, datos, constructor y métodos. (Técnicamente, el único
elemento requerido real es el nombre de la clase, pero el objetivo de la programación orientada a objetos es
incluir todo esto).
Así es como podemos tomar los elementos de un boceto simple no orientado a objetos y colocarlos en una clase
Car, desde donde podremos hacer objetos Car.
https://processing.org/tutorials/objects/[5/11/2019 7:03:09 p. m.]
Objetos \ Processing.org
Nombre de clase : el nombre se especifica mediante "clase WhateverNameYouChoose". Luego incluimos todo
el código de la clase entre llaves después de la declaración del nombre. Los nombres de clase se capitalizan
tradicionalmente (para distinguirlos de los nombres de variables, que tradicionalmente son minúsculas).
Datos : los datos de una clase son una colección de variables. Estas variables a menudo se denominan variables
de instancia, ya que cada instancia de un objeto contiene este conjunto de variables.
Constructor: El constructor es una función especial dentro de una clase que crea la instancia del objeto en sí.
Es donde da las instrucciones sobre cómo configurar el objeto. Es igual que la función setup () de Processing ,
solo que aquí se usa para crear un objeto individual dentro del boceto, cada vez que se crea un nuevo objeto a
partir de esta clase. Siempre tiene el mismo nombre que la clase y se invoca invocando al nuevo operador: "Car
myCar = new Car ();".
Funcionalidad : podemos agregar funcionalidad a nuestro objeto escribiendo métodos.
Tenga en cuenta que el código para una clase existe como su propio bloque y se puede colocar en cualquier lugar
fuera de setup () y draw () .
configuración nula () {
}
sorteo vacío () {
}
coche de clase {
}
Usar un objeto: los detalles
https://processing.org/tutorials/objects/[5/11/2019 7:03:09 p. m.]
Objetos \ Processing.org
Anteriormente, echamos un vistazo rápido a cómo un objeto puede simplificar en gran medida las partes
principales de un boceto de procesamiento (es decir, configuración () y dibujo () ).
// Paso 1. Declarar un objeto.
Car myCar;
configuración nula () {
// Paso 2. Inicializar objeto.
myCar = auto nuevo ();
}
sorteo vacío () {
fondo (255);
// Paso 3. Llama a métodos en el objeto.
myCar.drive ();
myCar.display ();
}
Veamos los detalles detrás de los tres pasos anteriores que describen cómo usar un objeto en su boceto.
Paso 1. Declarar una variable de objeto.
Una variable siempre se declara especificando un tipo y un nombre. Con un tipo de datos primitivo, como un
entero, se ve así:
// Declaración variable
int var; // escribe un nombre
Los tipos de datos primitivos son piezas singulares de información: un número entero, un flotante, un carácter,
etc. La declaración de una variable que se mantiene en un objeto es bastante similar. La diferencia es que aquí el
tipo es el nombre de la clase, algo que inventaremos, en este caso "Auto". Los objetos, por cierto, no son
primitivos y se consideran tipos de datos complejos. (Esto se debe a que almacenan múltiples piezas de
información: datos y funcionalidad. Las primitivas solo almacenan datos).
Paso 2. Inicializar un objeto.
Para inicializar una variable (es decir, darle un valor inicial), utilizamos una operación de asignación: la variable
es igual a algo. Con un primitivo (como un entero), se ve así:
// Inicialización variable
var = 10; // var es igual a 10
Inicializar un objeto es un poco más complejo. En lugar de simplemente asignarle un valor, como con un
número entero o de coma flotante, tenemos que construir el objeto. Se crea un objeto con el nuevo operador.
// Inicialización de objetos
myCar = auto nuevo (); // El nuevo operador se utiliza para hacer un nuevo objeto.
En el ejemplo anterior, "myCar" es el nombre de la variable del objeto y "=" indica que lo estamos configurando
igual a algo, que algo es una nueva instancia de un objeto Car. Lo que realmente estamos haciendo aquí es
inicializar un objeto Car. Cuando inicializa una variable primitiva, como un número entero, simplemente la
establece igual a un número. Pero un objeto puede contener múltiples piezas de datos. Recordando la clase Car,
vemos que esta línea de código llama al constructor , una función especial llamada Car () que inicializa todas las
variables del objeto y se asegura de que el objeto Car esté listo para funcionar.
Otra cosa: con el entero primitivo "var", si se hubiera olvidado de inicializarlo (ponerlo a 10), Processing le
habría asignado un valor predeterminado: cero. Sin embargo, un objeto (como "myCar") no tiene un valor
predeterminado. Si olvida inicializar un objeto, Processing le dará el valor nulo . nulo no significa nada. No cero
No negativo uno. Nada absoluta. Vacío. Si encuentra un error en la ventana de mensaje que dice
"NullPointerException" (y este es un error bastante común), ese error probablemente se deba a que se olvidó de
inicializar un objeto.
Paso 3. Usando un objeto
Una vez que hayamos declarado e inicializado con éxito una variable de objeto, podemos usarla. Usar un objeto
implica llamar a funciones que están integradas en ese objeto. Un objeto humano puede comer; un auto puede
conducir; Un perro puede ladrar. La llamada a una función dentro de un objeto se realiza mediante la sintaxis de
puntos: variableName.objectFunction (Function Arguments);
https://processing.org/tutorials/objects/[5/11/2019 7:03:09 p. m.]
Objetos \ Processing.org
En el caso del automóvil, ninguna de las funciones disponibles tiene un argumento, por lo que se ve así:
// Las funciones se llaman con la "sintaxis de puntos".
myCar.drive ();
myCar.display ();
Argumentos del constructor
En los ejemplos anteriores, el objeto del automóvil se inicializó utilizando el nuevo operador seguido por el
constructor de la clase.
Car myCar = nuevo Car ();
Esta fue una simplificación útil mientras aprendimos los conceptos básicos de OOP. Sin embargo, hay un
problema bastante serio con el código anterior. ¿Qué pasaría si quisiéramos escribir un programa con dos
objetos de automóvil?
// Creando dos objetos de carro
Car myCar1 = nuevo Car ();
Car myCar2 = nuevo Car ();
Esto logra nuestro objetivo; El código producirá dos objetos de automóvil, uno almacenado en la variable
myCar1 y otro en myCar2. Sin embargo, si se estudia la clase de coches, se dará cuenta de que estos dos coches
serán idénticas: cada uno será de color blanco, empezar en el centro de la pantalla, y tienen una velocidad de 1.
En Inglés, lo anterior se lee:
Hacer un coche nuevo.
En cambio, queremos decir:
Haga un nuevo auto rojo, en la ubicación (0,10) con una velocidad de 1.
Para que también podamos decir:
Haga un nuevo auto azul, en la ubicación (0,100) con una velocidad de 2.
Nosotros puede hacer esto colocando argumentos dentro del método constructor.
Car myCar = Car nuevo (color (255,0,0), 0,100,2);
El constructor debe reescribirse para incorporar estos argumentos:
Auto (color tempC, float tempXpos, float tempYpos, float tempXspeed) {
c = tempC;
xpos = tempXpos;
ypos = tempYpos;
xspeed = tempXspeed;
}
En mi experiencia, el uso de argumentos de constructor para inicializar variables de objeto puede ser algo
desconcertante. Por favor, no te culpes a ti mismo. El código tiene un aspecto extraño y puede parecer
terriblemente redundante: "¿Necesito colocar argumentos dentro del constructor para cada variable?"
Sin embargo, esta es una habilidad bastante importante para aprender y, en última instancia, es una de las cosas
que hace que la programación orientada a objetos sea poderosa. Pero por ahora, puede sentirse doloroso.
Veamos cómo funcionan los parámetros en este contexto.
https://processing.org/tutorials/objects/[5/11/2019 7:03:09 p. m.]
Objetos \ Processing.org
Los argumentos son variables locales utilizadas dentro del cuerpo de una función que se llenan de valores
cuando se llama a la función. En los ejemplos, tienen un solo propósito: para inicializar las variables dentro de un
objeto. Estas son las variables que cuentan: el color real del automóvil, la ubicación x real del automóvil , etc.
Los argumentos del constructor son solo temporales y existen únicamente para pasar un valor desde donde el
objeto se convierte en el objeto mismo.
Esto nos permite hacer una variedad de objetos usando el mismo constructor. También puede escribir la palabra
temp en los nombres de sus argumentos para recordarle lo que está sucediendo (c vs. tempC). También verá que
los programadores usan un guión bajo (c vs. c_) en muchos ejemplos. Puedes nombrarlos como quieras, por
supuesto. Sin embargo, es aconsejable elegir un nombre que tenga sentido para usted, y también para ser
coherente.
Ahora podemos echar un vistazo al mismo boceto con múltiples instancias de objetos, cada una con propiedades
únicas.
// Ejemplo: dos objetos de coche
Car myCar1;
Car myCar2; // ¡Dos objetos!
configuración nula () {
tamaño (200.200);
// Los parámetros van dentro de los paréntesis cuando se construye el objeto.
myCar1 = auto nuevo (color (255,0,0), 0,100,2);
myCar2 = auto nuevo (color (0,0,255), 0,10,1);
}
sorteo vacío () {
fondo (255);
myCar1.drive ();
myCar1.display ();
myCar2.drive ();
myCar2.display ();
}
// Aunque hay varios objetos, solo necesitamos una clase.
// No importa cuántas galletas hagamos, solo se necesita un cortador de galletas.
coche de clase {
color c;
flotador xpos;
flotan ypos;
flotar x velocidad;
// El constructor se define con argumentos.
Auto (color tempC, float tempXpos, float tempYpos, float tempXspeed) {
c = tempC;
xpos = tempXpos;
ypos = tempYpos;
xspeed = tempXspeed;
}
pantalla vacía () {
carrera (0);
relleno (c);
rectMode (CENTRO);
https://processing.org/tutorials/objects/[5/11/2019 7:03:09 p. m.]
Objetos \ Processing.org
rect (xpos, ypos, 20,10);
}
unidad vacía () {
xpos = xpos + xspeed;
if (xpos> ancho) {
xpos = 0;
}
}
}
¡Los objetos también son tipos de datos!
Suponiendo que esta sea su primera experiencia con la programación orientada a objetos, es importante que lo
tome con calma. Los ejemplos aquí son solo una clase y hacen, como máximo, dos o tres objetos de esa clase. Sin
embargo, no hay limitaciones reales. Un boceto de procesamiento puede incluir tantas clases como desee
escribir.
Si estaba programando el juego Space Invaders, por ejemplo, podría crear una clase de nave espacial , una clase
de enemigo y una clase de bala , utilizando un objeto para cada entidad en su juego.
Además, aunque no son primitivas, las clases son tipos de datos, como enteros y flotantes. Y como las clases
están formadas por datos, ¡un objeto puede contener otros objetos! Por ejemplo, supongamos que acaba de
terminar de programar unTenedor y cuchara de clase. Pasando a una clase PlaceSetting , es probable que incluya
variables para un objeto Fork y un objeto Spoon dentro de esa clase. Esto es perfectamente razonable y bastante
común en la programación orientada a objetos.
class PlaceSetting {
Tenedor tenedor;
Cuchara cuchara;
Configuración de lugar() {
fork = new Fork ();
cuchara = nueva cuchara ();
}
}
Los objetos, como cualquier tipo de datos, también se pueden pasar como argumentos a una función. En el
ejemplo del juego Space Invaders, si la nave espacial dispara la bala al enemigo, probablemente querríamos
escribir una función dentro de la clase Enemy para determinar si el enemigo había sido alcanzado por la bala.
golpe nulo (Bala b) {
// Código para determinar si
// la bala golpeó al enemigo
}
Cuando se pasa un valor primitivo (entero, flotante, etc.) en una función, se realiza una copia. Con los objetos,
este no es el caso, y el resultado es un poco más intuitivo. Si se realizan cambios en un objeto después de pasarlo
a una función, esos cambios afectarán a ese objeto utilizado en cualquier otro lugar del boceto. Esto se conoce
como pasar por referencia ya que, en lugar de una copia, una referencia al objeto real en sí se pasa a la función.
El procesamiento fue iniciado por Ben Fry y Casey Reas . Es desarrollado por un pequeño equipo de voluntarios .
© Info
https://processing.org/tutorials/objects/[5/11/2019 7:03:09 p. m.]
