Escuela Superior Politécnica del Litoral (Ecuador) 

1. SINTAXIS EN JAVA

2. Reglas de Léxico
Separadores:
 ( ) lista de parámetros en métodos, expresiones,
sentencias de control, conversiones de tipos.
 { } Inicialización de arreglos. Encierra: bloques de código,
contenido de clases y métodos.
 [ ] 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 métodos de una referencia.

3. 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.");
}
}

4. Comentarios
• No afectan a la ejecución del programa
• Ayudan a la compresión del ser humano
• Deben proveer un buen entendimiento del código.
• No debe ser ambigua o entrar en mucho detalle
• Se puede generar documentación automática a través de
la utilidad javadoc

5. 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

6. Identificadores
• Inician con una letra
• Puede contener letras, números, _ y $
• Deben ser descriptivos y legible
• Si el nombre es compuesto por varias palabras
debe iniciar con minúscula y luego cada palabra
con mayúscula.
promedio contador $test this_is_ok val1
2contador alto-ancho No/si itemActual
• Java es case sentive. Las letras minúsculas y
mayúsculas son diferentes

7. Secuencias de Escape
Secuencia Significado
b backspace
t tab
n Nueva linea
r Carro de retorno
” Comilla doble
’ Comilla simple
backslash

8. 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,ntViolets are blue,n" +
"Sugar is sweet,ntBut I have "commitment issues",nt" +
"So I'd rather just be friendsntAt this point in our " +
"relationship.");
}
}

9. Variables y Asignación
• 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
declaración.
• Puede incluir la palabra reservada final, en cuyo
caso se convierte en una constante y debe tener
un valor asociado.

10. Variables y Asignación
Ejemplos:
• int total;
• double num1, num2 = 4.356, num3;
• char letter = ‘A’, digit = ‘7’;
• final int MAX = 45

11. 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.");
}
}

12. String concatenación
/********************************************************************
// 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");
}
}

13. Precedencia de Operadores
Prec. Operador Operación Orden
1 +
-
Mas unario
Menos unario
R -> L
2 *
/
%
Multiplicación
División
Residuo
L -> R
3 +
-
+
Suma
Resta
Concatenación
L -> R
4 = Asignación R -> L

14. Conversión 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

15. Conversión 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

16. Conversión de Datos
Por asignación
float money;
int dollars=25;
money = dollars;
money = 25.0;
Por promoción aritmética
float sum, result;
int count;
result = sum / count; //count es conv. a float
Por casting
dollars = (int) money;

17. Bloques y sentencias
• Sentencia if
La sentencia if permite llevar a cabo la ejecución condicional de
sentencias.

18. if …else

19. if...else if…else

20. if...else anidado

21. switch

22. Bucles (loops)
• While
• Do…while
• for

23. bucle while
• Si el resultado de la expresión booleana es verdadero
entonces se ejecutarán el bloque de código dentro del
bucle.
• Se ejecutará n-veces siempre y cuando la expresión se
siga cumpliendo.

24. do...while
• Similar a un bucle while, excepto que este está
garantizando ejecutar al menos una vez el bloque de
código.

25. for
• Estructura de control de repetición que permite ejecutar
un conjunto de secuencias por un número determinado
de veces.

26. 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()

27. Paquetes en Java
java.applet Creación de programas (applets) fácilmente
transportables en la Web
java.awt Dibuja gráficos y crea interfaces de usuario
java.beans Define componentes de software que
pueden ser combinados fácilmente en otras
aplicaciones
java.io Ejecuta una amplia variedad de
funcionalidad de entrada y salida
java.lang Soporte general; es automáticamente
importada en todos los programas JAVA
java.math Ejecuta operaciones matemáticas
java.net Comunicación a través de redes

28. Paquetes en Java
java.rmi Crea programas que pueden ser distribuidos
a través de múltiples computadoras. RMI
(remote method invocation)
java.security Implementa restricciones de seguridad
java.sql Interactúa 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
ers
Procesa documentos XML (eXtensible
Markup Language)

29. Estructura básica de una clase en Java
public class MiClase
{
//Atributos de la clase
private String atributo1;
private int atributo 2;
private float atributo 3;
//Constructor con el mismo nombre de la clase
public MiClase(){}
//Métodos de la clase
public void metodo1()
{
//Método vacio
}
public String metodo2()
{
return "metodo2";
}
}
Atributos
Nombre
Tipo

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

31. Modificadores de Clase
public
 Las clases públicas son accesibles por todos los
objetos y pueden ser usadas como superclases o
subclases.
 Son accesibles por todas las clases que estén en su
mismo paquete y por todas aquellas clases que la
importen (de otro paquete).
abstract
 Una clase abstracta no se instancia, sino que se utiliza
para la herencia.

32. 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 métodos
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

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

34. Modificadores de Atributos y Métodos
private protected
 Pueden acceder a los atributos o métodos que tengan
este modificador, los métodos de las subclases que la
deriven y no podrán acceder a ella los métodos de las
otras clases del mismo paquete.
package (friendly, sin declaración específica)
 Por defecto, las variables y métodos 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.

35. Modificadores de Atributos y Métodos
static
 Si se tiene un atributo static, este es compartido por
todos los objetos creados a partir de una clase.
 Permite que un método pueda ser accesible aun
cuando la clase no ha sido instanciada.
final
 Un atributo que tiene el modificador final, es una
constante.
 Un método que tiene el modificador final, no puede ser
redefinido, es decir no podemos hacer un Method
Overriding.
 Todos los métodos de una clase final, son
implícitamente final.

36. Declaración 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;

37. Palabra clave super
Se lo usa para referirse a métodos de una
superclase.
Para llamar a un método en una superclase use:
super.nombremétodo(argumentos)
Al constructor de una superclase se lo llama, de
la siguiente forma:
super(arg1, arg2,....);

38. Pasando argumentos a aplicaciones Java
java MiPrograma arg1 arg2 arg3
Si un argumento contiene espacios, debería ir encerrado
entre comillas dobles.

39. 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]);
}
}
}

40. Clase System
Para imprimir datos:
System.out.println();
System.out.print();
Para leer datos de la consola:
System.in.read();
La función para leer datos de consola, lee un solo
carácter a la vez, y retorna un valor de tipo int.

41. 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 */

42. Arreglos
El primer elemento corresponde al índice 0.
En arreglos multidimensionales, es necesario
asignar memoria sola a la primera dimensión.
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];

43. Variables
En una clase pueden definirse tres tipos de variables:
Variables de clase o variables estáticas (static variables)
 Son compartidas por todos los objetos de la clase, y de otras clases
si el acceso a estas lo permite.
 Pueden existir, aún 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 métodos.
 Duran hasta cuando se termina de ejecutar el método.
 Se guardan en la RAM, en el stack storage.

44. Variables

45. Métodos estáticos
Los métodos estáticos (static), son aquellos que pueden
ser invocados, sin necesidad de crear una instancia de un
objeto.

46. EJERCICIO EN CLASES

47. 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 métodos get and set (Encapsulamiento)
• Cree El método sumar que reciba un Quebrado y retorne
otro quebrado resultante.
• Cree el método toString()
• Cree el método imprimir Quebrado

48. Programa principal
• Cree aleatoriamente 5 Quebrados
• Sumelos y muestre en pantalla el resultado.