Java 中的方法

许多人都听说过一个有趣的原则。这就是所谓的“分而治之”。这一原则应用于人类生活的许多领域，例如政治。它意味着国家内部大量异质部分的分裂，煽动和利用这些部分之间的敌意。换句话说：在那些可能对权力构成威胁的人之间制造冲突。但我们是程序员，所以我们只对这个原理的技术解释感兴趣。它是这样的：“分而治之的原则是将一个大问题分解成更小的问题，直到它们变得简单。然后你需要依次解决它们并将所有内容组合成一个完整的系统。这个程序应该解决给定的问题”也就是说，你只需将一个大问题分解成较小的问题，而这不是你需要解决的问题。然后你将解决方案收集成一个大解决方案。为了遵循这个简单而有用的原则，Java 编程使用了方法。 例如，我们正在创建一个机器人拳击手。对我们来说，重要的是他的移动灵活，打击准确，并且观察敌人寻找弱点。将所有这些都写在一个main方法中会很尴尬，不是吗？如果我们用一种方法来描述一切，它将是这样的：

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

如果我们需要在程序的其他地方向前迈出一步或踢出一步怎么办？再次描述一下所有的动作？不适合。重复的台词太多，很容易迷失方向。我们需要将动作细节的描述放在一个单独的模块中，该模块将执行机器人步骤。我们可以在一行中调用该方法。像这样的东西：

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

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

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

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

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

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

现在我们有了独立的机器人功能，以及一个紧凑而清晰的main()方法。剩下的方法也可以分为任意功能，比如欺骗攻击就可以分为欺骗移动、腿部移动、攻击等方法。反过来，他们被分配到更简单的任务，以便最终获得一组基本任务。好吧，现在让我们以 Java 可以接受的形式将其完美地编写出来。

public static void stepForward() {
  	    // Многострочный code, описывающий
  	    // действия робота для выполнения шага
  	    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() {
    	// Метод проверяет, атакует ли враг. returns логическое meaning.
    	return true;
}

我知道这段代码现在对你来说可能有点不清楚，尤其是一些像void、return之类的单词。别急着扔西红柿，我现在就解释一切。“分而治之”范式的总体思路你应该很清楚。方法将帮助我们做到这一点。方法声明的一般结构如下：

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

访问修饰符

访问修饰符是几个关键字：public、private、package。这些词表明了该方法的范围。我简单地解释一下：用这个词，你似乎在与他人分享美味。美味是你的方法。如果它是private，则不会与其他类共享该方法。如果是package，则仅与包内的类共享（类被收集到特定的包中，稍后您将了解这一点）。好吧，公开表明你本身就是善良的，并与整个节目分享美味佳肴（方法）。像这样的东西。经过几个级别后，您会更好地理解这些单词的作用。

返回值

看上面的例子：所有方法都用void关键字标记，除了一个 - isEnemyAttacked，它返回一个布尔值。如果一个方法被标记为void，它可能不会返回任何内容。这个方法只是执行一组操作，仅此而已。现在注意main方法。那些返回void的方法就像在方法体中一样被调用。但isEnemyAttacked方法是在if语句的括号内调用的。由于它返回一个布尔值，我们有机会不使用中间变量，而是直接插入它。使用return关键字返回一个值。如果方法返回int类型，我们可以从任何表达式调用该方法：

public static int getNumber() {
 	    return 5;
}

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

结论： getNumber 方法返回一个int值，因此我们可以从表达式中调用它。此外，该方法可以返回任何类型，包括您自己创建的类型。如果您为方法指定了返回类型，那么您必须返回一些内容。你不能这样写：

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

编译器会责骂你，当满足第一个条件时，你会返回一些东西，但当满足第二个条件时，你不会。

传递参数

您可以将参数传递给在其操作期间使用的方法。最原始的例子是两个数字的总和。但我们并不原始，对吧？我们再举一个例子，这个例子非常典型。假设我们有一个Chef()方法- Cook。我们可以在参数块中将汤成分传递给该方法，结果该方法将汤返回给我们。像这样：

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

}

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

（假设我们有一个预先创建的Soup类）在 main 方法中，我们创建一个配料数组，然后“将其交给厨师”（将其传递给厨师方法）。“厨师做汤”然后将其作为Soup类的对象返回给我们。一切都很简单。您可以将任何参数、基本类型、对象、数组等传递给该方法。

通过引用和值传递参数

在 Java 编程语言中，任何参数都按其值传递给方法。然而，这种机制对于原始类型和对象来说是不同的。如果将任何基本类型传递到方法中并更改它，它不会在 main 方法中更改。您只需传递该值的副本，原始变量就会被保留。最简单的例子：

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;
	}

结论： 但是，对于对象，更改会影响原始对象：

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;
	}
}

结论： 我们有一个具有iq属性的WiseMan类。以及控制该字段的值的两个方法。在main方法中我们创建一个wiseMan对象，将iq值设置为300。然后我们将智商为300的圣人传递给changeObject方法，但是在这个方法中他变得愚蠢了。我们将iq的值设置为 100。然后在 main 方法中我们打印该对象。您可以看到，在changeObject方法中，我们正在操作变量m中的另一个圣人。但是，我们正在修改原始对象。事实是，main方法中的wiseMan对象和changeObject方法中的m对象是同一个wise man，并且将该对象的引用作为参数复制到方法中。当您在各个方法中编辑对象时请记住这一点。

最后，关于 static 修饰符的几句话

一般来说，在这里几句话是不够的，但我会尝试。未用此修饰符标记的常规方法属于类对象。而静态方法属于类本身。常规方法可用于单个对象。查看上面示例中的WiseMan类。每个圣人都会有自己的getIq和setIq方法，因为每个人的 IQ 水平都不同。如果我们向这个类添加一个静态方法generateAWisePhrase，那么我们就可以在没有对象的情况下调用这样的方法：

WiseMan.generateAWisePhrase();

一般来说，这些信息目前已经足够了，因为可以写几篇关于static 的讲座。编写方法来维护代码中的顺序时，请遵循一些规则：

• 为您的方法提供有意义的名称，以便清楚它们的作用。
• 尽量不要写很长的方法。最佳长度是 8-15 行。
• 方法参数的数量不应超过4-5个。
• 如果您的代码中有两次类似的功能，请想一想：也许值得将其概括并放入单独的方法中？

这些技术将帮助您提高程序的性能，最重要的是，使您的代码更具可读性。