fundamentos de programación java

Fundamentos programación Java 1

Fundamentos de programación


Diseccionando mi primer programa Java

1 public class Hello2 {3 /**4 * My first Java program5 */6 public static void main( String[] args ){

7 //prints the string Hello world on screen8 System.out.println(“Hello world”);

9 }10 }


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

1 public class Hello2 {3 /**4 * My first Java program5 */



1 public class Hello 2 {3 /**4 * My first Java program5 */

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{



La siguiente línea es un comentario en Java

1 public class Hello 2 {3 /**4 * My first Java program5 */



Indica el nombre del método principal de la clase Hello

1 public class Hello 2 {3 /**4 * My first Java program5 */6 public static void main( String[] args ){




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


Otra manera de hacer un comentario en Java


7 //prints the string “Hello world” on screen



El comando System.out.println(), imprime el texto entre los paréntesis.



8 System.out.println(“Hello world”);



Las siguientes líneas son para cerrar las llaves abiertas para la clase y para el método.



8 System.out.println(“Hello world”);

9 }10 }



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");

}



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



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.



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.


Palabras clave 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

1 public class VariableSamples { 2 public static void main( String[] args ){ 3 //declare a data type with variable name 4 // result and boolean data type 5 boolean result;

6 //declare a data type with variable name 7 // option and char data type 8 char option; 9 option = 'C'; //assign 'C' to option

10 //declare a data type with variable name 11 //grade, double data type and initialized 12 //to 0.0 13 double grade = 0.0; 14 }15 }


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

1 public class OutputVariable {2 public static void main( String[] args ){3 int value = 10;4 char x;5 x = ‘A’;

6 System.out.println( value );7 System.out.println( “The value of x=“ + x );8 }9 }

El programa mostrará lo siguiente por pantalla:

10The 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:HelloWorld

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 typeString 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


Operadores Aritméticos: Ejemplo de programa

1 public class ArithmeticDemo {2 public static void main(String[] args){3 //a few numbers4 int i = 37;5 int j = 42;6 double x = 27.475;7 double y = 7.22;8 System.out.println("Variable values...");9 System.out.println(" i = " + i);10 System.out.println(" j = " + j);11 System.out.println(" x = " + x);12 System.out.println(" y = " + y);

System.out.println("Adding...");13 System.out.println(" i + j = " + (i + j));14 System.out.println(" x + y = " + (x + y));


15 //subtracting numbers16 System.out.println("Subtracting...");17 System.out.println(" i - j = " + (i – j));18 System.out.println(" x - y = " + (x – y));

19 //multiplying numbers20 System.out.println("Multiplying...");21 System.out.println(" i * j = " + (i * j));22 System.out.println(" x * y = " + (x * y));

23 //dividing numbers24 System.out.println("Dividing...");25 System.out.println(" i / j = " + (i / j));26 System.out.println(" x / y = " + (x / y));



29 //computing the remainder resulting from dividing30 // numbers31 System.out.println("Computing the remainder...");32 System.out.println(" i % j = " + (i % j));33 System.out.println(" x % y = " + (x % y));

34 //mixing types35 System.out.println("Mixing types...");36 System.out.println(" j + y = " + (j + y));37 System.out.println(" i * x = " + (i * x));38 } 39}



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



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;



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 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,

int i = 10; int j = 3; int k = 0; k = ++j + i; //will result to k = 4+10 = 14




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

1 public class RelationalDemo{2 public static void main(String[] args){3 //a few numbers4 int i = 37;5 int j = 42;6 int k = 42;7 System.out.println("Variable values...");8 System.out.println(" i = " +i);9 System.out.println(" j = " +j);10 System.out.println(" k = " +k);11 //greater than12 System.out.println("Greater than...");13 System.out.println(" i > j = "+(i>j));//false14 System.out.println(" j > i = "+(j>i));//true15 System.out.println(" k > j = "+(k>j));//false


16 //greater than or equal to17 System.out.println("Greater than or equal to...");18 System.out.println(" i >= j = "+(i>=j));//false19 System.out.println(" j >= i = "+(j>=i));//true20 System.out.println(" k >= j = "+(k>=j));//true21 //less than22 System.out.println("Less than...");23 System.out.println(" i < j = "+(i<j));//true24 System.out.println(" j < i = "+(j<i));//false25 System.out.println(" k < j = "+(k<j));//false26 //less than or equal to27 System.out.println("Less than or equal to...");28 System.out.println(" i <= j = "+(i<=j));//true29 System.out.println(" j <= i = "+(j<=i));//false30 System.out.println(" k <= j = "+(k<=j));//true



31 //equal to32 System.out.println("Equal to...");33 System.out.println(" i == j = " + (i==j));//false34 System.out.println(" k == j = " + (k==j));//true 35 //not equal to36 System.out.println("Not equal to...");37 System.out.println(" i != j = " + (i!=j));//true38 System.out.println(" k != j = " + (k!=j));//false39 }40 }



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 relacionales: Programa de ejemplo output


Operadores Lógicos• tienen uno o dos operandos booleanos que producen un

resultado booleano . • Hay seis operadores lógicos:

Categoría Operandos Significado

&& binario boolean Y lógica

& binario boolean Y lógica

|| binario boolean O lógica

| binario boolean O lógica

^ binario boolean O exclusiva

! unario boolean NO


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


1 public class TestAND {2 public static void main( String[] args ){3 int i = 0;4 int j = 10;5 boolean test= false;6 //demonstrate &&7 test = (i > 10) && (j++ > 9);8 System.out.println(i);9 System.out.println(j);10 System.out.println(test);11 //demonstrate &12 test = (i > 10) & (j++ > 9);13 System.out.println(i);14 System.out.println(j);15 System.out.println(test);16 }17 }



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



1 public class TestOR {2 public static void main( String[] args ){3 int i = 0;4 int j = 10;5 boolean test= false;6 //demonstrate ||7 test = (i < 10) || (j++ > 9);8 System.out.println(i);9 System.out.println(j);10 System.out.println(test);11 //demonstrate |12 test = (i < 10) | (j++ > 9);13 System.out.println(i);14 System.out.println(j);15 System.out.println(test);16 }17 }



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: ^ (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.



1 public class TestXOR {2 public static void main( String[] args ){3 boolean val1 = true;4 boolean val2 = true;5 System.out.println(val1 ^ val2);6 val1 = false; val2 = true;7 System.out.println(val1 ^ val2);8 val1 = false; val2 = false;9 System.out.println(val1 ^ val2);10 val1 = true; val2 = false;11 System.out.println(val1 ^ val2);12 }13 }


La salida del programa es, false true false true



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)

1 public class TestNOT {2 public static void main( String[] args ){3 boolean val1 = true;4 boolean val2 = false;5 System.out.println(!val1);6 System.out.println(!val2);7 } 8 }

La salida del programa es, false true


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.



1 public class ConditionalOperator {2 public static void main( String[] args ){3 String status = "";4 int grade = 80;5 //get status of the student6 status = (grade >= 60)?"Passed":"Fail";7 //print status8 System.out.println( status );9 }10 }

La salida de este programa es, Passed


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 Operadores1 () paréntesis

2 + - ++ -- ! (tipo) sgn/inc/dec/NO/casting der-izq

3 * / % mult/div/resto izq-der

4 + - + ad/sust/concatenación izq-der

5 > >= < <= mayor/menor izq-der

6 == != igual/distinto izq-der

7 ^ O exclusiva izq-der

8 && Y lógica izq-der

9 || O lógica izq-der

10 = += -= *= /= %= asignación der-izq


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

Documents

java program

los identificadores

comentarios en java

clase hello public class

bloques java bloque

string hello world

sus comentarios

programa y