SINTAXIS EN JAVA

Reglas de Lxico

Separadores:
( ) lista de parmetros en mtodos, expresiones,
sentencias de control, conversiones de tipos.
{ } Inicializacin de arreglos. Encierra: bloques de cdigo,
contenido de clases y mtodos.
[ ] Declara arreglos, referencia a elementos de arreglos.

; Para terminar una sentencia

, Separador de variables

. Separa nombres en paquetes en subpaquetes y clases.

Separador de variables o mtodos de una referencia.
PROGRAMA EN JAVA
//********************************************************************
// Lincoln.java Author: Lewis/Loftus
// Demonstrates the basic structure of a Java application.
//********************************************************************
public class Lincoln
{
//-----------------------------------------------------------------
// Prints a presidential quote.
//-----------------------------------------------------------------
public static void main (String[] args)
{
System.out.println ("A quote by Abraham Lincoln:");
System.out.println ("Whatever you are, be a good one.");
}
}
Comentarios
No afectan a la ejecucin del programa
Ayudan a la compresin del ser humano
Deben proveer un buen entendimiento del cdigo.
No debe ser ambigua o entrar en mucho detalle
Se puede generar documentacin automtica a travs de
la utilidad javadoc
 Palabras Reservadas en Java
abstract default goto* null switch
boolean do if package synchonized
break double implements private this
byte else import protected throw
case extends instanceof public throws
catch false int return transient
char final interface short true
class finally long static try
const* float native strictfp void
continue for new super volatile
while
Identificadores
Inician con una letra
Puede contener letras, nmeros, _ y $
Deben ser descriptivos y legible
Si el nombre es compuesto por varias palabras
debe iniciar con minscula y luego cada palabra
con mayscula.
promedio contador $test this_is_okval1
2contador alto-ancho No/si itemActual
Java es case sentive. Las letras minsculas y
maysculas son diferentes
Secuencias de Escape

Secuencia Significado
\b backspace
\t tab
\n Nueva linea
\r Carro de retorno
\ Comilla doble
\ Comilla simple
\\ backslash
Ejemplo
//********************************************************************
// Roses.java Author: Lewis/Loftus
// Demonstrates the use of escape sequences.
//********************************************************************

public class Roses

{
//-----------------------------------------------------------------
// Prints a poem (of sorts) on multiple lines.
//-----------------------------------------------------------------
public static void main (String[] args)
{
System.out.println ("Roses are red,\n\tViolets are blue,\n" +
"Sugar is sweet,\n\tBut I have \"commitment issues\",\n\t" +
"So I'd rather just be friends\n\tAt this point in our " +
"relationship.");
}
}
Variables y Asignacin
Una variable es un nombre para una espacio en
memoria que almacenara un valor de un
determinado tipo.
Consiste de un tipo seguido de una lista de
variables.
Cada variable puede ser inicializada en la
declaracin.
Puede incluir la palabra reservada final, en cuyo
caso se convierte en una constante y debe tener
un valor asociado.
Variables y Asignacin
Ejemplos:
int total;
double num1, num2 = 4.356, num3;
char letter = A, digit = 7;
final int MAX = 45
Ejemplo
//********************************************************************
// PianoKeys.java Author: Lewis/Loftus
//
// Demonstrates the declaration, initialization, and use of an
// integer variable.
//********************************************************************

public class PianoKeys

{
//-----------------------------------------------------------------
// Prints the number of keys on a piano.
//-----------------------------------------------------------------
public static void main (String[] args)
{
int keys = 88;

System.out.println ("A piano has " + keys + " keys.");

}
}
String concatenacin
/********************************************************************
// Facts.java Author: Lewis/Loftus
// Demonstrates the use of the string concatenation operator and the
// automatic conversion of an integer to a string.
//********************************************************************

public class Facts

{
//-----------------------------------------------------------------
// Prints various facts.
//-----------------------------------------------------------------
public static void main (String[] args)
{
// Strings can be concatenated into one long string
System.out.println ("We present the following facts for your + "extracurricular edification:");

System.out.println ();

// A string can contain numeric digits

System.out.println ("Letters in the Hawaiian alphabet: 12");

// A numeric value can be concatenated to a string

System.out.println ("Dialing code for Antarctica: " + 672);

System.out.println ("Year in which Leonardo da Vinci invented + "the parachute: " + 1515);

System.out.println ("Speed of ketchup: " + 40 + " km per year");

}
}
Precedencia de Operadores

Prec. Operador Operacin Orden

1 + Mas unario R -> L
- Menos unario
2 * Multiplicacin L -> R
/ Divisin
% Residuo
3 + Suma L -> R
- Resta
+ Concatenacin
4 = Asignacin R -> L
Conversin de Datos
De A
byte short, int, long, float, double
short int, long, float, double
char int, long, float, double
int long, float, double
long float, double
float double

Conversiones siempre posibles

Conversin de Datos
De A
byte char
short byte, char
char byte, short
int byte, short, char
long byte, short, char, int
float byte, short, char, int, long
double byte, short, char, int, long, float

Conversiones probables dependiendo de valores

Conversin de Datos

Por asignacin
float money;
int dollars=25;
money = dollars;
money = 25.0;
Por promocin aritmtica
float sum, result;
int count;
result = sum / count; //count es conv. a float
Por casting
dollars = (int) money;
Bloques y sentencias
Sentencia if
La sentencia if permite llevar a cabo la ejecucin condicional de
sentencias.
if else
if...else ifelse
if...else anidado
switch
Bucles (loops)
While
Dowhile
for
bucle while

Si el resultado de la expresin booleana es verdadero

entonces se ejecutarn el bloque de cdigo dentro del
bucle.
Se ejecutar n-veces siempre y cuando la expresin se
siga cumpliendo.
do...while

Similar a un bucle while, excepto que este est

garantizando ejecutar al menos una vez el bloque de
cdigo.
for

Estructura de control de repeticin que permite ejecutar

un conjunto de secuencias por un nmero determinado
de veces.
La clase String
String (String str)
Constructor
char charAt(int index)
int compareTo(String str)
String concat(string str)
boolean equals(String str)
boolean equalsIngnoreCase(String str)
int length()
String replace(char oldChar, char newChar)
String substring(int offset, int endIndex)
String toLowerCase()
String toUpperCase()
Paquetes en Java
java.applet Creacin de programas (applets) fcilmente
transportables en la Web
java.awt Dibuja grficos y crea interfaces de usuario
java.beans Define componentes de software que
pueden ser combinados fcilmente en otras
aplicaciones
java.io Ejecuta una amplia variedad de
funcionalidad de entrada y salida
java.lang Soporte general; es automticamente
importada en todos los programas JAVA
java.math Ejecuta operaciones matemticas
java.net Comunicacin a travs de redes
Paquetes en Java
java.rmi Crea programas que pueden ser distribuidos
a travs de mltiples computadoras. RMI
(remote method invocation)
java.security Implementa restricciones de seguridad
java.sql Interacta con bases de datos. SQL
(structured query language)
java.text Formatea textos para salidas
java.util Utilidades generales
java.swing Crea interfaces graficas con componentes
que extienden las capacidades del AWT
java.xml.pars Procesa documentos XML (eXtensible
ers Markup Language)
Estructura bsica de una clase en Java
public class MiClase
{
//Atributos de la clase
private String atributo1; Atributos
private int atributo 2;
private float atributo 3;
Nombre
//Constructor con el mismo nombre de la clase
public MiClase(){}

//Mtodos de la clase
public void metodo1() Tipo
{
//Mtodo vacio
}

public String metodo2()

{
return "metodo2";
}
}
Modificadores de acceso

Modificadores de acceso
Otra clase del Subclase de Otra clase de
La misma clase
mismo paquete otro paquete otro paquete
public X X X X
protected X X X
default X X
private X
Modificadores de Clase

public
Las clases pblicas son accesibles por todos los
objetos y pueden ser usadas como superclases o
subclases.
Son accesibles por todas las clases que estn en su
mismo paquete y por todas aquellas clases que la
importen (de otro paquete).
abstract
Unaclase abstracta no se instancia, sino que se utiliza
para la herencia.
Modificadores de Clase

final
Una clase que tiene el modificador final, es una clase,
de la cual no se puede heredar.
synchronizable
Este modificador especifica que todos los mtodos
definidos en la clase son sincronizados, es decir, que
no se puede acceder al mismo tiempo a ellos desde
distintos threads.

Por defecto (si no hay modificador) una clase es:

No final
No abstracta
Subclase de la clase Object
Modificadores de Atributos y Mtodos

public
Losatributos y mtodos declarados como public,
pueden ser accedidos por todos los objetos del sistema
(mismo u otros paquetes).
private
Los mtodos o atributos que tienen el modificador
private, solamente pueden ser usados por los mtodos
de la propia clase.
protected
Accesible
por aquellos objetos, que se encuentran en el
mismo paquete o en las subclases (mismo u otros
paquetes).
Modificadores de Atributos y Mtodos

private protected
Pueden acceder a los atributos o mtodos que tengan
este modificador, los mtodos de las subclases que la
deriven y no podrn acceder a ella los mtodos de las
otras clases del mismo paquete.
package (friendly, sin declaracin especfica)
Pordefecto, las variables y mtodos de instancia se
declaran package, lo que significa que son accesibles
por todos los objetos dentro del mismo paquete, pero
no por los externos al paquete.
Modificadores de Atributos y Mtodos

static
Si se tiene un atributo static, este es compartido por
todos los objetos creados a partir de una clase.
Permite que un mtodo pueda ser accesible aun
cuando la clase no ha sido instanciada.
final
Un atributo que tiene el modificador final, es una
constante.
Un mtodo que tiene el modificador final, no puede ser
redefinido, es decir no podemos hacer un Method
Overriding.
Todos los mtodos de una clase final, son
implcitamente final.
Declaracin de Constantes

El valor de una variable final no puede ser cambiado una

vez que es inicializado. Esta es la forma como
declaramos a las constantes en Java.
Ejemplo:
final float pi = 3.141592;
final boolean debug = false;
final int number = 87878;
Palabra clave super

Se lo usa para referirse a mtodos de una

superclase.
Para llamar a un mtodo en una superclase use:
super.nombremtodo(argumentos)
Al constructor de una superclase se lo llama, de
la siguiente forma:
super(arg1, arg2,....);
Pasando argumentos a aplicaciones Java

java MiPrograma arg1 arg2 arg3

Si un argumento contiene espacios, debera ir
encerrado entre comillas dobles.
Ejemplo de paso de argumentos

class EchoArgs {
public static void main (String arguments [])
{
for(int i = 0; i < arguments.length; i++) {
System.out.println(Argumento + i + : +
arguments [i]);
}
}
}
Clase System

Para imprimir datos:

System.out.println();
System.out.print();
Para leer datos de la consola:
System.in.read();
La funcin para leer datos de consola, lee un solo
carcter a la vez, y retorna un valor de tipo int.
Arreglos

Se pueden declarar en Java arreglos de

cualquier tipo:
char s[ ]; int iArray[ ] = {2, 4, 6, 8};
char[ ] s; int[ ] iArray;
Incluso se pueden construir arrays de arrays:
int tabla[ ][ ] = new int[4][5];
Para obtener la longitud del arreglo, se usa
length.
int a[ ][ ] = new int[10][3];
a.length; /* 10 */
a[0].length; /* 3 */
Arreglos

El primer elemento corresponde al ndice 0.

En arreglos multidimensionales, es necesario
asignar memoria sola a la primera dimensin.
int two[ ] [ ] = new int [3] [ ];
Las otras dimensiones pueden variar para cada
elemento.
two[0] = new int[1];
two[1] = new int[4];
two[2] = new int[6];
Variables

En una clase pueden definirse tres tipos de variables:

Variables de clase o variables estticas (static variables)
Son compartidas por todos los objetos de la clase, y de otras clases
si el acceso a estas lo permite.
Pueden existir, an asi no se hayan creado objetos y duran el
tiempo que la clase se encuentra cargada en memoria.
Se guardan en la RAM, en el static storage.
Variables de instancia o de objeto
Son variables guardadas en cada objeto de la clase.
Se guardan en la RAM, en el heap storage.
Variables locales a los mtodos.
Duran hasta cuando se termina de ejecutar el mtodo.
Se guardan en la RAM, en el stack storage.
Variables
Mtodos estticos

Los mtodos estticos (static), son aquellos que pueden

ser invocados, sin necesidad de crear una instancia de un
objeto.
EJERCICIO EN CLASES
Clase Quebrado
Crear la Clase Quebrado
Consta de un numerador y un denominador
Sobrecargue el constructor
Un contructor por defecto que inicialice en 1 al quebrado
Otro que reciba el numerador y denominador.
Cree los mtodos get and set (Encapsulamiento)
Cree El mtodo sumar que reciba un Quebrado y retorne
otro quebrado resultante.
Cree el mtodo toString()
Cree el mtodo imprimir Quebrado
Programa principal
Cree aleatoriamente 5 Quebrados
Sumelos y muestre en pantalla el resultado.