t3 Metodos
t3 Metodos
métodos
Investigación
INDICE
Introducción ....................................................................................................................... 2
estructura de un método .................................................................................................... 3
método de clase y método de instancia ............................................................................. 4
Métodos de instancia:..................................................................................................... 4
Métodos de clase: .......................................................................................................... 4
argumentos y parámetros en Java ..................................................................................... 5
método get y valor de retorno. ........................................................................................... 6
constructores ..................................................................................................................... 7
el método equals y toString................................................................................................ 9
Destructores en java. ......................................................................................................... 9
Conclusiones ................................................................................................................... 19
Bibliografía....................................................................................................................... 20
Introducción
Los métodos son una herramienta que se encuentra presente en la programación dentro
de cualquier programa un poco complejo que se realice ya los métodos nos ayudan a
crear estructuras como cadenas, objetos y algunos otros métodos más complejos,
también son útiles para realizar algunos trucos ya que estos comprimen la actividad del
código y lo hacen mas dinámico para su utilización en programas complejos que utilizan
muchos datos o utilizan código para realizar acciones mas complejas en una fracción
corta de tiempo.
Estos también tienen cierto parecido con otro tipo de funciones, aunque estos suelen
trabajar de manera mas especifica y controlada a lo que bien podría hacer ya que
distintas áreas dependen de estos para hacer más suficientemente su labor. Como serían
las áreas que aprovechan su funcionalidad como la creación de software, la industria de
los video juegos, la creación de IAS, el desarrollo de las industrias y la creación de
páginas web.
MÉTODOS EN JAVA
Método, es el nombre que reciben los subprogramas o procedimientos en Java. Todos los
métodos son funciones, es decir retornan un dato. Aunque si definimos un método que
retorna un tipo “void”, significa que no retorna nada.
Los métodos de programación sirven para agrupar instrucciones de código y luego este
conjunto de instrucciones pueden ser llamadas cuantas veces sean necesarias
simplemente haciendo la "llamada al método", esto nos permite reutilizar código y resolver
problemas cada vez más complejos gracias al aumento de abstracción sobre un
problema.
estructura de un método
Tipo
Especificador de Nombre Declarar
de acceso dato del limites o
de método parámetros
retorno
Métodos de instancia:
Los métodos de instancia, como su nombre lo indica, son aplicables a una instancia de la
clase en particular. Es decir, que un método de instancia trabaja sobre el estado actual de
la instancia, y para cada instancia tendrán un resultado distinto, por ejemplo, el hecho de
comer permitirá a la instancia Mario estar satisfecho, mientras que la instancia maría
estará insatisfecha hasta que también se le aplique el método comer.
Ejemplo en Java:
Métodos de clase:
Los métodos de clase son un comportamiento común a todas las instancias que
pertenecen a la misma clase. Al ser un método de clase, no hace falta instanciar un objeto
de la clase para utilizarlo. Estos métodos no hablan del estado actual de la clase, sino
solo de un comportamiento genérico de la clase, de un procedimiento que solo utiliza los
parámetros de entrada o las variables estáticas. Son para un uso particular y es bien
visible cuando un método debe ser estático.
Ejemplo en Java:
Las diferencias entre los métodos de instancia y los de clase se resumirían como:
En Java, los argumentos y parámetros son términos que se utilizan para referirse a
valores que se pasan a un método o función. Aunque a menudo se utilizan
indistintamente, hay una diferencia importante entre los dos términos.
Un argumento, por otro lado, es el valor real que se proporciona cuando se llama a un
método o función. En el siguiente ejemplo, "5" y "10" son argumentos del método "sumar":
En resumen, los parámetros son valores esperados en la definición del método o función,
mientras que los argumentos son los valores reales que se pasan cuando se llama a ese
método o función.
En Java, un método "get" se refiere a un tipo de método que se utiliza para obtener o
acceder a un valor privado de una clase desde fuera de esa clase. Por convención, los
nombres de los métodos "get" comienzan con la palabra "get" seguida del nombre de la
propiedad que se está accediendo.
Por ejemplo, consideremos la siguiente clase "Persona" que tiene una propiedad privada
llamada "nombre":
return this.nombre;
this.nombre = nombre;
En este ejemplo, el método "getNombre ()" se utiliza para obtener el valor de la propiedad
"nombre". El método utiliza la palabra clave "return" para devolver el valor almacenado en
la propiedad "nombre".
Los métodos "get" son comunes en Java y se utilizan para acceder a las propiedades
privadas de una clase desde fuera de esa clase. El uso de métodos "get" y "set" (como el
método "setNombre ()" en el ejemplo anterior) es una práctica común en Java y se conoce
como "encapsulamiento", que ayuda a mantener la integridad de los datos y a evitar el
acceso directo a las propiedades privadas de una clase.
constructores
un constructor es un método especial que se utiliza para inicializar los objetos de una
clase. Un constructor puede ser vacío o no vacío, según si toma o no argumentos.
Un constructor vacío (también conocido como constructor predeterminado) es un
constructor que no toma argumentos y que se utiliza para inicializar los objetos con
valores predeterminados. Si una clase no define ningún constructor, se crea
automáticamente un constructor vacío. Por ejemplo:
public Persona () {
this.nombre = "Sin nombre";
this.edad = 0;
}
}
En este ejemplo, la clase "Persona" tiene un constructor vacío que inicializa los valores
predeterminados para las propiedades "nombre" y "edad".
Por otro lado, un constructor no vacío (también conocido como constructor parametrizado)
es un constructor que toma uno o más argumentos y se utiliza para inicializar los objetos
con valores específicos. Por ejemplo:
En este ejemplo, la clase "Persona" tiene un constructor no vacío que toma dos
argumentos: "nombre" y "edad". El constructor utiliza el puntero "this" para referirse a las
propiedades de la clase y asignarles los valores correspondientes.
El puntero "this" es una palabra clave en Java que se utiliza para hacer referencia a la
instancia actual de la clase. Se utiliza para evitar confusiones entre los nombres de las
variables locales y las propiedades de la clase. Por ejemplo, en el constructor no vacío de
la clase "Persona" anterior, se utiliza "this.nombre" y "this.edad" para referirse a las
propiedades de la clase y asignarles los valores de los argumentos.
En resumen, los constructores son métodos especiales que se utilizan para inicializar los
objetos de una clase. Un constructor vacío no toma argumentos y se utiliza para inicializar
los objetos con valores predeterminados, mientras que un constructor no vacío toma uno
o más argumentos y se utiliza para inicializar los objetos con valores específicos. El
puntero "this" se utiliza para hacer referencia a las propiedades de la clase y evitar
confusiones con las variables locales.
El método `equals()` es un método que se utiliza para comparar si dos objetos son iguales
en términos de contenido. Mientras que el método `toString()` es un método que devuelve
una cadena de caracteres que representa el objeto actual en forma de texto.
Java diferencia los métodos sobrecargados con base en el número y tipo de parámetros o
argumentos que tiene el método y no por el tipo que devuelve.
Destructores en java.
p. ej., Ejercicio1: este ejemplo muestra la factorial de un numero ingresado desde consola.
p. ej., Ejercicio2: esta muestra los números pares que hay entre cero y numero ingresado por el
usuario
p. ej., Ejercicio2: esta manda llamar al programa anterior e imprime los datos en pantalla.
p. ej., Ejercicio4: en este programa se imprimen los números primos del uno hasta el límite puesto
por el usuario.
p. ej., Ejercicio5: en este programa es similar al anterior con la diferencia que este imprime la
sucesión Fibonacci.
p. ej., Ejercicio6: en este programa compara las respuestas del anterior para dar una respuesta
lógica.
p. ej., Ejercicio7: en este programa pide tres valores al usuario y luego los compara para mostrar el
valor más alto.
p. ej., Ejercicio8: en este programa se imprime las potencias de dos hasta llegar al número
ingresado por el usuario.
p. ej., Ejercicio8: este programa manda a llamar al programa anterior y complementa instrucciones.
p. ej., Ejercicio9: este programa imprime valores enteros de 1000 a 2000 en 5 filas.
p. ej., Ejercicio11: este calcula la distancia a la que se encontraran dos personas que se mueven a
la misma dirección.
p. ej., Ejercicio12: este programa aprovecha el dinamismo del código para crear la figura del
código.
p. ej., Ejercicio13: este programa pide un numero al usuario para mostrar su equivalente en binario.
p. ej., Ejercicio14: este programa ordenas los mismos números del programa de menor a mayor.
Conclusiones
Los métodos son muy útiles para los programadores no solamente ayudan al programa a
no trabarse en demasiadas tareas ya que estas seleccionan solamente la parte de código
a la que han sido adecuadas esto te permite tomar ciertas partes de código para
diferentes clases o hacer función de diferentes librerías sin que nuestro código se sature y
no quede inutilizable y aprovechar parte del potencial.
Así como evolucionar para hacer más fáciles diferentes áreas y el ingreso a más
utilidades dentro de la programación.
Bibliografía
arkaitzgarro.com. (s.f.). Obtenido de arkaitzgarro.com:
https://www.arkaitzgarro.com/java/capitulo-14.html