Fundamentos de programación Java

Diseccionando mi primer programa Java public class Hello { /** * My first Java program */ public static void main( String[] args ){ //prints the string Hello world on screen System.out.println(“Hello world”); } }

Indica el nombre de la clase, Hello Todo el código debe ir dentro de una declaración de clase La clase usa un especificador de acceso público, lo que indica que nuestra clase es accesible desde otras clases de otros paquetes (colección de clases). Diseccionando mi primer programa Java public class Hello { /** * My first Java program */

La próxima línea contiene una llave { indica el comienzo de un bloque También se puede escribir al final de la declaración de clase, quedando así: public class Hello { Diseccionando mi primer programa Java public class Hello { /** * My first Java program */

La siguiente línea es un comentario en Java Diseccionando mi primer programa Java public class Hello { /** * My first Java program */

Indica el nombre del método principal de la clase Hello public class Hello { /** * My first Java program */ public static void main( String[] args ){ Diseccionando mi primer programa Java

Diseccionando mi primer programa Java El método principal es el punto de inicio de un programa Java.

Otra manera de hacer un comentario en Java Diseccionando mi primer programa Java public class Hello { /** * My first Java program */ public static void main( String[] args ){ //prints the string “Hello world” on screen

El comando System.out.println() , imprime el texto entre los paréntesis. Diseccionando mi primer programa Java public class Hello { /** * My first Java program */ public static void main( String[] args ){ //prints the string “Hello world” on screen System.out.println(“Hello world”);

Las siguientes líneas son para cerrar las llaves abiertas para la clase y para el método. Diseccionando mi primer programa Java public class Hello { /** * My first Java program */ public static void main( String[] args ){ //prints the string “Hello world” on screen System.out.println(“Hello world”); } }

Directrices de codificación 1. Tus programas Java deben acabar siempre con la extensión . java 2. Los nombres de archivo debe coincidir con el nombre de su clase pública . Por ejemplo, si el nombre de la clase pública es Hello, debe guardarlo en un archivo llamado Hello.java. 3. Usted debe escribir comentarios en el código que explica lo que hace una cierta clase, o lo que hace un determinado método.

Comentarios Java Comentarios Se trata de notas escritas a un código a efectos de documentación. Estos textos no son parte del programa y no afecta el flujo del programa. 3 tipos de comentarios en Java C++ estilo de comentarios C estilo de comentarios Especial comentarios Javadoc

C++-Style Comments Comienzan con // Todo el texto tras // es tratado como comentario. Por ejemplo: // This is a C++ style or single line comments Comentarios Java

C-Style Comments C-estilo de los comentarios o también llamados comentarios multilínea comienza con un / * y termina con un * /. Todo el texto entre los dos se tratan como comentarios. A diferencia del estilo de comentario de C + +, pueden extenderse a varias líneas. Por ejemplo: /* this is an exmaple of a C style or multiline comments */ Comentarios Java

Comentarios especiales de Javadoc Especial Javadoc comentarios se utilizan para la generación de una documentación HTML para sus programas de Java. Puede crear javadoc comentarios empezando por la línea con /** y termina con */. Al igual que los comentarios de estilo C, también puede abarcar varias líneas . También puede contener ciertas etiquetas para añadir más información a sus comentarios. Por ejemplo: /** This is an example of special java doc comments used for \n generating an html documentation. It uses tags like: @author Florence Balagtas @version 1.2 */ Comentarios Java

Documentación Java API Java http://java.sun.com/reference/api/ JSE http://java.sun.com/j2se/1.5.0/docs/api/ JEE http://java.sun.com/javaee/5/docs/api/

Declaraciones Java Declaración una o más líneas de código, termina con punto y coma. Ejemplo: System.out.println(“Hello world”);

Bloques Java Bloque es de una o más declaraciones limitada por una apertura y cierre de llaves de las declaraciones que los grupos como una unidad. Bloque de declaraciones se pueden anidar indefinidamente. Cualquier cantidad de espacio en blanco está permitido. Ejemplo: public static void main( String[] args ){ System.out.println("Hello"); System.out.println("world”); }

Java declaraciones y directrices de los bloques de codificación 1. En la creación de bloques, puede colocar la llave de apertura de conformidad con la declaración. Por ejemplo: public static void main( String[] args ) { o puede colocar la llave en la línea siguiente, como , public static void main( String[] args )‏ {

2. Usted debe introducir las próximas declaraciones tras el inicio de un bloque. Por ejemplo: public static void main( String[] args ){ System.out.println("Hello"); System.out.println("world"); } Java declaraciones y directrices de los bloques de codificación

Identificadores Java Identificadores son fichas que representan los nombres de variables, métodos, clases, etc. Ejemplos: Hello, main, System, out. Los identificadores Java son sensibles a mayúsculas / minúsculas. Esto significa que el identificador de Hola no es lo mismo que hola.

Identificadores deben comenzar con una letra o bien, un guión de subrayado "_" o un signo de dólar "$". Letras puede ser mayúsculas o minúsculas. Los siguientes caracteres pueden usar números de 0 a 9. No puede utilizar como identificadores las palabras clave de Java, como class, public, void , etc. Identificadores Java

1. Para los nombres de las clases, en mayúscula la primera letra del nombre de clase. Por ejemplo, ThisIsAnExampleOfClassName 2. Para los nombres de los métodos y variables, la primera letra de la palabra debe comenzar con una minúscula. Por ejemplo, thisIsAnExampleOfMethodName Java declaraciones y directrices de los bloques de codificación

3. En el caso de varias palabras identificadores, utilice letras mayúsculas para indicar el inicio de la palabra, excepto la primera palabra. Por ejemplo, charArray, fileNumber, ClassName. 4. Evite el uso de barra baja al comienzo de la identificación como _read o _write. Java declaraciones y directrices de los bloques de codificación

Palabras clave Java Las palabras clave son identificadores predefinidos reservados por Java para un propósito específico. Usted no puede utilizar palabras clave como nombres de variables, clases, métodos ... etc. La siguiente diapositiva contiene la lista de palabras clave de Java.

Literales y Primitivos Los tipos primitivos son tipos de datos especiales incrustados dentro del lenguaje, no son objetos creados de una clase. Un literal es la representación en código fuente de un valor fijo, los literales se representan directamente en su código sin necesidad de computación. Es posible asignar un literal a una variable de un tipo primitivo, como se muestra a continuación: boolean result = true; char capitalC = 'C'; byte b = 100; short s = 10000; int i = 100000;

Literales Java Un valor constante en Java se crea utilizando una representación literal de él. Un literal es la representación en código fuente de un valor fijo, los literales se representan directamente en su código sin necesidad de computación. Los diferentes tipos de literales en Java son: Enteros Coma flotante Booleanos Caracteres Cadenas

Literales Java: Enteros / Integer Integer literals vienen en distintas formas: decimal (base 10)‏ hexadecimal (base 16)‏ octal (base 8).

Decimal Sin una notación especial ejemplo: 12 Hexadecimal Precedido por 0x ó 0X ejemplo: 0xC Octal Precedido por 0 ejemplo: 014 Literales Java: Enteros / Integer

Literales Java: Coma flotante / Floating Point Representa números con punto decimal Ejemplo: 3.1416 Puede ser expresado de manera estándar o con notación científica. Ejemplo : 583.45 (estándar), 5.8345e2 (científico)‏

Literales Java : booleano Sencillamente true o false

Literales Java: char Una variable de tipo char almacena un carácter Unicode. Carácter Unicode Un carácter de 16-bit sustituye el character de 8-bit usado en ASCII. Unicode permite la inclusión de símbolos y caracteres especiales de otros idiomas.

Un literal de tipo char se expresa encerrando el carácter entre comillas simples. Por ejemplo la letra a, se representa como ‘a’ . caracteres especiales, como un carácter de nueva línea, se utiliza una barra invertida seguida por el código de caracteres. Por ejemplo, '\ n' para el carácter de nueva línea, '\ r' para el retorno de carro, '\ b' para retroceder. Literales Java: char

Literales Java: String Un String representa múltiples caracteres. Para indicar una cadena de caracteres se encierran entre comillas dobles. Un ejemplo de Cadena es, “Hello World”.

Tipo de datos Primitivo Llamamos tipos primitivos de un lenguaje cuando hablamos de tipos de datos ya definidos en el lenguaje y de los que se puede partir para la construcción de expresiones o tipos de compuestos. Se definen 8 tipos: boolean char byte short int long double float

Tipo de datos Primitivo: char Un tipo de datos de carácter (char), representa un único carácter Unicode. Se debe tener su literal cerrado entre comillas simples ( ‘’ ). Por ejemplo, ‘a’ //La letra a ‘\t’ //Un tab Para representar los caracteres especiales como '(comillas simples) o "(comillas dobles), utilice el carácter de escape \. Por ejemplo, '\'' //comillas simples '\"' //comillas dobles

Tipo de datos Primitivo: Entero – byte, short, int & long Tipo de datos entero en Java utiliza tres formas – decimal, octal or hexadecimal. Ejemplos, 2 //el valor decimal 2 077 //el 0 indica un valor octal 0xBACC //el 0x indica un valor hexadecimal Tipo Entero tiene a int como tipo de datos predeterminado. Usted puede definir su valor a Long añadiendo la letra l ó L. Por ejemplo: 10L

Rango de tipo de datos enteros: Tipo de datos Primitivo: Entero – byte, short, int & long

Tipo de datos Primitivo: Floating Point – float and double Floating point tiene double como tipo de dato por defecto. De punto flotante, ya sea literal incluye un punto decimal o uno de los siguientes, E or e //(add exponential value) F or f //(float) D or d //(double) Ejemplos, 3.14 //A simple floating-point value (a double) 6.02E23 //A large floating-point value 2.718F //A simple float size value 123.4E+306D//A large double value with redundant D

Tipo de datos Primitivo: Floating Point – float and double Rango de coma flotante:

Tipo de datos Primitivo: Resumen

Variables Las variables son la manera en que indicamos al compilador el espacio en memoria que debe de reservar para almacenar la información. Una variable tiene: Tipo de dato El tipo de datos indica el tipo de valor que la variable puede contener. nombre El nombre de la variable debe seguir las reglas para los identificadores.

Declarando e inicializando Variables Declara una variable de la siguiente manera : <data type> <name> [=initial value]; Nota: Los valores encerrados en <> son valores necesarios, mientras que los valores en [] son opcionales.

Declarando e inicializando Variables : Ejemplo public class VariableSamples { public static void main( String[] args ){ //declare a data type with variable name // result and boolean data type boolean result; //declare a data type with variable name // option and char data type char option; option = 'C'; //assign 'C' to option //declare a data type with variable name //grade, double data type and initialized //to 0.0 double grade = 0.0; } }

Declarando e inicializando Variables: Directrices de codificación 1. Es siempre bueno inicializar las variables cuando se declaran . 2. Utilice nombres descriptivos de las variables. Como por ejemplo, si usted quiere tener una variable que contiene un grado de un estudiante, como nombre, categoría y no sólo algunas letras al azar que usted elija.

3. Declarar una variable en cada línea de código. Por ejemplo, la declaraciones de variables, double exam=0; double quiz=10; double grade = 0; es preferible a lo siguiente, double exam=0, quiz=10, grade=0; Declarando e inicializando Variables: Directrices de codificación

Salida de datos de variables Con el fin de mostrar el valor de una determinada variable, podemos usar los siguientes comandos: System.out.println() System.out.print()

Salida de datos de variables: Programa ejemplo public class OutputVariable { public static void main( String[] args ){ int value = 10; char x; x = ‘A’; System.out.println( value ); System.out.println( “The value of x=“ + x ); } } El programa mostrará lo siguiente por pantalla: 10 The value of x=A

System.out.println() vs. System.out.print() System.out.println()‏ Añade una nueva línea al final de la salida de datos System.out.print() No añadir una nueva línea al final de la salida de datos

Programa 1: Output: HelloWorld Programa 2: Output: Hello World System.out.print(“Hello”); System.out.print(“World”); System.out.println(“Hello”); System.out.println(“World”); System.out.println() vs. System.out.print()

Variables por Referencia vs. Variables primitivas Dos tipos de variables en Java: Variables primitivas Variables de referencia Variables primitivas variables con tipos de datos primitivos como int o largo. almacena los datos en la memoria real de la ubicación donde la variable está

Variables de referencia las variables que almacena la dirección en la ubicación de la memoria apunta a otra ubicación de memoria donde los datos reales están Cuando declara una variable de una determinada clase, en realidad está declarando una variable de referencia con el objeto de cierta clase. Variables por Referencia vs. Variables primitivas

Ejemplo Supongamos que tenemos dos variables con tipos de datos int y string. int num = 10; // primitive type String name = "Hello"; // reference type

Ejemplo La imagen se muestra a continuación es la memoria de su ordenador, que tiene la dirección de la memoria de las células, el nombre de la variable y los datos que posean.

Operadores Distintos tipos de operadores : operadores aritméticos operadores relacionales operadores lógicos operadores condicionales Estos operadores siguen un cierto tipo de preferencia para que el compilador sepa que operador evaluar en primer lugar en caso de múltiples operadores en una misma declaración.

Operadores Aritméticos: Ejemplo de programa public class ArithmeticDemo { public static void main(String[] args){ //a few numbers int i = 37; int j = 42; double x = 27.475; double y = 7.22; System.out.println("Variable values..."); System.out.println(" i = " + i); System.out.println(" j = " + j); System.out.println(" x = " + x); System.out.println(" y = " + y); System.out.println("Adding..."); System.out.println(" i + j = " + (i + j)); System.out.println(" x + y = " + (x + y));

Operadores Aritméticos: Ejemplo de programa //subtracting numbers System.out.println("Subtracting..."); System.out.println(" i - j = " + (i – j)); System.out.println(" x - y = " + (x – y)); //multiplying numbers System.out.println("Multiplying..."); System.out.println(" i * j = " + (i * j)); System.out.println(" x * y = " + (x * y)); //dividing numbers System.out.println("Dividing..."); System.out.println(" i / j = " + (i / j)); System.out.println(" x / y = " + (x / y));

Operadores Aritméticos: Ejemplo de programa //computing the remainder resulting from dividing // numbers System.out.println("Computing the remainder..."); System.out.println(" i % j = " + (i % j)); System.out.println(" x % y = " + (x % y)); //mixing types System.out.println("Mixing types..."); System.out.println(" j + y = " + (j + y)); System.out.println(" i * x = " + (i * x)); } }

Operadores Aritméticos: Ejemplo de programa Variable values... i = 37 j = 42 x = 27.475 y = 7.22 Adding... i + j = 79 x + y = 34.695 Subtracting... i - j = -5 x - y = 20.255 Multiplying... i * j = 1554 x * y = 198.37 Dividing... i / j = 0 x / y = 3.8054 Computing the remainder... i % j = 37 x % y = 5.815 Mixing types... j + y = 49.22 i * x = 1016.58

¿Qué pasa si los operandos no son del mismo tipo? Se convierten automáticamente según el siguiente orden de generalidad: byte  short  int  long  float  double El resultado de una expresión se convierte al tipo más general Operadores Aritméticos

Ejemplos: double goodDouble = 17.5 + 4; int badInt = 5 – 3.0; float goodFloat = 491 + 5162631234L; float badFloat = 16.2 / 7; ¡A veces el resultado no es lo que uno desea! double cociente = 15 / 4; Operadores Aritméticos

Los operadores de incremento y decremento incremento operador de unidad(++) decremento operador de unidad(--)‏ Operadores de incremento y decremento aumentan y disminuyen un valor almacenado en un número variable más 1. Por ejemplo, count=count + 1;//increment the value of count by 1 es lo mismo que, count++;

Los operadores de incremento y decremento

Los operadores de incremento y decremento se pueden colocar antes o después de un operando. Cuando se utiliza antes de un operando, que provoca la variable que se incrementa o decrementa en 1, y luego el nuevo valor se utiliza en la expresión en la que aparece Por ejemplo, Los operadores de incremento y decremento int i = 10; int j = 3; int k = 0; k = ++j + i; //will result to k = 4+10 = 14

Los operadores de incremento y decremento Cuando los operadores de incremento y decremento se colocan después del operando, el antiguo valor de la variable se utiliza en la expresión que aparece. Por ejemplo, int i = 10; int j = 3; int k = 0; k = j++ + i; //will result to k = 3+10 = 13

Los operadores de incremento y decremento: Directrices de codificación Siempre mantenga las expresiones que contienen operadores de incremento y decremento simple y fácil de entender.

Operadores relacionales Los operadores relacionales comparan dos valores y determina la relación entre esos valores. El resultado de la evaluación son los valores booleanos verdadero o falso.

Operadores relacionales: Programa de ejemplo public class RelationalDemo{ public static void main(String[] args){ //a few numbers int i = 37; int j = 42; int k = 42; System.out.println("Variable values..."); System.out.println(" i = " +i); System.out.println(" j = " +j); System.out.println(" k = " +k); //greater than System.out.println("Greater than..."); System.out.println(" i > j = "+(i>j));//false System.out.println(" j > i = "+(j>i));//true System.out.println(" k > j = "+(k>j));//false

Operadores relacionales: Programa de ejemplo //greater than or equal to System.out.println("Greater than or equal to..."); System.out.println(" i >= j = "+(i>=j));//false System.out.println(" j >= i = "+(j>=i));//true System.out.println(" k >= j = "+(k>=j));//true //less than System.out.println("Less than..."); System.out.println(" i < j = "+(i<j));//true System.out.println(" j < i = "+(j<i));//false System.out.println(" k < j = "+(k<j));//false //less than or equal to System.out.println("Less than or equal to..."); System.out.println(" i <= j = "+(i<=j));//true System.out.println(" j <= i = "+(j<=i));//false System.out.println(" k <= j = "+(k<=j));//true

Operadores relacionales: Programa de ejemplo //equal to System.out.println("Equal to..."); System.out.println(" i == j = " + (i==j));//false System.out.println(" k == j = " + (k==j));//true //not equal to System.out.println("Not equal to..."); System.out.println(" i != j = " + (i!=j));//true System.out.println(" k != j = " + (k!=j));//false } }

Operadores relacionales: Programa de ejemplo output Variable values... i = 37 j = 42 k = 42 Greater than... i > j = false j > i = true k > j = false Greater than or equal to... i >= j = false j >= i = true k >= j = true Less than... i < j = true j < i = false k < j = false Less than or equal to... i <= j = true j <= i = false k <= j = true Equal to... i == j = false k == j = true Not equal to... i != j = true k != j = false

Operadores Lógicos tienen uno o dos operandos booleanos que producen un resultado booleano . Hay seis operadores lógicos: O lógica boolean binario | Y lógica boolean binario && NO boolean unario ! O exclusiva boolean binario ^ O lógica boolean binario || Y lógica boolean binario & Significado Operandos Categoría

Operadores Lógicos La expresión básica para una operación es, x1 op x2 donde, x1, x2 – pueden ser expresiones booleana, variables o constantes. La tabla que se muestra a continuación resume el resultado de cada operación para todas las posibles combinaciones de x1 y x2.

Tabla de verdad para && y &, Operadores Lógicos: &&(logical) and &(boolean logical) AND

La diferencia básica entre && y & operadores: && soporta evaluaciones parciales, mientras que & no lo soporta.

Dada una expresión: exp1 && exp2 Evaluará la expresión exp1, y de inmediato devolverá false si exp1 es falso. Si exp1 es false, el operador nunca evaluara exp2 porque el resultado del operador será falso independientemente del valor de exp2. En cambio, el operador & siempre evalúa ambos antes de devolver un valor. Operadores Lógicos: &&(logical) y &(boolean logical) AND

Operadores Lógicos: &&(logical) y &(boolean logical) AND public class TestAND { public static void main( String[] args ){ int i = 0; int j = 10; boolean test= false; //demonstrate && test = (i > 10) && (j++ > 9); System.out.println(i); System.out.println(j); System.out.println(test); //demonstrate & test = (i > 10) & (j++ > 9); System.out.println(i); System.out.println(j); System.out.println(test); } }

La salida del programa es, 0 10 false 0 11 false Tenga en cuenta que la j++ en la línea que contiene el operador && no se evalúa desde la primera expresión (i> 10) ya que es igual a false. Operadores Lógicos: &&(logical) y &(boolean logical) AND

Operadores Lógicos: || (logical) y | (boolean logical) inclusive OR Tabla de verdad para || y |,

La diferencia básica entre | | y | operadores: && soporta evaluaciones parciales, mientras que & no lo soporta.

Dada la expresión: exp1 || exp2 Evaluará la expresión exp1, y de inmediato devolverá true si exp1 es true. Si exp1 es true, el operador nunca evaluara exp2 porque el resultado del operador será true independientemente del valor de exp2. En cambio, el operador | siempre evalúa ambos antes de devolver un valor. Operadores Lógicos: || (logical) y | (boolean logical) inclusive OR

Operadores Lógicos: || (logical) y | (boolean logical) inclusive OR public class TestOR { public static void main( String[] args ){ int i = 0; int j = 10; boolean test= false; //demonstrate || test = (i < 10) || (j++ > 9); System.out.println(i); System.out.println(j); System.out.println(test); //demonstrate | test = (i < 10) | (j++ > 9); System.out.println(i); System.out.println(j); System.out.println(test); } }

La salida del programa es, 0 10 true 0 11 true Tenga en cuenta que la j++ en la línea que contiene el operador && no se evalúa desde la primera expresión (i> 10) ya que es igual a true. Operadores Lógicos: || (logical) y | (boolean logical) inclusive OR

Operadores Lógicos: ^ (boolean logical exclusive OR) Tabla de verdad para ^, El resultado de una operación exclusiva OR es TRUE, si y sólo si un operando es true y el otro es false. Tenga en cuenta que ambos operandos deben siempre ser evaluados con el fin de calcular el resultado de un exclusivo OR.

Operadores Lógicos: ^ (boolean logical exclusive OR)‏ public class TestXOR { public static void main( String[] args ){ boolean val1 = true; boolean val2 = true; System.out.println(val1 ^ val2); val1 = false; val2 = true; System.out.println(val1 ^ val2); val1 = false; val2 = false; System.out.println(val1 ^ val2); val1 = true; val2 = false; System.out.println(val1 ^ val2); } }

La salida del programa es, false true false true Operadores Lógicos: ^ (boolean logical exclusive OR)‏

Operadores Lógicos: ! ( logical NOT)‏ El NOT lógico puesto en un argumento, cuando ese argumento puede ser una expresión, variable o constante. Tabla de verdad para !,

Operadores Lógicos: ! ( logical NOT)‏ La salida del programa es, false true public class TestNOT { public static void main( String[] args ){ boolean val1 = true; boolean val2 = false; System.out.println(!val1); System.out.println(!val2); } }

Operadores Lógicos: Conditional Operator (?:)‏ El operador condicional?: es un operador ternario. Esto significa que se toma en tres argumentos que forman juntos una expresión condicional . La estructura de una expresión utilizando un operador condicional es exp1?exp2:exp3 donde, exp1 – es una expresión booleana cuyo resultado deber ser true o false. Resultado: Si exp1 es true, exp2 es el valor devuelto. Si es false, entonces exp3 es devuelto.

Operadores Lógicos: Conditional Operator (?:)‏ La salida de este programa es, Passed public class ConditionalOperator { public static void main( String[] args ){ String status = ""; int grade = 80; //get status of the student status = (grade >= 60)?"Passed":"Fail"; //print status System.out.println( status ); } }

Operadores Lógicos: Conditional Operator (?:)‏

Prioridad y Asociatividad Determinan el orden de evaluación Los operadores se evalúan en orden de prioridad Si dos operadores tienen la misma prioridad, se evalúan según asociatividad Asociatividad izquierda-derecha significa que el operador a la izquierda se evalúa primero Siempre se puede utilizar paréntesis para cambiar el orden de evaluación

Prioridad de Operadores der-izq asignación = += -= *= /= %= 10 izq-der O lógica || 9 izq-der Y lógica && 8 izq-der O exclusiva ^ 7 izq-der igual/distinto == != 6 izq-der mayor/menor > >= < <= 5 izq-der ad/sust/concatenación + - + 4 izq-der mult/div/resto * / % 3 der-izq sgn/inc/dec/NO/casting + - ++ -- ! (tipo) 2 paréntesis () 1

Dada una expresión complicada, 6%2*5+4/2+88-10 podemos volver a escribir la expresión y colocar algunos paréntesis basado el la prioridad de operadores, ((6%2)*5)+(4/2)+88-10; Prioridad de Operadores

Prioridad de Operadores: Directrices de codificación Para evitar confusiones en la evaluación de las operaciones matemáticas, mantener su uso de expresiones sencillas y paréntesis .

Fundamentos de programación Java

Más contenido relacionado

La actualidad más candente

Destacado

Similar a Fundamentos de programación Java

Fundamentos de programación Java