Unidad 2 Sintaxis en java
48
SINTAXIS EN JAVA
-
Upload
cindy-adriana-bohorquez-santana -
Category
Engineering
-
view
169 -
download
2
Transcript of Unidad 2 Sintaxis en java
SINTAXIS EN JAVA
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.
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 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
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, 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
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 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.
Variables y Asignación
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 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 stringSystem.out.println ("We present the following facts for your “ + "extracurricular edification:");
System.out.println ();
// A string can contain numeric digitsSystem.out.println ("Letters in the Hawaiian alphabet: 12");
// A numeric value can be concatenated to a stringSystem.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 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
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
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
Conversión de Datos
Por asignaciónfloat money;
int dollars=25;
money = dollars;
money = 25.0;
Por promoción aritméticafloat sum, result;
int count;
result = sum / count; //count es conv. a float
Por castingdollars = (int) money;
Bloques y sentencias
• Sentencia if
La sentencia if permite llevar a cabo la ejecución condicional de
sentencias.
if …else
if...else if…else
if...else anidado
switch
Bucles (loops)
• While
• Do…while
• for
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.
do...while
• Similar a un bucle while, excepto que este está
garantizando ejecutar al menos una vez el bloque de
código.
for
• Estructura de control de repetición que permite ejecutar
un conjunto de secuencias por un número 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 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
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)
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
Modificadores de acceso
La misma claseOtra 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
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.
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
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).
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.
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.
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;
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,....);
Pasando argumentos a aplicaciones Java
java MiPrograma arg1 arg2 arg3
Si un argumento contiene espacios, debería 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 función para leer datos de consola, lee un solo
carácter 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 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];
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.
Variables
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.
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 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
Programa principal
• Cree aleatoriamente 5 Quebrados
• Sumelos y muestre en pantalla el resultado.
