Usuario:
Clases y Objetos
Storyboard 
Los elementos básicos de la programación por objetos son las clases (una suerte de modelo) y los objetos (implementaciones de las clases para casos concretos).
ID:(92, 0)
Controlando el Acceso
Definición
El acceso a campos y metodos se controla con las palabras public y private. En general debe considerarse que
public - tiene acceso dentro de la clase (class), del paquete (package), subclases (Subclass) y el programa en general (World).
Existe una categiria que no incluye el mundo general, o sea solo clase, paquete y subclases, y se denomina protected.
Si no se incluye una enominación se supone que se tiene acceso desde la clase pero tambien dentro del paquete.
Por ultimo si se usa el tipo private solo se puede accesar desde el interior de la clase.
ID:(1125, 0)
Creación de un Objeto
Imagen
La clase se empela como un tipo. O sea al igual que variables que eran enteros (int) existen por ejemplo elementos tipo bicicletas (Bicyclle). O sea se puede definir al igual que
```
int n;
```
un
```
Bicycle miBici;
```
De igual forma se pueen introducir arreglos como
```
Bicycle[] miBicis;
```
Pero esta definición no creo el espacio en memoria, solo un puntero enq ue se puede asignar la dirección en donde esta la información. Para reservar la memoria se debe empelar el comando new y el cosntructor:
```
Clase objeto = new Constructor();
```
En el caso de la bicicleta
```
Bicycle miBici = new Bicycle(1,0,1);
```
En el caso del arreglo de bicicletqas se debe primero crera el arreglo de direccioens en memoria:
```
Bicycle[] miBicis = new Bicycle[3];
```
y luego crera cada objeto:
```
miBicis[0] = new Bicycle(1,0,1);
miBicis[1] = new Bicycle(2,0,0);
miBicis[2] = new Bicycle(0,0,1);
```
ID:(1122, 0)
Declaración de la Clase
Nota
Las clases se declaran usando la palabra class y las definciones (campos, constructor y metodos) se esciben entre parentesis redondeados:
```
class MiClass {
campos
constructor
metodos
}
```
En caso de que uno quiera extender una clase existente se agrega tras la palabra extends el nombre de dicha clase.
Ademas se puede implementar una interface (teclado, mouse, etc.) que le da la posibilidad a la clase de actuar en función de eventos que ocurren en el sistema. En dicho caso se agrega la palabra implements y se listan las interfaces separadas por comas.
Un ejemplo de esto es:
```
class MiClass extends MasterClass implements MiInterface {
definiciones adicionales
constructor que incluye al constructor de la clase maestra
metodos adicionales
}
```
ID:(1118, 0)
Declaración de Métodos
Cita
Los metodos pueden ser simples funciones con o sin valores retornados. En general son modificsaciones de los campos de la clase, calculos a realizar sobre estos o con estos o consultas de valores de estos.
Pueden ser definidos como publicos o privados. En el primer caso se pueden consultar fuera de la clase como una propiedad del objeto que se crea con la clase. Si son privadas no pueden ser accedas desde afuera y son solo para uso interno dentro de la clase.
Los argumentos son de cualquier tipo o arreglos de estos.
Un ejemplo podria ser
```
public double calc(double param, int num) {
calculo
return valor a retornar
}
```
ID:(1120, 0)
Declaración y Consulta de Miembros
Ejercicio
La declaración de variables, que aqui se llaman campos, se hace anteponiendo la forma como se van a usar. Esto es si los campos son privados o publicos. En general se recomienda definirlos como provado para evitar que en algun momento a la clase se le modifique un parametros por similitud de nombre de campo/variable con otra parte del programa. Por ello se tendra como definicioens algo de la forma:
```
private int cadence;
private int gear;
private int speed;
```
Si se quieren accesar los fampos, ya sea para consultar valores de los campos o modificar estos, se pueden definir los metodos get y set.
El metod get puede ser citado fuera de la clase para consultar el valor de la variable que tiene algun objeto en particular:
```
public int getCadence() {
return cadence;
}
```
De igual forma se pueden modificar los valores empelando un metod del tipo set:
```
public void setCadence(int newValue) {
cadence = newValue;
}
```
ID:(1119, 0)
Definición de un Constructor
Ecuación
Pueden existir varios constructores pero todos deben tener el mismo nombre de la clase y solo pueden variar en el numero y tipo de argumentos.
Se puede asi incluir un constructor sin unidades que solo cera la estructura pero no le asigna valores iniciales. Los valores se pueden despues incluir mediante metodos del tipo set. Un ejemplo podria ser
```
public Bicycle() {}
```
con un método del tipo
```
public void setCadence(int newValue) {
cadence = newValue;
}
```
Otro ejemplo, en que algunos se definen con parametros y otro se definen por defecto sería
```
public Bicycle(int startSpeed) {
gear = 1;
cadence = 1;
speed = startSpeed;
}
```
ID:(1121, 0)
Miembros de una Clase
Script
Hay variables que simepre en todas las implementaciones (instantaciones) son iguales y por ello basta con definirlas una sola vez. En ese caso se habla de campos estaticos. En ese caso se antepone al tipo de variable la palabra static:
private static double referencia;
En ese caso si se carga en una implementación el numero, este sera igual en todas los objetos cerados.
ID:(1126, 0)
Usando un Objeto
Variable
Para usar el objeto se pocede a usar los métodos con lo que se puede generar proceso que corren dentro de la clase, consultar campos y/o modificar estos.
El formato general es el nombre del objeto, un punto y el nombre del metodo ademas de los argumentos:
```
objeto.metodo(....);
```
A modo de ejemplo en el caso de la clase de bicicletas se da que el objeto podria ser miBici y se puede aumentar su velocidad usando el método speedUp indicando el incremento:
```
miBici.speedUp(2);
```
Se puede ademas obtener valores
```
double gear = miBici.getGear();
```
o asignar valores
```
miBici.setGear(2);
```
ID:(1123, 0)
Uso de Punteros al Objeto mismo
Audio
Dentro de una clase se puede hacer referencia a si misma. Para ello se usa la palabra
```
this
```
Como ejemplo si en la case se definión una variable como por ejemplo
```
private double x;
```
y despues se emplea
```
this.x
```
se esta haciendo referencia al campo definido en la clase. De esa forma se puede tener una variable local en un metiodo del mismo nombre sin que se haga referencia a esta. Por ejemplo
```
public void setCoordinate(double x,double y){
this.x = x;
this.y = y;
}
```
ID:(1124, 0)
Programa Main
Video
El objetivo es reescribir el código del ejemplo Feigenbaum escrito en Java en uno en C++. Para ello se debe desarrollar un archivo FeigenbaumStatistics.cpp que tenga la siguiente estructura:
```
#include ... generales necesarias
#include ... ".h" de las clases
using namespace std;
int main()
{
... definiciones de variables necesarias ...
... creación de punteros a clase feigenbaum y statistics ...
... resetear statistics ...
... generar un numero de series y agregar valores a ls distribución ...
... analisis ...
... mostrar resultado ...
return 0;
}
```
ID:(1159, 0)