{"id":261,"date":"2026-10-01T17:53:02","date_gmt":"2026-10-01T17:53:02","guid":{"rendered":"https:\/\/java.nosoyia.es\/?page_id=261"},"modified":"2026-10-01T17:53:02","modified_gmt":"2026-10-01T17:53:02","slug":"metodos","status":"publish","type":"page","link":"https:\/\/java.nosoyia.es\/?page_id=261","title":{"rendered":"M\u00e9todos"},"content":{"rendered":"\n
\n
\n

Correspondencia en Python —><\/p>\n<\/div>\n\n\n\n

\n
\"\"<\/a><\/figure>\n<\/div>\n<\/div>\n\n\n\n

Java es un lenguaje de programaci\u00f3n especialmente dise\u00f1ado para trabajar con clases y objetos.
Un m\u00e9todo es un bloque de c\u00f3digo que se va a encargar de efectuar una determinada tarea con un objeto cuando sea invocado por dicho objeto.<\/p>\n\n\n\n

Un tipo importante de m\u00e9todo, es el que est\u00e1 declarado como static. Los m\u00e9todos static son lo m\u00e1s parecido a las funciones de otros lenguajes como Python. Se pueden llamar desde cualquier lugar del c\u00f3digo solo hace falta mencionar la clase y el nombre del m\u00e9todo, pero no est\u00e1n ligados a ning\u00fan objeto de clase, es decir, no precisan de instanciar un objeto para ser utilizadas.
Estos m\u00e9todos static, pueden estar dentro de cualquier clase y tambi\u00e9n dentro del bloque principal main.<\/p>\n\n\n\n

Una parte importante del m\u00e9todo es que puede ser llamado tantas veces como se precise. Es un c\u00f3digo reutilizable.
Vemos el m\u00e9todo saludo( ) <\/p>\n\n\n\n

import java.util.ArrayList;\nimport java.util.Arrays;\nimport java.util.List;\n\npublic class Prueba3 {\n    public static void main(String[] args) {\n        List<String> invitados = new ArrayList<>(Arrays.asList("Pedro", "Juan", "Javier"));\n        for (String invitado : invitados) {\n            System.out.println("Saludamos a " + invitado);\n            saludo();\n        }\n    }\n\n    public static void saludo(){\n        System.out.println("Hola. Bienvenido al grupo.");\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
Resultado:\n\nSaludamos a Pedro\nHola. Bienvenido al grupo.\nSaludamos a Juan\nHola. Bienvenido al grupo.\nSaludamos a Javier\nHola. Bienvenido al grupo.<\/code><\/pre><\/div>\n\n\n\n
M\u00e9todos y Par\u00e1metros.<\/mark><\/em><\/strong><\/p>\n\n\n\n
El uso de los m\u00e9todos se vuelve m\u00e1s interesante cuando les pasamos argumentos para que puedan trabajar con ellos. Para que esto pueda ser posible, al definir el m\u00e9todo debemos a\u00f1adir uno o m\u00e1s par\u00e1metros entre par\u00e9ntesis. El m\u00e9todo tomar\u00e1 los argumentos recibidos y los convertir\u00e1 en variables locales para ser usadas dentro de su c\u00f3digo. Los argumentos pueden ser cualquier tipo de dato, pero deben de coincidir con los par\u00e1metros que espera recibir.<\/p>\n\n\n\n
import java.util.ArrayList;\nimport java.util.Arrays;\nimport java.util.List;\n\npublic class Prueba3 {\n    public static void main(String[] args) {\n        List<String> invitados = new ArrayList<>(Arrays.asList("Pedro", "Juan", "Javier"));\n        for (String invitado : invitados) {\n            saludo(invitado);\n        }\n    }\n\n    public static void saludo(String invitado){\n        System.out.println("Hola. Bienvenido al grupo.");\n        System.out.println("Saludamos a " + invitado);\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
Resultado:\n\nHola. Bienvenido al grupo.\nSaludamos a Pedro\nHola. Bienvenido al grupo.\nSaludamos a Juan\nHola. Bienvenido al grupo.\nSaludamos a Javier<\/code><\/pre><\/div>\n\n\n\n
En la definici\u00f3n del m\u00e9todo podemos a\u00f1adir tantos par\u00e1metros como creamos necesarios. Como regla general, al invocar al m\u00e9todo deberemos de a\u00f1adir tantos argumentos como par\u00e1metros est\u00e9n incluidos en su definici\u00f3n, y adem\u00e1s deben de estar informados en el mismo orden y contener el mismo tipo de datos.<\/p>\n\n\n\n
public class Prueba3 {\n    public static void main(String[] args) {\n\n        float compra_1=producto("leche",10, 1.28F,4);\n        float compra_2=producto("pan",20, 0.65F,4);\n        float compra_3=producto("aceite",2, 8.20F,12);\n\n        float total_compra=(compra_1+compra_2+compra_3);\n        System.out.println("\\nEl importe de su compra es: "+total_compra);\n    }\n\n    public static float producto(String nombre,int cantidad,float precio_unidad,float iva){\n        float total_sin_iva=cantidad*precio_unidad;\n        float resultado=(total_sin_iva*(1+(iva\/100)));\n        System.out.println("Producto: "+ nombre+". Total producto: " + resultado);\n        return resultado;\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
Resultado:\n\nProducto: leche. Total producto: 13.311998\nProducto: pan. Total producto: 13.5199995\nProducto: aceite. Total producto: 18.368\n\nEl importe de su compra es: 45.199997<\/code><\/pre><\/div>\n\n\n\n
La instrucci\u00f3n return<\/mark><\/em><\/strong><\/p>\n\n\n\n
En el ejemplo anterior, hemos visto que se ha a\u00f1adido una instrucci\u00f3n \u201creturn\u201d en el cuerpo del m\u00e9todo. Esta instrucci\u00f3n no es obligada, pero nos ayuda a devolver a la parte del programa que le llama, un dato que luego puede seguir utiliz\u00e1ndose.<\/p>\n\n\n\n
Si el m\u00e9todo no va a devolver ning\u00fan dato, el \u00abreturn\u00bb simplemente servir\u00e1 para indicar que el control se devuelve al punto de llamada.<\/p>\n\n\n\n
Si debemos devolver alg\u00fan tipo de dato, al nombrar el m\u00e9todo debemos especificar el tipo de dato de retorno, en lugar de la palabra reservada \u00abvoid\u00bb que indicar\u00eda que no se devuelve ning\u00fan valor.<\/p>\n\n\n\n

Lo normal es que si el m\u00e9todo va a devolver alg\u00fan dato, ese dato quede almacenado en la variable que le llama, aunque tambi\u00e9n podemos aplicar dicho valor directamente en una expresi\u00f3n que forme parte del c\u00f3digo, como har\u00edamos con cualquier otro valor.<\/p>\n\n\n\n
Un m\u00e9todo tambi\u00e9n puede ser llamado desde otro m\u00e9todo:<\/p>\n\n\n\n
import java.util.ArrayList;\nimport java.util.Arrays;\nimport java.util.List;\n\npublic class Prueba3 {\n    public static void main(String[] args) {\n        List<String> invitados = new ArrayList<>(Arrays.asList("Pedro", "Juan", "Javier"));\n        for (String invitado : invitados) {\n            nuevo_alumno(invitado);\n        }\n    }\n\n    public static void nuevo_alumno(String nombre){\n        System.out.println("Saludamos a " + nombre);\n        saludo(nombre);\n    }\n\n    public static void saludo(String invitado){\n        System.out.println("Hola "+invitado+". Bienvenido al grupo."+"\\n");\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
Resultado:\n\nSaludamos a Pedro\nHola Pedro. Bienvenido al grupo.\n\nSaludamos a Juan\nHola Juan. Bienvenido al grupo.\n\nSaludamos a Javier\nHola Javier. Bienvenido al grupo.<\/code><\/pre><\/div>\n\n\n\n
La instrucci\u00f3n return (si existe), no debe de estar siempre al final del c\u00f3digo del m\u00e9todo. Puede estar incluida en cualquier otro lugar de su c\u00f3digo. En el momento en que aparezca un \u201creturn\u201d (puede haber varios incluidos dentro del mismo m\u00e9todo), se devuelve autom\u00e1ticamente el control a la parte del programa que le llama.
Veamos un ejemplo con un m\u00e9todo que recibe como argumento un ArrayList.<\/p>\n\n\n\n
import java.util.ArrayList;\nimport java.util.Arrays;\n\npublic class Prueba3 {\n    public static void main(String[] args) {\n        ArrayList<Integer> listado = new ArrayList<>(Arrays.asList(5, 76, 14, 38, 100));\n        String mensaje=divisible(listado);\n        System.out.println(mensaje);\n    }\n\n    public static String divisible(ArrayList<Integer> mi_listado) {\n        for (int numero : mi_listado) {\n            if (numero % 7 == 0) {\n                return ("El n\u00famero " + numero + " es divisible entre 7.");\n            }\n        }\n        return ("No hemos encontrado ning\u00fan n\u00famero divisible entre 7.");\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
Resultado:\n\nEl n\u00famero 14 es divisible entre 7.<\/code><\/pre><\/div>\n\n\n\n
Sobrecarga de m\u00e9todos.<\/mark><\/em><\/strong><\/p>\n\n\n\n
La sobrecarga de m\u00e9todos consiste en dos (o m\u00e1s) m\u00e9todos que tienen el mismo nombre, pero distinto n\u00famero de par\u00e1metros, o incluso tambi\u00e9n el mismo n\u00famero de par\u00e1metros pero (al menos uno) de diferente tipo.<\/p>\n\n\n\n
Veamos un ejemplo con uno de los programas anteriores, donde el m\u00e9todo \u00abproducto\u00bb recib\u00eda antes 4 par\u00e1metros. Crearemos un nuevo m\u00e9todo id\u00e9ntico, pero que solo reciba 3 par\u00e1metros.<\/p>\n\n\n\n
public class Prueba3 {\n    public static void main(String[] args) {\n\n        float compra_1=producto("leche",10, 1.28F);\n        float compra_2=producto("pan",20, 0.65F);\n        float compra_3=producto("aceite",2, 8.20F);\n\n        float total_compra=(compra_1+compra_2+compra_3);\n        System.out.println("\\nEl importe de su compra es: "+total_compra);\n    }\n\n    public static float producto(String nombre,int cantidad,float precio_unidad,float iva){\n        float total_sin_iva=cantidad*precio_unidad;\n        float resultado=(total_sin_iva*(1+(iva\/100)));\n        System.out.println("Producto: "+ nombre+". Total producto: " + resultado);\n        return resultado;\n    }\n\n    public static float producto(String nombre, int cantidad, float precio_unidad){\n        float iva=7.0F;\n        float total_sin_iva=cantidad*precio_unidad;\n        float resultado=(total_sin_iva*(1+(iva\/100)));\n        System.out.println("Producto: "+ nombre+". Total producto: " + resultado);\n        return resultado;\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
Resultado:\n\nProducto: leche. Total producto: 13.696\nProducto: pan. Total producto: 13.910001\nProducto: aceite. Total producto: 17.548\n\nEl importe de su compra es: 45.154<\/code><\/pre><\/div>\n\n\n\n
En el m\u00e9todo sobrecargado con 3 par\u00e1metros, establecemos el iva como fijo para todos los productos en 7, por lo tanto no hace falta pasarle el 4\u00ba par\u00e1metro en la llamada al m\u00e9todo, que tampoco espera recibirlo.<\/p>\n\n\n\n
M\u00e9todos y variables. Variables locales y variables static<\/mark><\/em><\/strong><\/p>\n\n\n\n
Un detalle muy importante a tener en cuenta es el valor que pueden tomar las variables dentro de un m\u00e9todo. Una variable declarada dentro de un m\u00e9todo, solo ser\u00e1 reconocida dentro de dicho m\u00e9todo.<\/p>\n\n\n\n
public class Prueba3 {\n    public static void main(String[] args) {\n        float salario=2000F;\n        float irpf=0.15F;\n        float gastos=1500;\n        float ahorro=salario*(1-irpf)-gastos;\n        System.out.println("El ahorro antes de intereses banco es: "+ahorro);\n        ahorro_banco(ahorro,500);\n        System.out.println("El ahorro sumados ahorro banco es: "+ahorro);\n    }\n\n    public static void ahorro_banco( float ahorro_anterior, float intereses_banco){\n        float ahorro=(ahorro_anterior)+intereses_banco*(1-irpf);\n        System.out.println("Seg\u00fan el m\u00e9todo, el ahorro sumados intereses del banco es: "+ahorro);\n    }\n\n}<\/code><\/pre><\/div>\n\n\n\n
Si intentamos compilar este c\u00f3digo, nos dar\u00e1 error. El problema que nos encontramos es que el m\u00e9todo ahorro_banco no reconoce la variable irpf porque pertenece al \u00e1mbito del m\u00e9todo principal main. <\/p>\n\n\n\n
Para solucionarlo declaramos la variable como variable de clase<\/mark><\/em><\/strong> (no de m\u00e9todo), y hacemos que est\u00e9 disponible para cualquier m\u00e9todo de la clase. Esto lo hacemos con el modificador static.<\/mark><\/em><\/strong><\/p>\n\n\n\n
public class Prueba3 {\n        static float irpf;\n\n    public static void main(String[] args) {\n        float salario=2000F;\n        irpf=0.15F;\n        float gastos=1500;\n        float ahorro=salario*(1-irpf)-gastos;\n        System.out.println("El ahorro antes de intereses banco es: "+ahorro);\n        ahorro_banco(ahorro,500);\n        System.out.println("El ahorro sumados ahorro banco es: "+ahorro);\n    }\n\n    public static void ahorro_banco( float ahorro_anterior, float intereses_banco){\n        float ahorro=(ahorro_anterior)+intereses_banco*(1-irpf);\n        System.out.println("Seg\u00fan el m\u00e9todo, el ahorro sumados intereses del banco es: "+ahorro);\n    }\n\n}<\/code><\/pre><\/div>\n\n\n\n
Resultado:\n\nEl ahorro antes de intereses banco es: 200.0\nSeg\u00fan el m\u00e9todo, el ahorro sumados intereses del banco es: 625.0\nEl ahorro sumados ahorro banco es: 200.0<\/code><\/pre><\/div>\n\n\n\n
Vemos que el resultado tampoco es el esperado. Esto es porque tenemos dos variables llamadas igual (\u00abahorro\u00bb), pero que son variables locales para cada uno de los m\u00e9todos que la declara. La soluci\u00f3n es la misma, declarar esta variable como variable de clase y a\u00f1adirle el modificador static.<\/p>\n\n\n\n
public class Prueba3 {\n        static float irpf;\n        static float ahorro;\n\n    public static void main(String[] args) {\n        float salario=2000F;\n        irpf=0.15F;\n        float gastos=1500;\n        ahorro=salario*(1-irpf)-gastos;\n        System.out.println("El ahorro antes de intereses banco es: "+ahorro);\n        ahorro_banco(ahorro,500);\n        System.out.println("El ahorro sumados ahorro banco es: "+ahorro);\n    }\n\n    public static void ahorro_banco( float ahorro_anterior, float intereses_banco){\n        ahorro=(ahorro_anterior)+intereses_banco*(1-irpf);\n        System.out.println("Seg\u00fan el m\u00e9todo, el ahorro sumados intereses del banco es: "+ahorro);\n    }\n\n}<\/code><\/pre><\/div>\n\n\n\n
Resultado:\n\nEl ahorro antes de intereses banco es: 200.0\nSeg\u00fan el m\u00e9todo, el ahorro sumados intereses del banco es: 625.0\nEl ahorro sumados ahorro banco es: 625.0<\/code><\/pre><\/div>\n\n\n\n
Ahora s\u00ed nos concuerda todo.<\/p>\n\n\n\n
Los par\u00e1metros ser\u00e1n variables locales dentro del m\u00e9todo.<\/mark><\/em><\/strong><\/p>\n\n\n\n
Cuando un m\u00e9todo recibe un par\u00e1metro (y aunque ese par\u00e1metro tenga el mismo nombre que otra variable definida fuera del m\u00e9todo), el par\u00e1metro pasar\u00e1 a ser una variable local para el m\u00e9todo. Si se modifica dentro del m\u00e9todo, no quedar\u00e1 modificada tambi\u00e9n fuera.<\/p>\n\n\n\n
public class Prueba3 {\n\n    public static void main(String[] args) {\n        float dividendo=9F;\n        float divisor=2;\n        float resultado=division(dividendo,divisor);\n        System.out.println(resultado);\n        System.out.println(dividendo);\n    }\n\n    public static float division( float dividendo, float divisor){\n        dividendo=dividendo+1;\n        float division=dividendo\/divisor;\n        return division;\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
Resultado:\n\n5.0\n9.0<\/code><\/pre><\/div>\n\n\n\n
Hemos modificado dentro del m\u00e9todo el par\u00e1metro dividendo, sin embargo la variable dividendo ha quedado sin tocar fuera de dicho m\u00e9todo.<\/p>\n\n\n\n
ArrayList como par\u00e1metro.<\/mark><\/em><\/strong><\/p>\n\n\n\n
Una peque\u00f1a diferencia est\u00e1 en si pasamos como argumento un ArrayList (o un dato tipo objeto). En este caso, si modificamos el ArrayList (o el dato) dentro del m\u00e9todo, SI<\/mark><\/em><\/strong> que quedar\u00e1 modificado en origen.<\/p>\n\n\n\n
import java.util.ArrayList;\nimport java.util.Arrays;\n\npublic class Prueba {\n    public static void main(String[] args) {\n        ArrayList<Integer> mis_numeros = new ArrayList<>(Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8, 9, 10));\n        duplicar(mis_numeros);\n        System.out.println(mis_numeros);\n    }\n\n    public static void duplicar(ArrayList <Integer> mis_numeros) {\n        for (int k = 0; k<mis_numeros.size(); k++){\n            int antes=mis_numeros.get(k);\n            mis_numeros.set(k,antes*2);\n        }\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
Resultado:\n\n[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]<\/code><\/pre><\/div>\n\n\n\n
Archivo de m\u00e9todos.<\/mark><\/em><\/strong><\/p>\n\n\n\n
Puede sernos de utilidad crear un archivo dentro de nuestro proyecto que contenga una serie de m\u00e9todos que est\u00e9n todos relacionados entre s\u00ed. Por ejemplo, podemos tener un archivo llamado Financieras que contenga la clase Financieras con una serie de m\u00e9todos que se encarguen de gestionar las finanzas.<\/p>\n\n\n\n
public class Financieras {\n\n    public static double intereses(double cantidad, double tipo, double meses) {\n        double interes = cantidad + (cantidad * tipo \/ 100 * meses);\n        return (interes);\n    }\n\n    public static double descuentos(double cantidad, double descuento) {\n        double midescuento = cantidad - (cantidad * descuento \/ 100);\n        return (midescuento);\n    }\n\n    public static double nominas(double sueldo,double primas, double irpf) {\n        double bruto = sueldo + primas;\n        double neto = bruto - (bruto * irpf \/ 100);\n        return (neto);\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
Estos m\u00e9todos los hemos definido todos como \u00abstatic\u00bb, simplemente porque as\u00ed pueden ser utilizados desde fuera de la clase sin necesidad de instanciar un objeto de la clase \u00abFinancieras\u00bb.<\/p>\n\n\n\n
Para poder ser utilizados estos m\u00e9todos, tan solo deben de ser mencionados anteponiendo el prefijo de la clase.<\/p>\n\n\n\n
public class Prueba3 {\n\n    public static void main(String[] args) {\n        double mi_sueldo= Financieras.nominas(1200,500,12);\n        System.out.println("Mi sueldo es: "+mi_sueldo+" euros.");\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
Resultado:\n\nMi sueldo es: 1496.0 euros.<\/code><\/pre><\/div>\n\n\n\n
El ejemplo anterior implica que el archivo de m\u00e9todos est\u00e9 en el mismo directorio que el archivo donde se encuentra \u00abmain\u00bb.<\/p>\n\n\n\n
Pero puede ocurrir tambi\u00e9n de que tengamos una carpeta (paquete) diferente dentro de nuestro proyecto que contenga una serie de ficheros, todos ellos con m\u00e9todos relacionados entre s\u00ed, y listos para usarse. Por ejemplo, supongamos que tenemos una carpeta donde uno de sus archivos sea el que contenga la clase Financieras, adem\u00e1s de otros muchos archivos con m\u00e1s m\u00e9todos.<\/p>\n\n\n\n
En este caso, tambi\u00e9n podemos utilizarlos, pero debemos primero de importarlos:<\/p>\n\n\n\n
import Utilidades.Financieras;\n\npublic class Prueba3 {\n\n    public static void main(String[] args) {\n        double mi_sueldo= Financieras.nominas(1200,500,12);\n        System.out.println("Mi sueldo es: "+mi_sueldo+" euros.");\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
El resultado ser\u00e1 el mismo.<\/p>\n\n\n\n
Recursividad de los m\u00e9todos.<\/mark><\/em><\/strong><\/p>\n\n\n\n
Una de las caracter\u00edsticas de los m\u00e9todos es la recursividad. Gracias a ella, un m\u00e9todo puede llamarse a s\u00ed mismo. Por ejemplo, podemos hallar el factorial de un n\u00famero con un m\u00e9todo recursivo:<\/p>\n\n\n\n
public class Prueba3 {\n    static int numero;\n\n    public static void main(String[] args) {\n        numero = 8;\n        int inicio = numero;\n        System.out.println(numero);\n        if (numero > 2) {\n            int resultado = mifactorial(numero);\n            System.out.println("Factorial de " + inicio + " es " + resultado);\n        } else {\n            System.out.println("El factorial de 2 es 2.");\n        }\n    }\n\n        public static int mifactorial ( int n) {\n            if (n > 2) {\n                System.out.println(numero + "*" + (n - 1) + "=" + (numero * (n - 1)));\n                numero = numero * (n - 1);\n                return (mifactorial(n - 1));\n            }\n            else {\n                return numero;\n            }\n        }\n    }<\/code><\/pre><\/div>\n\n\n\n
Resultado:\n\n8\n8*7=56\n56*6=336\n336*5=1680\n1680*4=6720\n6720*3=20160\n20160*2=40320\nFactorial de 8 es 40320<\/code><\/pre><\/div>\n\n\n\n
Este m\u00e9todo se va llamando a s\u00ed mismo hasta que n vale 3. En ese momento se multiplica el acumulado por (n-1) que es 2 y se vuelve a llamar con el valor de 2. Pero en la nueva llamada ya no se ejecuta el condicional (en realidad tocar\u00eda multiplicar el acumulado por 2-1 que ser\u00eda 1) y se sale devolviendo el acumulado al flujo principal.<\/p>\n\n\n\n
Otro ejemplo de recursividad. En este caso el m\u00e9todo se va llamando a s\u00ed mismo hasta que la cadena queda vac\u00eda, momento en el cual se sale del m\u00e9todo.<\/p>\n\n\n\n
public class Prueba3 {\n    static int numero;\n\n    public static void main(String[] args) {\n        String cadena="abcdefghijklmnopqrstuvwxyz";\n        alfabeto(cadena);\n    }\n\n    public static void alfabeto (String cadena) {\n        if (cadena.length()==0) {\n            return;\n        }\n        else {\n            System.out.println(cadena);\n            cadena = cadena.substring(0, cadena.length() - 1);\n            alfabeto(cadena);\n        }\n    }\n}<\/code><\/pre><\/div>\n\n\n\n
Resultado:\n\nabcdefghijklmnopqrstuvwxyz\nabcdefghijklmnopqrstuvwxy\nabcdefghijklmnopqrstuvwx\nabcdefghijklmnopqrstuvw\nabcdefghijklmnopqrstuv\nabcdefghijklmnopqrstu\nabcdefghijklmnopqrst\nabcdefghijklmnopqrs\nabcdefghijklmnopqr\nabcdefghijklmnopq\nabcdefghijklmnop\nabcdefghijklmno\nabcdefghijklmn\nabcdefghijklm\nabcdefghijkl\nabcdefghijk\nabcdefghij\nabcdefghi\nabcdefgh\nabcdefg\nabcdef\nabcde\nabcd\nabc\nab\na<\/code><\/pre><\/div>\n\n\n\n
Inicio<\/a><\/td>Comandos Java<\/a><\/td>Bloques de c\u00f3digo.<\/a><\/td><\/tr>
Comentar c\u00f3digo<\/a><\/td>System.out.print<\/a><\/td>Scanner (System.in)<\/a><\/td><\/tr>
Captura de errores<\/a><\/td>String<\/a><\/td>Datos  Num\u00e9ricos<\/a><\/td><\/tr>
Elementos aleatorios<\/a><\/td>Datos Fecha\/hora<\/a><\/td>Constantes<\/a><\/td><\/tr>
Bucles for<\/a><\/td>Bucles while<\/a><\/td>Bloque if<\/a><\/td><\/tr>
Arrays<\/a><\/td>ArrayList<\/a><\/td>switch case<\/a><\/td><\/tr>
HashSet<\/a><\/td>HashMap<\/a><\/td>M\u00e9todos.<\/a><\/td><\/tr>
Clases<\/a><\/td>Archivos<\/a><\/td>Entorno gr\u00e1fico Swing<\/a><\/td><\/tr>
JFrame (Ventanas)<\/a><\/td>Componentes b\u00e1sicos.<\/a><\/td><\/td><\/tr><\/tbody><\/table><\/figure>\n","protected":false},"excerpt":{"rendered":"
Correspondencia en Python —> Java es un lenguaje de programaci\u00f3n especialmente dise\u00f1ado para trabajar con clases y objetos.Un m\u00e9todo es un bloque de c\u00f3digo que se va a encargar de efectuar una determinada tarea con un objeto cuando sea invocado por dicho objeto. Un tipo importante de m\u00e9todo, es el que est\u00e1 declarado como static. […]<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":0,"menu_order":0,"comment_status":"closed","ping_status":"closed","template":"","meta":{"footnotes":""},"class_list":["post-261","page","type-page","status-publish","hentry"],"_links":{"self":[{"href":"https:\/\/java.nosoyia.es\/index.php?rest_route=\/wp\/v2\/pages\/261","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/java.nosoyia.es\/index.php?rest_route=\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/java.nosoyia.es\/index.php?rest_route=\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/java.nosoyia.es\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/java.nosoyia.es\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=261"}],"version-history":[{"count":6,"href":"https:\/\/java.nosoyia.es\/index.php?rest_route=\/wp\/v2\/pages\/261\/revisions"}],"predecessor-version":[{"id":269,"href":"https:\/\/java.nosoyia.es\/index.php?rest_route=\/wp\/v2\/pages\/261\/revisions\/269"}],"wp:attachment":[{"href":"https:\/\/java.nosoyia.es\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=261"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}