Mga pamamaraan sa Java

May isang kawili-wiling prinsipyo na narinig ng marami. Ito ay tinatawag na "Divide and Conquer." Ang prinsipyong ito ay ginagamit sa maraming larangan ng buhay ng tao, halimbawa, sa pulitika. Tinutukoy nito ang paghahati ng malaking bilang ng mga magkakaibang bahagi sa estado, na nag-uudyok at gumagamit ng poot sa pagitan ng mga bahaging ito. Sa madaling salita: lumikha ng salungatan sa pagitan ng mga posibleng magdulot ng banta sa kapangyarihan. Ngunit kami ay mga programmer, kaya interesado lamang kami sa teknikal na interpretasyon ng prinsipyong ito. At ito ay ganito: “Ang prinsipyo ng “Divide and Conquer” ay ang hatiin ang isang malaking problema sa maliliit na problema hanggang sila ay maging elementarya. Pagkatapos ay kailangan mong lutasin ang mga ito nang sunud-sunod at pagsamahin ang lahat sa isang buong sistema. Dapat lutasin ng program na ito ang ibinigay na problema” Ibig sabihin, hatiin mo lang ang isang malaking problema sa mas maliit, na hindi problema para sa iyo upang malutas. At pagkatapos ay kinokolekta mo ang solusyon sa isang malaking solusyon. Upang sundin ang simple at kapaki-pakinabang na prinsipyong ito, ang Java programming ay gumagamit ng mga pamamaraan. Halimbawa, gumagawa kami ng robot boxer. Mahalaga para sa amin na siya ay gumagalaw nang maayos, nagsasagawa ng tumpak na mga welga, at pinapanood din ang kaaway sa paghahanap ng mga mahihinang punto. Magiging awkward na isulat ang lahat ng ito sa isang pangunahing pamamaraan , hindi ba? Kung ilalarawan namin ang lahat sa isang paraan, ito ay magiging katulad nito:

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

Paano kung kailangan nating gumamit ng isang hakbang pasulong o sipa sa ibang lugar sa programa? Ilarawan muli ang lahat ng mga aksyon? Hindi kasya. Napakaraming paulit-ulit na linya na madaling mawala. Kailangan nating ilagay ang paglalarawan ng mga detalye ng aksyon sa isang hiwalay na module, na magsasagawa ng robot step. At maaari nating tawagan ang pamamaraan sa isang linya. Isang bagay na tulad nito:

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

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

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

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

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

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

Ngayon ay pinaghiwalay na namin ang pag-andar ng robot, pati na rin ang isang compact at malinaw na main() na pamamaraan . Ang natitirang mga pamamaraan ay maaari ding hatiin sa anumang pag-andar, halimbawa, mapanlinlang na Pag-atake Strike ay maaaring nahahati sa mga pamamaraan ng panlilinlang Movement , Leg movement , attack . At sila naman, ay itinalaga sa mas simpleng mga gawain upang sa huli ay makakuha ng isang hanay ng mga elementarya. Okay, ngayon ay isulat natin ang lahat nang maganda sa isang form na tatanggapin ng 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;
}

Naiintindihan ko na ang code na ito ay maaaring medyo hindi malinaw sa iyo ngayon, lalo na ang ilang mga salita tulad ng void , return at iba pa. Huwag magmadaling magtapon ng mga kamatis, ipapaliwanag ko ang lahat ngayon. Ang pangkalahatang ideya ng paradigm na "Hatiin at Lupigin" ay dapat na malinaw sa iyo. Ang mga pamamaraan ay makakatulong sa atin dito. Ang pangkalahatang istraktura ng mga deklarasyon ng pamamaraan ay ang mga sumusunod:

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

Access modifier

Ang access modifier ay ilang mga keyword: pampubliko , pribado , package . Ang mga salitang ito ay nagpapahiwatig ng saklaw ng pamamaraan. Ipapaliwanag ko ito nang simple: sa salitang ito ay tila nagbabahagi ka ng masarap na pagkain sa iba. Masarap ang paraan mo. Kung ito ay pribado , hindi mo ibabahagi ang pamamaraan sa ibang mga klase. Kung package , nagbabahagi ka lamang sa mga klase sa loob ng package (ang mga klase ay kinokolekta sa mga partikular na pakete, malalaman mo ito sa ibang pagkakataon). Well, public shows na ikaw mismo ay kabaitan at nagbabahagi ng masarap na treat (paraan) sa buong programa. Isang bagay na tulad nito. Pagkatapos ng ilang antas ay mas mauunawaan mo ang papel ng mga salitang ito.

Ibalik ang halaga

Tingnan ang halimbawa sa itaas: lahat ng mga pamamaraan ay minarkahan ng void na keyword , maliban sa isa - isEnemyAttacked , na nagbabalik ng boolean value . Kung ang isang paraan ay minarkahan na walang bisa , maaaring wala itong ibalik. Ang pamamaraang ito ay nagsasagawa lamang ng isang hanay ng mga aksyon at iyon na. Ngayon bigyang pansin ang pangunahing pamamaraan . Ang mga pamamaraan na nagbabalik ng walang bisa ay tinatawag na ganoon, sa katawan ng pamamaraan. Ngunit ang isEnemyAttacked na pamamaraan ay tinatawag sa loob ng mga panaklong ng if statement . Dahil sa katotohanang nagbabalik ito ng boolean na halaga, nagkakaroon kami ng pagkakataong hindi gumamit ng intermediate variable, ngunit direktang ipasok ito. Ang pagbabalik ng isang halaga ay nangyayari gamit ang return keyword . Kung ang isang pamamaraan ay nagbabalik ng uri int , maaari naming tawagan ang pamamaraan mula sa anumang expression:

public static int getNumber() {
 	    return 5;
}

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

Konklusyon: Ang getNumber method ay nagbabalik ng int value , para matawag natin ito mula sa isang expression. Gayundin, maaaring ibalik ng pamamaraan ang anumang uri, kabilang ang mga ginawa mo mismo. Kung tinukoy mo ang isang uri ng pagbabalik para sa isang paraan, dapat kang magbalik ng isang bagay. Hindi mo maaaring isulat ito ng ganito:

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

Papagalitan ka ng compiler na kapag natugunan ang unang kundisyon, may ibabalik ka, ngunit kapag natugunan ang pangalawang kundisyon, hindi mo.

Pagpasa ng mga parameter

Maaari mong ipasa ang mga parameter sa paraan na ginagamit sa panahon ng operasyon nito. Ang pinaka-primitive na halimbawa ay ang kabuuan ng dalawang numero. Pero hindi naman tayo primitive diba? Kumuha tayo ng isa pang halimbawa, medyo stereotypical. Sabihin nating mayroon tayong pamamaraan chef() - magluto. Maaari naming ipasa ang mga sangkap ng sopas sa paraang ito sa bloke ng parameter, at bilang resulta, ibinabalik sa amin ng pamamaraang ito ang sopas. Ganito:

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

}

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

(Sabihin natin na mayroon tayong paunang ginawang klase ng Soup ) Sa pangunahing pamamaraan, gumagawa tayo ng hanay ng mga sangkap at pagkatapos ay “ibigay ito sa chef” (ipasa ito sa paraan ng chef ). "Ginagawa ng kusinero ang sopas" at pagkatapos ay ibinalik ito sa amin bilang isang bagay ng klase ng Soup . Napakasimple ng lahat. Maaari mong ipasa ang anumang mga parameter, primitive na uri, bagay, array, at iba pa sa pamamaraan.

Pagpasa ng mga parameter sa pamamagitan ng sanggunian at sa pamamagitan ng halaga

Sa Java programming language, ang anumang mga parameter ay ipinapasa sa isang paraan sa pamamagitan ng kanilang halaga. Gayunpaman, ang mekanismong ito ay naiiba para sa mga primitive na uri at para sa mga bagay. Kung ipapasa mo ang anumang primitive na uri sa isang pamamaraan at babaguhin ito, hindi ito magbabago sa pangunahing pamamaraan. Nagpasa ka lang ng kopya ng value, at napanatili ang orihinal na variable. Ang pinakasimpleng halimbawa:

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

Konklusyon: Gayunpaman, sa kaso ng mga bagay, ang mga pagbabago ay nakakaapekto sa orihinal na bagay:

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

Konklusyon: Mayroon kaming klase ng WiseMan na mayroong iq property . At dalawang paraan na kumokontrol sa halaga ng field na ito. Sa pangunahing paraan lumikha kami ng isang bagay na wiseMan , itakda ang halaga ng iq sa 300 . Pagkatapos ay ipinapasa namin ang aming sage na may iq 300 sa paraan ng changeObject . Ngunit sa pamamaraang ito siya ay nagiging tanga. Itinakda namin ang halaga ng iq sa 100. Pagkatapos ay sa pangunahing paraan namin i-print ang bagay. Makikita mo na sa paraan ng changeObject kami ay nagmamanipula ng isa pang pantas sa variable na m . Gayunpaman, binabago namin ang aming orihinal na bagay. Ang katotohanan ay ang bagay na wiseMan sa pangunahing pamamaraan at ang bagay na m sa paraan ng changeObject ay ang parehong matalinong tao, at ang isang sanggunian sa bagay ay kinopya sa pamamaraan bilang isang parameter. Isaisip ito kapag nag-edit ka ng isang bagay sa mga indibidwal na pamamaraan.

Panghuli, ilang salita tungkol sa static na modifier

Sa pangkalahatan, ang ilang mga salita ay hindi gagawin dito, ngunit susubukan ko. Ang mga regular na pamamaraan na hindi minarkahan ng modifier na ito ay nabibilang sa object ng klase. At ang mga static na pamamaraan ay nabibilang sa klase mismo. Maaaring gamitin ang mga regular na pamamaraan sa mga indibidwal na bagay. Tingnan ang klase ng WiseMan mula sa halimbawa sa itaas. Ang bawat pantas ay magkakaroon ng sariling getIq at setIq na pamamaraan , dahil ang antas ng IQ ng bawat isa ay iba-iba. Kung magdaragdag kami ng isang static na paraan generateAWisePhrase sa klase na ito , pagkatapos ay maaari naming tawagan ang ganoong pamamaraan nang walang object:

WiseMan.generateAWisePhrase();

Sa pangkalahatan, sapat na ang impormasyong ito sa ngayon, dahil maraming mga lektura ang maaaring isulat tungkol sa static . Sundin ang ilang panuntunan kapag nagsusulat ng paraan upang mapanatili ang kaayusan sa iyong code:

• Bigyan ang iyong mga pamamaraan ng makabuluhang mga pangalan upang ito ay malinaw kung ano ang kanilang ginagawa.
• Subukang huwag magsulat ng napakahabang pamamaraan. Ang pinakamainam na haba ay 8-15 linya.
• Ang bilang ng mga parameter ng pamamaraan ay hindi dapat lumampas sa 4-5.
• Kung mayroon kang katulad na pag-andar nang dalawang beses sa iyong code, isipin: marahil ito ay nagkakahalaga ng pag-generalize nito at ilagay ito sa isang hiwalay na paraan?

Tutulungan ka ng mga diskarteng ito na mapabuti ang pagganap ng iyong programa at, higit sa lahat, gawing mas nababasa ang iyong code.