Empecemos..

Java es un lenguaje de alto nivel, interpretado y orientado a objetos. Su sintaxis es muy similar a la de C o C++, lo cual se ha hecho con la intención de que represente un esfuerzo pequeño en la transición de un lenguaje a otro, aunque presenta algunas diferencias significativas con C. La compilación de código Java consiste en su traslación a un código independiente de la máquina conocido como bytecode, el cual es interpretado por la Máquina Virtual Java., y por supuesto es multiplataforma, lo que significa que puede ser ejecutado en cualquier tipo de arquitectura conocida.

Esta es, sin duda, la clave del gran interés que está despertando Java: es un lenguaje multiplataforma. Al ejecutarse sobre una máquina virtual que le proporciona una abstracción no sólo del hardware sino también del sistema operativo, un programa Java puede ejecutarse sobre cualquier plataforma, sin importar si trabajamos con un ordenador PC, Macintosh o UNIX

Algunas características notables:
-robusto
-gestiona la memoria automáticamente
-no permite el uso de técnicas de programación inadecuadas
-multithreading
-cliente-servidor
-mecanismos de seguridad incorporados
-herramientas de documentación incorporadas

Lenguaje de Objetos
Por qué "de" objetos y no "orientado a" objetos? Para destacar que, al contrario de otros lenguajes como C++, no es un lenguaje modificado para poder trabajar con objetos sino que es un lenguaje creado para trabajar con objetos desde cero. De hecho, TODO lo que hay en Java son objetos.

¿Qué es un objeto?
Bueno, se puede decir que todo puede verse como un objeto. Pero seamos más claros. Un objeto, desde nuestro punto de vista, puede verse como una pieza de software que cumple con ciertas características:

Encapsulamiento significa que el objeto es auto-contenido, o sea que la misma definición del objeto incluye tanto los datos que éste usa (atributos) como los procedimientos (métodos) que actúan sobre los mismos.

Cuando se utiliza programación orientada a objetos, se definen clases (que definen objetos genéricos) y la forma en que los objetos interactúan entre ellos, a través de mensajes. Al crear un objeto de una clase dada, se dice que se crea una instancia de la clase, o un objeto propiamente dicho. Por ejemplo, una clase podría ser "autos", y un auto dado es una instancia de la clase.

La ventaja de esto es que como no hay programas que actúen modificando al objeto, éste se mantiene en cierto modo independiente del resto de la aplicación. Si es necesario modificar el objeto (por ejemplo, para darle más capacidades), esto se puede hacer sin tocar el resto de la aplicación… lo que ahorra mucho tiempo de desarrollo y debugging! En Java, inclusive, ni siquiera existen las variables globales! (Aunque parezca difícil de aceptar, esto es una gran ventaja desde el punto de vista del desarrollo).

En cuanto a la herencia, simplemente significa que se pueden crear nuevas clases que hereden de otras preexistentes; esto simplifica la programación, porque las clases hijas incorporan automáticamente los métodos de las madres. Por ejemplo, nuestra clase "auto" podría heredar de otra más general, "vehículo", y simplemente redefinir los métodos para el caso particular de los automóviles… lo que significa que, con una buena biblioteca de clases, se puede reutilizar mucho código inclusive sin saber lo que tiene adentro.

Un ejemplo simple
Para ir teniendo una idea, vamos a poner un ejemplo de una clase Java:

public class Muestra extends Frame {
    // atributos de la clase
    Button si;
    Button no;
// métodos de la clase:
public Muestra () {
    Label comentario = new Label("Presione un botón", Label.CENTER);
    si = new Button("Sí");
    no = new Button("No");
    add("North", comentario);
    add("East", si);
    add("West", no);
                        }
                                                        }

Esta clase no está muy completa así, pero da una idea… Es una clase heredera de la clase Frame (un tipo de ventana) que tiene un par de botones y un texto. Contiene dos atributos ("si" y "no"), que son dos objetos del tipo Button, y un único método llamado Muestra (igual que la clase, por lo que es lo que se llama un constructor).

Esto es casi del todo cierto… En realidad, Java podría hacerse correr hasta sobre una Commodore 64! La realidad es que para utilizarlo en todo su potencial, requiere un sistema operativo multithreading (como Unix, Windows95, OS/2…).

Cómo es esto? Porque en realidad Java es un lenguaje interpretado… al menos en principio.

Al compilar un programa Java, lo que se genera es un seudocódigo definido por Sun, para una máquina genérica. Luego, al correr sobre una máquina dada, el software de ejecución Java simplemente interpreta las instrucciones, emulando a dicha máquina genérica. Por supuesto esto no es muy eficiente, por lo que tanto Netscape como Hotjava o Explorer, al ejecutar el código por primera vez, lo van compilando (mediante un JIT: Just In Time compiler), de modo que al crear por ejemplo la segunda instancia de un objeto el código ya esté compilado específicamente para la máquina huésped.

Además, Sun e Intel se han puesto de acuerdo para desarrollar procesadores que trabajen directamente en Java, con lo que planean hacer máquinas muy baratas que puedan conectarse a la red y ejecutar aplicaciones Java cliente-servidor a muy bajo costo.

El lenguaje de dicha máquina genérica es público, y si uno quisiera hacer un intérprete Java para una Commodore sólo tendría que implementarlo y pedirle a Sun la aprobación (para que verifique que cumple con los requisitos de Java en cuanto a cómo interpreta cada instrucción, la seguridad, etc.)

Algunas características…
Entre las características que nombramos nos referimos a la robustez. Justamente por la forma en que está diseñado, Java no permite el manejo directo del hardware ni de la memoria (inclusive no permite modificar valores de punteros, por ejemplo); de modo que se puede decir que es virtualmente imposible colgar un programa Java. El intérprete siempre tiene el control.

Inclusive el compilador es suficientemente inteligente como para no permitir un montón de cosas que podrían traer problemas, como usar variables sin inicializarlas, modificar valores de punteros directamente, acceder a métodos o variables en forma incorrecta, utilizar herencia múltiple, etc.

Ya que se toca ese tema , el compilador de java por excelencia es el JDK (Java Development Kit); para poder programar en lenguaje java es necesario este compilador hecho por Sun Microsystem.

Java implementa mecanismos de seguridad que limitan el acceso a recursos de las máquinas donde se ejecuta, especialmente en el caso de los Applets (que son aplicaciones que se cargan desde un servidor y se ejecutan en el cliente).

También está diseñado específicamente para trabajar sobre una red, de modo que incorpora objetos que permiten acceder a archivos en forma remota (via URL por ejemplo).

Además, con el JDK (Java Development Kit) vienen incorporadas muchas herramientas, entre ellas un generador automático de documentación que, con un poco de atención al poner los comentarios en las clases, crea inclusive toda la documentación de las mismas en formato HTML!

el compilador Java, javac
el intérprete Java, java
un visualizador de applets, appletviewer
el debugger Java, jdb (que para trabajar necesita conectarse al server de Sun)
el generador de documentación, javadoc
También se puede bajar del mismo site un browser que soporta Java (y de hecho está escrito totalmente en Java), el Hotjava.

Para instalarlo simplemente hay que descompactar el archivo (sugiero que creen un directorio java para eso), pero tengan en cuenta NO DESCOMPRIMIR el archivo classes.zip!

Importante para los usuarios de Windows95: todas estas aplicaciones deben ejecutarse desde una ventana DOS. En particular, utilizan nombres largos y distinguen mayúsculas de minúsculas, así que tengan en cuenta esto que es fuente de muchos errores.

Javascript: es una versión de Java directamente interpretada, que se incluye como parte de una página HTML, lo que lo hace muy fácil y cómodo para aplicaciones muy pequeñas, pero que en realidad tiene muchas limitaciones:

-no soporta clases ni herencia
-no se precompila
-no es obligatorio declarar las variables
-verifica las referencias en tiempo de ejecución
-no tiene protección del código, ya que se baja en ascii
-no todos los browsers lo soportan completamente; Explorer, por ejemplo, no soporta las últimas adiciones de Netscape, como las imágenes animadas.

Java standalone: programas Java que se ejecutan directamente mediante el intérprete java.
Applets: programas Java que corren bajo el entorno de un browser (o del appletviewer)

En sí los dos últimos son el mismo lenguaje, pero cambia un poco la forma en que se implementa el objeto principal (la aplicación). Vamos a ver cómo crear las aplicaciones para que, sin cambios, se puedan ejecutar casi igual en forma standalone o como applet (en realidad hay cosas que los applets no pueden hacer, como acceder a archivos sin autorización).

La programación en java cae en dos categorías: applets y aplicaciones(Standalone).

Applets son programas java que son cargados en su computador desde la World Wide Web y es executado por un navegador o browser de internet en la maquina local; applets dependen de un navegador que pueda leer programas java para asi poder correr (aunque pueden ser executados en otra clase de herramientas como el appletviewer que viene en el JDK pero de esto se hablara mas tarde)

Las aplicaciones (comunmente conocidos como programas Standalone) son programas mas generales escritos en el lenguaje java. Las aplicaciones en java no necesitan un navegador como los applets, y de hecho puden ser como cualquier aplicacion que usted ha hecho con anterioridad en un compilador comun, en si el Browser creado por Sun Microsystem Hotjava esta escrito todo en java y es una muy buen ejemplo.de una aplicacion en java.

Un simple programa en java puede ser una aplicacion o un applet o los dos, dependiendo de como escribe tal programa
y los recursos que el programa use.

los applets:
No se pueden ejecutar fuera de un visualizador
No tiene acceso a los archivos de disco
Tienen acceso limitado a las redes

Por otro lado, las aplicaciones necesitar contener un método main(), que es el que se ejecuta en su inicio. Se podría desarrollar un código que fuera al mismo tiempo un Applet y una Aplicación, generando una clase derivada de Applet y que contuviera un método main().

Empezaremos creando una simple aplicación Java. El ejemplo clásico de "Hola Mundo". Así como la programación de cualquier otro lenguaje sus archivos Java fuente son creados en un editor de textos, o en un editor que puede salvar archivos en ASCII, sin caracteres formateados. En Unix y Linux se usa el EMACS, PICO, VI; en Windows el NOTE PAD o el DOS EDIT; aunque desarrollaremos aplicaciones auxiliados por una herramienta especial llamada KAWA es importante conocer lo anterior.
En su editor de texto escriba:

class HolaMundo {
         public static void main (String args[]) {
        System.out.println ("Hola Mundo")
                                                                   }
                               }

Este programa tiene dos partes principales:
- Todo el programa está contenido en una definición de clase, en este caso llamada HolaMundo.
- El cuerpo del programa (que en este caso es una línea) está contenido en un método llamado main. En las aplicaciones JAVA, como en los programas hechos en C o C++, main es el primer método que es corrido cuando el programa se ejecute.

Crear un applet es diferente a crear una simple aplicación, debido a que los applets corren y son vistos desde un navegador de web; esto hace que su programación sea más compleja en la mayoría de los casos, debido a las reglas especiales que rigen el comportamiento de una página web, pero es sencillo cuando se saben los fundamentos de la creación del applet.

Para hacer un applet simple, que haga lo mismo que la aplicación anterior además de que sólo se imprima un mensaje a la pantalla, tiene que crear un applet para que haga espacio para su mensaje y después usar operaciones gráficas para pintar el mensaje en dicho applet.

        public void paint(Graphics g) {
            g.drawString("Hola Mundo!", 5,25);
    }
}

Segundo, escribiremos su respectivo archivo html por donde será llamado el applet:

<HTML>
<HEAD>
<TITLE> Hola a todos!</TITLE>
</HEAD>
<BODY>
<P>Mi appletJava dice:
<APPLET CODE="HolaMundoApplet.class" WIDTH = 150 HEIGHT=25></APPLET>
</BODY>
</HTML>

Salve estos dos archivos en un solo directorio justo como lo hizo cuando creó una aplicación JAVA, y nombre al archivo fuente del applet como HolaMundoApplet.Java y el archivo HTML como ejercicio1.html

Hay ciertas cosas que hay que ver en el archivo fuente del applet:
- La línea import al principio del archivo fuente es de alguna manera análoga al #include del C o C++; capacita al applet para tener acceso a la clase direccionada que sería en este caso la clase que dibuja gráficos en la pantalla (awt).

- El método paint() despliega el contenido del applet hacia la pantalla, aquí la cadena hola mundo se dibuja. Las applet usan algunos métodos estandar en lugar del método main el cual es usado en una aplicación java típica; en su lugar, utiliza algunos métodos como: init() para inicializar el applet, start() para que empiece a ejecutarse, y paint() para desplegar en pantalla.
Aprenderá más sobre estos métodos más adelante.

En el archivo HTML:
- Use el atributo COUT para indicar el nombre de la clase que contiene su applet.
- Use los atributos WIDTH y HEIGHT para indicar el tamaño del applet. El Browser usa estos valores para saber el espacio que debe dejar en la página para el applet. En este ejemplo, pusimos 150 pixeles por 25.

Para compilar la aplicación JAVA necesitará, para empezar, el compilador de SUN llamado JAVAC que viene en el JDK de Sun Microsystem (en estos ejemplos usaremos dicho compilador, aunque en un futuro se usará otra herramienta, que utiliza al JDK), asegúrese que el compilador JAVAC y sus archivos fuentes en el caso de la aplicación el HolaMundo.Java esté en el mismo directorio y escriba en la línea de comandos:

El compilador debe compilar este archivo sin ningún error, en caso de que no suceda, vuelva al editor de textos y cheque de nuevo la sintaxis de su programa, en caso de compilar sin errores, javac crea un archivo binario con extensión .class el cual es el archivo java bytecode.
Terminado esto, usted ya puede correr el programa utilizando una herramienta que viene en el JDK, el interpretador JAVA, de nombre JAVA. Asegúrese que el archivo generado, HolaMundo.class, esté en el mismo directorio que el intérprete JAVA y escriba en la línea de comandos:

No es necesario indicar la extensión. Si su programa fue compilado correctamente, debe obtener una cadena "Hola Mundo" escrita en pantalla.

Igual que con la aplicación, necesitará el compilador JAVAC para pasar su archivo fuente a un archivo binario, con extensión .class, asegúrese que su archivo fuente del applet en este caso, llamado HolaMundoApplet.Java esté en el mismo directorio que el compilador y escriba en la línea de comandos:

Si no le avisa de ningún error, su archivo es compilado exitosamente y se genera, automáticamente, su archivo binario con extensión .class, el cual, en este caso, debe ser HolaMundoApplet.Class.

Ahora, está listo para la prueba final, para ver el resultado de su applet, usted necesita hacer lo siguiente:

- Un browser que soporte applets en Java, como Netscape 2.0 o en su defecto, el AppletViewer, el cual ya viene incluido en el JDK.

El modo del uso del appletviewer es tan simple como el compilador y el interpretador Java, sólo, asegúrese de que sus archivos HTML y .Class estén en el mismo directorio del appletviewer y escriba en la línea de comandos de MS-DOS (Estando en Windows):

Si no hubo ningún error, podrá ver la cadena Hola Mundo ya sea en el browser o en el appletviewer.

-estatus de java y expresiones
-variables y tupos de datos
-comentarios
-Literales
-aritmetica
-comparaciones
-opeardores logicos

Un estatuto (statement) en java es lo mas simple que puede hacer en java, un estatuto es la forma de una operacion simple como estos ejemplos que son estatutos validos:

Los estatutos a veces regresanvalores como cuando sumas dos enteros o cancatenas un a cadena de caracteres como veremos mas adelante. Lo mas importante a saber es que siempre terminan con un punto y coma (;). Los estatutos pueden formar un cuerpo de un programa que se llaman bloques que por lo general estan rodeados por llaves ({}).

Las variables son locaciones de memoria que almacenan un dato o varios de ellos, tienen un nombre , tipo y valor, antes de usar una variables usted tienen que declararla antes, java tienen tres clase de variables; las variables de instancia, las variables de clase y las variables locales.

Las variables de clase son usadas para definir attributos o estados a un objeto en particular, las variables de clase son similares a las de instancia, excepto que sus valores se aplican a todas las instancias que esa clase haga y a la clase tambien,en vez de tener valores diferentes para todos las instancias, esto sera mejor explicado en capitulos posteriores ahora nos enfocaremos en la variables locales.

Las variables locales son usadas y declaradas solo dentro del cuerpo del metodo, por ejemplo las variables que se utilizan como contadores en ciclos de ejecucion. Nomas el metodo deje de ejecutarse la variable deja de existir. Aunque los tre tipos de variables son declarados de la misma manera varian en la forma en que se le son asignados valores. Java no soporta variables globales asi que solo se utilizan variables locales y las otras dos ya antes mencionadas que pueden funcionar como medio de comunicacion entre objetos.

Para usar una variable hay que primero declararla, las declaraciones de variable consisten en un tipo y un nombre de variable.Ejemplo:

La decaracion de variables tambien pueden ir adentro de un metodo de nuestra aplicacion de java o applet por asi decirlo, ejemplo:

public static void main(String args[]){
int edad,cont =0;
String hola;
booleand tam;
//hace algo
}

Por cada declaracion de un tipo de variable puede haber varios nombres si los separa esto con comas asi como tambien se pueden inicializar con un valor antes de hacer alguna operacion en el cuerpo del metodo. Es recomendable inicializar las variables locales con algun valor antes de utilizarlas para seguridad de los datos que se manejan en estos. Las variable de instancia y las de clase no es necesario su inicializacion. Otra cosa es que la declaracion del nombre de una variable es case- sensitive, es decir, la variable X es diferente a la variable x.

Ademas del nombre de las variables a estos se les tiene que asociar un tipo de variable los cuales pueden se unos de estos:

-Uno de los ocho tipos de datos basicos
-el nombre de una clase
-un arreglo(array)

Los ocho tipos de datos que se mencionaron son los comunes enteros valores de coma flotante , los booleanos etc y son llamados primitivos puesto que no son ningun objeto, tambien se puede decir que son dependientes de maquina pues sus valores que puede tomar ya esta preestablecido y se puede confiar en ellos.

hay 4 tipos de valores que toman los enteros y pueden ser:

Type	Size	Range
byte	8 bits	—128 to 127
short	16 bits	—32,768 to 32,767
int	32 bits	—2,147,483,648 to 2,147,483,647
long	64 bits	—9223372036854775808 a 9223372036854775807

Los numeros flotantes son los que tienen punto decimal asi que son faciles de Explicar. Los booleanos son los de tipo logico y pueden tener false o true o cero y uno respectivamente

Ademas de los ocho tipos basicos las variables de java tambien pueden ser declaradas para que almacenen una instancia de una clase esto se vera mas adelante.

Una ves que se les declaro usted puede asignarles un valor claro que sea de acuerdo al tipo de variable por ejemplo:
int tamaño;
tamaño=0;

Los comentarios en java tienen tres tipos de representacion, el clasico que vienen de c y c++ son /* */ todo lo que este en medio de estos delimitadores se ignora tambien estan las diagonales dobles // toda la linea hacia la derecha es ignorada y el ultimo que es igual al primero se ignora todo lo que esta en medio de : /** */ estos ultimos no son usados ..

literales
Llamamos literales a los números enteros, los numeros de coma flotante, los booleanos, los caracteres y las cadenas que se presentan de forma explícita dentro del código. A su vez, cada uno de estos literales puede aparecer en diferentes formatos:

Decimales (base 10)
Hexadecimales (base 16): Comienzan con 0x ó 0X
Octales (base 8): Comienzan con 0
De coma flotante:

double (64 bits)
float (32 bits): Terminan con f ó F
Notación científica
Booleanos:

\ \ backslash
\ b retroceso
\ r retorno de carro
\ t tabulador
\ f form feed
\ n line feed
\ ' comilla simple
\ " comilla doble
\udddd caracter Unicode
\ddd número Octal
\ continuación

Una combinacion de letras es una cadena , Las cadenas (Strings) en java son una instancia de la clase String que se encuentra en en el paquete java.lang, y no son simple arreglo de caracterees como en el c estos son clase con algunos metodos definidos los cuales nos dan su longitud concatenacion etc, por eso son mas versatiles que las antigüas literales CHAR del c.

Los operadores nos permiten realizar operaciones entre datos u objetos. Los operadores junto a las variables y datos a los que se aplican forman las expresiones. Un ejemplo de expresión sería:

La precedencia de operadores determina el orden en que estos se evalúan. A continuación se presenta una lista de operadores desde la máxima a la mínima precedencia. Todos los que están en la misma fila tienen la misma precedencia, y esta precedencia va disminuyendo al bajar a las filas inferiores:

    . [] ()
    ++ -- ! ~
    * / %
    + -
    << >> >>>
    < > <= >=
    == !=
    &
    ^
    &&
    ||
    ?:
    =

Se pueden realizar tres tipos de operaciones sobre enteros: unarias, binarias y relacionales.

Operadores Unarios:
Los operadores unarios actúan sobre un solo entero.
Devuelve un tipo int excepto cuando el operando es un long, en cuyo caso el resultado será también de tipo long.

Incremento: ++
Aumenta una variable entera una unidad
Se puede utilizar como prefijo o como sufijo.

Prefijo: Se produce la variación antes de evaluar la expresión en la que se encuentra
Ejemplo:
y = ++x
Antes de la expresión: x = 4
Después de la expresión: y = 5, x = 5

Sufijo: Se produce la variación después de evaluar la expresión en la que se encuentra
Ejemplo:
y = x++
Antes de la expresión: x = 4
Después de la expresión: y = 4, x = 5

Decremento: --
Disminuye una variable entera una unidad
Se puede utilizar como prefijo o como sufijo.

Negación: -
Cambia el signo de un valor entero
Ejemplo:
y = -x
Antes de la expresión: x = 4
Después de la expresión: y = -4

Complemento a nivel de bits: ~
Se conmuta cada bit del número, los 1 pasan a 0 y viceversa.

Operadores Binarios:
Los operadores unarios actúan sobre pares de números enteros.
Devuelven un tipo int excepto cuando uno de los operandos es un long, en cuyo caso el resultado será también de tipo long.

Adición: +
Sustracción: -
Multiplicación: *
División: /
Devuelve un número entero. El resto se puede calcular con el operando Módulo
Módulo: %
Resto de una división
AND a nivel de bits: &
OR a nivel de bits: |
XOR a nivel de bits: ^
Comparan cada bit de cada numero realizan las operaciones lógicas especificadas.
Desplazamiento a la izquierda: <<
Desplazamiento a la derecha: >>
Desplazamiento a la derecha con inclusión de ceros: >>>
Desplazan los bits individuales de un entero en una cantidad entera determinada.

Operadores Relacionales:
Los operadores unarios actúan sobre pares de números enteros.
Devuelven un Booleano.

Menor que: <
Mayor que: >
Menor o igual que: <=
Mayor o igual que: >=
Igual que: =
Distinto a: !=

Igual que sobre enteros, sobre números de coma flotante se pueden realizar tres tipos de operaciones: unarias, binarias y relacionales.

Operadores Unarios:
Los operadores unarios actúan sobre un solo número de coma flotante.
Devuelve un tipo float cuando el número es de este tipo, y un tipo double si el número es un double.

Incremento: ++
Aumenta una variable de coma flotante en 1.0
Se puede utilizar como prefijo o como sufijo.

Decremento: --
Disminuye una variable de coma flotante en 1.0
Se puede utilizar como prefijo o como sufijo.

Operadores Binarios:
Los operadores unarios actúan sobre pares de números de coma flotante.
Devuelven un tipo float excepto cuando uno de los operandos es un double, en cuyo caso el resultado será también de tipo double.

Adición: +
Sustracción: -
Multiplicación: *
División: /
Módulo: %
El operador módulo, sobre números de coma flotante, da el resto en coma flotante si el resultado se considerara un entero.

Operadores Relacionales:
Los operadores unarios actúan sobre pares de números de coma flotante.
Devuelven un Booleano.

Menor que: <
Mayor que: >
Menor o igual que: <=
Mayor o igual que: >=
Igual que: =
Distinto a: !=

Operadores booleanos:
Los operadores booleanos operan sobre tipos booleanos.
Devuelven un resultado Booleano.

AND: &
OR: |
XOR: ^
AND lógico: &&
Evita la evaluación del lado derecho de la expresión si no es necesario
OR lógico: ||
Evita la evaluación del lado derecho de la expresión si no es necesario
Negación: !
Igual que: ==
Distinto a: !=
Condicional: ?:

Operadores de asignación:
Hacen la misma función que los operadores normales, pero almacenando el valor resultante en la parte izquierda de la expresión.

Adición: +=
Sustracción -=
Multiplicación: *=
División: /=
Módulo: %=
AND: &=
OR: |=
XOR: ^=
Desplazamiento a la izquierda: <<=
Desplazamiento a la derecha: >>=
Desplazamiento a la derecha con inclusión de ceros: >>>=

Java tiene cuatro operadores basico aritmeticos antes ya descritos en el tema anterior, cada operador toma dos operandos y nos da un producto el operador de substraccion nos puede tambie servir como el negado de un solo operando, las divisiones de enteros da el resultado entero, como los enteros no tienen fraccion decimal, todo lo del residuo es ignorado. El modulo(%)
nos da el residuo de una division de dos opearandos. veamos un ejemplo para que quede mas claro:

class ArithmeticTest {
     public static void main (String args[]) {
        short x = 6;
        int y = 4;
       float a = 12.5f;
       float b = 7f;

En c y c++ los operadores monarios ++ y -- son usados para incrementar y decrementar respectivamente , ¿pues adivina que? tambien en java, y funciona de la misma manera decrementa por uno o incrementa por uno , estos operadores pueden ser prefijos o subfijos es decir pueden ir al principio de el valor a decrementar o incrementar.
Ve estas dos expresiones:
z = f++;
z =++f;

estas dos expresiones dan muy diferentes valores , cuando se usa f++ o f-- obtienes el valor de f antes de ser incrementado y cuando es ++f o --f el valor de f es asignado y despues de ser cambiado por el operador.

     System.out.println("y = x++ (postfix) results in:");
     System.out.println("x is " + x);
     System.out.println("y is " + y);
    System.out.println("——————");
     y = ++x;
     System.out.println("y = ++x (prefix) results in:");

Java tiene estos operadores de comparaciones

operador	significado	ejemplo
= =	igual	x= =3
!=	desigual	x ! =3
<	menor que	x<3
>	mayor que	x>3
<=	menor igual	x<=3
>=	mayor igual	x>=3

Expresiones que dan un valor booleano por ejemplo comparaciones, pueden combinarse usando operadores logicos que representan conmbinaciones logicas de AND, OR, XOR, y NOT.
Para las combinaciones AND se usa el & o &&, para el or se usa | o || para el XOR se usa el ^ y por ultimo para el NOT se utiliza el !.

Una expresion especial que tiene el java es el operador + usado en los Strings o cadenas para crear y concatenar strings. In la mayoria de los ejemplos previos a este has visto algo como esto:

La salida de esta linea seria una cadena concatenado el string que se encuentra en nombre con es y con maria, asi que uno se pregunta ¿Que pasa aqui?, cuando se usa el operador + en strings concatena los strings dados como operadores y crea un string con todo los strings ateriores concatenados , como veremos esto es una herramienta muy util cuando programemos mas adelante.

El operador += tambien funciona en los strings por ejemplo veremos esta expresiones:

Las estructuras de control en Java son básicamente las misma que en C, con excepción del goto, que no existe (al fin un lenguaje serio! )

if…[else]
La más común de todas, permite ejecutar una instrucción (o secuencia de instrucciones) si se da una condición dada (o, mediante la cláusula else, ejecutar otra secuencia en caso contrario).

if (expresión_booleana) {
instrucciones_si_true;
}
else {
instrucciones_si_false;
}

public final String toString() {
if (y<0)
return x+"-i"+(-y);
else
return +x+"+i"+y;
}

Switch…case…brake…default
Permite ejecutar una serie de operaciones para el caso de que una variable tenga un valor entero dado. La ejecución saltea todos los case hasta que encuentra uno con el valor de la variable, y ejecuta desde allí hasta el final del case o hasta que encuentre un break, en cuyo caso salta al final del case. El default permite poner una serie de instrucciones que se ejecutan en caso de que la igualdad no se de para ninguno de los case.

switch (expresión_entera) {
case (valor1): instrucciones_1;
    [break;]
case (valor2): instrucciones_2;
    [break;]
…..
case (valorN): instrucciones_N;
    [break;]
default: instrucciones_por_defecto;
}

switch (mes) {
case (2): if (bisiesto()) dias=29;
   else dias=31;
   break;
case (4):
case (6):
case (9):
case (11): dias = 30;
   break;
default: dias = 31;
}

While
Permite ejecutar un grupo de instrucciones mientras se cumpla una condición dada:

while ( linea != null) {
linea = archivo.LeerLinea();
System.out.println(linea);
}

Do…while
Similar al anterior, sólo que la condición se evalúa al final del ciclo y no al principio:

do {
linea = archivo.LeerLinea();
if (linea != null) System.out.println(linea);
} while (linea != null);

For
También para ejecutar en forma repetida una serie de instrucciones; es un poco más complejo:

for ( instrucciones_iniciales; condición_booleana; instruccion_repetitiva_x ) {
instrucciones…
}

Si bien las instrucciones pueden ser cualquiera (el bucle se repite mientras la condición sea verdadera), lo usual es utilizarlo para "contar" la cantidad de veces que se repiten las instrucciones; se podría indicar así:

for ( contador = valor_inicial; contador < valor_final; contador++ ) {
instrucciones…
}

Break y continue
Estas instrucciones permiten saltar al final de una ejecución repetitiva (break) o al principio de la misma (continue).

import java.io.*;
class Bucles {
public static void main (String argv[ ]) {
int i=0;
for (i=1; i<5; i++) {
System.out.println("antes "+i);
if (i==2) continue;
if (i==3) break;
System.out.println("después "+i);
}
}
}

Por qué? "i" comienza en 1 (imprime "antes" y "después"); cuando pasa a 2, el continue salta al principio del bucle (no imprime el "después"). Finalmente, cuando "i" vale 3, el break da por terminado el bucle for.

synchronized (para ver junto con los threads)
catch,
throw,
try,
finally (para ver con las excepciones)

Bueno, antes que nada conviene saber que en Java hay un montón de clases ya definidas y utilizables.

java.lang - clases esenciales, números, strings, objetos, compilador, runtime, seguridad y threads (es el único paquete que se incluye automáticamente en todo programa Java)
java.io - clases que manejan entradas y salidas
java.util - clases útiles, como estructuras genéricas, manejo de fecha, hora y strings, número aleatorios, etc.
java.net - clases para soportar redes: URL, TCP, UDP, IP, etc.
java.awt - clases para manejo de interface gráfica, ventanas, etc.
java.awt.image - clases para manejo de imágenes
java.awt.peer - clases que conectan la interface gráfica a implementaciones dependientes de la plataforma (motif, windows)
java.applet - clases para la creación de applets y recursos para reproducción de audio.
Para que se den una idea, los números enteros, por ejemplo, son "instancias" de una clase no redefinible, Integer, que desciende de la clase Number e implementa los siguientes atributos y métodos:

public final class java.lang.Integer extends java.lang.Number {
        // Atributos
    public final static int MAX_VALUE;
    public final static int MIN_VALUE;
        // Métodos Constructores
    public Integer(int value);
    public Integer(String s);
        // Más Métodos
    public double doubleValue();
    public boolean equals(Object obj);
    public float floatValue();
    public static Integer getInteger(String nm);
    public static Integer getInteger(String nm, int val);
    public static Integer getInteger(String nm, Integer val);
    public int hashCode();
    public int intValue();
    public long longValue();
    public static int parseInt(String s);
    public static int parseInt(String s, int radix);
    public static String toBinaryString(int i);
    public static String toHexString(int i);
    public static String toOctalString(int i);
    public String toString();
    public static String toString(int i);
    public static String toString(int i, int radix);
    public static Integer valueOf(String s);
    public static Integer valueOf(String s, int radix);
}

la estructura de una clase
caramba, hay métodos repetidos!
De la estructura enseguida hablaremos; en cuanto a los métodos repetidos (como parseInt por ejemplo), al llamarse al método el compilador decide cuál de las implementaciones del mismo usar basándose en la cantidad y tipo de parámetros que le pasamos. Por ejemplo, parseInt("134") y parseInt("134",16), al compilarse, generarán llamados a dos métodos distintos.

algunas_palabras class nombre_de_la_clase [algo_más] {
[lista_de_atributos]
[lista_de_métodos]
}

Ya veremos qué poner en "algunas_palabras" y "algo_más", por ahora sigamos un poco más con los fundamentos de esto acontinuacion.

En los años ochenta el paradigma orientado a objetos comenzaba a madurar como un enfoque sólido de desarrollo de software. En los últimos años esta metodología ha experimentado un gran progreso, tanto en el desarrollo de programas como en la forma de presentar las aplicaciones del sistema al usuario.

La programación orientada a objetos es una disciplina diseñada para realizar programación imperativa. Uno de los defectos de la programación imperativa es que las variables globales pueden ser utilizadas desde cualquier punto del programa, incluyendo la posibilidad de modificar su contenido. Los programas que carecen de disciplina para acceder a variables globales tienden a ser inmanejables. La razón es que los módulos que acceden a estas variables no se pueden comprender completamente, de forma independiente, de todos aquellos otros módulos que también acceden a las mismas variables globales.

La programación orientada a objetos es una disciplina que descansa en el concepto de objeto para imponer la estructura modular de los programas. Una metodología, frente al paradigma imperativo, que nos ayudará a comprender el dominio del problema a resolver, al intentar construir un modelo del mundo real que envuelve nuestro sistema: la representación de este mundo mediante la identificación de los objetos que constituyen el vocabulario del dominio del problema, su organización y la representación de sus responsabilidades.

El paradigma orientado a objetos se basa en los tres métodos de organización que utilizamos desde nuestra infancia y en los que basamos todo nuestro pensamiento: la diferencia entre un objeto y sus atributos (por ejemplo, entre un camión y su altura o peso), la diferencia entre un objeto y sus componentes (por ejemplo, entre un camión y sus ruedas o motor) y la formación y distinción entre clases de objetos (por ejemplo, entre camiones, turismos y bicicletas).

La idea de manejar objetos reales como contenedores de estados y comportamientos es mucho más atractiva desde el punto de vista del usuario. Así no deberá tener que batallar con construcciones orientadas al computador, sino que podrá manejar objetos (y operaciones) que se asemejen más a sus equivalentes en el mundo real. La elevación del nivel de abstracción es sin duda un objetivo deseable.

Las técnicas orientadas a objetos usan un mismo modelo conceptual para el análisis, el diseño y la programación. La transición desde el análisis al diseño es tan natural que es difícil especificar donde comienza uno y donde acaba el otro.

Definiciones de los conceptos básicos
Un objeto es la abstracción de algo que forma parte del dominio de nuestro problema, reflejando las posibilidades de un sistema para mantener información sobre él. Representa una entidad, real o abstracta, con un papel bien definido dentro de nuestro mundo y con dos características: su estado y su comportamiento. Podríamos decir, también, que es una variable equipada con operaciones exclusivas para trabajar con ella.

Ejemplos de objetos podrían ser: tú perro, tú televisión, tú bicicleta, etc.

Los objetos se describen mediante atributos o variables, que aclaran el significado del objeto. Un atributo de un objeto es algo que el objeto conoce y refleja el estado del objeto. Cuando un objeto necesite conocer atributos de otros objetos del modelo estos podrán asociarse mediante un tipo de conexión que denominaremos asociación (o interconexión).

Los atributos de nuestro objeto bicicleta podrían ser: el número de ruedas que tiene, el número de marchas, el número de sillines y pedales, la marcha actual, la velocidad en cada momento, etc.

Para alterar su estado los objetos necesitan de servicios o métodos. Un servicio de un objeto es algo que el objeto sabe hacer y define el comportamiento general del objeto. Los servicios modifican uno o más atributos de los objetos. El concepto de servicio de la programación orientada a objetos es similar al concepto de procedimiento o función de la programación imperativa.

Los servicios de nuestro objeto bicicleta podrían ser: acelerar, frenar, cambiar de marcha, etc.

El empaquetamiento de los atributos y sus servicios, dentro de un objeto, es lo que llamamos encapsulación. Para cambiar las marchas de una bicicleta no necesito conocer el mecanismo del cambio, simplemente información de cómo mover el cambio. Así la implementación puede cambiarse sin que tengan que cambiarse otras partes del programa que usan este objeto, ya que ellos sólo ven su "interface público".

En el mundo real hay muchos objetos del mismo tipo, por ejemplo nuestra bicicleta es como otras muchas bicicletas del mundo. Usando la terminología orientada o objetos deberíamos decir que nuestra bicicleta es una instancia de la clase de los objetos bicicletas. Una clase es una descripción -una plantilla- aplicada a un númmmero de objetos similares, con un conjunto uniforme de atributos y servicios. Es la especificación de la estructura, comportamiento y herencia del objeto. También puede especificar permisos de acceso para otras clases derivadas y su visibilidad.

La clase de las bicicletas representaría la definición de todas las bicicletas (entendiendo bicicletas como "ciclos" de dos ruedas). La clase de los "ciclos" (es una superclase) representaría la definición de todos los ciclos, en general, ya sean monociclos, bicicletas, triciclos o tandems (las subclases).

Sin pretenderlo, en el ejemplo anterior, hemos introducido el concepto de herencia que más tarde explicaremos...

Cuando necesitemos crear un nuevo objeto debemos definir a que clase pertenece este objeto e indicar con que clase lo instanciamos. Yo puedo decir: mi bicicleta (un objeto) es un "ciclo" (de la clase de los "ciclos") y lo instancio como una bicicleta (de la clase de las bicicletas).

Existen determinadas clases de las que nunca instanciaremos objetos. A este tipo de clases se les denomina clases abstractas. Es obvio que para que una clase abstracta sea útil debe ser una superclase de otras clases que hereden sus atributos y servicios, sino la clase no servirá para nada. Como ejemplo de clases abstractas podríamos tener la clase de los "ciclos", o la clase de los números (nunca instanciaremos un objeto a esta clase, sino a la clase de los enteros, de los reales o de los complejos).

Aunque en capítulos posteriores veremos la forma de declarar clases, atributos, servicios e instanciar objetos; aquí tenemos un ejemplo que puede ilustrarnos:

(3) ciclo mi_bicicleta=new bicicleta();
Lo que interpretaremos como:
Defino la clase abstracta de los "ciclos".
Defino la clase de las bicicletas como una subclase de la clase de los "ciclos".
Defino un objeto mi_bicicleta como un "ciclo" instanciado a bicicleta.

Podemos considerar que el conjunto de servicios aplicables a una clase dada se almacena junto con la definición de esa clase; juntos definen el "interface público" de los objetos de esa clase. Los objetos pueden actualizarse o examinarse sólo a través de su "interface público", lo que ofrece un acceso disciplinado a objetos (una ventaja más de la orientación a objetos).

Los objetos pueden pedir realizar servicios a otros objetos mediante el envío de mensajes. El objeto emisor será el que emite la petición de realización de un servicio a un objeto receptor que entiende el servicio, enviando información de un objeto a otro (parámetros). Así los objetos de diferentes procesos, o de diferentes máquinas, pueden comunicarse. Podríamos traducirlo como: cuando un objeto ejecuta un servicio de otro objeto lo que realmente está haciendo es enviarle un mensaje para que el objeto receptor ejecute el servicio.

Representando gráficamente nuestro modelo
La mejor forma de compartir nuestra modelización del dominio del problema a resolver, para que sea comprensible por cualquier humano, es representarla gráficamente:

Podemos representar gráficamente un objeto con dos círculos concéntricos. En el círculo interno tendríamos encapsulados sus atributos y en el externo sus servicios (representando el escudo de los atributos a ser modificados por otros objetos).
También podemos representarlo, de forma más correcta y académica, mediante un cuadrado doble con tres zonas o divisiones: la primera para el nombre de la clase a la que pertenece, la segunda para sus atributos y la tercera para sus servicios. A este elemento dibujado se le denomina Class&Objects (ya que representa una clase que puede instanciar objetos). Si la clase es abstracta (una clase que no instanciará objetos) el cuadrado no será doble, sino simple.
La representación de la herencia, o generalización-especialización, se dibujará mediante un icono de media luna con los "cuernos" apuntando a las especializaciones.
La estructura todo-parte se representará mediante un triángulo apuntando a la clase totalidad, pudiendo indicar la cardinalidad de la relación.
Para conectar (o asociar) dos clases las uniremos mediante un línea simple, indicando también la cardinalidad de la relación.
Los mensajes se dibujarán como una línea doble con punta de flecha, desde el objeto emisor del mensaje al receptor.

Como conclusión, podemos repasar los conceptos que nos ayudarán en la gestión de la complejidad de nuestros programas orientados a objetos:

Abstracción: ignorar aquellos aspectos que no sean relevantes al propósito actual para concentrarse más profundamente en aquellos que lo son.
Encapsulación: el interface de cada componente del programa se define de forma que revele tan poco como sea posible de sus particularidades interiores.
Polimorfismo: es la propiedad de dos o más clases para responder al mismo mensaje, cada una de ellas según su especificación.
Enlace dinámico: es la propiedad que poseen los objetos para enviar mensajes a otros objetos sin necesidad de conocer (quizá por imposibilidad de hacerlo) la clase a la que pertenecen, se resolverá en tiempo de ejecución.
Herencia: expresa la similitud entre clases de objetos, mostrando la especialización de los estados y los comportamientos de las clases de objetos de nuestro sistema en forma jerárquica.
Asociación y mensajes: los objetos de un sistema se relacionan y se comunican entre sí.

Estructura de una clase

Declaración de la clase

[public] [final | abstract] class Clase [extends ClaseMadre] [implements Interfase1 [, Interfase2 ]…]

[public] interface Interfase [extends InterfaseMadre1 [, InterfaseMadre2 ]…]

Como se ve, lo único obligatorio es class y el nombre de la clase. Las interfases son un caso de clase particular que veremos más adelante.

Public, final o abstract

Una clase final (final) es aquella que no puede tener clases que la hereden. Esto se utiliza básicamente por razones de seguridad (para que una clase no pueda ser reemplazada por otra que la herede), o por diseño de la aplicación.

Una clase abstracta (abstract) es una clase que puede tener herederas, pero no puede ser instanciada. Es, literalmente, abstracta (como la clase Number definida en java.lang). ¿Para qué sirve? Para modelar conceptos. Por ejemplo, la clase Number es una clase abstracta que representa cualquier tipo de números (y sus métodos no están implementados: son abstractos); las clases descendientes de ésta, como Integer o Float, sí implementan los métodos de la madre Number, y se pueden instanciar.

Por lo dicho, una clase no puede ser final y abstract a la vez (ya que la clase abstract requiere descendientes…)

¿Un poco complejo? Se va a entender mejor cuando veamos casos particulares, como las interfases (que por definición son abstractas ya que no implementan sus métodos).

Extends

Cuando una clase desciende de otra, esto significa que hereda sus atributos y sus métodos (es decir que, a menos que los redefinamos, sus métodos son los mismos que los de la clase madre y pueden utilizarse en forma transparente, a menos que sean privados en la clase madre o, para subclases de otros paquetes, protegidos o propios del paquete). Veremos la calificación de métodos muy pronto, a no desesperar!

Implements

Esto sirve para dar un ascendiente común a varias clases, obligándolas a implementar los mismos métodos y, por lo tanto, a comportarse de forma similar en cuanto a su interfase con otras clases y subclases.

Interface

Todos sus métodos son por definición abstractos y sus atributos son finales (aunque esto no se indica en el cuerpo de la interfase).

Son útiles para generar relaciones entre clases que de otro modo no están relacionadas (haciendo que implementen los mismos métodos), o para distribuir paquetes de clases indicando la estructura de la interfase pero no las clases individuales (objetos anónimos).

Si bien diferentes clases pueden implementar las mismas interfases, y a la vez descender de otras clases, esto no es en realidad herencia múltiple ya que una clase no puede heredar atributos ni métodos de una interface; y las clases que implementan una interfase pueden no estar ni siquiera relacionadas entre sí.

El cuerpo de la clase

No es obligatorio, pero en general se listan primero los atributos y luego los métodos.

Declaración de atributos

Por otra parte, además de los atributos de la propia clase se puede acceder a todos los atributos de la clase de la que desciende; por ejemplo, cualquier clase que descienda de la clase Polygon hereda los atributos npoints, xpoints e ypoints.

Finalmente, los atributos miembros de la clase pueden ser atributos de clase o atributos de instancia; se dice que son atributos de clase si se usa la palabra clave static: en ese caso la variable es única para todas las instancias (objetos) de la clase (ocupa un único lugar en memoria). Si no se usa static, el sistema crea un lugar nuevo para esa variable con cada instancia (o sea que es independiente para cada objeto).

[private|protected|public] [static] [final] [transient] [volatile] Tipo NombreVariable [= Valor];

Private, protected o public

De acuerdo a la forma en que se especifica un atributo, objetos de otras clases tienen distintas posibilidades de accederlos:

Acceso desde:	private	protected	public	(package)
la propia clase	S	S	S	S
subclase en el mismo paquete	N	S	S	S
otras clases en el mismo paquete	N	S	S	S
subclases en otros paquetes	N	X	S	N
otras clases en otros paquetes	N	N	S	N

X: puede acceder al atributo en objetos que pertenezcan a la subclase, pero no en los que pertenecen a la clase madre. Es un caso especial ; más adelante veremos ejemplos de todo esto.

Static y final

En cuanto a final, como en las clases, determina que un atributo no pueda ser sobreescrito o redefinido. O sea: no se trata de una variable, sino de una constante.

Transient y volatile

Transient denomina atributos que no se graban cuando se archiva un objeto, o sea que no forman parte del estado permanente del mismo.

Volatile se utiliza con variables modificadas asincrónicamente por objetos en diferentes threads (literalmente "hilos", tareas que se ejecutan en paralelo); básicamente esto implica que distintas tareas pueden intentar modificar la variable simultáneamente, y volatile asegura que se vuelva a leer la variable (por si fue modificada) cada vez que se la va a usar (esto es, en lugar de usar registros de almacenamiento como buffer).

Primero empezaremos con definir que clase ,Valga la redundancia, va a ser nuestra clase, en mi caso definire una clase bicicleta que haga lo que hace una bicicleta.

class bicicleta{
   String marca;
   String color;
   int NumRuedas;
   boolean LucesOn;

   //metodos de clase
   void QueMarca(String x1){
   marca=x1;
   System.out.println(marca);

   bicicleta baika= new bicicleta();
   //¿que marca es?
   baika.QueMarca("BIMEX");
   //¿que color es?
   baika.QueColor("Azul");
   //¿Cuantas ruedas tiene?
   baika.QueNumRuedas(5);
   //¿Estan las luces prendidas?
   baika.EstaLucesOn(true);

La Herencia es el mecanismo por el que se crean nuevos objetos definidos en términos de objetos ya existentes. Por ejemplo, si se tiene la clase Ave, se puede crear la subclase Pato, que es una especialización de Ave.

La palabra clave extends se usa para generar una subclase (especialización) de un objeto. Una Pato es una subclase de Ave. Cualquier cosa que contenga la definición de Ave será copiada a la clase Pato, además, en Pato se pueden definir sus propios métodos y variables de instancia. Se dice que Pato deriva o hereda de Ave.

Además, se pueden sustituir los métodos proporcionados por la clase base. Utilizando nuestro anterior ejemplo de MiClase, aquí hay un ejemplo de una clase derivada sustituyendo a la función Suma_a_i():

    import MiClase;
    public class MiNuevaClase extends MiClase {
        public void Suma_a_i( int j ) {
            i = i + ( j/2 );
            }
        }

Ahora cuando se crea una instancia de MiNuevaClase, el valor de i también se inicializa a 10, pero la llamada al método Suma_a_i() produce un resultado diferente:

En Java no se puede hacer herencia múltiple. Por ejemplo, de la clase aparato con motor y de la clase animal no se puede derivar nada, sería como obtener el objeto toro mecánico a partir de una máquina motorizada (aparato con motor) y un toro (aminal). En realidad, lo que se pretende es copiar los métodos, es decir, pasar la funcionalidad del toro de verdad al toro mecánico, con lo cual no sería necesaria la herencia múltiple sino simplemente la compartición de funcionalidad que se encuentra implementada en Java a través de interfaces.

    public MiClase {
         int i;
         public MiClase() {
             i = 10;
             }
         public void Suma_a_i( int j ) {
             i = i + j;
             }
         }

La clase MiClase contiene una variable (i) y dos métodos, MiClase que es el constructor de la clase y Suma_a_i( int j ).

Ambito de una variable
Los bloques de sentencias compuestas en Java se delimitan con dos llaves. Las variables de Java sólo son válidas desde el punto donde están declaradas hasta el final de la sentencia compuesta que la engloba. Se pueden anidar estas sentencias compuestas, y cada una puede contener su propio conjunto de declaraciones de variables locales. Sin embargo, no se puede declarar una variable con el mismo nombre que una de ámbito exterior.

El siguiente ejemplo intenta declarar dos variables separadas con el mismo nombre. En C y C++ son distintas, porque están declaradas dentro de ámbitos diferentes. En Java, esto es ilegal.

Class Ambito {
    int i = 1;        // ámbito exterior
        {             // crea un nuevo ámbito
        int i = 2;    // error de compilación
        }
    }

Los métodos son funciones que pueden ser llamadas dentro de la clase o por otras clases. El constructor es un tipo específico de método que siempre tiene el mismo nombre que la clase.

Cuando se declara una clase en Java, se pueden declarar uno o más constructores opcionales que realizan la inicialización cuando se instancia (se crea una ocurrencia) un objeto de dicha clase.

Utilizando el código de ejemplo anterior, cuando se crea una nueva instancia de MiClase, se crean (instancian) todos los métodos y variables, y se llama al constructor de la clase:

La palabra clave new se usa para crear una instancia de la clase. Antes de ser instanciada con new no consume memoria, simplemente es una declaración de tipo. Después de ser instanciado un nuevo objeto mc, el valor de i en el objeto mc será igual a 10. Se puede referenciar la variable (de instancia) i con el nombre del objeto:

Al tener mc todas las variables y métodos de MiClase, se puede usar la primera sintaxis para llamar al método Suma_a_i() utilizando el nuevo nombre de clase mc:

En un momento determinado se puede querer crear una clase en la que el valor de una variable de instancia sea el mismo (y de hecho sea la misma variable) para todos los objetos instanciados a partir de esa clase. Es decir, que exista una única copia de la variable de instancia. Se usará para ello la palabra clave static.

El valor de la variable version será el mismo para cualquier objeto instanciado de la clase Documento. Siempre que un objeto instanciado de Documento cambie la variable version, ésta cambiará para todos los objetos.

De la misma forma se puede declarar un método como estático, lo que evita que el método pueda acceder a las variables de instancia no estáticas:

    class Documento extends Pagina {
        static int version = 10;
        int numero_de_capitulos;
        static void annade_un_capitulo() {
            numero_de_capitulos++;        // esto no funciona
            }
        static void modifica_version( int i ) {
            version++;                    // esto si funciona
            }
        }

La modificación de la variable numero_de_capitulos no funciona porque se está violando una de las reglas de acceso al intentar acceder desde un método estático a una variable no estática.

Todas las clases que se derivan, cuando se declaran estáticas, comparten la misma página de variables; es decir, todos los objetos que se generen comparten la misma zona de memoria. Las funciones estáticas se usan para acceder solamente a variables estáticas.

    class UnaClase {
        int var;
        UnaClase()
            {
            var = 5;
            }
        UnaFuncion()
            {
            var += 5;
            }
        }

En el código anterior, si se llama a la función UnaFuncion a través de un puntero a función, no se podría acceder a var, porque al utilizar un puntero a función no se pasa implícitamente el puntero al propio objeto (this). Sin embargo, sí se podría acceder a var si fuese estática, porque siempre estaría en la misma posición de memoria para todos los objetos que se creasen de UnaClase.

Java no utiliza destructores (al contrario que C++) ya que tiene una forma de recoger automáticamente todos los objetos que se salen del alcance. No obstante proporciona un método que, cuando se especifique en el código de la clase, el reciclador de memoria (garbage collector) llamará:

    // Cierra el canal cuando este objeto es reciclado
    protected void finalize() {
        close();

En el cuerpo de la definicion del metodo, usted quiere referirse al objeto acal que ha sido creado y que es el que esta llamando a dicho metodo, para referirse a la instancia del objeto asi como sus variables o para pasar el objeto actual como argumento se utiliza la palabra this, this se refiere al objeto actual, y usted puede utilizarlo donde sea que el objeto exista veamos un ejemplo.

t.this.x //la variable x de el objeto actual que le hablo a este metodo
this.miMetodo(this) //llama al metodo miMetodo del objeto actual
return this //regresa todo el objeto actual

En muchos casos usted no sera necesario que utilize la palabra reservada this para .

Se llama a un método de la misma clase simplemente con el nombre del método y los parámetros entre paréntesis, como se ve, entre otros, en el ejemplo en negrita:

// Archivo: Complejo.java
// Compilar con: javac Complejo.java
public final class Complejo extends Number {
// atributos:
private float x;
private float y;
// constructor:
public Complejo(float rx, float iy) {
x = rx;
y = iy;
}
// métodos:
public float Norma() {
return (float)Math.sqrt(x*x+y*y);
}
// obligatorios (son abstractos en Number):
public double doubleValue() {
return (double)Norma( );
}
public float floatValue() {
return Norma();
}
public int intValue() {
return (int)Norma();
}
public long longValue() {
return (long)Norma();
}
public String toString() {
return "("+x+")+i("+y+")";
}
}

Pueden probar la clase (mínima) con el siguiente ejemplo de aplicación; la línea en negrita es un ejemplo de un llamado a un método de un objeto de otra clase. Notar que es este caso, es necesario llamar al método sobre un objeto (instancia) existente, por lo que se indica:

// Archivo: Ejemplo4.java
// Compilar con: javac Ejemplo4.java
// Ejecutar con: java Ejemplo4
import java.io.*;

public class Ejemplo4 {
public static void main(String args[]) {
Complejo numComp = new Complejo(4,-3);
System.out.println(numComp.toString());
System.out.println(numComp.Norma());
}
}

En la clase Complejo tenemos también un ejemplo de un llamado a un método de clase, o sea static:

Como el método es de clase, no hace falta llamarlo para un objeto en particular. En ese caso, en lugar del nombre de un objeto existente se puede utilizar directamente el nombre de la clase:

Ya hemos aprendido como se define una clase con algunos ejemplos e inclusive ya hemos adelantado algo sobre la instancializacion de objetos de dichas clases, lo que hay que notar es que cuando uno instancia una clase, es decir define un objeto que va a ser instanciación de la clase creada, se usa un operador llamado new , pero se preguntaran porque cuando instanciamos una variable cadena de la clase String no utilizamos este operador , lo que pasa es sencillo la clase string como muchas otras (ver documentacion API de java) es una clase especial que ya tienen un atajo para asi no usar el operador new , al decir "atajo" quiero decir que ya tienen implementado su propio sistema para ubicar memoria para ese objeto, que es basicamente lo que el operador new hace, por lo tanto la clase String no es necesario usar el operador new pero en clases creadas por nosoytros y algunas ya creadas si se va a utilizar.

Veamos un ejemplo de como se usa el operador new (Puede ver el ejemplo del capitulo 3 "creando una clase"):

String str = new String(); //No es necesario usar new en este caso pero se puede utilizar
Random r = new Random(); //siendo Random una clase

No olvide los parentesis estos son importantes si los parentesis estan vacios se crea un objeto simple , en cambio si los parentesis tienen valores, eso quiere decir que quiere que el objeto sea creado con valores iniciales , el tipo y numero de argumentos esta determinado por el constructor de la clase que se vera mas adelante.

d3= new Date();
System.out.println("Dia 3: " +d3);
}
Compile este ejemplo y vea el resultado.

Lo que el operador new haces es lo siguiente , primero la nueva instancia dada es creada, y luego se le asigna la memoria pertinente para el tamaño de la instancia , y ademas algo muy importante pasa , cuando se crea el nuevo objeto se llama a un metodo de la clase llamada constructor , los constructores son metodos especiales que uno define dentro de la clase para incializar valores , usted puede tener tantos constructores como desee, en si hemos visto que algunas clases ya preestablecidas en el lenguaje cuentan con mucha clases de constructores.

void imprime(){
    System.out.println("Hola mi nombre es" + nombre);
    System.out.println("tengo" +edad + "de edad");
                     }

Para obtener el valor de una variable de instancia se usa la notacion de punto, la notacion de punto tienen dos partes, el objeto a la izquierda del punto y la variable en la derecha , por esa manera la podemos acceder o cambiar el valor, por ejemplo si tiene un objeto, llamado miobjeto, el cual tienen una variable de instancia llamada variable se puede acceder o cambiar el valor de dicha variable de esta manera:

Asi como usted trabaja con objetos, una de las cosas importantes es el trabajo que se hace tras bastidores llamado , uso de referencias a objetos, cuando usted asigna objetos a variables, o pasa objetos como argumentos a metodos, usted esta pasando referencias a esos objetos, no a copias como se hace en el c++.

    public static void main(String args []){
        Point pt1,pt2;
        pt1= new Point(100,100);
        pt2=pt1;

        pt1.x=200;
        pt1.y=200;
    System.out.println("punto1" + pt1.x + "," +pt1.y);
    System.out.println("Punto2" + pt2.x + "," +pt2.y);

Si recuerda los capitulos anteriores vio que se puede comparar valores con los diferentes operadores que existen que son: =, >=,=>,! <,>, etc.. la mayoria de estos operadores trabajan con literales primitivas y no con objetos , si usted trata de compilar un programa que utilize algunos de estos operadores con objetos obtendra un error de compilacion; la exceptcion a esta regla es el operador == (igual), este operador si lo usa con los objetos checa si si los dos operadores dados son el mismo objeto.

Un buen ejemplo es la clase String, es posible que dos objetos instanciados de la clase String , tengan el mismo valor , eso es, tienen los caracteres en el mismo order y son iguales , en este ejemplo veremos un metodo que esta definido en la clase de String llamado equal() el cual checa cada carater en el String y regresa true si los dos operandos tienen el mismo valor

Class iguales{
    public static void main (String args[]){
        String str1, str2;
        str1="Hola como estan";
        str2=str1;

        System.out.println("cadena 1" + str1);
        System.out.println("cadena2" + str2);
        System.out.println("Es el mismo objeto?" + (str1==str2));

        System.out.println("cadena 1" + str1);
        System.out.println("cadena2" + str2);
        System.out.println("Es el mismo objeto?" + (str1==str2));
        System.out.println("Es el mismo valor?" + str1.equals(str2));

Gran parte de este curso esta basado

en el libro "Teach Yourself Java in 21 Days"

Por Laura Lemay & Charles L. Perkins