SoloCodigo

CLR: .Net / Mono / Boo / Otros CLR => C# => Mensaje iniciado por: buhito en Viernes 17 de Junio de 2005, 18:33

Título: Poo
Publicado por: buhito en Viernes 17 de Junio de 2005, 18:33

hola

mi duda es la siguiente
me estoy leyendo un interezante libro sobre c#

estoy en el capitulo de poo (la de objetos) y me trabe

se me dice que cree el fichero
CCuenta

Citar

class Ccuenta

//atributos
private string nombre;
private string cuenta;
private double saldo;
private double tipoDeInteres;

//metodos
public void asignarNombre(string nom)
{
if (nom.Length== 0)
{
System.Console.WriteLine("Error: cadena vacia");
return;
}
nombre=nom;
}
public string obtenerNombre()
{
return nombre;
}
public void asignarCuenta(string cue)
{
if (cue Length == 0)
{
System.Console.WriteLine("Error: cuenta no valida");
return;
}
cuenta = cue;
}

public string obtenercuenta()
{
return cuenta;
}
public double estado()
{
return saldo;
}
public void ingreso(double cantidad)
{
if (cantidad < 0)
{
System.Console.WriteLine("Error: cantidad negativa");
return;
}
saldo = saldo + cantidad;
}
public void reintegro(double cantidad)
{
if (saldo - cantidad < 0)
{
System.Console.WriteLine("Error: no dispone de saldo");
return;
}
saldo= saldo-cantidad
}
public void asignarTipoDeinteres(double tipo)
{
if (tipo < 0)
{
System.Console.WriteLine("tipo no valido");
return;
}
tipoDeinteres= tipo;
}
public double obtenerTipoDeInteres()
{
return tipoDeInteres; 

}
}

aja

despues que cree un nuevo fichero llamado Test

Citar

class Test
{
public static void Main(string[] args)
{
CCuenta cuenta01 = new CCuenta();
cuenta01.asignarNombre("un nombre");
cuenta01.asignarcuenta("una cuenta");
cuenta01.asignarTipoDeInteres(2.5);



cuenta01.ingreso(1000000);
cuenta01.reintegro(500000);

System.Console.WriteLine(cuenta01.obtenerNombre());
System.Console.WriteLine(cuenta01.obtenerCuenta());
System.Console.WriteLine(cuenta01.estado());
System.Console.WriteLine(cuenta01.obtenerTipoDeInteres());
}
}

"tenemos un fichero fuente, CCuenta.cs, con la clase CCuenta. Añadir en la misma carpeta (directorio) otro fichero fuente, Test.cs,con la clase principal (la que contiene el metodo Main) que vamos a denominar Test

Una vez creadas las 2 clases que forman nuestro programa, podemos comprobar que tenemos 2 ficheros fuente: CCuenta.cs y Test.cs ¿como compilamos estre programa? pues utilizando la orden csc Test.cs CCuenta.cs almacenando el fichero en Test.exe (bueno estoy usando sharp y eso es de consola :S)

...

en nuestro caso el metodo Main de Test tiene una linea de codigo que crea un objeto de la clase CCuenta(donde? pregunto)

, por lo tanto durante el proceso de compilacion buscara en la carpeta actual un fichero con la clase requerida, esto es CCuenta, si no lo encuentra dara error

para ejecutar el programa
escriba la orden Test puesto que Test es el fichero que tiene el ejecutable"




mi duda es que tiene que tener el "Main" no entiendo la verdad si le tengo que poner la clase CCuenta o no se

voy a poner el proyecto que estaba haciendo no para que me lo hagan si no para ver cual es la torpeza que estoy cometiendo para que no se compile

gracias


ps: poo significa crear un programa con ventana y botones de windows o es una forma de que las clases interactuen?

Título: Re: Poo
Publicado por: RadicalEd en Sábado 18 de Junio de 2005, 01:29

La programación orientada a objetos expresa un programa como un conjunto de objetos, que se comunican entre ellos para realizar tareas, como dices para que las clases interactuen entre ellas y no para crear ventanitas, JuanK te explica mejor, es el que medio me enseña a mi

Título: Re: Poo
Publicado por: JuanK en Sábado 18 de Junio de 2005, 17:07

hola,
no bajé tu exe por que ya se cual es el problema...
tienes deficiencias en los conceptos de POO, asi que esa va a ser la unica pregunta que dare respuesta, pues ademas no encuentra otras preguntas en el post.

POO es un paradigma de programación que nos permite hace una abstracción del mundo real y convertir esa abstracción en un componente, o pieza de software.

Anteriormente, en la porgramación en spagetti podiamos invertir muchas horas haciendo un prorama con muchos fragmentos de código, incluso teniamos muchos fragmentos que hacian exactamente lo mismo  o cosas muy similares, por ejempo un programa como un video juego tenia las instrucciones de como dibujar y de como producir sonidos repetidas o casi iguales para todos los personajes, lo cual hacia la programación algo muy largo y dispendioso de hacer, pero principalmente imposible de entender si tu mismo no eras quien habia hecho el programa.

Luego llago la programación estructurada a poner algo de ordem agrupando miles de lineas de código dentro de funciones, donde se debia tratar al máximo que las funciones fueran reutilizadas dentro del programa...
todo parecia ir muy bien.. pero los programas cada vez eran más grandes asi que pasaban cosas como estas:

Cuanta de ahorros, cuenta corriente

Los archivos fuente donde estaban las operaciones de una cuenta de ahorros y los fuentes donde estaban las operaciones de las cuentas corrientes tenien funciones parecidas, es decir umm por ejemplo la funcion bloquear cuenta estaba en ambas y si tenia que hacer un programa que manejara cuentas de ahorro y cuentas corrientes pues haria algo como esto:

Código: Text

1.  
2. #include &#34;cuantasA.h&#34;
3. #include &#34;cuantasC.h&#34;
4.  
5. int main()
6. {
7.     ....?
8.     ...?
9. }
10.  
11.  

Como puedo hacer referecia a las operaciones de cuenta de ahorros o a las de cuenta corriente si ambas tienen el mismo nombre?, si fueran mis propios fuentes es simple... modificar los nombres de las operaciones... pero si son librerias que compre cada una por aparte y no tengo los fuentes?

que pasaría si cada libreria maneja constantes con el mismo nombre? o variables con el mismo nombre?...

Si tengo un enorme programa y quiero hacer uno nuevo que reutiliza miles de cosas que el anterior... quien me garantiza que las funciones que tome me vallan a servir si vienen de un programa diferente? como se que si tomo una libreria que se llame Ahorros voy a tener realmente solo las cosas que sirven para ahorros?

Estos y miles de miles de problemas más ya eran inmanejables asi que alguien se puso en la tarea de diseñar una froma de programar que me permitiera aislar un componente de otro, reutilizar los componentes y librarme de todos mis anteriores enrredos... asi nacio POO, que como veraz no tiene nada que ver con ventanas y cosas de un entorno grafico.. de hecho en lenguajes no Orientados a objetos como los lenguaje c, puedes hacer ventanas y botones y todo identico de como lo haces con un lenguaje orientado a objetos.

La idea es muy sencilla, imaginemos cun cuaderno,
que cosas se pueden decir de nuestro cuaderno pues podemos decirt:

*numero de paginas
*dibujo de la portada
*color de las hojas
*estilo de las hojas
*estilo de agrupamiento de hojas (grapado, argollado, anillado, etc)
*precio
*calidad del papel
*marca
*etc

que cosas se pueden hacer con un cuaderno? (solo co el cuaderno por el momento)

*abrir
*cerrar
*adelantar pagina
*atrasar pagina
*arrancar hojas

bien, pues nuetro cuaderno es un objeto, y cada una de las cosas que mencionamos que tenia el cuaderno son sus atributos y las cosas que puedo hacer copn el cuaderno son sus metodos.

Listo ahi ya esta nuestro 'objeto' cuaderno, veamoslo en una especia de pseudocodigo:

Código: Text

1.  
2. cuaderno
3. {
4.   int numPag;
5.   string imgPortada;
6.   string colorHojas;
7.   string estiloHojas;
8.   string estiloAgrupaHojas;
9.   long  precio;
10.   long calidadPapell;
11.   string marca;
12.  
13.   Abrir()
14.   {
15.      ...
16.   }
17.  
18.   Cerrar()
19.   {
20.      ...
21.   }
22.  
23.   AdelantarPagina()
24.   {
25.      ...
26.   }
27.  
28.   AtrasarPagina()
29.   {
30.      ...
31.   }
32.  
33.   ArrancarHojas()
34.   {
35.      ...
36.   }
37.  
38. }
39.  
40.  

Listo.. ahora fijate que nuestro cuaderno expresado asi aplica para cualquier cuaderno no para uno solo asi que lo que hicimos realmente aplica para representar cualquier cuaderno asiq eu es una plantilla.. en POO una plantilla se llama clase.

Código: Text

1.  
2. class cuaderno
3. {
4.   ...
5.   ...
6. }
7.  
8.  

Bueno me salteare mucho tema....
Para el compilador saber cual es la clase que comienza un programa (en modo consola) requiere diferenciarla... bien él la diferencia buscando la clase que con tiene al metodo Main, asi que la clase que tenga al main es el inicio del programa.

Código: Text

1.  
2. public class miProg
3. {
4.    public static void Main()
5.   {
6.      
7.   }
8. }
9.  
10.  

Tienes tu programa y vas a usar lo que hiciste en cuaderno para manejar tres cuadernos

Código: Text

1.  
2. public class miProg
3. {
4.    public static void Main()
5.   {
6.       int numCuads;
7.       cuaderno c1 = new cuaderno();
8.       cuaderno c2 = new cuaderno();
9.       cuaderno c3 = new cuaderno();
10.   }
11. }
12.  
13.  

Que paso ahi?
bueno una clase es una plantilla a travez de la cual puedes crear diferentes objetos (el siguiente ejemplo aplica más para C# que para otros lenguajes) si escribes

int i

estas diciendo que i es un objeto y que este debe ser construido de acuerdo a la clase (plantilla) int, asi que i es un objeto tipo int. (en otros lenguajes no se puede concebir int como una clase sino simplemente es un tipo de dato)

asi que si hacemos
cuaderno c1;

estos creando un objeto c1 y este debe ser creado de acuerdo a la plantilla (clase) cuaderno.

A medida que profundices en POO te daras cuenta prque int i no requiere hacer
int i= new int i;

por el momento solo te digo que
cuaderno c1 = new cuaderno();

es decir realmente c1 es un contenedor de objetos del tipo cuaderno, pero aun no contiene ningun objeto, asi que

 c1 = new cuaderno();

es colocar  un objeto cuaderno dentro de su contenedor c1.

Ahora usemos lo que hay dentro de cada cuaderno:

Código: Text

1.  
2. public class miProg
3. {
4.    public static void Main()
5.   {
6.       int numCuads;
7.       cuaderno c1 = new cuaderno();
8.       cuaderno c2 = new cuaderno();
9.       cuaderno c3 = new cuaderno();
10.  
11.       c1.numPag = 100;
12.       c1.precio    = 10.000;
13.       c2.numPag = 100;
14.       c2.precio    = 10.000;
15.       c3.numPag = 100;
16.       c3.precio    = 10.000;
17.  
18.       c1.Abrir();
19.       c2.Abrir();
20.       c3.Abrir();
21.   }
22. }
23.  
24.  

En fin espero que esto haya ayuda, para mas informacion te recomiendo los tutoriales con los que yo aprendi C# y mejoré notablemente en POO.

http://www.elguille.info/NET/cursoCSharpErik/index.htm (http://www.elguille.info/NET/cursoCSharpErik/index.htm)

Y este que es nuevo pero se ve muy bueno.

http://www.elguille.info/colabora/NET2005/...rado/Indice.htm (http://www.elguille.info/colabora/NET2005/cursoCS_vecrado/Indice.htm)

 :hola:

Título: Re: Poo
Publicado por: arielb en Sábado 18 de Junio de 2005, 17:26

valla juank un buen ejemplo, bien aplicado y bastante claro, sugeriria que lo colgarás porque van a ver muchos mas que nosotros que estaremos en esas dudas, y como tu dices no se encuentra post de ese tema en este foro, solo es mi opinión.

Título: Re: Poo
Publicado por: buhito en Domingo 19 de Junio de 2005, 07:49

hola

bueno era para decirles que ya resolvi la duda

que fue?

que cuando lei "en Main" pense que se ocupaba "Main.cs" (que aparece automaticamente cuando se escoge "aplicacion de consola)........... no :huh: ,
se referia a la entrada main que estaba en test.cs

Citar

class Test
{
public static void Main(string[] args) :whistling:
{
CCuenta cuenta01 = new CCuenta();
cuenta01.asignarNombre("un nombre");
cuenta01.asignarcuenta("una cuenta");
cuenta01.asignarTipoDeInteres(2.5);



cuenta01.ingreso(1000000);
cuenta01.reintegro(500000);

System.Console.WriteLine(cuenta01.obtenerNombre());
System.Console.WriteLine(cuenta01.obtenerCuenta());
System.Console.WriteLine(cuenta01.estado());
System.Console.WriteLine(cuenta01.obtenerTipoDeInteres());
}
}

era que no entendi muy bien la explicacion del libro pero por preguntar juank puso una explicacion muy completa
gracias  :hola: