⭐ 欢迎来到虫虫下载站！ | 📦 资源下载 📁 资源专辑 ℹ️ 关于我们
⭐ 虫虫下载站
📤 上传资源

📄 java6.htm

📁 E-books about Java Programing in Spanish
💻 HTM
字号:
🔍 
<HTML>
<HEAD>
<TITLE>Java desde Cero</TITLE>
</HEAD>
<BODY background=/iconos/1.gif  TEXT=000000 LINK=FF0000 VLINK=A62A2A>
<H1>Hagamos algo...</H1>
<P>
Bueno, vamos a hacer una peque&ntilde;a aplicaci&oacute;n para
practicar un poco.
<P>
Para empezar, vamos a desarrollar un poquito una clase para trabajar
con n&uacute;meros complejos.
<H2>La clase Complejo</H2>
<PRE>
<FONT SIZE=2>// grabar como Complejo.java
// compilar con &quot;javac Complejo.java&quot;
public final class Complejo extends Number {

	// atributos:
		private float x;
		private float y;

	// constructores:
	public Complejo() {
		x = 0;
		y = 0;
	}
	public Complejo(float  rx, float iy) {
		x = rx;
		y = iy;
	}

	// m&eacute;todos:
	// Norma
	public final float Norma() {
		return (float)Math.sqrt(x*x+y*y);
	}
	public final float Norma(Complejo c) {
		return (float)Math.sqrt(c.x*c.x+c.y*c.y);
	}
	// Conjugado
	public final Complejo Conjugado() {
		Complejo r = new Complejo(x,-y);
		return r;
	}
	public final Complejo Conjugado(Complejo c) {
		Complejo r = new Complejo(c.x,-c.y);
		return r;
	}
	// obligatorios (son abstractos en Number):
	public final double doubleValue() {
		return (double)Norma();
	}
	public final float floatValue() {
		return Norma();
	}
	public final int intValue() {
		return (int)Norma();
	}
	public final long longValue() {
		return (long)Norma();
	}
	public final String toString() {
		if (y&lt;0)
			return x+&quot;-i&quot;+(-y);
		else
			return x+&quot;+i&quot;+y;
	}
	// Operaciones matem&aacute;ticas
	public static final Complejo Suma(Complejo c1, Complejo c2) {
		return new Complejo(c1.x+c2.x,c1.y+c2.y);
	}
	public static final Complejo Resta(Complejo c1, Complejo c2) {
		return new Complejo(c1.x-c2.x,c1.y-c2.y);
	}
	public static final Complejo Producto(Complejo c1, Complejo c2) {
		return new Complejo(c1.x*c2.x-c1.y*c2.y,c1.x*c2.y+c1.y*c2.x);
	}
	// Nos va a venir bien para aprender excepciones...
	// como divisi&oacute;n por cero!
	public static final Complejo DivEscalar(Complejo c, float f) {
		return new Complejo(c.x/f,c.y/f);
	}
	public static final Complejo Cociente(Complejo c1, Complejo c2) {
		float x = c1.x*c2.x+c1.y*c2.y;
		float y = -c1.x*c2.y+c1.y*c2.x;
		float n = c2.x*c2.x+c2.y*c2.y;
		Complejo r = new Complejo(x,y);
		return DivEscalar(r,n);
	}
}<BR>
</FONT>
</PRE>
<P>
Podemos hacer algunos comentarios...
<P>
Primero: no hay include aqu&iacute;, ya que la &uacute;nica biblioteca
que usamos es <B>java.lang</B> y se incluye autom&aacute;ticamente.
<P>
Segundo: la clase es <FONT FACE="Arial">public final</FONT>, lo
que implica que cualquier clase en &eacute;ste u otros paquetes
puede utilizarla, pero ninguna clase puede heredarla (o sea que
es una clase est&eacute;ril...).
<P>
Hagamos un resumen de los atributos y m&eacute;todos de la clase:
<PRE>
<FONT SIZE=2>	// atributos:
		private float x;
		private float y;</FONT>
</PRE>
<P>
Siendo privados, no podemos acceder a ellos desde el exterior.
Como adem&aacute;s la clase es final, no hay forma de acceder
a <FONT FACE="Arial">x</FONT> e <FONT FACE="Arial">y</FONT>. Adem&aacute;s,
al no ser static, cada instancia de la clase tendr&aacute; su
propio <FONT FACE="Arial">x</FONT> e <FONT FACE="Arial">y</FONT>.
<PRE>
<FONT SIZE=2>	// constructores:
	public Complejo()
	public Complejo(float  rx, float iy)</FONT>
</PRE>
<P>
La clase tiene dos constructores, que se diferencian por su &quot;firma&quot;
(<I>signature</I>), o sea por la cantidad y tipo de par&aacute;metros.
El primero nos sirve para crear un objeto de tipo <B>Complejo</B>
y valor indefinido (aunque en realidad el m&eacute;todo lo inicializa
en cero); con el segundo, podemos definir el valor al crearlo.
<PRE>
<FONT SIZE=2>	// m&eacute;todos:
	public final float Norma()
	public final float Norma(Complejo c)
	public final Complejo Conjugado()
	public final Complejo Conjugado(Complejo c)</FONT>
</PRE>
<P>
Estos m&eacute;todos tambi&eacute;n son duales; cuando los usamos
sin par&aacute;metros devuelven la norma o el conjugado del objeto
individual (instancia):
<PRE>
<FONT SIZE=2>v = miComplejo.Norma();			// por ejemplo
		otroComplejo = miComplejo.Conjugado();</FONT>
</PRE>
<P>
Con par&aacute;metros, en cambio, devuelven la norma o el conjugado
del par&aacute;metro:
<PRE>
<FONT SIZE=2>		v = unComplejo.Norma(miComplejo);
		otroComplejo = unComplejo.Conjugado(miComplejo);</FONT>
</PRE>
<P>
Notar que lo siguiente es inv&aacute;lido:
<P>
<FONT FACE="Arial">  otroComplejo = Complejo.Norma(miComplejo);
// NO SE PUEDE!</FONT>
<P>
...porque el m&eacute;todo no es <I>static</I>, por lo tanto <B>debe</B>
llamarse para una instancia en particular (en este caso, <I>unComplejo</I>).
<BR>
<PRE>
<FONT SIZE=2>	// obligatorios (son abstractos en Number):
	public final double doubleValue()
	public final float floatValue()
	public final int intValue()
	public final long longValue()</FONT>
</PRE>
<P>
Estos m&eacute;todos es obligatorio definirlos, ya que en la clase
madre <I>Number</I> son m&eacute;todos abstractos, o sea que debemos
implementarlos aqu&iacute;.
<P>
Como todos los m&eacute;todos de esta clase son final, o sea que
no puede ser redefinido. No es importante en realidad puesto que
la clase no puede tener descendientes...
<PRE>
<FONT SIZE=2>	public final String toString()</FONT>
</PRE>
<P>
Este m&eacute;todo nos sirve para representar el complejo como
una cadena de caracteres, de la forma <FONT FACE="Arial">x+iy</FONT>.
<PRE>
<FONT SIZE=2>	// Operaciones matem&aacute;ticas
	public static final Complejo Suma(Complejo c1, Complejo c2)
	public static final Complejo Resta(Complejo c1, Complejo c2)
	public static final Complejo Producto(Complejo c1, Complejo c2)
	public static final Complejo DivEscalar(Complejo c, float f)
	public static final Complejo Cociente(Complejo c1, Complejo c2)</FONT>
</PRE>
<P>
Aqu&iacute; definimos varias operaciones matem&aacute;ticas. Notar
que se han definido como <FONT FACE="Arial">static</FONT>, o sea
que los m&eacute;todos son &uacute;nicos independientemente de
las instancias. Esto permite que los podamos ejecutar sobre una
instancia o directamente sobre la clase:
<PRE>
<FONT SIZE=2>miComplejo = unComplejo.Suma(comp1,comp2);	// vale
miComplejo = Complejo.Suma(comp1,comp2);		// TAMBIEN VALE!</FONT>
</PRE>
<P>
Por ejemplo, la siguiente aplicaci&oacute;n nos muestra c&oacute;mo
podemos usar algunos de estos m&eacute;todos:
<PRE>
<FONT SIZE=2>// Archivo:  Ejemplo5.java
// Compilar con: javac Ejemplo5.java
// Ejecutar con: java Ejemplo5
import java.io.*;

public class Ejemplo5 {

  public static void main(String args[]) {
    Complejo c1 = new Complejo(4,-3);
    System.out.println(c1+&quot;\tNorma=&quot;+c1.Norma());
    Complejo c2 = new Complejo(-2,5);
    System.out.println(c2+&quot;\tNorma=&quot;+c2.Norma()+&quot;\n&quot;);

    System.out.println(&quot;(&quot;+c1+&quot;)/4 :&quot;+Complejo.DivEscalar(c1,4));
    System.out.println(&quot;Suma  : &quot;+Complejo.Suma(c1,c2));
    System.out.println(&quot;Resta : &quot;+Complejo.Resta(c1,c2).toString());
    System.out.println(&quot;Multip: &quot;+Complejo.Producto(c1,c2).toString());
    System.out.println(&quot;Divis : &quot;+Complejo.Cociente(c1,c2).toString());
  }
}</FONT>
</PRE>
<P>
Hay varias cosas para notar: por ejemplo, que podemos declarar
las variables a la vez que las creamos:
<PRE>
<FONT SIZE=2>Complejo c1 = new Complejo(4,-3);</FONT>
</PRE>
<P>
<FONT FACE="Arial">c1</FONT> y <FONT FACE="Arial">c2</FONT> son
dos objetos (instancias) de la clase Complejo.
<P>
Notar tambi&eacute;n que no hace falta poner para imprimir:
<PRE>
<FONT SIZE=2>System.out.println(c1.toString().......);</FONT>
</PRE>
<P>
ya que <FONT FACE="Arial">println</FONT> autom&aacute;ticamente
usa el m&eacute;todo<FONT FACE="Arial"> toString()</FONT> de la
clase para imprimir. Basta con poner <FONT FACE="Arial">c1</FONT>,
como en el programa, aunque <FONT FACE="Arial">c1.toString()</FONT>
tambi&eacute;n es v&aacute;lido.
<P>
Tambi&eacute;n se ve el uso de los m&eacute;todos <FONT FACE="Arial">static</FONT>,
accedi&eacute;ndolos directamente por la clase, en:
<PRE>
<FONT SIZE=2>System.out.println(&quot;Suma  : &quot;+Complejo.Suma(c1,c2));</FONT>
</PRE>
<P>
Y tampoco aqu&iacute; usamos <FONT FACE="Arial">toString()</FONT>,
aunque no est&aacute; mal si se usa <FONT FACE="Arial">Complejo.Suma(c1,c2).toString()</FONT>.
<H2>Algo sobre los m&eacute;todos</H2>
<P>
Analicemos un poco ahora c&oacute;mo implementamos los m&eacute;todos
de la clase <I>Complejo</I>.
<PRE>
<FONT SIZE=2>	public final int intValue() {
		return (int)Norma();
	}</FONT>
</PRE>
<P>
Ya que no podemos convertir as&iacute; nom&aacute;s un complejo
en un entero, para implementar estos m&eacute;todos hemos elegido
usar como valor de retorno la norma del complejo. En este caso,
y dado que el m&eacute;todo <FONT FACE="Arial">Norma()</FONT>
devuelve un <FONT FACE="Arial">float</FONT>, usamos <I>typecasting</I>,
es decir, lo convertimos en entero precedi&eacute;ndolo con <FONT FACE="Arial">(int)</FONT>.
<PRE>
<FONT SIZE=2>	public final String toString() {
		if (y&lt;0)
			return x+&quot;-i&quot;+(-y);
		else
			return x+&quot;+i&quot;+y;
	}</FONT>
</PRE>
<P>
Aqu&iacute; representamos el complejo en forma de cadena de caracteres.
Hemos usado el <I>if</I> para representar adecuadamente el signo
de la parte imaginaria. Noten tambi&eacute;n la asombrosa ayuda
que nos brinda Java, al convertir autom&aacute;ticamente las variables
<FONT FACE="Arial">x</FONT> e <FONT FACE="Arial">y</FONT> a String
para la concatenaci&oacute;n (mediante el signo &quot;+&quot;)!
<PRE>
<FONT SIZE=2>	public static final Complejo Cociente(Complejo c1, Complejo c2) {
		float x = c1.x*c2.x+c1.y*c2.y;
		float y = -c1.x*c2.y+c1.y*c2.x;
		float n = c2.x*c2.x+c2.y*c2.y;
		Complejo r = new Complejo(x,y);
		return DivEscalar(r,n);
	}</FONT>
</PRE>
<P>
Aqu&iacute; tengan en cuenta que las variables <FONT FACE="Arial">x</FONT>
e <FONT FACE="Arial">y</FONT>, definidas como <I>float</I>, no
tienen nada que ver con las variables (atributos) de la clase
que est&aacute;n definidas al principio de la misma, sino que
son variables locales al m&eacute;todo.
<P>
Podemos usar <FONT FACE="Arial">return DivEscalar(r,n)</FONT>,
ya que <FONT FACE="Arial">DivEscalar</FONT> es un m&eacute;todo
propio de la clase; no hace falta poner <FONT FACE="Arial">Complejo.DivEscalar</FONT>.
<P>
Qu&eacute; pasa con <FONT FACE="Arial">r</FONT>, el new <FONT FACE="Arial">Complejo(x,y)</FONT>
que creamos? Nada; cuando un objeto no se usa m&aacute;s, el &quot;recogedor
de basura&quot; de Java lo elimina autom&aacute;ticamente (tarde
o temprano) de la memoria.
<PRE>
<FONT SIZE=2>	public final float Norma(Complejo c) {
		return (float)Math.sqrt(c.x*c.x+c.y*c.y);
	}</FONT>
</PRE>
<P>
Aqu&iacute; estamos usando otra clase, <B>Math</B>, que nos permite
realizar varias operaciones matem&aacute;ticas. Esta clase dispone
de las constantes <FONT FACE="Arial">E</FONT> y <FONT FACE="Arial">PI</FONT>,
y los m&eacute;todos:
<PRE>
<FONT SIZE=2>abs(x)			valor absoluto
acos(x)			arco coseno
asin(x)			arco seno
atan(x)			arco tangente
atan2(x,y)		componente angular de la representaci&oacute;n polar de x,y
ceil(x)			menor entero mayor que x
cos(x)			coseno
exp(x)			e<SUP>x
</SUP>floor(x)		mayor entero menor que x
IEEEremainder(x,y)	resto de la divisi&oacute;n x/y seg&uacute;n el est&aacute;ndar IEEE 754
log(x)			logaritmo natural
max(x,y)		el mayor de x e y
min(x,y)		el menor de x e y
pow(x,y)		x<SUP>y
</SUP>random()		n&uacute;mero aleatorio entre 0 y 1
rint(x)			entero m&aacute;s cercano a x (devuelve un doble)
round(x)		entero m&aacute;s cercano a x (devuelve un entero o un long)
sin(x)			seno
sqrt(x)			ra&iacute;z cuadrada
tan(x)			tangente</FONT>
</PRE>
<P>
Algunos de estos m&eacute;todos disparan <I>excepciones</I>, como
<FONT FACE="Arial">sqrt</FONT> o <FONT FACE="Arial">log</FONT>
de n&uacute;meros negativos. M&aacute;s adelante veremos c&oacute;mo
se usan las excepciones.
<P>
Otra clase que hemos estado usando mucho es la <FONT FACE="Arial">PrintStream</FONT>,
a la que pertenece el m&eacute;todo <FONT FACE="Arial">println</FONT>.
En
<PRE>
<FONT SIZE=2>		System.out.println(...)</FONT>
</PRE>
<P>
<FONT FACE="Arial">out</FONT> es un <I>atributo</I> de la clase
<FONT FACE="Arial">System</FONT>, del tipo (clase)<FONT FACE="Arial">
PrintStream</FONT>:
<PRE>
<FONT SIZE=2>public final class System extends Object
{
        // Fields
    public static PrintStream err;
    public static InputStream in;
    public static PrintStream out;

        // Methods
.............
}</FONT>
</PRE>
<P>
Veremos otras bibliotecas (para entrada/salida, gr&aacute;ficos,
etc) muy pronto. Nos vemos en el cap&iacute;tulo VII.
<BR>
<HR>
<P>
Jorge Bourdette
<P>
<A HREF="mailto:jpb@amarillas.com">jpb@amarillas.com</A>
</BODY>
</HTML>

⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -