domingo, 26 de octubre de 2008

lunes, 26 de mayo de 2008

Java 9 Preguntas Resueltas

1 concepto de objetos

Al comenzar esta parte del curso, “Programación Orientada a Objetos” (POO), uno de los primeros conceptos que me vienen a la mente es el de programación. Se llama programación a la creación de un programa de computadora, el cual es un conjunto concreto de instrucciones que una computadora puede ejecutar. El programa se escribe en un lenguaje de programación, aunque también se pueda escribir directamente en lenguaje de máquina, con cierta dificultad. Un programa se puede dividir en diversas partes, que pueden estar escritas en lenguajes distintos.
Para diferenciar, Software es el sustantivo que denomina a los programas y datos de computadora, mientras que un algoritmo es una secuencia no ambigua, finita y ordenada de instrucciones que han de seguirse para resolver un problema. Un programa normalmente implementa (traduce a un lenguaje de programación concreto) un algoritmo. Puede haber programas que no se ajusten a un algoritmo (pueden no terminar nunca), en cuyo caso se denomina procedimiento a tal programa.
La programación de ordenadores debe perseguir tres objetivos fundamentales:
Corrección: Un programa es correcto si hace lo que debe hacer. Para determinar si un programa hace lo que debe es muy importante especificar claramente qué debe hacer el programa antes de desarrollarlo y una vez acabado compararlo con lo que realmente hace.
Claridad: Es muy importante que el programa sea lo más claro posible y legible posible para mejorar el mantenimiento del software. Cuando se acaba de escribir el código del programa, se deben buscar errores y corregirlos. Más concretamente, cuando el programa está concluido, es necesario hacerle ampliaciones y/o modificaciones, según la demanda de los usuarios, esta labor puede ser llevada acabo por el mismo programador que implementó el programa o por otros.
Eficiencia: Debe consumir la menor cantidad de recursos posible. Normalmente al hablar de eficiencia se suele hacer referencia al consumo de tiempo y/o memoria.
Para lograr estos puntos, es necesario utilizar utilizar una metodología de programación.
Entonces, lo primero que nos preguntaremos es qué se entiende por metodología de la programación. Para ello, lo más directo es acudir al DRAE (Diccionario de la Real Academia de la Lengua) donde se define:
Metodología:
Ciencia del método.
Conjunto de métodos que se siguen en una investigación científica o en una exposición doctrinal.
Así pues aplicado al campo de la programación sería el conjunto de métodos, herramientas que nos sirven para desarrollar programas. Cuando hablamos de herramientas nos estamos refiriendo tanto a aquellos elementos simples que nos encontramos en cualquier lenguaje de programación (tipos de datos, estructuras de control, etc) como el estudio de técnicas (algoritmos voraces, divide y vencerás, etc.) para el diseño de algoritmos. Estudio que se realiza atendiendo a criterios de eficiencia y corrección.
El desarrollo de programas ha sufrido una evolución desde los primeros sistemas de cálculo, implementados en grandes computadores. Aquellos sistemas enfocaban todo el esfuerzo de desarrollo en la escritura de programas que realizaban todo tipo de cálculo. Desde entonces han surgido dos grandes cambios. El primero, la aparición del modelo relacional, modelo con una fuerte base algebraica, que supuso el desarrollo y estructuración de las bases de datos. El segundo, sobre los lenguajes de programación fue la aparición de los Lenguajes orientados a objetos. La escritura de programas pasa a ser una tarea no sólo de codificación algorítmica sino también una tarea de estructuración del problema, en el que la abstracción y modelado de objetos juega un papel importante.
Esta parte del curso tiene como objetivo introducirnos en el paradigma de la programación orientada a objetos. De esta forma seremos capaces de realizar programas fácilmente mantenibles, modificables y reusables.
Cuando se escribe un programa en un lenguaje orientado a objetos, se define una plantilla o clase que describe las características y el comportamiento de un conjunto de objetos similares. La clase automóvil describe las características comunes de todos los automóviles: sus atributos y su comportamiento. Los atributos o propiedades se refieren a la marca o fabricante, el color, las dimensiones, si tienen dos, tres, cuatro o más puertas, la potencia, si utiliza como combustible la gasolina o gas, etc. El comportamiento se refiere a la posibilidad de desplazarse por una carretera, frenar, acelerar, cambiar de marcha, girar, etc.
Luego, tenemos automóviles concretos, por ejemplo el automóvil propio de una determinada marca, color, potencia, etc., el automóvil del vecino de otra marca, de otro color, etc., el automóvil de un amigo, etc.
Una clase es por tanto una plantilla implementada en software que describe un conjunto de objetos con atributos y comportamiento similares.
Una instancia u objeto de una clase es una representación concreta y específica de una clase y que reside en la memoria del ordenador.

2 ejemplos de objetos

Avion
Atributos: tiene alas, turbinas, llantas, ventanillas, cuerpo metalico,, asientos, color. etc.
Comportamiento: vuela, transporta cargas pesadas aereamente.,
Perro
Atributos: tiene cola, pelo, hocico, patas, colmillos, etc.
Comportamiento: ladra, muerde, cuida las casas
Camara:
Atributos: tiene flash, lente, botones, cubierta, bocinas
Comportamiento: Toma Fotos, videos, audio.
Automovil
Atributos: tiene llantas, motor, escape, calaveras, volante, palancas, chasis, carroceria etc.
Comportamiento: transporte terrestre de personas y cosas.
Computadora
Atributos: tiene teclado, mouse, monitor, chips, memoria, disco duro, procesador, tarjetas de video, tarjetas de audio etc.
Comportamiento: Realiza trabajos, estadisticas, procesa datos, hace calculos, organiza, etc.

3 Concepto de clases

Definición de una clase
a.) Introducción
El elemento básico de la programación orientada a objetos en Java es la clase. Una clase define la forma y comportamiento de un objeto.
Para crear una clase sólo se necesita un archivo fuente que contenga la palabra clave reservada class seguida de un identificador legal y un bloque delimitado por dos llaves para el cuerpo de la clase.
class MiPunto {
}
Un archivo de Java debe tener el mismo nombre que la clase que contiene, y se les suele asignar la extensión ".java". Por ejemplo la clase MiPunto se guardaría en un fichero que se llamase MiPunto.java. Hay que tener presente que en Java se diferencia entre mayúsculas y minúsculas; el nombre de la clase y el de archivo fuente han de ser exactamente iguales.
Aunque la clase MiPunto es sintácticamente correcta, es lo que se viene a llamar una clase vacía, es decir, una clase que no hace nada. Las clases típicas de Java incluirán variables y métodos de instancia. Los programas en Java completos constarán por lo general de varias clases de Java en distintos archivos fuente.
Una clase es una plantilla para un objeto. Por lo tanto define la estructura de un objeto y su interfaz funcional, en forma de métodos. Cuando se ejecuta un programa en Java, el sistema utiliza definiciones de clase para crear instancias de las clases, que son los objetos reales. Los términos instancia y objeto se utilizan de manera indistinta. La forma general de una definición de clase es:
class Nombre_De_Clase {
tipo_de_variable nombre_de_atributo1;
tipo_de_variable nombre_de_atributo2;
// . . .
tipo_devuelto nombre_de_método1( lista_de_parámetros ) {
cuerpo_del_método1;
}
tipo_devuelto nombre_de_método2( lista_de_parámetros ) {
cuerpo_del_método2;
}
// . . .
}
Los tipos tipo_de_variable y tipo_devuelto, han de ser tipos simples Java o nombres de otras clases ya definidas. Tanto Nombre_De_Clase, como los nombre_de_atributo y nombre_de_método, han de ser identificadores Java válidos.
b.) Los atributos
Los datos se encapsulan dentro de una clase declarando variables dentro de las llaves de apertura y cierre de la declaración de la clase, variables que se conocen como atributos. Se declaran igual que las variables locales de un método en concreto.
Por ejemplo, este es un programa que declara una clase MiPunto, con dos atributos enteros llamados x e y.
class MiPunto {
int x, y;
}
Los atributos se pueden declarar con dos clases de tipos: un tipo simple Java (ya descritos), o el nombre de una clase (será una referencia a objeto, véase el punto C.a de este mismo apartado).
Cuando se realiza una instancia de una clase (creación de un objeto) se reservará en la memoria un espacio para un conjunto de datos como el que definen los atributos de una clase. A este conjunto de variables se le denomina variables de instancia.
c.) Los métodos
Los métodos son subrutinas que definen la interfaz de una clase, sus capacidades y comportamiento.
Un método ha de tener por nombre cualquier identificador legal distinto de los ya utilizados por los nombres de la clase en que está definido. Los métodos se declaran al mismo nivel que las variables de instancia dentro de una definición de clase.
En la declaración de los métodos se define el tipo de valor que devuelven y a una lista formal de parámetros de entrada, de sintaxis tipo identificador separadas por comas. La forma general de una declaración de método es:
tipo_devuelto nombre_de_método( lista-formal-de-parámetros ) {
cuerpo_del_método;
}
Por ejemplo el siguiente método devuelve la suma de dos enteros:
int metodoSuma( int paramX, int paramY ) {
return ( paramX + paramY );
}
En el caso de que no se desee devolver ningún valor se deberá indicar como tipo la palabra reservada void. Así mismo, si no se desean parámetros, la declaración del método debería incluir un par de paréntesis vacíos (sin void):
void metodoVacio( ) { };
Los métodos son llamados indicando una instancia individual de la clase, que tendrá su propio conjunto único de variables de instancia, por lo que los métodos se pueden referir directamente a ellas.
El método inicia() para establecer valores a las dos variables de instancia sería el siguiente:
void inicia( int paramX, int paramY ) {
x = paramX;
y = paramY;
}

4 ejemplo de clases

1.- Clase Punto
Crear una clase Punto, que almacene las 3 coordenadas (enteras) x,y,z, contenga de 3 constructores y un método para imprimir el punto en pantalla con el formato : (x,y,z)
Además deberá contener un método main( ) para la prueba del programa.
Atributosx , y , z : coordenadas enteras del punto
ConstructoresPunto(x,y,z) : asigna las tres coordenadasPunto(c) : asigna c a las tres coordenadasPunto( ) : asigna 0 a las tres coordenadas
Métodosimprimir( ) : imprime el punto en pantalla con formato : (x,y,z)main( ) : Realiza las pruebas de la claseclass Punto{ int x, y, z; /* constructor de 3 parametros */ public Punto(int x, int y, int z) { this.x = x; this.y = y; this.z = z; } /* contructor de 1 parametro*/ public Punto(int c) { x = y = z = c; } /* constructor sin parametros -- llama al contructor de un parametro */ public Punto() { this(0); } public void imprimir() { System.out.println ("( " + x + " , " + y + " , " + z + " )"); } public static void main(String arg[]) { Punto p = new Punto(2,3,6); p.imprimir(); p = new Punto(10); p.imprimir(); p = new Punto(0); p.imprimir(); } }

Salida del programa

2.- Clase NumInt
Crear una clase NumInt, que almacene una variable entera num de ambito privado, contenga 2 constructores y métodos para sumar y multiplicar dicho numero por un factor pasado com parámetro.
Además deberá contener un método main( ) para la prueba del programa.
Atributosnum : variable entera
ConstructoresNumInt(num) : valor inicial de num pasado como parámetroNumInt( ) : num se inicializa en cero.
Métodossumar(b) : realiza la operación interna : num = num + bmultiplicar(x) : realiza la operación interna : num = num * xgetNum( ) : retorna el valor de nummain( ) : Realiza las pruebas de la claseclass NumInt{ private int num; public NumInt(int num) { this.num = num; } public NumInt() { this.num = 0; } public void sumar(int b) { this.num += b; } public void multiplicar(int x) { this.num *= x; } public int getNum() { return num; } public static void main(String arg[]) { NumInt a = new NumInt(8); System.out.println("Valor Inicial : " + a.getNum()); a.sumar(2); a.multiplicar(5); System.out.println("ahora el numero vale : " + a.getNum()); }}

Salida del programa

3.- Clase Esfera
Crear una clase Esfera, que almacene el radio, contenga 2 constructores, y métodos para calcular el volumen y la superficie, además de un método para imprimir la información de la esfera.
Además deberá contener un método main( ) para la prueba del programa.
Atributosradio : almacena el valor del radio de la esfera
ConstructoresEsfera(radio) : crea una esfera con radio pasado como parámetro Esfera( ) : crea una esfera de radio 1.0
Métodosvolumen( ) : retorna el volumen de la esferasuperficie( ) : retorna la superficie de la esferaimprimir( ) : imprime la información de la esferamain( ) : Realiza las pruebas de la claseclass Esfera{ double radio; public Esfera(double radio) { this.radio = radio; } public Esfera() { this(1.0); } public double volumen() { return (4.0 / 3.0) * Math.PI * Math.pow(radio,3.0); } public double superficie() { return 4.0 * Math.PI * Math.pow(radio,2.0); } public void imprimir() { System.out.println("radio : " + radio); System.out.println("volumen : " + volumen()); System.out.println("superficie : " + superficie()); } public static void main(String arg[]) { Esfera e = new Esfera(); e.imprimir(); System.out.println("\n"); e = new Esfera(Math.PI); e.imprimir(); }}
Salida del programa

4.- Clase Circunferencia
Crear una clase Circunferencia, que almacene el radio, contenga 2 constructores, y métodos para calcular el area y el perímetro.
Además deberá contener un método main( ) para la prueba del programa.
Atributosradio : almacena el valor del radio de la circunferencia
ConstructoresCircunferencia(r) : crea una circunferencia con radio pasado como parámetro Circunferencia( ) : crea una circuenferencia de radio 1.0
Métodosarea( ) : retorna el area de la circunferenciaperimetro( ) : retorna el perímetro de la circunferenciamain( ) : Realiza las pruebas de la claseclass Circunferencia{ double radio; public Circunferencia(double r) { this.radio = r; } public Circunferencia() { this(1); } public double area() { return 2 * Math.PI * radio; } public double perimetro() { return Math.PI * Math.pow(radio,2); } public static void main(String arg[]) { Circunferencia c = new Circunferencia(); System.out.println(" c : circunferencia de radio 1 "); System.out.println(" area : " + c.area()); System.out.println(" perimetro : " + c.perimetro()); System.out.println("\n"); /* nueva circunferencia de radio PI */ c = new Circunferencia(Math.PI); System.out.println(" c : circunferencia de radio PI"); System.out.println(" area : " + c.area()); System.out.println(" perimetro : " + c.perimetro()); System.out.println("\n"); }}

Salida del programa

5 Representación de las clases en UML

Representación de las Clases en UML
Una clase es una descripción de un conjunto de objetos que comparten los mismos atributos,
operaciones, relaciones y semántica. Hay que hacer una especial diferenciación para no confundir el concepto de clase con el de objeto. Un objeto es una instancia individual de una clase, así podríamos tener una clase que fuera los monitores y un objeto de la clase monitores que fuera un monitor marca
“
A
”
de 17 pulgadas, con la pantalla plana. En UML se usan un rectángulo para representar las clases, con distintos compartimentos para indicar sus atributos y sus operaciones. Una clase es identifica por un nombre que la distingue del resto, el nombre es una cadena de texto. Ese
nombre sólo se denomina nombre simple; un nombre de camino consta del nombre de la clase
precedido del nombre del paquete en el que se encuentra incluida. En las figuras 20 y 21 podemos ver la estructura de una clase y distintos nombres de camino y nombres simples. Monitor Marca modelo
encender()
Nombre Atributos Operaciones

Un atributo es una propiedad de una clase identificada con un
nombre. Describe un rango de valores que pueden tomar las instancias de la propiedad. Los atributos representan propiedades comunes a todos los objetos de una determinada clase, por ejemplo
todos los monitores tienen la propiedad dimensión, que se suele
medir en pulgadas. Un cliente tiene las propiedades nombre,
Figura 20. Representación de Clases Cliente Figura Nombres simples Ordenadores::Monitor java::awt::Rectangle Nombres de camino Figura 21. Tipos de nombres
apellidos, dirección, teléfono... Los atributos son propiedades interesantes de las clases. Una instancia de una determinada clase tendrá valores concretos para sus atributos, mientras que las clases tienen rangos de valores que pueden admitir sus atributos. El nombre de los atributos es un texto que normalmente se escribe
en minúsculas si sólo es una palabra o la primera palabra del
nombre del atributo en minúsculas y el resto de las palabras con la primera letra en mayúsculas, por ejemplo, nombrePropietario. Una operación es una implementación de un servicio que puede ser requerido a cualquier objeto de la clase para que muestre su comportamiento. Una operación representa algo que el objeto puede hacer. Por ejemplo, un comportamiento esperado por cualquier usuario de un monitor es que este se pueda encender y apagar. El nombre de las operaciones sigue las mismas reglas de notación que los atributos pero suelen ser verbos cortos que indican una acción o comportamiento de la clase. Como norma general, cuando se dibuja una clase no hay que mostrar todos sus atributos ni todas sus operaciones, sólo se deben mostrar los subconjuntos de estos más relevantes y una buena práctica es utilizar estereotipo, para organizar los atributos y las operaciones.

6. efectuar y/o diseñar clases en rational rose

ANÁLISIS Y DISEÑO CON UML Y RATIONAL ROSE 2003
Dirigido a:Esta acción formativa va dirigida a Programadores, Analistas, Jefes de Proyecto y personal de alta cualificación técnica, que deseen manejar el entorno de modelado Rational Rose 2003.
Requisitos previos: Los alumnos deberán tener conocimientos previos en el desarrollo de aplicaciones bajo alguna plataforma que emplee un lenguaje orientado a objetos y conceptos de diseño de bases de datos.
ModalidadPresencial
Duración35 horas
ObjetivosConocer los elementos y diagramas provistos por UMLEfectuar una captura de requisitos correcta para iniciar un desarrolloModelar los conceptos asociados a cada fase dentro de un desarrollo mediante los diagramas adecuadosManejar el entorno de modelado Rational Rose 2003
Contenido MÓDULO 1: INTRODUCCIÓN 1.1.Introducción a UML 1.2.Modelos y vistas 1.3.Elementos básicos de representación empleados en UML 1.4.Descripción y arquitectura del entorno de modelado Rational Rose 2003MÓDULO 2: MODELADO CON UML 2.1.Tipos de diagramas disponibles 2.2.Captura de requerimientos, modelado del dominio de la aplicación y diseño de diagramas de casos de uso 2.3.Definición de actividades y diseño de diagramas de actividad 2.4.Generación del modelo de clases y empleo de diagramas de clases 2.5.Empleo de patrones de diseño en el modelado de clases 2.6.Descripción del diagrama de objetos .7.Modelado del comportamiento .8.Diagramas de secuencia 2.9.Diagramas de colaboración 2.10.Diagramas de estado-transiciónMÓDULO 3: MODELO FÍSICO 3.1.Generación del modelo físico 3.2.Generación de código a partir de diagramas de clases en Rational Rose 2003 3.3.Ingeniería directa e inversa 3.4.Diagramas de componentes 3.5.Diagramas de despliegueMÓDULO 4: CONSIDERACIONES FINALES 4.1. Descripción del proceso unificado de Rational 4.2. Consideraciones finales a la hora de realizar un modelado

7 indicar tipos de relaciones en el diagrama de clases

Relaciones entre clases
Existen tres relaciones diferentes entre clases, Dependencias, Generalización y Asociación. En las relaciones se habla de una clase destino y de una clase origen. La origen es desde la que se realiza la acción de relacionar. Es decir desde la que parte la flecha, la destino es la que recibe la flecha. Las relaciones se pueden modificar con estereotipos o con restricciones.
Dependencias
Es una relación de uso, es decir una clase usa a otra, que la necesita para su cometido. Se representa con una flecha discontinua va desde la clase utilizadora a la clase utilizada. Con la dependencia mostramos que un cambio en la clase utilizada puede afectar al funcionamiento de la clase utilizadora, pero no al contrario. Aunque las dependencias se pueden crear tal cual, es decir sin ningún estereotipo (palabreja que aparece al lado de la línea que representa la dependencia) UML permite dar mas significado a las dependencias, es decir concretar mas, mediante el uso de estereotipos.
Estereotipos de relación Clase-objeto.
Bind: La clase utilizada es una plantilla, y necesita de parámetros para ser utilizada, con Bind se indica que la clase se instancia con los parámetros pasándole datos reales para sus parámetros.
Derive: Se utiliza al indicar relaciones entre dos atributos, indica que el valor de un atributo depende directamente del valor de otro. Es decir el atributo edad depende directamente del atributo Fecha nacimiento.
Friend: Especifica una visibilidad especial sobre la clase relacionada. Es decir podrá ver las interioridades de la clase destino.
InstanceOF: Indica que el objeto origen es una instancia del destino.
Instantiate: indica que el origen crea instancias del destino.
Powertype: indica que el destino es un contenedor de objetos del origen, o de sus hijos.
Refine: se utiliza para indicar que una clase es la misma que otra, pero mas refinada, es decir dos vistas de la misma clase, la destino con mayor detalle.
Generalización
Pues es la herencia, donde tenemos una o varias clases padre o superclase o madre, y una clase hija o subclase. UML soporta tanto herencia simple como herencia múltiple. Aunque la representación común es suficiente en el 99.73% de los casos UML nos permite modificar la relación de Generalización con un estereotipo y dos restricciones.
Estereotipo de generalización.
Implementation: El hijo hereda la implementación del padre, sin publicar ni soportar sus interfaces.
Restricciones de generalización.
Complete: La generalización ya no permite mas hijos.
Incomplete: Podemos incorporar mas hijos a la generalización.
Disjoint: solo puede tener un tipo en tiempo de ejecución, una instancia del padre solo podrá ser de un tipo de hijo.
Overlapping: puede cambiar de tipo durante su vida, una instancia del padre puede ir cambiando de tipo entre los de sus hijos.
Asociación
Especifica que los objetos de una clase están relacionados con los elementos de otra clase. Se representa mediante una línea continua, que une las dos clases. Podemos indicar el nombre, multiplicidad en los extremos, su rol, y agregación.




















En este diagrama se han creado cuatro clases. La clase principal es Usuario, que tiene dos clases hijas UsuarioADM y UsuarioINF. El usuario mantiene una relación de asociación con la clase Clave, se indica que es propietario de una clave, o de un número indeterminado de ellas. Se le crea también una relación de dependencia con la clase Perfil, es decir las instancias de usuario contendrán como miembro una instancia de Perfil.


8 ejemplos de diagramas de clases con sus relaciones

Diagrama de clases (estructura estática)
Los diagramas de clases son diagramas de estructura estática que muestran las clases del sistema y sus interrelaciones (incluyendo herencia, agregación, asociación, etc). Los diagramas de clase son el pilar básico del modelado con UML, siendo utilizados tanto para mostrar lo que el sistema puede hacer (análisis), como para mostrar cómo puede ser construido (dise no). El diagrama de clases de más alto nivel ( main class diagram), será lógicamente un dibujo de los paquetes que componen el sistema. A su vez cada paquete tendrá un main class diagram que muestra las clases del paquete
Las clases se documentan con una descripción de lo que hacen, sus métodos y sus atributos. Las relaciones entre clases se documentan con una descripción de su propósito, su cardinalidad (cuantos objetos intervienen en la relación) y su opcionalidad (cuando un objeto es opcional el que intervenga en una relación). La descripción de clases complejas se puede documentar con diagramas de estados (sección 5.1).

























Supongamos el modelado de una máquina de café. Un diagrama de estructura estática inicial podría ser el representado en la figura 3.2. En dicha figura vemos que la representación gráfica UML para las clases es un rectángulo con compartimentos internos, siendo dichos rectángulos (clases) los elementos fundamentales del diagrama. Los compartimentos de una clase contienen su nombre, atributos y operaciones. En el ejemplo de la figura 3.2 encontramos las clases Ingrediente, Producto, Maquina, DepositoMonedas y DepositoMonedasIguales. Los atributos, como hemos mencionado, identifican las características propias de cada clase. Generalmente son de tipos simples, ya que los atributos de tipos compuestos se representan mediante relaciones de composición con otras clases. La sintaxis textual UML para un atributo es:
visibility name : type-expression = initial-value { property-string}
Donde visibility puede ser public, protected y private; y type-expression es el tipo del atributo con nombre name. Además puede especificarse un valor inicial y un conjunto de propiedades del atributo. La visibilidad de un atributo (o operación puede ser):
public +: Cualquier clase externa con visibilidad hacia la clase dada puede utilizar la característica (ya se atributo u operación).
protected #: Cualquier descendiente de la clase puede utilizar la característica.
private -: Sólo el propio clasificador puede utilizar la característica.
En el modelo de la máquina de café (fig.3.2), la clase Ingrediente tiene dos atributos: cantidad, de tipo float y con valor inicial 0; y nombre de tipo string sin valor inicial. En la herramienta CASE Rational Rose se utiliza para la representación de la visibilidad los símbolos que se muestran en la figura 3.3.


Figura: Símbolos en Rose para visibilidad privada, protegida y pública

La sintaxis de una operación en UML es:
visibility name (parameter-list) : return-type-expression {property-string}
Donde cada uno de los parámetros en parameter-list se denota igual que un atributo. Los demás elementos son los mismos que encontramos en la notación de un atributo.
Otro detalle importante que se puede especificar en los atributos y operaciones de una clase es su alcance. El alcance de propiedad de una característica especifica si la propiedad aparece en cada instancia de la clase o si sólo hay una instancia la propiedad para todas las instancias de la clase. En UML se pueden especificar dos tipos de alcance de propiedad:
instancia: Cada instancia de la clase tiene su propio valor.
clasificador: Sólo hay un valor para todas las instancias del clasificador.
Un atributo u operación con alcance de clasificador se denota subrayando la característica. El alcance de clasificador se corresponde con lo que en C++ son atributos y operaciones estáticas.
Una relación en un diagrama de clases, se representa mediante una línea que une dos o más clases. La línea puede ir acompa nada de diferentes tipos de adornos que definen su semántica y características. Como hemos ido viendo en esta sección las relaciones más comunes entre las clases presentes en un diagrama estático pueden ser: asociación (binaria o n-aria), agregación, generalización, dependencia, composición y clasificación.
Los elementos adicionales que pueden aparecer en la representación de una relación son:
Rol: Identifica con nombres a los elementos que aparecen en los extremos de la línea que denota la relación, dicho nombre describe la semántica que tiene la relación en el sentido indicado. Por ejemplo, la asociación de composición entre Maquina e Ingrediente recibe el nombre de existencias como rol en ese sentido.
Multiplicidad: Indica la cardinalidad de la relación. En el ejemplo se utilizan 1, 1 ..*, 5, *, como indicadores de multiplicidad.
Una asociación binaria se representa mediante una línea sólida que une dos clases, se trata de una relación entre las dos clases no muy fuerte, es decir, no se exige dependencia existencial ni encapsulamiento. Un ejemplo de asociación de este tipo es la que existe entre una compa nía y sus empleados (fig.3.4). En este caso la asociación binaria recibe el nombre Trabaja Para, y en ella intervienen una o más instancias (objetos) de la clase Persona denominadas empleado. Además cada empleado se asocia a un empleador que en este caso es único.







La agregación ( aggregation) es, como ya hemos mencionado, una forma especial de asociación que especifica una relación todo-parte entre el agregado (todo) y una parte que lo compone. Una agregación se representa mediante un rombo en el extremo ``todo'' de la relación. Un ejemplo puede encontrarse entre Producto e Ingrediente en la figura 3.2.
Una agregación de composición o simplemente composición ( composite aggregation) es una agregación más fuerte que implica:
Dependencia existencial: El elemento dependiente desaparece al destruirse el que lo contiene y, si es de cardinalidad 1, es creado al mismo tiempo.
Pertenencia fuerte: Se puede decir que el objeto contenido es parte constitutiva y vital del que lo contiene.
No compartición: Los objetos contenidos no son compartidos, esto es, no forman parte del estado de otro objeto.
La composición se representa mediante un rombo relleno del lado de la clase que contiene a la otra en la agregación. En el ejemplo de la máquina de café vemos composiciones entre Maquina y Producto, Maquina y DepositoMonedas y, Maquina y DepositoMonedasIguales. La relación de generalización, denotando herencia entre clases, se representa mediante un triángulo sin rellenar del lado de la superclase. La subclase hereda todos los atributos y mensajes descritos en la superclase. En el ejemplo encontramos generalización entre DepositoMonedas (superclase) y DepositoMonedasIguales (subclase).
Una clase paramétrica ( parametrized class) se corresponde con el concepto de clases molde ( template) en C++. Se representa acompa nando la clase con un rectángulo en la esquina superior derecha donde estarían los parámetros. Por ejemplo, la clase Lista que utiliza un parámetro formal Tipo se representaría como en la figura 3.5, pudiendo representar una lista de diferentes tipos de objetos dependiendo del valor del parámetro.


Figura: Ejemplo de clase paramétrica ( parametrized class)





















En UML los paquetes se representan como carpetas (fig 3.6) que pueden presentar relaciones de dependencia o de generalización entre ellos.

Figura 3.6: Ejemplo de paquetes













































En el ejemplo de la figura 1.11 existen tres paquetes (que aparecen vacíos, es decir, con su contenido encapsulado), con dos de ellos dependiendo del Modelo del Mundo. Una dependencia puede ir acompa nada de una explicación del tipo de dependencia de que se trate, utilizando estereotipos (ver

9 ejemplos de clases en java

Clase Math
Esta clase contiene variables de campo y métodos estáticos utilizados para realizar operaciones matemáticas que van desde el cálculo de una raíz cuadrada hasta el de funciones trigonométricas. Se van a comentar los menos conocidos. Para familiarizarse con el resto ir a la API.
static double ceil(double num): devuelve el double de tipo entero (double-entero, a partir de ahora) más cercano al argumento que se le pasa, yéndose hacia + infinito. Un double-entero es un número decimal cuya parte decimal es siempre 0.
Ejemplo:
System.out.println(Math.ceil(2.3);// muestra por consola 3.0
System.out.println(Math.ceil(0.895);// muestra por consola 1.0
System.out.println(Math.ceil(-1.87);// muestra por consola -1.0
System.out.println(Math.ceil(-0.9);// muestra por consola -0.0
static double floor(double num): ídem anterior, pero devolviendo el double-entero más cercano al argumento que se le pasa, yéndose hacia - infinito.
Ejemplo:
System.out.println(Math.floor(2.3);// muestra por consola 2.0
System.out.println(Math.floor(0.895);// muestra por consola 0.0
System.out.println(Math.floor(-1.87);// muestra por consola -2.0
System.out.println(Math.floor(-0.9);// muestra por consola -1.0
static double rint(double num): devuelve el double-entero redondeado y asociado al argumento que se le pasa, tomando como cifra base para el redondeo, la primera después de la coma del argumento, y siguiendo los criterios habituales de redondeo
NOTA: si la cifra base para el redondeo es mayor o igual que 5, se aumenta en una unidad la cifra anterior; si la cifra base es menor que 5, no se modifica la cifra anterior.
Si se quiere redondear a partir de una determinada cifra decimal, se multiplicará por la potencia de 10 que corresponda, se aplicará el método y, después, se dividirá entre la potencia de 10 por la que anteriormente se ha multiplicado.
Ejemplo:
System.out.println(Math.rint(0.891));// muestra por consola 1.0
Si se quisiera aproximar a dos decimales:
System.out.println(Math.rint(0.891*100)/100);// muestra por consola 0.89
Ahora conviene hacer los ejercicios 1, 2 y 3.
Clases envoltorio de las variables primitivas o wrapper classes
Estas clases pertenecen al paquete java.lang y son las siguientes: Byte, Short, Integer, Long, Float, Double, Boolean y Character. Uno de los usos más habituales de la clases envoltorio es la utilización de métodos estáticos que permiten obtener a partir de una String que almacena un número en forma de texto, el correspondiente valor numérico almacenado en la variable primitiva que interese.
Así, la clase Integer dispone del método "static int parseInt(String)" que transforma la String del argumento en un número que se almacena en la variable primitiva int.
Para el resto de las clases envoltorio se tienen los siguientes métodos:
Si se quiere almacenar la String 250 en una variable int se utilizaría el siguiente código:
Ejemplo:
Código fuente
Por consola:
135
125125
11
Clase Integer
Se va a estudiar la clase Integer. El estudio del resto de clases envoltorio es similar exceptuando Character y Boolean.
CLASE ASOCIADA:
java.lang.Integer. Es una clase "final", es decir, no puede heredarse de ella (la herencia se tratará en temas posteriores).
CONSTRUCTORES:
Los constructores son métodos especiales del mismo nombre que la clase a la que pertenecen y sin tipo de retorno, que se emplean para crear e inicializar objetos de una clase y que no admiten tipo de retorno. Cada clase perteneciente a la API de Java tiene los suyos propios y pueden estudiarse sin más que consultarla. Para crear un objeto de una clase se utilizará un constructor de la misma y la palabra reservada de Java new. Además de los constructores de clases de la API, pueden definirse constructores de clases propias realizadas por el programador, que no forman parte de la API (se verán más adelante).
Integer(int num): crea un objeto Integer en base al entero que se le pasa a su argumento.
Integer(String num): ídem anterior pero pasándole un entero almacenado en forma de String. Si el argumento no es un número almacenado en una String se lanza una NumberFormatException (se verá qué es una excepción más adelante)
Ejemplo de creación de un objeto Integer usando el segundo constructor:
Antes de estudiar los principales métodos de la clase se recuerdan los sistemas de numeración más extendidos para representar datos numéricos:
























MÉTODOS INTERESANTES:
Hay muchísimos métodos en cada clase de la API. En el curso se van a tratar en profundidad unos cuantos, abarcar todos sería imposible. La consulta a la API, aparte de la explicación que se haga, es fundamental para entender la funcionalidad de un método. Por eso, cada vez que se explique un método conviene consultarlo en la API. Un programador sin API está perdido.
static int parseInt(String num): convierte en un entero la cadena de texto que se le pasa al argumento. Si la cadena no es un número se produce una NumberFormatException. MUY USADO.
static int parseInt(String num, int base): ídem anterior, pero indicando en el segundo argumento el sistema de numeración (base 2, base 8, base 10, base 16, etc.) en el que se expresa el primer argumento.
Ejemplo:
String num="1001"; //Esto es un número binario o en base 2 almacenado en forma de String
System.out.println(Integer.parseInt(num,2)); //Por consola va a mostrarse 9.
static Integer valueOf(String num): crea un objeto Integer en base a la cadena de texto que se le pasa. Si la cadena no es un número se produce una NumberFormatException.
static String toHexString(int num): devuelve una cadena de texto cuyo contenido es el entero expresado en hexadecimal del entero expresado en decimal que se le pasa al argumento.
static String toOctalString(int num): ídem, pero ahora el contenido es un entero expresado en octal.
static String toBinaryString(int num): ídem, pero ahora el contenido es un entero expresado en binario.
int intValue(): devuelve el entero asociado al contenido de un objeto Integer. Los métodos anteriores, al ser estáticos, no precisan de un objeto Integer sobre el que aplicarlos; en cambio, este método sí.

Por consola:
47
47
47
47
Ahora se recomienda realizar el Ejercicio 4
Clase Character
CLASE ASOCIADA:
java.lang.Character. Al igual que Integer es una clase "final" y, por tanto, no puede heredarse de ella.
CONSTRUCTORES:
Character(char ch): crea un objeto Character pasándole a su argumento un carácter.
MÉTODOS INTERESANTES:
static boolean isLetter(char ch): devuelve true si el carácter del argumento es una letra. False en caso contrario.
static boolean isDigit(char ch): devuelve true si el carácter del argumento es un dígito (0,1,2,.,9). False en caso contrario.
static boolean isLowerCase(char ch): devuelve true si el carácter del argumento es una letra minúscula. False en caso contrario.
static boolean isUpperCase(char ch): devuelve true si el carácter del argumento es una letra mayúscula. False en caso contrario.
char charValue(): devuelve el carácter asociado al objeto Character sobre el que se aplica.




martes, 13 de mayo de 2008

TRABAJO DEL METODO 6 D

/*El programa irá preguntando por la cantidad de billetes y monedas de cada valor que tiene el usuario y luego determinará la suma de dinero que hay en monedas y luego la suma de dinero que hay en billetes. Luego el programa dirá la suma total de dinero que hay. Finalmente el programa dará al usuario la posibilidad de transformar la cantidad en dólares a la cantidad equivalente en quetzales, lempiras o euros, según lo decida el usuario.*/

ingresamos al programa de microsoft visual C++ .


ingresamos a: inicio, programas, microsoft visual 6.0 y adamos click a microsoft visual C++
aplicamos click en el comando que dice close



entramos a archivo,file,new.



ingresamos a file, C++ source file y a la parte derecha ponemos el nombre de el proyecto y abajo la direccion donde deseen guardar

y ahora una vez entrado al C++ ingresamos los codigos de el proyecto por realizar:





#include "STdio.h"
#include
void clrscr()/*Creando funcion para limpiar pantalla.*/
{
HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
COORD coord = {0, 0};
DWORD count;
CONSOLE_SCREEN_BUFFER_INFO csbi;
GetConsoleScreenBufferInfo(hStdOut, &csbi);
FillConsoleOutputCharacter(hStdOut, ' ', csbi.dwSize.X * csbi.dwSize.Y, coord, &count);
SetConsoleCursorPosition(hStdOut, coord);
}
void main()
{
int salir,saliryesno;
salir=0;
while(salir==0){
clrscr();/*Llamando la funcion para limpiar pantalla.*/
int cambiarmoneda;
float total_bill1,total_bill5,total_bill10,total_bill20,total_bill50,total_bill100,total_cent1,total_cent5,total_cent10,total_cent25,total_bill,total_cent,total_dinero,quetzal,lempira,euro;
printf("\nCantidad de billetes de un dolar: ");
scanf("%f",&total_bill1);
printf("Cantidad de billetes de cinco dolares: ");
scanf("%f",&total_bill5);
printf("Cantidad de billetes de diez dolares: ");
scanf("%f",&total_bill10);
printf("Cantidad de billetes de veinte dolares: ");
scanf("%f",&total_bill20);
printf("Cantidad de billetes de cincuenta dolares: ");
scanf("%f",&total_bill50);
printf("Cantidad de billetes de cien dolares: ");
scanf("%f",&total_bill100);
total_bill=(total_bill1*(1)+total_bill5*(5)+total_bill10*(10)+total_bill20*(20)+total_bill50*(50)+total_bill100*(100));
printf("Cantidad de monedas de un centavo: ");
scanf("%f",&total_cent1);
printf("Cantidad de monedas de cinco centavos: ");
scanf("%f",&total_cent5);
printf("Cantidad de monedas de diez centavos: ");
scanf("%f",&total_cent10);
printf("Cantidad de monedas de veinticinco: ");
scanf("%f",&total_cent25);
total_cent=(total_cent1*(0.01)+total_cent5*(0.05)+total_cent10*(0.10)+total_cent25*(0.25));
printf("\nLA CANTIDAD DE DINERO QUE HAY EN BILLETES ES: $%.2f\n",total_bill);
printf("LA CANTIDAD DE DINERO QUE HAY EN MONEDAS ES: $%.2f\n",total_cent);
total_dinero=(total_bill+total_cent);
printf("LA CANTIDAD TOTAL DE DINERO QUE HAY ES: $%.2f\n\n",total_dinero);
printf("\t\tMONEDA\t\tCODIGO\n");
printf("\t\tQuetzal\t\t 1\n");
printf("\t\tLempira\t\t 2\n");
printf("\t\tEuro\t\t 3\n\n");
printf("Introduzca el codigo de la moneda a la que desea convertir los $%.2f: ",total_dinero);
scanf("%d",&cambiarmoneda);
quetzal=total_dinero*7.95270;
lempira=total_dinero*19.71674;
euro=total_dinero*0.82396;
if(cambiarmoneda==1){
printf("\n$%.2f EQUIVALE A %.2f QUETZALES\n\n",total_dinero,quetzal);
printf("SI DESEA SALIR PRESIONE 1 O DE LO CONTRARIO PRESIONE OTRO NUMERO: ");
scanf("%d",&saliryesno);
if(saliryesno==1){
salir=1;
}
}
else{
if(cambiarmoneda==2){
printf("\n$%.2f EQUIVALE A %.2f LEMPIRAS\n\n",total_dinero,lempira);
printf("SI DESEA SALIR PRESIONE 1 O DE LO CONTRARIO PRESIONE OTRO NUMERO: ");
scanf("%d",&saliryesno);
if(saliryesno==1){
salir=1;
}
}
else{/*cambiarmoneda==3*/
printf("\n$%.2f EQUIVALE A %.2f EUROS\n\n",total_dinero,euro);
printf("SI DESEA SALIR PRESIONE 1 O DE LO CONTRARIO PRESIONE OTRO NUMERO: ");
scanf("%d",&saliryesno);
if(saliryesno==1){
salir=1;
}
}
}
}
}





le damos compilar y una ves de damos ejecutar y como veras se trata sobre contar billetes y monedas en doares .. y te mostrara el resultado...



aki abajo sale seleccionar tres tipos de monedas .. para cambiar de dolares a un valor de ellas... ejemplo.. dolar -- euro.




domingo, 27 de abril de 2008

ALGORITMOS




Tabla de contenidos:






Características de los algoritmos :




El científico de computación Donald Knuth ofreció una lista de cinco propiedades, que son ampliamente aceptadas como requisitos para un algoritmo:
Carácter finito. "Un algoritmo siempre debe terminar después de un número finito de pasos".
Precisión. "Cada paso de un algoritmo debe estar precisamente definido; las operaciones a llevar a cabo deben ser especificadas de manera rigurosa y no ambigua para cada caso".
Entrada. "Un algoritmo tiene cero o más entradas: cantidades que le son dadas antes de que el algoritmo comience, o dinámicamente mientras el algoritmo corre. Estas entradas son tomadas de conjuntos específicos de objetos".
Salida. "Un algoritmo tiene una o más salidas: cantidades que tienen una relación específica con las entradas".
Eficacia. "También se espera que un algoritmo sea eficaz, en el sentido de que todas las operaciones a realizar en un algoritmo deben ser suficientemente básicas como para que en principio puedan ser hechas de manera exacta y en un tiempo finito por un hombre usando lápiz y papel".
Knuth admite que, aunque su descripción pueda ser intuitivamente clara, carece de rigor formal, puesto que no está exactamente claro qué significa "precisamente definido", "de manera rigurosa y no ambigua", o "suficientemente básicas", y así sucesivamente.
A partir del caracter finito y de la salida se deduce que ante una misma situación inicial (o valores de entrada) un algoritmo debe proporcionar siempre el mismo resultado (o salida), con excepción de los algoritmos probabilistas.

Medios de expresión de un algoritmo:




Los algoritmos pueden ser expresados de muchas maneras, incluyendo al lenguaje natural, pseudocódigo, diagramas de flujo y lenguajes de programación entre otros. Las descripciones en lenguaje natural tienden a ser ambiguas y extensas. El usar pseudocódigo y diagramas de flujo evita muchas ambigüedades del lenguaje natural. Dichas expresiones son formas más estructuradas para representar algoritmos; no obstante, se mantienen independientes de un lenguaje de programación específico.
La descripción de un algoritmo usualmente se hace en tres niveles:
Descripción de alto nivel. Se establece el problema, se selecciona un modelo matemático y se explica el algoritmo de manera verbal, posiblemente con ilustraciones y omitiendo detalles.
Descripción formal. Se usa pseudocódigo para describir la secuencia de pasos que encuentran la solución.
Implementación. Se muestra el algoritmo expresado en un lenguaje de programación específico o algún objeto capaz de llevar a cabo instrucciones.
También es posible incluir un teorema que demuestre que el algoritmo es correcto, un análisis de complejidad o ambos.


Diagramas De Flujo:


Artículo principal: Diagrama de flujo
Los diagramas de flujo son descripciones gráficas de algoritmos; usan símbolos conectados con flechas para indicar la secuencia de instrucciones y están regidos por ISO.
Los diagramas de flujo son usados para representar algoritmos pequeños, ya que abarcan mucho espacio y su construcción es laboriosa. Por su facilidad de lectura son usados como introducción a los algoritmos, descripción de un lenguaje y descripción de procesos a personas ajenas a la computación.

Pseudocódigo:




Artículo principal: Pseudocódigo
Pseudocódigo es la descripción de un algoritmo que asemeja a un lenguaje de programación pero con algunas convenciones del lenguaje natural. Tiene varias ventajas con respecto a los diagramas de flujo, entre las que se destaca el poco espacio que se requiere para representar instrucciones complejas. El pseudocódigo no está regido por ningún estándar. pseudo viene de falso y por ende es un codigo al que aunque es entendible no se aplica al proceso que debe realizar la maquina.

Máquina de Turing:




Artículo principal: Máquina de Turing
La máquina de Turing es un modelo matemático, diseñado por Alan Turing, que formaliza el concepto de algoritmo. A este modelo se le refiere comúnmente como la "descripción de más bajo nivel" por el hecho de que no utiliza ninguna expresión coloquial.

Implementación:




Muchos algoritmos son ideados para implementarse en un programa. Sin embargo, los algoritmos pueden ser implementados en otros medios, como una red neuronal, un circuito eléctrico o un aparato mecánico. Algunos algoritmos inclusive se diseñan especialmente para implementarse usando lápiz y papel. El algoritmo de multiplicación tradicional, el algoritmo de Euclides, la criba de Eratóstenes y muchas formas de resolver la raíz cuadrada son sólo algunos ejemplos.

Análisis de algoritmos :




Artículo principal: Análisis de algoritmos
Como medida de la eficiencia de un algoritmo, se suelen estudiar los recursos (memoria y tiempo) que consume el algoritmo. El análisis de algoritmos se ha desarrollado para obtener valores que de alguna forma indiquen (o especifiquen) la evolución del gasto de tiempo y memoria en función del tamaño de los valores de entrada.
El análisis y estudio de los algoritmos es una disciplina de las ciencias de la computación y, en la mayoría de los casos, su estudio es completamente abstracto sin usar ningún tipo de lenguaje de programación ni cualquier otra implementación; por eso, en ese sentido, comparte las características de las disciplinas matemáticas. Así, el análisis de los algoritmos se centra en los principios básicos del algoritmo, no en los de la implementación particular. Una forma de plasmar (o algunas veces "codificar") un algoritmo es escribirlo en pseudocódigo o utilizar un lenguaje muy simple tal como Léxico, cuyos códigos pueden estar en el idioma del programador.
Algunos escritores restringen la definición de algoritmo a procedimientos que deben acabar en algún momento, mientras que otros consideran procedimientos que podrían ejecutarse eternamente sin pararse, suponiendo el caso en el que existiera algún dispositivo físico que fuera capaz de funcionar eternamente. En este último caso, la finalización con éxito del algoritmo no se podría definir como la terminación de éste con una salida satisfactoria, sino que el éxito estaría definido en función de las secuencias de salidas dadas durante un periodo de vida de la ejecución del algoritmo. Por ejemplo, un algoritmo que verifica que hay más ceros que unos en una secuencia binaria infinita debe ejecutarse siempre para que pueda devolver un valor útil. Si se implementa correctamente, el valor devuelto por el algoritmo será válido, hasta que evalúe el siguiente dígito binario. De esta forma, mientras evalúa la siguiente secuencia podrán leerse dos tipos de señales: una señal positiva (en el caso de que el número de ceros sea mayor que el de unos) y una negativa en caso contrario. Finalmente, la salida de este algoritmo se define como la devolución de valores exclusivamente positivos si hay más ceros que unos en la secuencia y, en cualquier otro caso, devolverá una mezcla de señales positivas y negativas.

Ejemplo de algoritmo:




El problema consiste en encontrar el máximo de un conjunto de números. Para un ejemplo más complejo véase Algoritmo de Euclides.

Descripción de alto nivel :




Dado un conjunto finito C de números, se tiene el problema de encontrar el número más grande. Sin pérdida de generalidad se puede asumir que dicho conjunto no es vacío y que sus elementos están numerados como .
Es decir, dado un conjunto se pide encontrar m tal que para todo elemento x que pertenece al conjunto C.
Para encontrar el elemento máximo, se asume que el primer elemento (c0) es el máximo; luego, se recorre el conjunto y se compara cada valor con el valor del máximo número encontrado hasta ese momento. En el caso que un elemento sea mayor que el máximo, se asigna su valor al máximo. Cuando se termina de recorrer la lista, el máximo número que se ha encontrado es el máximo de todo el conjunto.




Descripción formal:




El algoritmo escrito de una manera más formal, esto es, en pseudocódigo tendría el siguiente aspecto:
Algoritmo Encontrar el máximo de un conjunto
función
//C es un conjunto no vacío de números//
// C es el número de elementos de C//

para hasta hacer
si m\," src="http://upload.wikimedia.org/math/5/8/d/58dbc3694932347c0487f405d44d259b.png"> entonces

devolver
Sobre la notación:
"" representa la asignación entre dos objetos. Por ejemplo, significa que el objeto m cambia su valor por el de x
"devolver" termina el algoritmo y devuelve el valor a su derecha (en este caso, el máximo de C)

Implementación:



En lenguaje Visual Basic 8 (2005):
Public Function max(C As Integer()) As Integer
Dim n As Integer = C.GetLength(0)
Dim m As Integer = C(0)
For i As Integer = 1 To n
If C(i) > m Then
m = C(i)
End If
Next
Return m
End Function
En lenguaje Delphi:
function Max(const ListaNumeros: array of Integer): Integer;
var
vTemp, i: Integer;
begin
vTemp:= 0;

for i:= 1 to High(ListaNumeros) do
if ListaNumeros[i] > vTemp then
vTemp:= ListaNumeros[i];

Result:= vTemp;
end;

Análisis:



El algoritmo anterior tiene un orden de eficiencia en tiempo de O(n), en la notación O mayúscula, siendo n el tamaño de la entrada, más concretamente, en este caso, el número de elementos de C. Además, como el algoritmo necesita recordar un único valor (el máximo) requiere un espacio adicional de O(1) (hay que tener en cuenta que el tamaño de las entradas no se considera como memoria usada por el algoritmo).

Historia:




La palabra algoritmo proviene del nombre del matemático llamado Muhammad ibn Musa al-Jwarizmi que vivió entre los siglos VIII y IX. Su trabajo consistió en preservar y difundir el conocimiento de la antigua Grecia y de la India. Sus libros eran de fácil comprensión, de ahí que su principal logro no fuera el de crear nuevos teoremas o corrientes de pensamiento, sino el de simplificar la matemática a punto tal que pudieran ser comprendidas y aplicadas por un mayor número de personas. Cabe destacar cómo señaló las virtudes del sistema decimal indio (en contra de los sistemas tradicionales árabes) y cómo explicó que, mediante una especificación clara y concisa de cómo calcular sistemáticamente, se podrían definir algoritmos que fueran usados en dispositivos mecánicos en vez de las manos (por ejemplo, ábacos). También estudió la manera de reducir las operaciones que formaban el cálculo. Es por esto que aún no siendo el creador del primer algoritmo, el concepto lleva aunque no su nombre, sí su pseudónimo.
Así, de la palabra algorismo, que originalmente hacía referencia a las reglas de uso de la aritmética utilizando dígitos árabes, se evolucionó a la palabra latina, derivación de al-Khwarizmi, algobarismus, que más tarde mutaría a algoritmo en el siglo XVIII. La palabra ha cambiado de forma que en su definición se incluye a todos los procedimientos finitos para resolver problemas.
Ya en el siglo XIX, se produjo el primer algoritmo escrito para un computador. La autora fue Ada Byron, en cuyos escritos se detallaban la máquina analítica en 1842. Por ello que es considerada por muchos como la primera programadora aunque, desde Charles Babbage, nadie completó su máquina, por lo que el algoritmo nunca se implementó.
La falta de rigor matemático en la definición de "procedimiento bien definido" para los algoritmos trajo algunas dificultades a los matemáticos y lógicos del siglo XIX y comienzos de XX. Este problema fue en gran parte resuelto con la descripción de la máquina de Turing, un modelo abstracto de computadora formulado por Alan Turing, y la demostración de que cualquier método anticipado por otros matemáticos que pueda encontrarse para describir "procedimientos bien definidos" puede ser emulado en una máquina de Turing (una afirmación conocida como "tesis de Church-Turing").
En la actualidad, el criterio formal para definir un algoritmo es que se trata de un proceso que puede implementarse en una máquina de Turing completamente especificada, o en alguno de los formalismos equivalentes. El interés original de Turing era el problema de la detención: decidir cuándo un algoritmo describe un procedimiento de terminación. En términos prácticos importa más la teoría de la complejidad computacional, que incluye los problemas llamados NP-completos, es decir aquellos sobre los que generalmente se presume que requerirán tiempo más que polinómico para cualquier algoritmo (determinístico). NP denota la clase de los problemas de decisión que pueden ser resueltos en tiempo polinómico por una máquina de Turing no determinística.

Tipos de algoritmos según su función:




Algoritmo de ordenamiento
Algoritmo de búsqueda

Técnicas de diseño de algoritmos:




Algoritmos voraces (greedy): seleccionan los elementos más prometedores del conjunto de candidatos hasta encontrar una solución. En la mayoría de los casos la solución no es óptima.
Algoritmos paralelos: permiten la división de un problema en subproblemas de forma que se puedan ejecutar de forma simultánea en varios procesadores.
Algoritmos probabilísticos: algunos de los pasos de este tipo de algoritmos están en función de valores pseudoaleatorios.
Algoritmos determinísticos: sus pasos están perfectamente definidos y aportan una solución exacta.
Algoritmos no determinísticos
Divide y vencerás: dividen el problema en subconjuntos disjuntos obteniendo una solución de cada uno de ellos para después unirlas, logrando así la solución al problema completo.
Metaheurísticas: encuentran soluciones aproximadas (no óptimas) a problemas basándose en un conocimiento anterior (a veces llamado experiencia) de los mismos.
Programación dinámica: intenta resolver problemas disminuyendo su coste computacional aumentando el coste espacial.
Ramificación y acotación: se basa en la construcción de las soluciones al problema mediante un árbol implícito que se recorre de forma controlada encontrando las mejores soluciones.
Vuelta Atrás (Backtracking): se construye el espacio de soluciones del problema en un árbol que se examina completamente, almacenando las soluciones menos costosas.

Temas relacionados:












Fundamentos de Algoritmia, G. Brassard y P. Bratley. (ISBN 848966000)
The Art of Computer Programming, Knuth, D. E. [quien fue también, el creador del TeX]
Introduction to Algorithms (2nd ed), Cormen, T. H., Leiserson, C. E., Rivest, R. L. y Stein, C.
Introduction to Algorithms. A Creative Approach, Mamber, U.
Algorithms in C (3r ed), Sedgewick, R. (también existen versiones en C++ y Java)
The Design and Analysis of Computer Algorithms, Aho, A.
www.rodrigoseenojayseva.com.ar Mario DiazMario Diaz

Enlaces externos:




DIAGRAMAS DE FLUJO




Tabla de contenidos:

Definición :

Es un esquema para representar gráficamente un algoritmo. Se basan en la utilización de diversos símbolos para representar operaciones específicas. Se les llama diagramas de flujo porque los símbolos utilizados se conectan por medio de flechas para indicar la secuencia de operación.

Símbolos utilizados :
Para hacer comprensibles los diagramas a todas las personas, los símbolos se someten a una normalización; es decir, se hicieron símbolos casi universales, ya que, en un principio cada usuario podría tener sus propios símbolos para representar sus procesos en forma de Diagrama de flujo. Esto trajo como consecuencia que sólo aquel que conocía sus símbolos, los podía interpretar. La simbología utilizada para la elaboración de diagramas de flujo es variable y debe ajustarse a un patrón definido previamente.
En teoría, no es necesario usar un tipo especial de símbolos para crear un diagrama de flujo, pero existen algunos ampliamente utilizados por lo que es adecuado conocerlos y utilizarlos, ampliando así las posibilidades de crear un diagrama más claro y comprensible para crear un proceso lógico y con opciones múltiples adecuadas. Se utilizan los símbolos indicados a continuación, estandarizados según la norma ISO 5807:
Flecha. Indica el sentido y trayectoria del proceso de información o tarea.
Rectángulo. Se usa para representar un evento o proceso determinado. Éste es controlado dentro del diagrama de flujo en que se encuentra. Es el símbolo más comúnmente utilizado. Se usa para representar un evento que ocurre de forma automática y del cual generalmente se sigue una secuencia determinada.
Rombo. Se utiliza para representar una condición. Normalmente el flujo de información entra por arriba y sale por un lado si la condición se cumple o sale por el lado opuesto si la condición no se cumple. El rombo además especifica que hay una bifurcación.
Círculo. Representa un punto de conexión entre procesos. Se utiliza cuando es necesario dividir un diagrama de flujo en varias partes, por ejemplo por razones de espacio o simplicidad. Una referencia debe darse dentro para distinguirlo de otros. La mayoría de las veces se utilizan números en los mismos.
Existen además un sin fin de formas especiales para denotar las entradas, las salidas, los almacenamientos, etcétera.
De acuerdo al estándar ISO, los símbolos e incluso las flechas deben tener ciertas características para permanecer dentro de sus lineamientos y ser considerados sintácticamente correctos. En el caso del círculo de conexión, se debe procurar usarlo sólo cuando se conecta con un proceso contenido dentro de la misma hoja.
Existen también conectores de página, que asemejan a una "casita" y se utilizan para unir actividades que se encuentran en otra hoja.


Características que debe cumplir un diagrama de flujo

En los diagramas de flujo se presuponen los siguientes aspectos:
Existe siempre un camino que permite llegar a una solución (finalización del algoritmo).
Existe un único inicio del proceso.
Existe un único punto de fin para el proceso de flujo (salvo del rombo que indica una comparación con dos caminos posibles).

Recomendaciones:

A su vez, es importante que al construir diagramas de flujo, se observen las siguientes recomendaciones:
Evitar sumideros infinitos, burbujas que tienen entradas pero no salidas.
Evitar las burbujas de generación espontánea, que tienen salidas sin tener entradas, porque son sumamente sospechosas y generalmente incorrectas.
Tener cuidado con los flujos y procesos no etiquetados. Esto suele ser un indicio de falta de esmero, pero puede esconder un error aún más grave: a veces el analista no etiqueta un flujo o un proceso porque simplemente no se le ocurre algún nombre razonable.

Tipos de diagramas de flujo:


Formato Vertical: En él el flujo o la secuencia de las operaciones, va de arriba hacia abajo. Es una lista ordenada de las operaciones de un proceso con toda la información que se considere necesaria, según su propósito.
Formato Horizontal: En el flujo o la secuencia de las operaciones, va de izquierda a derecha.
Formato Panorámico: El proceso entero está representado en una sola carta y puede apreciarse de una sola mirada mucho más rápidamente que leyendo el texto, lo que facilita su comprensión, aun para personas no familiarizadas. Registra no solo en línea vertical, sino también horizontal, distintas acciones simultáneas y la participación de más de un puesto o departamento que el formato vertical no registra.
Formato Arquitectónico: Describe el itinerario de ruta de una forma o persona sobre el plano arquitectónico del área de trabajo. El primero de los flujogramas es eminentemente descriptivo, mientras que los últimos son fundamentalmente representativos.

Véase también:



Diagrama de secuencia

Enlaces externos: