Métodos en Java

Hay un principio interesante del que muchos han oído hablar. Se llama "Divide y vencerás". Este principio se utiliza en muchas áreas de la vida humana, por ejemplo, en la política. Denota la división de un gran número de partes heterogéneas del estado, incitando y utilizando la hostilidad entre estas partes. En otras palabras: crear conflicto entre quienes potencialmente representan una amenaza al poder. Pero somos programadores, por lo que sólo nos interesa la interpretación técnica de este principio. Y dice así: “El principio de “Divide y Conquistarás” es dividir un problema grande en otros más pequeños hasta que se vuelvan elementales. Luego debes resolverlos secuencialmente y combinar todo en un sistema completo. Este programa debería resolver el problema dado”. Es decir, simplemente divide un problema grande en otros más pequeños, que no son un problema que usted pueda resolver. Y luego reúnes la solución en una grande. Para seguir este principio simple y útil, la programación Java utiliza métodos. Por ejemplo, estamos creando un robot boxeador. Para nosotros es importante que se mueva bien, realice ataques precisos y también vigile al enemigo en busca de puntos débiles. Sería incómodo escribir todo esto en un método principal , ¿no? Si describimos todo en un solo método, será algo como esto:

метод main() {
// Описание действий шага вперед
подача напряжения в отдельные модули;
поднятие ноги;
перевод в другую точку;
поставить ногу;
перенести вес на другую ногу;
если (противникАтакует()) {
        	// Описание действий уклонения робота.
        	...
} еслиНет {
        	// Описание действий обманного атакующего удара.
        	...
}
// Описание действий шага назад
...
}

¿Qué pasa si necesitamos dar un paso adelante o patear en otra parte del programa? ¿Describir todas las acciones nuevamente? No encaja. Hay demasiadas líneas repetidas en las que es fácil perderse. Necesitamos colocar la descripción de los detalles de la acción en un módulo separado, que realizará el paso del robot. Y podemos llamar al método en una línea. Algo como esto:

метод шагВперед() {
// Описание действий шага вперед
  	подача напряжения в отдельные модули;
  	поднятие ноги;
  	перевод в другую точку;
  	поставить ногу;
  	перенести вес на другую ногу;
}

метод уклонение() {
  	// Действия для уклонения
  	...
}

метод обманныйАтакующийУдар() {
  	// Действия для удара
  	...
}

метод шагНазад() {
  	// Действия для шага назад
  	...
}

метод противникАтакует() {
	// Робот проверяет атакует ли противник
}

метод main() {
	шагВперед();
	если (противникАтакует()) {
        	уклонение();
	} еслиНет {
  	  обманныйАтакующийУдар();
	}
	шагНазад();
}

Ahora hemos separado la funcionalidad del robot, así como un método main() compacto y claro . Los métodos restantes también se pueden dividir en cualquier funcionalidad, por ejemplo, Golpe de ataque engañoso se puede dividir en métodos de engaño Movimiento , Movimiento de piernas , Ataque . Y a ellos, a su vez, se les asignan tareas más simples para, en última instancia, obtener un conjunto de tareas elementales. Bien, ahora escribamos todo bellamente en una forma que Java acepte.

public static void stepForward() {
  	    // Многострочный código, описывающий
  	    // действия робота для выполнения шага
  	    System.out.println("The robot takes a step forward");
}

public static void evasion() {
  	    // Действия для уклонения
  	    System.out.println("Robot shy of impact");
}

public static void deceptiveAttackBlow() {
  	    // Действия для удара
  	    System.out.println("The robot performs a deceptive strike");
}

public static void stepBack() {
  	    // Действия для шага назад
  	    System.out.println("The robot takes a step backwards");
}

public static void main(String[] args) {
    	stepForward();
    	if (isEnemyAttacked()) {
        		evasion();
    	} else {
  	    	deceptiveAttackBlow();
    	}
    	stepBack();
}

public static boolean isEnemyAttacked() {
    	// Метод проверяет, атакует ли враг. devoluciones логическое significado.
    	return true;
}

Entiendo que este código puede resultarle un poco confuso ahora, especialmente algunas palabras como void , return , etc. No te apresures a tirar tomates, ahora te lo explicaré todo. La idea general del paradigma “Divide y vencerás” debería quedarte clara. Los métodos nos ayudarán con esto. La estructura general de las declaraciones de métodos es la siguiente:

модификатор_доступа возвращаемое_significado Nombre_метода(принимаемые_параметры) {
   	//Тело метода
}

modificador de acceso

El modificador de acceso son varias palabras clave: público , privado , paquete . Estas palabras indican el alcance del método. Te lo explicaré de forma sencilla: con esta palabra parece que estás compartiendo un sabroso manjar con los demás. Delicioso es tu método. Si es privado , no compartes el método con otras clases. Si es paquete , solo comparte con las clases dentro del paquete (las clases se recopilan en paquetes específicos; aprenderá esto más adelante). Bueno, el público demuestra que eres la bondad misma y compartes un delicioso manjar (método) con todo el programa. Algo como esto. Después de algunos niveles comprenderás mucho mejor el papel de estas palabras.

Valor de retorno

Mire el ejemplo anterior: todos los métodos están marcados con la palabra clave void , excepto uno: isEnemyAttacked , que devuelve un valor booleano . Si un método está marcado como nulo , es posible que no devuelva nada. Este método simplemente realiza un conjunto de acciones y listo. Ahora preste atención al método principal . Los métodos que devuelven void se llaman así, en el cuerpo del método. Pero el método isEnemyAttacked se llama entre paréntesis de la declaración if . Debido al hecho de que devuelve un valor booleano, tenemos la oportunidad de no utilizar una variable intermedia, sino insertarla directamente. La devolución de un valor se produce utilizando la palabra clave return . Si un método devuelve tipo int , podemos llamar al método desde cualquier expresión:

public static int getNumber() {
 	    return 5;
}

public static void main(String[] args) {
    	int result = 5 + 6 + getNumber();
    	System.out.println(result);
}

Conclusión: El método getNumber devuelve un valor int , por lo que podemos llamarlo desde una expresión. Además, el método puede devolver cualquier tipo, incluidos los que usted mismo creó. Si especificaste un tipo de devolución para un método, entonces debes devolver algo. No puedes escribirlo así:

public static int findMaxNumber(int a, int b) {
 	if(a>b) {
 	    return a;
 	}
}

El compilador le regañará diciendo que cuando se cumple la primera condición, devuelve algo, pero cuando se cumple la segunda condición, no.

Pasando parámetros

Puede pasar parámetros al método que se utilizan durante su operación. El ejemplo más primitivo es la suma de dos números. Pero no somos primitivos, ¿verdad? Pongamos otro ejemplo, bastante estereotipado. Digamos que tenemos un método chef() - cocinar. Podemos pasar los ingredientes de la sopa a este método en el bloque de parámetros y, como resultado, este método nos devuelve la sopa. Como esto:

public static void main(String[] args) {
    	String[] ingredients;
    	// Инициализация массива ингредиентов
    	Soup soup = chef(ingredients);

}

public static Soup chef(String[] ingredients) {
    	Soup soup = new Soup();
    	// Процесс варки супа
    	return soup;
}

(Digamos que tenemos una clase de Sopa creada previamente ) En el método principal, creamos una variedad de ingredientes y luego “se los damos al chef” (se los pasamos al método del chef ). “El cocinero hace la sopa” y luego nos la devuelve como objeto de la clase Sopa . Todo es muy sencillo. Puede pasar cualquier parámetro, tipo primitivo, objeto, matriz, etc. al método.

Pasar parámetros por referencia y por valor.

En el lenguaje de programación Java, todos los parámetros se pasan a un método por su valor. Sin embargo, este mecanismo es diferente para tipos primitivos y para objetos. Si pasa cualquier tipo primitivo a un método y lo cambia, no cambiará en el método principal. Simplemente pasó una copia del valor y se conservó la variable original. El ejemplo más simple:

public static void main(String[] args) {
    	int x = 1;
    	System.out.println(x);
    	getNumber(x);
    	System.out.println(x);

	}

	public static void getNumber(int i) {
    	i = i + 100;
	}

Conclusión: Sin embargo, en el caso de los objetos, los cambios afectan al objeto original:

public class Program
{
	public static void main(String[] args) {
    	WiseMan wiseMan = new WiseMan();
    	wiseMan.setIq(300);
    	System.out.println(wiseMan);
    	changeObject(wiseMan);
    	System.out.println(wiseMan);

	}

	public static void changeObject(WiseMan m) {
    	m.setIq(100);
	}
}

public class WiseMan {
	int iq;

	public void setIq(int iq) {
    	this.iq = iq;
	}

	public int getIq() {
    	return iq;
	}

	public String toString() {
    	return "Our wise man has an IQ "+iq;
	}
}

Conclusión: Tenemos una clase WiseMan que tiene una propiedad iq . Y dos métodos que controlan el valor de este campo. En el método principal creamos un objeto WiseMan , establecemos el valor de iq en 300 . Luego pasamos nuestro sabio con iq 300 al método changeObject , pero en este método se vuelve estúpido. Establecemos el valor de iq en 100. Luego, en el método principal imprimimos el objeto. Puedes ver que en el método changeObject estamos manipulando otro sabio en la variable m . Sin embargo, estamos modificando nuestro objeto original. El hecho es que el objeto WiseMan en el método principal y el objeto m en el método ChangeObject son el mismo Wise Man, y una referencia al objeto se copia en el método como parámetro. Tenga esto en cuenta cuando edite un objeto en métodos individuales.

Finalmente, unas palabras sobre el modificador estático.

En general, unas pocas palabras aquí no son suficientes, pero lo intentaré. Los métodos regulares no marcados con este modificador pertenecen al objeto de clase. Y los métodos estáticos pertenecen a la propia clase. Se pueden utilizar métodos regulares en objetos individuales. Mire la clase WiseMan del ejemplo anterior. Cada sabio tendrá sus propios métodos getIq y setIq , porque el nivel de IQ de cada uno es diferente. Si agregamos un método estático generateAWisePhrase a esta clase , entonces podemos llamar a dicho método sin un objeto:

WiseMan.generateAWisePhrase();

En general, esta información es suficiente por ahora, porque se pueden escribir varias conferencias sobre estática . Siga algunas reglas al escribir un método para mantener el orden en su código:

• Asigne a sus métodos nombres significativos para que quede claro lo que hacen.
• Trate de no escribir métodos muy largos. La longitud óptima es de 8 a 15 líneas.
• El número de parámetros del método no debe exceder de 4 a 5.
• Si tiene una funcionalidad similar dos veces en su código, piense: ¿tal vez valga la pena generalizarla y ponerla en un método separado?

Estas técnicas le ayudarán a mejorar el rendimiento de su programa y, lo más importante, a hacer que su código sea más legible.