Algoritmo figuras geometricas_doc

UNIVERSIDAD TECNOLOGICA DE PANAMA

FACULTAD DE INGENIERIA DE SISTEMAS COMPUTACIONALES

DESARROLLO DE SOFTWARE I

PROYECTO FINAL

PROFESOR:

REGIS RIVERA

ESTUDIANTES:

ABDIEL VILLARREAL

EDUARDO ALVEO

GADIEL GONZALEZ

JOSUEL BARBA

ROBOAN GONZALEZ

I – SEMESTRE 2013

FECHA:

2 DE JULIO 2013

Índice

INTRODUCCIÓN ..................................................................................................................................3

Definición del problema: ....................................................................................................................4

Algoritmo orientado a objetos para resolución del problema ...........................................................5

Diagrama VML ..................................................................................................................................18

Explicación del algoritmo orientado a objetos: ................................................................................19

Súper clase figuras geométricas ...........................................................................................19

o Atributos...........................................................................................................................19

o Métodos ...........................................................................................................................19

Sub clase bidimensional .......................................................................................................19

o Atributos...........................................................................................................................19

o Métodos ...........................................................................................................................19

Sub clases de figuras bidimensionales .............................................................................................19

Sub clase tridimensional ...........................................................................................................20

o Atributos ..............................................................................................................................20

o Métodos ...............................................................................................................................20

Subclases de figuras tridimensionales: .............................................................................................20

Void Main .........................................................................................................................................20

A nivel de usuario: ........................................................................................................................20

Void main .........................................................................................................................................21

A nivel de programación: .............................................................................................................21

Variables ...............................................................................................................................21

Alternativas múltiples...........................................................................................................21

Objetos .................................................................................................................................21

Conclusión ........................................................................................................................................23

INTRODUCCIÓN

A continuación tendremos el gusto de explicarles cómo resolver un algoritmo

orientado a objetos, utilizando clases, métodos, atributos, objetos, Alternativas,

instrucciones alternativas, repetitivas, herencia, sobre escritura.

Se resuelve un problema donde el usuario elije con que tipos de figuras

geométricos desea trabajar, luego de eso sigue una serie de instrucciones que le permiten

al final obtener el resultado del área, perímetro o volumen de la figura seleccionada.

Cabe mencionar que esta es una de las tantas formas que podemos resolver un

algoritmo orientado a objeto; que sirva para calcular área y perímetro en figuras

bidimensionales a su vez también sirva para el cálculo de área y volumen en figuras

tridimensionales.

Definición del problema:

Resolver un algoritmo orientado a objetos, que esté relacionado con figuras

geométricas bidimensionales y tridimensionales.

El usuario elige con qué tipo de figuras geométricas desea trabajar, si elige figuras

bidimensionales se le pide que elija una de las figuras, luego se le pide que desea

calcular, se le da la opción de que elija entra área y perímetro, seguido de esto se le

indica que introduzca los datos correspondientes a la figura que elija, para proceder con el

cálculo del área o el perímetro; si el usuario elije figuras tridimensionales se le piden que

elija una de las figuras, luego se da la opción que elija que desea calcular, si área o

volumen, seguido de esto se le da la opción de que introduzca los datos necesarios para

realizar el cálculo y al final se le muestra el resultado.

Para resolver esto se implementa todos los conceptos básicos de la programación

orientada a objetos tales como: Clases, métodos, atributos, objetos, alternativas,

instrucciones alternativas, repetitivas, herencia, sobre-escritura.

En este algoritmo orientado a objetos se trata de ser lo más preciso para que de esta

manera se pueda desarrollar el programa con la menor cantidad de líneas de códigos y

así ahorrarnos espacio en la memoria RAM.

Algoritmo orientado a objetos para resolución del problema

Publico Clase Figuras_Geometricas

{

Publico Real Area;

Publico void Calcular()

{

}

Publico void Calcular1()

{

}

}

Publico Clase Bidimensional extiende Figuras_Geometricas

{

Publico Real Perimetro, base, altura, lado1, lado2, Diag1, Diag2,

baseMay, baseMen;

Publico void Calcular()

{

}

Publico void Calcular1()

{

}

}

Publico Clase Cuadrado extiende Bidimensional

{

Publico Void Calcular()

{

Imprimir(“Ingrese la medida de uno de los lados del cuadrado”);

Leer(lado);

Area = lado * lado;

Imprimir(“El área es: “ +Area);

}

Publico Void Calcular1()

{

Imprimir(“Ingrese la medida de uno de los lados del cuadrado”);

Leer(lado);

Perimetro = 4 * lado;

Imprimir(“El perímetro es: “ +Perimetro);

}

}

Publico Clase Rectangulo extiende Bidimensional

{


{

Imprimir(“Ingrese la medida de la base del rectángulo”);

Leer(base);

Imprimir(“Ingrese la medida de la altura del rectángulo”);

Leer(altura);

Area = base * altura;

Imprimir(“El area es: “ +Area);

}


{

Imprimir(“Ingrese la medida de la base del rectángulo”);

Leer(base);

Imprimir(“Ingrese la medida de la altura del rectángulo”);

Leer(altura);

Perimetro = (2 * base) + 2 * altura;


}

}

Publico Clase Paralelogramo extiende Bidimensional

{


{

Imprimir(“Ingrese la medida de la base del paralelogramo”);

Leer(base);

Imprimir(“Ingrese la medida de la altura del paralelogramo”);

Leer(altura);

Area = base * altura;


}


{

Imprimir(“Ingrese la medida de la base del paralelogramo”);

Leer(base);

Imprimir(“Ingrese la medida del lado del paralelogramo ”);

Leer(lado);

Perimetro = (2 * base) + (2 * lado);


}

}

Publico Clase Rombo extiende Bidimensional

{

Publico Void Calcular ()

{

Imprimir(“Ingrese la diagonal menor del rombo”);

Leer(Diag1);

Imprimir (“Ingrese la diagonal mayor del rombo);

Leer(Diag2);

Area = (Diag1 * Diag2) / 2;


}


{

Imprimir(“Ingrese la medida de uno de los lado del rombo”);

Leer(lado);



}

}

Publico Clase Trapecio extiende Bidimensional

{


{

Imprimir(“Ingrese la base menor del trapecio”);

Leer(BaseMen);

Imprimir(“Ingrese la base mayor del trapecio”);

Leer(“BaseMay);

Imprimir(“Ingrese la altura del trapecio”);

Leer(altura);

Area = ((BaseMen + BaseMay)/2) * (altura);

Imprimir(“EL area es: “ +Area);

}


{

Imprimir(“Ingrese lado 1 del trapecio”);

Leer(altura);


Leer(BaseMen);


Leer(BaseMay);


Leer(lado);

Perimetro = altura + BaseMen + BaseMay + lado;

Imprimir(“El perimetro es: “ +Perimetro);

}

}

Publico Clase Trapecio_Recto extiende Bidimensional

{


{

Imprimir(“Ingrese la altura del trapecio recto”);

Leer(altura);

Imprimir(“Ingrese la base menor del trapecio recto”);

Leer(BaseMen);

Imprimir(“Ingrese la base mayor del trapecio recto”);

Leer(BaseMay);

Area = ((BaseMen + BaseMay)/2) * (altura);


}


{

Imprimir(“Ingrese lado 1 del trapecio recto”);

Leer(altura);


Leer(BaseMen);


Leer(BaseMay);


Leer(lado);

Perimetro = altura + BaseMen + BaseMay + lado;

Imprimir(“El perimetro es: “ +Perimetro);

}

}

Publico Clase Triangulo_equilatero extiende Bidimensional

{


{

Imprimir(“Ingrese la medida del lado del triángulo equilátero”);

Leer(lado);

Imprimir(“Ingrese la altura del triángulo equilátero”);

Leer(altura);

Area = (lado * altura) / 2;

Imprimir (“El área es: “ +Area);

}


{

Imprimir(“Ingrese la medida del lado del triángulo equilátero ”);

Leer(lado);



}

}

Publico Clase Triangulo_isosceles extiende Bidimensional

{


{

Imprimir(“Ingrese la medida de la base del triángulo isósceles”);

Leer(base);

Imprimir(“Ingrese la altura del triángulo isósceles”);

Leer(altura);

Area = (base * altura) / 2;

Imprimir(“El área es:” +Area);

}


{

Imprimir(“Ingrese la medida del lado del triángulo isósceles”);

Leer(lado);

Imprimir(“Ingrese la base del triángulo isósceles”);

Leer(base);

Perimetro = (2 * lado) + base;


}

}

Publico Clase Triangulo_escaleno extiende Bidimensional

{


{

Imprimir(“Ingrese la base del triángulo escaleno”);

Leer(base);

Imprimir(“Ingrese la altura del triángulo escaleno”);

Leer(altura);



}


{

Imprimir(“Ingrese la medida del lado 1 del triángulo escaleno”);

Leer(lado1);

Imprimir(“Ingrese la base”);

Leer(base);

Imprimir(“Ingrese la medida del lado 2 del triángulo escaleno”);

Leer(lado2);

Perimetro = lado1 + base + lado2;


}

}

Publico Clase Triangulo_rectangulo extiende Bidimensional

{


{

Imprimir(“Ingrese la base del triángulo rectángulo”);

Leer(base);

Imprimir(“Ingrese la altura del triángulo rectángulo”);

Leer(altura);


Imprimir(“El área es: “ +Area); }


{

Imprimir(“Ingrese la medida del lado 1 del triángulo rectángulo”);

Leer(lado1);

Imprimir(“Ingrese la base del triángulo rectángulo”);

Leer(base);

Imprimir(“Ingrese la medida del lado 2 triangulo rectángulo”);

Leer(lado2);

Perimetro = lado1 + base + lado2;


}

}

Publico Clase tridimensional extiende Figuras_Geometricas

{

Publico Real Volumen, lado1, lado2, base, radio, generatriz, altura,

Alturalat, Alturabas;

Publico void Calcular();

Publico void Calcular1();

}

Publico Clase Cubo extiende tridimensional

{


{

Imprimir(“Ingrese la medida del lado del cubo”);

Leer(lado1);

Area = 6 * lado1 * lado1;


}

Publico Void Calcular1 ()

{

Imprimir(“Ingrese la medida del lado del cubo”);

Leer(lado1);

Volumen = lado1 * lado1 * lado1;

Imprimir(“El Volumen es: “ +Volumen);

}

}

Publico Clase Prisma_recto extiende tridimensional

{


{

Imprimir(“Ingrese la medida del lado 1 del prisma recto”);

Leer(lado1);

Imprimir(“Ingrese la base del prisma recto”);

Leer(base);


Leer(lado2);

Area = (2 * lado1 * base) + (2 * lado1 * lado2) + (2 * base * lado2);


}


{

Imprimir(“Ingrese la medida del lado 1 del prima recto”);

Leer(lado1);

Imprimir(“Ingrese la base del prisma recto”);

Leer(base);


Leer(lado2);

Publico Volumen = lado1 * lado2 * base;

Imprimir(“El Volumen es: “ +Volumen”);

}

}

Publico Clase Esfera extiende tridimensional

{


{

Imprimir(“Ingrese el radio de la esfera”);

Leer(radio);

Area = (4 * 3.1416 * (radio * radio));


}


{

Imprimir(“Ingrese el radio de la esfera”);

Leer(radio);

Volumen = (4 * 3.1416 * (radio * radio * radio)) / 3;

Imprimir(“El Volumen es: “ +Volumen);

}

}

Publico Clase Cilindro extiende tridimensional

{


{

Imprimir(“Ingrese el radio del cilindro”);

Leer(radio);

Imprimir(“Ingrese la altura del cilindro”);

Leer(altura);

Area = (2 * 3.1416 * radio) * (altura * radio);


}


{

Imprimir(“Ingrese el radio del cilindro”);

Leer(radio);

Imprimir(“Ingrese la altura del cilindro”);

Leer(altura);

Volumen = (3.1416 * (radio + radio) * altura);

Imprimir(“El volumen es: “ +Volumen);

}

}

Publico Clase Cono extiende tridimensional

{


{

Imprimir(“Ingrese el radio del cono”);

Leer(radio);

Imprimir(“Ingrese la medida de la generatriz del cono”);

Leer(generatriz);

Area = (3.1416 * radio * generatriz) + (3.1416 *(radio * radio));


}


{

Imprimir(“Ingrese el radio del cono”);

Leer(radio);

Imprimir(“Ingrese la altura del cono”);

Leer(altura);

Volumen = (3.1416 * (radio * radio) * altura) / 3;


}

}

Publico Clase Piramide extiende tridimensional

{


{

Imprimir(“Ingrese la altura lateral de la pirámide”);

Leer(AlturaLat);

Imprimir(“Ingrese la Altura base de la pirámide”);

Leer(Alturabas);

Area = AlturaLat + Alturabas;


}


{

Imprimir(“Ingrese la altura base de la pirámide”);

Leer(Alturabas);

Imprimir(“Ingrese la altura de la pirámide”);

Leer(altura);

Volumen = (Alturabas * altura) / 3;


}

}

Void Main ()

{

entero opcion1, opcion2, opcion3;

Imprimir (“Escoja una de las Opciones”);

Imprimir (“1. Figuras Bidimensionales”);

Imprimir (“2. Figuras Tridimensionales”);

Leer (opcion1);

Si (opcion1 = 1)

{

Imprimir (“¿Qué Tipo de Figura Usaras?”);

Imprimir (“1. Cuadrado”);

Imprimir (“2. Rectángulo”);

Imprimir (“3. Paralelogramo”);

Imprimir (“4. Rombo”);

Imprimir (“5. Trapecio”);

Imprimir (“6. Trapecio Recto”);

Imprimir (“7. Triángulo Equilátero”);

Imprimir (“8. Triangulo Isósceles”);

Imprimir (“9. Triangulo Escaleno”);

Imprimir (“10. Triangulo Rectángulo”);

Leer(opcion2);

Según sea (opcion2)

{

Caso 1:

{

Cuadrado cu = nuevo Cuadrado();

Imprimir (“Que deseas realizar”);

Imprimir (“1. Calcular Área”);

Imprimir (“2. Calcular Perímetro);

Leer (opcion3);

Si (opcion3 = 1)

{

cu.Calcular();

}

De otro modo Si(opcion3 = 2)

{

cu.Calcular1();

}

Interrumpir;

}

Caso 2:

{

Rectangulo Rec = nuevo Rectangulo();

Imprimir (“Que deseas hacer”);


Imprimir (“2. Calcular Perímetro”);

Leer (“opcion3);

Si (opcion3 = 1)

{

Rec.Calcular();

}

De otro modo Si (opcion3 = 2);

{

Rec.Calcular1();

}

Interrumpir;

}

caso 3:

{

Paralelogramo plg = nuevo Paralelogramo();




Leer (opcion3);

Si (opcion3 = 1)

{

plg.Calcular();

}


{

plg.Calcular1();

}

Interrumpir;

}

caso 4:

{

Rombo rbo = nuevo Rombo();




Leer (opcion3);

Si (opcion3 = 1)

{

rbo.Calcular();

}


{

rbo.Calcular1();

}

Interrumpir;

}

caso 5:

{

Trapecio tpc = nuevo Trapecio();




Leer (opcion3);

Si (opcion3 = 1)

{

tpc.Calcular();

}


{

tpc.Calcular1();

}

Interrumpir;

}

caso 6:

{

Trapecio_Recto tpr = nuevo Trapecio_Recto();




Leer (opcion3);

Si (opcion3 = 1)

{

tpr.Calcular();

}


{

tpr.Calcular1();

}

Interrumpir;

}

caso 7:

{

Triangulo_equilatero treq = nuevo Triangulo_equilatero();




Leer (opcion3);

Si (opcion3 = 1)

{

treq.Calcular();

}


{

treq.Calcular1();

}

Interrumpir;

}

caso 8:

{

TIsosceles tric = nuevo TIsosceles();




Leer (opcion3);

Si (opcion3 = 1)

{

tric.Calcular();

}


{

tric.Calcular1();

}

Interrumpir;

}

caso 9:

{

TEscaleno tres = nuevo TEscaleno();




Leer (opcion3);

Si (opcion3 = 1)

{

tres.Calcular();

}


{

tres.Calcular1();

}

Interrumpir;

}

caso 10:

{

Trectangulo treg = nuevo Trectangulo();




Leer (opcion3);

Si (opcion3 = 1)

{

treg.Calcular();

}


{

treg.Calcular1();

}

Interrumpir;

}

Defecto:

{

Imprimir(“No existe esa opción”);

}

}

}

Si (opcion1 = 2)

{

Imprimir (“¿Qué Tipo de Figura Usaras?”);

Imprimir (“1. Cubo”);

Imprimir (“2. Prisma Recto”);

Imprimir (“3. Esfera”);

Imprimir (“4. Cilindro”);

Imprimir (“5. Cono”);

Imprimir (“6. Pirámide”);

Leer(opcion2);

Según sea (opcion2)

{

Caso 1:

{

Cubo cub = nuevo Cubo();



Imprimir (“2. Calcular Volumen);

Leer (opcion3);

Si (opcion3 = 1)

{

cub.Calcular();

}


{

cub.Calcular1();

}

Interrumpir;

}

Caso 2:

{

Prisma_recto psr = nuevo Prisma_recto();

Imprimir (“Que deseas hacer”);


Imprimir (“2. Calcular Volumen”);

Leer (“opcion3);

Si (opcion3 = 1)

{

psr.Calcular();

}

De otro modo Si (opcion3 = 2);

{

psr.Calcular1();

}

Interrumpir;

}

caso 3:

{

Esfera esf = nuevo Esfera();




Leer (opcion3);

Si (opcion3 = 1)

{

esf.Calcular();

}


{

esf.Calcular1();

}

Interrumpir;

}

caso 4:

{

Cilindro cil = nuevo Cilindro();




Leer (opcion3);

Si (opcion3 = 1)

{

cil.Calcular();

}


{

cil.Calcular1();

}

Interrumpir;

}

caso 5:

{

Cono con = nuevo Cono();




Leer (opcion3);

Si (opcion3 = 1)

{

con.Calcular();

}


{

con.Calcular1();

}

Interrumpir;

}

caso 6:

{

Piramide pir = nuevo Piramide();




Leer (opcion3);

Si (opcion3 = 1)

{

pir.Calcular();

}


{

pir.Calcular1();

}

Interrumpir;

}

Defecto:

{

Imprimir(“No existe esa opción”);

}

}

}

}

+ Clase Tridimensional

+ Real Volumen, lado1, lado2,

base, radio, generatriz, altura,

Alturalat, Alturabas;

+ Void Calcular ()

+ Void Calcular1 ()

+ Clase Bidimensional

+ Real Perimetro, base, altura,

lado1, lado2, Diag1, Diag2,

baseMay, baseMen;

+ Clase

Figuras_Geometricas

+ Void Calcular ()

+ Void Calcular1 ()

+ Real Area

+ Void Calcular ()

+ Void Calcular1 ()

+ Clase Cuadrado

+ Void Calcular ()

+ Void Calcular1 ()

+ Clase Rectangulo

+ Void Calcular ()

+ Void Calcular1 ()

+ Clase Paralelogramo

+ Void Calcular ()

+ Void Calcular1 ()

+ Clase Rombo

+ Void Calcular ()

+ Void Calcular1 ()

+ Clase Trapecio

+ Void Calcular ()

+ Void Calcular1 ()

+ Clase Trapecio_Recto

+ Void Calcular ()

+ Void Calcular1 ()

+ Clase Triangulo_equilatero

+ Void Calcular ()

+ Void Calcular1 ()

+ Clase Triangulo_isosceles

+ Void Calcular ()

+ Void Calcular1 ()

+ Clase Triangulo_escaleno

+ Void Calcular ()

+ Void Calcular1 ()

+ Clase Triangulo_rectangulo

+ Void Calcular ()

+ Void Calcular1 ()

+ Clase Prisma_recto

+ Void Calcular ()

+ Void Calcular1 ()

+ Clase Cubo

+ Void Calcular ()

+ Void Calcular1 ()

+ Clase Cilindro

+ Void Calcular ()

+ Void Calcular1 ()

+ Clase Esfera

+ Void Calcular ()

+ Void Calcular1 ()

+ Clase Cono

+ Void Calcular ()

+ Void Calcular1 ()

+ Clase Piramide

+ Void Calcular ()

+ Void Calcular1 ()

Diagrama VML

Explicación del algoritmo orientado a objetos:

En este algoritmo tenemos:

Súper clase figuras geométricas Publico Clase Figuras_Geometricas

o Atributos Publico Real Area;

o Métodos Publico void Calcular(); y Publico void Calcular1();

Esta clase es pública para que pueda ser heredada por sus subclases al igual que

variable ya que la misma va ser utilizada para las subclases los métodos también son

públicos para poder utilizarlos como sobre escritura en los métodos de las subclases.

Sub clase bidimensional Publico Clase Bidimensional extiende

Figuras_Geometricas

o Atributos Publico Real Perimetro, base, altura, lado1, lado2,

Diag1, Diag2, baseMay, baseMen;


La sub clase está heredando el atributo de la súper clase y sobre escribe los métodos, la

subclase es pública para que pueda ser heredada por sus subclases las variables también

son publica para que sean utilizadas por las subclases, los métodos son públicos para

poder aplicar el concepto de sobre escritura.

Sub clases de figuras bidimensionales

Sub clase Publico Clase Cuadrado extiende Bidimensional

Sub clase Publico Clase Rectangulo extiende Bidimensional

Sub clase Publico Clase Paralelogramo extiende Bidimensional

Sub clase Publico Clase Rombo extiende Bidimensional

Sub clase Publico Clase Trapecio extiende Bidimensional

Sub clase Publico Clase Triangulo_equilatero extiende Bidimensional

Sub clase Publico Clase Triangulo_isosceles extiende Bidimensional

Sub clase Publico Clase Triangulo_escaleno extiende Bidimensional

Sub clase Publico Clase Triangulo_rectangulo extiende Bidimensional

Todos estas sub clases mencionadas heredan los atributos de la clase Bidimensional y

sobre escribe los métodos, cada una de estas subclases están compuestas por dos

métodos público que son usados para calcular área y perímetro de cada figura

bidimensional; están públicos por que según nuestra lógica no sería necesario poner los

métodos privados.

Dentro de cada una de las clases en cada método se van a imprimir los resultados del

área o del perímetro dependiendo que decide calcular el usuario, esto se hizo para que

una vez sean creados los objetos estos impriman automáticamente los resultados en el

void main.

Sub clase tridimensional Publico Clase tridimensional extiende

Figuras_Geometricas

o Atributos Publico Real Volumen, lado1, lado2, base, radio,

generatriz, altura, Alturalat, Alturabas;


La sub clase está heredando el atributo de la súper clase y sobre escribe los métodos, la

subclase es pública para que pueda ser heredada por sus subclases las variables también

son publica para que sean utilizadas por las subclases, los métodos son públicos para

poder aplicar el concepto de sobre escritura.

Subclases de figuras tridimensionales:

Sub clase Publico Clase Cubo extiende tridimensional

Sub clase Publico Clase Prisma_recto extiende tridimensional

Sub clase Publico Clase Esfera extiende tridimensional

Sub clase Publico Clase Cilindro extiende tridimensional

Sub clase Publico Clase Cono extiende tridimensional

Sub clase Publico Clase Piramide extiende tridimensional

Todas las sub clases aquí mencionadas heredan los atributos de la clase tridimensional y

sobre escribe los métodos, cada una de las clases esta compuestas por dos métodos

publico, decidimos ponerlos métodos públicos por que según nuestra lógica no seria

necesario que sean métodos privados, estos metodos calculan el área y el volumen de

cada figura tridimensional.

Dentro de cada una de las clases en cada método se van a imprimir los resultados del

área y del volumen para que una vez sean creados los objetos estos impriman

automáticamente los resultados en el void main.

Void Main

A nivel de usuario:

En nuestro método principal se le pide a los usuarios escoger que tipo de figuras

geométricas desea calcular, como opción numero uno tiene figuras bidimensionales,

como opción numero dos tiene figuras tridimensionales.

Si el usuario escoge la opción número uno automáticamente se le desglosa un

listado de figuras geométricas bidimensionales las cuales son: Cuadrado,

rectángulo, paralelogramo, rombo, trapecio, triángulo equilátero, triángulos

isósceles, triangulo escaleno, triangulo rectángulo.

Luego de que el usuario escoge la figura geométrica, al usuario se le da la opción

de que elija que desea realizar, calcular área o calcular perímetro.

Dependiendo de lo que elija el usuario se le piden los datos necesarios para

realizar el cálculo y se le brinda su respectiva respuesta.

Si el usuario se decide por las figuras tridimensionales al igual que la opción

anterior al usuario se le desglosa el listado de figuras tridimensionales las cuales

son: cono, prisma recto, esfera, cilindro, cono, pirámide.

Luego de que el usuario escoge la figura geométrica, se le da la opción de que

escoja que desea realizar, calcular área o volumen.

Una vez el usuario elija se le piden los datos necesarios para hacer el cálculo y

finalmente se le brinda su respectiva respuesta.

Void main

A nivel de programación:

Variables entero opcion1, opcion2, opcion3;

Alternativas múltiples

o Si (opcion1 = 1)

o Según sea (opcion2) o Caso 1:

o De otro modo Si(opcion3 = 2)

Objetos cu.Calcular(),cu.Calcular1()

Debido a la cantidad de alternativas múltiples y a la cantidad de objetos que se crearon,

solo mencionaremos algunos de ellos como se puede apreciar.

Para que el programa principal realice todos estos los pase que se le muestran a el

usuario, fue necesario utilizar alternativas múltiples (case, sino si), declaramos 3 variables

que reciben la opción que elija el usuario, creamos todo esto dentro del void main,

Con los imprimir que mostramos a continuación le pedimos al usuario que escoja una

figura geométrica.

Imprimir (“Escoja una de las opciones”);

Imprimir (“1. Figuras de bidimensionales”);

Imprimir (“2. Figuras de tridimensionales”);

Si el usuario elije la opción 1, esta pasa a la primera condición de que Si (opcion1 = 1)

Entonces se le muestra al usuario lo siguiente:

Imprimir (“Que tipo de figura usaras”);

Imprimir (“1. Cuadrado”);

Imprimir (“2. Rectángulo”);

Imprimir (“3. Paralelogramo”);

Imprimir (“4. Rombo”);

Imprimir (“5. Trapecio”);

Imprimir (“6. Trapecio recto”);

Imprimir (“7. Triángulo equilátero”);

Imprimir (“8. Triangulo isósceles”);

Imprimir (“9. Triangulo Escaleno”);

Imprimir (“10. Triangulo Rectángulo”);

Cada una de las opciones las recibe la alternativa múltiple (caso), luego se crea un objeto

que llama a la clase dependiendo de que figura escoja el usuario, dentro de las 10

opciones se le muestra lo siguiente al usuario.




Se lee el número que elige el usuario Leer (opcion3), entramos en una alternativa

doble, y llamamos al método al que corresponda la opción indicada por el usuario.

Si en el menú anterior el usuario elije la opción 2, Si (opcion1 = 2),

Se muestra al usuario lo siguiente:

Imprimir (“Que tipo de figura usaras”);

Imprimir (“1. Cubo”);

Imprimir (“2. Prisma Recto”);

Imprimir (“3. Esfera”);

Imprimir (“4. Cilindro”);

Imprimir (“5. Cono”);

Imprimir (“6. Piramide”);

Cada una de las opciones las recibe la alternativa múltiple (caso), luego se crea un objeto

que llama a la clase dependiendo de que figura escoja el usuario, dentro de las 6

opciones se le muestra lo siguiente al usuario.

Se lee el número que elige el usuario Leer (opcion3), entramos en una alternativa

doble, y llamamos al método al que corresponda la opción indicada por el usuario.

Conclusión

Un trabajo realizado lamentablemente no da una conclusión final a un proyecto,

pero si nos da perspectivas; esta es una conclusión que hemos llegado tras un debut en

lo que realmente será nuestro trabajo aunque a un nivel, creemos, aún más bajo de lo que

vendrá. Pues nos dio desde un principio, múltiples ideas, múltiples posibles soluciones,

múltiples mal-interpretaciones, múltiples todo.

Aplicamos con entereza el uso de las clases y subclases conociendo que estas

son la base de la programación orientada a objetos y viéndola desde nuestro punto de

vista, es una opción extraordinaria para una construcción más ordenada del algoritmo o

de la creación del software en sus distintos lenguajes. Además de que nos ha ayudado

este modelo para una mejor aplicación de la herencia.

Hemos trabajando herencia como deber y a la vez propósito para un mejor control

del algoritmo, ya que si se aplica adecuadamente la herencia, se puede producir

programas mucho más robustos y fáciles de ampliar. Una estrategia de herencia bien

diseñada es la base para reutilizar el código.

En resumen, aplicando los principios orientados a objetos, las distintas partes de un

programa complejo se pueden unir para formar un conjunto unido, robusto y mantenible y

con una mejor lectura.

.

Algoritmo figuras geometricas_doc

Technology

Transcript of Algoritmo figuras geometricas_doc