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 

Declaración de variables 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.util.GregorianCalendar;
  9 
 10 /**
 11  *
 12  * @author Igor
 13  */
 14 public class DeclaracionVariables {
 15     /*
 16      * DECLARACION DE VARIABLES
 17      * Las variables en java se deben declarar siguendo los siguientes
 18      * puntos:
 19      * a. Se deben declarar las variables dentro de la clase pero fuera
 20      *    de cualquier método. ejemplo:
 21      */
 22     public class ListaNombresAlumnos{
 23         int indice = -1;
 24         String lista[] = new String[20];
 25 
 26         public void AgregarNombre(String nuevoNombre){
 27             lista[++indice] = nuevoNombre;
 28         }
 29     }
 30 
 31     /*
 32      * b. Se deben declarar las variables antes de que se utilicen dentro
 33      *    de un método. ejemplo:
 34      */
 35     public class Cuadrado{
 36         //se declara primero la variable lado
 37         float lado;
 38 
 39         //luego se utiliza en los siguientes métodos
 40         public void IngresarLado(float nuevoLado){
 41             this.lado = nuevoLado;
 42         }
 43         public float CalcularArea(){
 44             return (float) Math.pow(lado, 2);
 45         }
 46     }
 47 
 48     /*
 49      * c. Es típico declarar las variables al principio del bloque de la
 50      *    clase. ejemplo:
 51      */
 52     public class Rectangulo{
 53         //variables declaradas al principio del bloque de la clase
 54         float largo;
 55         float ancho;
 56 
 57         public float CalcularArea(){
 58             return largo * ancho;
 59         }
 60     }
 61 
 62     /*
 63      * d. El alcance o visibilidad de las variables se determina en el bloque
 64      *    del código. ejemplo:
 65      */
 66     public class Persona{
 67         //en este caso el tipo de alcance es privado
 68         private String dniPersona;
 69         private String nombrePersona;
 70         private String apellidoPersona;
 71         private GregorianCalendar fechaNacimientoPersona;
 72 
 73         public Persona(String dniPersona, String nombrePersona,
 74                 String apellidoPersona,
 75                 GregorianCalendar fechaNacimientoPersona) {
 76             this.dniPersona = dniPersona;
 77             this.nombrePersona = nombrePersona;
 78             this.apellidoPersona = apellidoPersona;
 79             this.fechaNacimientoPersona = fechaNacimientoPersona;
 80         }
 81 
 82         public Persona() {
 83             this("no definido","no definido","no definido",
 84                     new GregorianCalendar());
 85         }
 86     }
 87 
 88     /*
 89      * e. Se deben inicializar las variables del método antes de usarlas.
 90      *    ejemplo:
 91      */
 92     public class Operaciones{
 93 
 94         public String InvertirCadena(String cadena){
 95             //variables inicializadas
 96             String cadenaInvertida = "";
 97             int i = cadena.length() - 1;
 98             while(i > -1){
 99                 cadenaInvertida += cadena.charAt(i);
100                 i--;
101             }
102             return cadenaInvertida;
103         }
104 
105         public float SumaLista(float lista[]){
106             //variables inicializadas
107             int i = 0;
108             int suma = 0;
109             while(i < lista.length){
110                 suma += lista[i];
111                 i++;
112             }
113             return suma;
114         }
115     }
116 
117     /*
118      * f. Las clases y las variables de instancia son inicializadas
119      *    automaticamete.
120      */
121 }
122 
123 

Definición de métodos 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.util.Calendar;
 9 import java.util.GregorianCalendar;
10 
11 /**
12  *
13  * @author Igor
14  */
15 public class EjemploMetodos {
16     /*
17      * METODOS EN JAVA
18      * los métodos en java siempre se encuentran dentro de una clase,
19      * conforman las siguientes partes
20      * a. Modificador de Acceso
21      *    Que pueden ser los cuatro tipos que posee java
22      *    public, private, protected y friendly.
23      * b. Palabra Reservada
24      *    En caso de ser un metodo de clase va acompañado de la palabra
25      *    reservada static.
26      * c. Nombre
27      *    El nombre que le asignamos al método
28      * d. Parametros
29      *    Una lista de parametros que recibe el metodo, o como tambien
30      *    puede 0 parametros.
31      * e. Tipo de Retorno
32      *    El valor que retorna el método
33      * f. Bloque de código.
34      *    Las lineas de código que implementamos.
35      * ejemplos:
36      */
37     public static String Abc (){
38         String Abc = "";
39         for(int i=0; i<26; i++){
40             char letra = (char) (97 + i);
41             Abc += " - " + letra;
42         }
43         return Abc;
44     }
45     public static boolean numeroPrimo (int num, int mitad){
46         if(mitad > 1){
47             if(num % mitad == 0){
48                 return false;
49             }
50             else{
51                 return numeroPrimo(num, mitad - 1);
52             }
53         }
54         else{
55             return true;
56         }
57     }
58     public static String InvertirCadena(String cadena){
59         String cadenaInvertida = "";
60         for (int i = cadena.length()-1; i>-1; i--){
61             cadenaInvertida += cadena.charAt(i);
62         }
63         return cadenaInvertida;
64     }
65 
66     public static String FechaActualSistema(){
67         GregorianCalendar fechaActual = new GregorianCalendar();
68         return fechaActual.get(Calendar.DAY_OF_MONTH)+ "/" +
69                 (fechaActual.get(Calendar.MONTH)+1)+ "/" +
70                 fechaActual.get(Calendar.YEAR)+ "-" +
71                 fechaActual.get(Calendar.HOUR_OF_DAY)+ ":" +
72                 fechaActual.get(Calendar.MINUTE);
73     }
74     //provando a los metodos creados
75     public static void main(String[] args) {
76         System.out.println("Abc" + Abc());
77         System.out.println("El 4 es numero primo: " + numeroPrimo(4, 4/2));
78         System.out.println("El 10 es numero primo: " + numeroPrimo(10, 10/2));
79         System.out.println("El 13 es numero primo: " + numeroPrimo(13, 13/2));
80         System.out.println("Igor Alexander: " + InvertirCadena("Igor " +
81                 "Alexander"));
82         System.out.println("Fecha y Hora Actual del Sistema: "+
83                 FechaActualSistema());
84     }
85 
86 
87 }
88 
89 

-->
Salida por consola...

run:

Abc - a - b - c - d - e - f - g - h - i - j - k - l - m - n - o - p - q - r - s - t - u - v - w - x - y - z

El 4 es numero primo: false

El 10 es numero primo: false

El 13 es numero primo: true

Igor Alexander: rednaxelA rogI

Fecha y Hora Actual del Sistema: 25/12/2012-23:44

GENERACIÓN CORRECTA (total time: 1 second)

-->

Contenido de una clase en java

  1 /*
  2  * To change this template, choose Tools | Templates
  3  * and open the template in the editor.
  4  */
  5 
  6 package entidades;
  7 
  8 /**
  9  *
 10  * @author Igor
 11  * Este ejemplo muestra como es la estructura de una clase.
 12  *
 13  */
 14 
 15 /*
 16  * Una clase tienen un modificador de acceso, en este caso es public
 17  * la palabra reservada class, seguido del nombre de la clase, en este
 18  * caso Empleado es el nombre, a continuacion un par de llaves {...}
 19  * dentro de estas llaves se implementa el código para nuestra clase
 20  */
 21 public class Empleado {
 22     /*
 23      * CAMPOS DE INSTANCIA, que son los atributos o
 24      * propiedades de instancia(luego hablaremos mas a fondo de esto), pero
 25      * de una manera breve un campo de instancia permanece siempre a una
 26      * instancia, mejor dicho a un objeto, cada instancia contiene una
 27      * copia de todos los campos de instancia de la clase, de forma
 28      * independiente.
 29      */
 30     private String dni;
 31     private String nombre;
 32     private String apellidos;
 33 
 34     /*
 35      * CAMPOS DE CLASE, que son los atributos de clase que van acompados de la
 36      * palabra reservada static, estos campos no forman parte de los objetos
 37      * creados por la clase si no que son unicos, solo hay una copia de
 38      * estos sin importar el numero de instancias.
 39      */
 40     private static float SueldoFijo = 750.0f;
 41 
 42     /*
 43      * CONSTRUCTORES, este es un tipo de método que tiene el mismo nombre
 44      * que la clase, no tiene valor de retorno y se usan para inicializar
 45      * a los atributos.
 46      * la clase puede tener 0, 1, ó n contructores
 47      */
 48     //Constructor por defecto
 49     public Empleado() {
 50         dni = "no definido";
 51         nombre = "no definido";
 52         apellidos = "no definido";
 53     }
 54 
 55     //Constructor que recibe parametros
 56     public Empleado(String dni, String nombre, String apellidos) {
 57         this.dni = dni;
 58         this.nombre = nombre;
 59         this.apellidos = apellidos;
 60     }
 61 
 62     /*
 63      * METODOS DE INSTANCIA, que son las operaciones, metodos. de la misma
 64      * forma que un campo de instancia por cada objeto de la clase Empleado se
 65      * crea una copia de cada método de forma independiente
 66      */
 67     public String getDni() {
 68         return dni;
 69     }
 70 
 71     public void setDni(String dni) {
 72         this.dni = dni;
 73     }
 74 
 75     public String getNombre() {
 76         return nombre;
 77     }
 78 
 79     public void setNombre(String nombre) {
 80         this.nombre = nombre;
 81     }
 82 
 83     public String getApellidos() {
 84         return apellidos;
 85     }
 86 
 87     public void setApellidos(String apellidos) {
 88         this.apellidos = apellidos;
 89     }
 90 
 91     /*
 92      * METODOS DE CLASE, solo se crea una copia de estos métodos sin importar
 93      * el número de objetos creados
 94      */
 95     public static float getSueloFijo(){
 96         return SueldoFijo;
 97     }
 98     
 99 }
100 
101 

-->