Palabras reservadas en java

  1 /*
  2  * To change this template, choose Tools | Templates
  3  * and open the template in the editor.
  4  */
  5 
  6 package pruebas;
  7 
  8 import java.io.Serializable;
  9 import java.util.GregorianCalendar;
 10 
 11 /**
 12  *
 13  * @author Igor
 14  */
 15 public class PalabrasReservadas {
 16     /*
 17      * PALABRAS RESERVADAS EN JAVA
 18      *
 19      * (1)boolean, por ejemplo se utiliza para la declaracion de variables
 20      * de este tipo, o como tipo de retorno de un método.
 21      * ejemplo:
 22      */
 23     boolean band = false;
 24     boolean existe = true;
 25     //por defecto se inicializa con false
 26     static boolean numeroPrimo;
 27 
 28     /*
 29      * (2)byte, para la declaracion de variables de tipo entero de 2 bytes.
 30      * rango: [-128~127]
 31      * ejemplo:
 32      */
 33     byte var;
 34     byte x;
 35     byte y = 100;
 36 
 37     /*
 38      * (3)char, tipo de dato primitivo para la declaracion de variables
 39      * tipo caracter. rango[0~65535]
 40      * ejemplo:
 41      */
 42     char Letra = 'A';
 43     char vocal = 'a';
 44     char andpersand = '&';
 45 
 46     /*
 47      * (4)double, para la declaracion de variables de tipo coma flotante
 48      * con una precisión de 64 bits (8 bytes), las variables declaradas
 49      * con este tipo alamacenan aproximaciones de los numeros reales.
 50      */
 51     double largoRectangulo = 5.89;
 52     double coeficienteCorrelacion;
 53     double totalIntereses;
 54     double promedioNotas;
 55     double cantidadBytes;
 56     double tamañoCelula;
 57     double cantidadCompuesto;
 58 
 59     /*
 60      * (5)float, para la declaracion de variables de ese tipo. 
 61      * ejemplo:
 62      */
 63     float sueldo;
 64     float perimetro;
 65     float area;
 66 
 67     /*
 68      * (6)int, tipo de dato primitivo para la declaracion de enteros
 69      * de 32 bits. rango[-2147483648~2147483647]
 70      * ejemplo:
 71      */
 72     int numero;
 73     int edad;
 74     int año;
 75     int cantidadProductos;
 76 
 77     /*
 78      * (7)long, tipo de dato primitivo para la declaración de enteros
 79      * de 64 bits. rango[-9223372036854775808~9223372036854775807]
 80      * ejemplo:
 81      */
 82     long num;
 83     long numeroLargo;
 84 
 85     /*
 86      * (8)short, tipo de dato primitivo para la declaracion de enteros
 87      * de 16 bits rango[-32768~32767].
 88      * ejemplo:
 89      */
 90     short n;
 91     short sum;
 92 
 93     /*
 94      * (9)void, se utiliza para indicar a un método que no devuelva nada
 95      * ejemplo:
 96      */
 97 
 98     public class Persona{
 99         private String nombre;
100 
101         public void AsignarNombre(String nuevoNombre){
102             this.nombre = nuevoNombre;
103         }
104     }
105 
106     /*
107      * (10)true, como valor de inicializacion o asignacion de una variable
108      * de tipo boolean o como valor de retorno de un metodo.
109      *
110      * (11) false, como valor de inicializacion o asignacion de una variable
111      * de tipo boolean o como tipo de retorno de un metodo.
112      * ejemplo:
113      */
114     public class Operaciones{
115 
116         public boolean NumeroPrimo(int nuevoNumero){
117             int mitad = nuevoNumero/2;
118             boolean primo = false;
119             while(mitad>1){
120                 if((nuevoNumero % mitad == 0) && primo == false ){
121                     primo = true;
122                 }
123                 mitad--;
124             }
125             if(primo == true){
126                 return false;
127             }
128             else{
129                 return true;
130             }
131         }
132     }
133 
134     /*
135      * (12)null, las variables que no son de tipo primitivo se les conoce
136      * como objetos, un objeto es una variable que instancia una clase
137      * y se tiene que hacer que apunte a un objeto.
138      * se inicializa o asigna null a las variables que no apuntan a un objeto
139      * ejemplo:
140      */
141     String nombre = null;
142     GregorianCalendar fecha = null;
143     Persona persona = null;
144     Integer listaNum[] = null;
145     String listaNombres[] = null;
146 
147     /*
148      * (13)abstract, para indicar que una clase o metodo es abstracto, se
149      * usa en herencia, se declara abstract a la clase padre
150      * ejemplo:
151      */
152     public abstract class Empleado{
153         String id;
154         String nombre;
155         String sueldo;
156 
157         //este metodo por declararse abstract no se implementa
158         //lo implementara la clase hija que herede de empleado
159         public abstract float CalcularPagoDescuentoAFP();
160     }
161 
162     /*
163      * (14)final, no permite que se modifique el valor de una constante.
164      * ejemplo:
165      */
166     public final static double CTE_RAZON_DORADA = 0.618;
167 
168     /*
169      * (15)native, no tengo referencias por ahora ^^
170      */
171 
172     /*
173      * (16)private, es un alcance en java que se le asigna a un miembro(
174      * atributo o método) o una clase, que solo es visible dentro del
175      * archivo de código fuente java
176      */
177     //un atributo
178     private String codEmpleado;
179 
180     //un método
181     private String getCódigoEmpleado(){
182         return codEmpleado;
183     }
184 
185     //una clase
186     private class Encriptacion{
187         String codGenerador;
188     }
189 
190     /*
191      * (17)protected, para indicar que un mienbro o clase tiene alcande
192      * protejido, su visibilidad es a nivel de paquete y de las clases
193      * que se heredan.
194      * ejemplo:
195      */
196     //la clase padre Animal
197     public abstract class Animal{
198         protected String nombre;
199         protected float peso;
200         protected int edad;
201     }
202 
203     //la clase hija Mamifero que hereda de animal
204     public class Mamifero extends Animal{
205         protected String lugarProcedencia;
206 
207         public Mamifero(String nombre, float peso, int edad
208                 ,String lugarProcedencia) {
209             this.nombre = nombre;
210             this.peso = peso;
211             this.edad = edad;
212             this.lugarProcedencia = lugarProcedencia;
213         }
214     }
215 
216     /*
217      * (18)public, para indicar que un miembro o una clase tiene alcance
218      * public que es visible desde cualquier parte.
219      */
220     public class Celular{
221         public String marca;
222         public String modelo;
223         public double precio;
224 
225         public Celular(){
226             marca = "no definido";
227             modelo = "no definido";
228             precio = 0.0;
229         }
230     }
231 
232     /*
233      * (19)static, para indicar si una clase es statica, o si un miembro
234      * es de clase
235      */
236     //clase estatica
237     public static class FechaIngreso{
238         int dia;
239         int mes;
240         int año;
241 
242         public FechaIngreso() {
243             dia = 1;
244             mes = 1;
245             año = 1800;
246         }
247     }
248 
249     public static class OperacionesArray{
250 
251         //un metodo estatico o de clase
252         public static int sumarNumerosArray(int lista[]){
253             int suma = 0;
254             for(int i = 0; i<lista.length; i++){
255                 suma +=lista[i];
256             }
257             return suma;
258         }
259     }
260 
261     /*
262      * (20)synchronized, esta palabra reservada se usa para indicar que
263      * ciertas partes de código(habitualmente un metodo), estan
264      * sincronizadas, es decir, que solamente un subproceso puede
265      * acceder a dicho método a la vez. mas adelante se tratará de este
266      * tema.
267      */
268 
269     synchronized
270     /*
271      * (21)transient, denomina atributos que no se graban cuando se archiva
272      * un objeto, osea que no forman parte del estado permanente del mismo
273      */
274     transient
275             
276     /*
277      * (22)volatile, se utiliza con variables modificadas asincrónicamente
278      * por objetos en diferentes threads(hilos, tareas que se ejecutan
279      * en paralelo), esto implica que distintas tareas pueden modificar
280      * la variable simultaneamente, y volatile asegura que se vuelva a 
281      * a leer la variable(por si fue modificada) cada vez que se la va
282      * a usar(esto es, en lugar de usar registros de alamacenamiento como 
283      * buffer.
284      */
285     volatile
286 
287     /*
288      * (23)strictfp, utilizada para restringir calculos de coma flotante
289      * para garantizar la portabilidad.
290      */
291     //strictfp
292 
293      /*
294       * (24)break, es de tipo de control de bucles, dentro de la iteracion
295       * de un bucle, de cualquiera de los tipos(while, for, do while), el
296       * uso de esta sentencia rompe la iteracion de dicho bucle.
297       * ejemplo:
298       */
299      public static String CuentaDigitos(int num){
300         int numDigitos = 0;
301         while(num>0){
302             num /=10;
303             numDigitos++;
304             if(numDigitos == 5){
305                 break;
306             }
307         }
308         if(numDigitos == 5){
309             return "el numero tiene 5 o más dígitos";
310         }
311         else{
312             return "el numero tiene menos de 5 dígitos";
313         }
314     }
315 
316      /*
317       * (25)case, utilizado para presentar los casos de seleccion multiple
318       * dentro de un bloque switch.
319       * ejemplo:
320       */
321      public class Fecha{
322          int d;
323          int m;
324          int a;
325          
326          public String nombreMes(int numMes){
327              String nomMes = "";
328              switch(numMes){
329                  case 1:
330                      nomMes = "Enero";
331                      break;
332                  case 2:
333                      nomMes = "Febrero";
334                      break;
335                  case 3:
336                      nomMes = "Marzo";
337                      break;
338                  case 4:
339                      nomMes = "Abril";
340                      break;
341                  case 5:
342                      nomMes = "Mayo";
343                      break;
344                  case 6:
345                      nomMes = "Junio";
346                      break;
347                  case 7:
348                      nomMes = "Julio";
349                      break;
350                  case 8:
351                      nomMes = "Agosto";
352                      break;
353                  case 9:
354                      nomMes = "Setiembre";
355                      break;
356                  case 10:
357                      nomMes = "Octubre";
358                      break;
359                  case 11:
360                      nomMes = "Noviembre";
361                      break;
362                  case 12:
363                      nomMes = "Diciembre";
364                      break;
365                  default:
366                      nomMes = "Fuera de Rango";
367                      break;                         
368              }
369              return nomMes;
370          }
371          public String fecha(){
372              return d+"-"+nombreMes(m)+"-"+a;
373          }
374      
375      /*
376       * (26)catch, para capturar la excepcion que podrian causar algunas lineas
377       * de código.
378       * Es el código que se ejecuta cuando se produce la
379       * excepción. No hay código alguno entre un bloque try y un
380       * bloque catch, ni entre bloques catch.
381       * ejemplo:
382       */
383       public class Conversiones{
384           
385           public int RetornaEntero(String numero){
386               int num = 0;
387               try{
388                   num = Integer.parseInt(numero);
389               //se usa esta sentencia para capturar la excepcion    
390               }catch(Exception ex){
391                   System.out.println("Excepcion: "+ex.getMessage());
392               }
393               return num;
394           }
395       }
396       
397       /*
398        * (27)continue, para detener unicamente la iteracion actual y saltar
399        * a la siguiente
400        */
401 
402       /*
403        * (28)default, se usa en el bloque de la sentencia switch como un
404        * caso por defecto
405        */
406 
407       /*
408        * (29)do, parte de la sentencia de un bucle do-while
409        */
410       public class Operacion{
411 
412           public int CuentaDigitos(int num){
413               int numDig = 0;
414               do{
415                   numero /= 10;
416                   numDig++;
417               }while(num>0);
418               return numDig;
419           }
420       }
421 
422       /*
423        * (30)else, en las estructuras condicionales else es en español
424        * de otro modo.
425        */
426       public boolean numeroImpar(int num){
427           if(num%2 == 0){
428               return false;
429           }
430           else{
431               return true;
432           }
433       }
434       /*
435        * (31)finally.
436        * En ocasiones, nos interesa ejecutar un fragmento de código
437        * independiente de si se produce o no una excepción (por
438        * ejemplo, cerrar un archivo que estemos manipulando o una
439        * conexión a una fuente de datos).
440        */
441 
442       /*
443        * (32)for, sentecia que utiliza el bucle for
444        */
445       public int SumaHasta(int n){
446           int num = 0;
447           for(int i = 0; i<=n; i++){
448               num += i;
449           }
450           return num;
451       }
452 
453       /*
454        * (33)if, en el uso de sentencias selectivas luego de esta sentencia
455        * va la condicion que se evalua.
456        */
457 
458       /*
459        * (34)return, indica el valor que devuelve un metodo.
460        */
461 
462       /*
463        * (35)swicth, utilizada en una estructura de selección multiple.
464        */
465 
466       /*
467        * (36)throw,
468        * La sentencia throw se utiliza para lanzar explícitamente una
469        * excepción.
470        */
471 
472       /*
473        * (37)try, se utiliza esta sentencia en el
474        * bloque de código donde se prevé que se genere una
475        * excepción. El bloque try tiene que ir seguido, al menos, por
476        * una cláusula catch o una cláusula finally.
477        */
478 
479       /*
480        * (38)while, sentencia usada para el bucle while
481        */
482 
483       /*
484        * (39)class, para indicar que lo que viene despues es una clase
485        * ejemplo:
486        */
487       public class Ordenador{
488           //por implementar...
489       }
490 
491       /*
492        * (40)extends, para indicar que una clase hereda de otra.
493        * ejemplo:
494        */
495       public abstract class Felino{
496           //por implementar...
497       }
498       public class Gato extends Felino{
499           //por implementar
500       }
501 
502       /*
503        * (41)implements, para indicar que la clase implementa una o varias
504        * interfaces.
505        * ejemplo:
506        */
507       public class Alumno implements Serializable{
508           //por implementar
509       }
510 
511       /*
512        * (42)interface, para indicar que lo que viene despues es una
513        * interface.
514        * ejemplo:
515        */
516       public interface Calculos{
517 
518               public double calcularArea();
519       }
520 
521       /*
522        * (43)throws, se coloca al principio del método indicando que tipo
523        * de excepcion puede lanzar, utilizado para propagar la excepcion.
524        */
525 
526       /*
527        * (44)import, para importar clases externas al paquete.
528        */
529 
530       /*
531        * (45)package, para indicar el nombre de un paquete. se coloca al
532        * inicio del código fuente.
533        */
534 
535       /*
536        * (46)instanceof, se utiliza para averiguar si una instancia
537        * pertenece a una determinada clase.
538        */
539 
540       /*
541        * (47)new, para la creacion de un objeto, luego de esta sentencia
542        * se hace un llamado al constructor de la clase.
543        */
544 
545       /*
546        * (48)super, en herencia, llama al constructor de la clase de la que
547        * se hereda.
548        */
549 
550       /*
551        * (49)this, cuando un constructor utiliza a otro constructor dentro
552        * de una clase.
553        */
554 
555   }
556 
557 }
558 
559