Programujeme v jazyku C# - Diel 30. - OOP III.
Michal Čižmár / 13. 07. 2005, 00:00
V minulom dieli sme „načali“ metódy. Ukázali sme spôsob ich deklarácie a použitie. Dnes vám ukážem, že existujú 2 rôzne spôsoby ako predať vstupnú premennú. Ďalej sa pozrieme na to, ako si pomôcť keď má mať metóda viac výstupných premenných a niečo o preťažovaní metód.
>>Spôsob predávania vstupných parametrov
Existujú dva spôsoby ako predať vstupným parameter:
1. Predávanie hodnotou - napr. int NaDruhu(int x) x je predávane hodnotou. To znamená, že po zavolaní metódy NaDruhu() sa vytvorí dočasná premenná x (lokálna pre metódu NaDruhu), do tejto sa prekopíruje obsah vstupného parametra a po skončení funkcie zanikne.
2. Predávanie odkazom(referenciou) - nie je vytváraná dočasná premenná, ale sa len vstupná premenná previaže s novým menom podľa toho, ako je uvedené v deklarácii metódy. Všetko čo sa udeje vo vnútri metódy sa prejaví aj na vstupnej premennej na rozdiel od predávania hodnotou.
Príklad 30.1
//---------------------------------------------------
using System;
class MainClass
{
public static void Main()
{
int prva = 5;
int druha = 50;
Tools.Vymen(ref prva,ref druha);
Console.WriteLine("prva = {0},druha = {1}",
prva, druha);
}
}
//---------------------------------------------------
class Tools
{
public static void Vymen(ref int a, ref int b)
{
int temp;
temp = a;
a = b;
b = temp;
}
} //_==_
//---------------------------------------------------
Príklad na stiahnutie: www.inet.sk/download/user/Priklad30.1_referencie.zip
Vidíte, že ak chcete predávať premennú odkazom (referenciu) stačí napísať ref v deklarácii metódy pred dátový typ, ale pozor ref treba napísať aj pri volaní metódy. Naschvál som triedu Tool dal až za triedu ClassMain, aby ste videli, že trieda môže byť používaná aj pred tým, ako je jej telo uvedené.
Odporúčam každú triedu vždy ukladať do zvlášť súboru, najlepšie s tým istým menom ako má daná trieda. (Java to dokonca striktne vyžaduje).
>>Viac výstupných premenných
Niekedy si nevystačíme iba s jednou výstupnou premennou ako sú štandardne navrhnuté funkcie. Vtedy použijeme podobne ako pri ref v deklarácii metódy slovíčko out.
Príklad 30.2
//----------------------------------------------------
using System;
class Kalkulacka
{
public static void MaxMin(int[] pole, out int max,
out int min)
{
int tempMax = pole[0];
int tempMin = pole[0];
for(uint i = 0; i < pole.Length; i++)
{
if (pole[i] < tempMin) tempMin = pole[i];
if (pole[i] > tempMax) tempMax = pole[i];
}
max = tempMax;
min = tempMin;
}
}
//----------------------------------------------------
class MainClass
{
public static void Main()
{
int[] pole = new int[] {5,6,8,4,6,9,4,5};
int max,min;
Kalkulacka.MaxMin(pole,out max,out min);
Console.WriteLine("max = {0}, min={1}",max,min);
}
} //_==_
//----------------------------------------------------
Príklad na stiahnutie: www.inet.sk/download/user/Priklad30.2_out.zip
Upozorňujem, že zas treba uviesť out aj pri volaní metódy. Ak ste doteraz všetkému dobre pochopili, tak si asi hovoríte : Načo používať out, keď tým, že premennú predám ako ref sa jej hodnota zachová aj po ukončení premennej? Rozdiel je len v tom, že ak predávate nejakú premennú či už hodnotou alebo odkazom, musí byť niekde predtým inicializovaná.
Napr. v našom príklade by sme museli napísaať int max=0, min =0 a potom by to šlo.
Pri predávaní premennej pomocou out nemusí byť premenná inicializovaná.
>>Neznámi počet vstupných premenných rovnakého typu
sa dá riešiť v C# veľmi elegantne. Z príkladu všetko pochopíte. Kľúčové je slovíčko params.
Príklad 30.3
//-------------------------------------------------
using System;
class MainClass
{
private static int Max(params int[] pole)
{
int max = pole[0];
for(uint i = 0; i < pole.Length; i++)
if (pole[i] > max) max = pole[i];
return max;
}
public static void Main()
{
int[] pole = new int[] { 5,8,20,30,2,1};
Console.WriteLine(Max(pole));
}
} //_==_
//-------------------------------------------------
Príklad na stiahnutie: www.inet.sk/download/user/Priklad30.3_params.zip
>>Preťažovanie metód
Keď som sa stretom s výrazom ”preťažovanie“ metód prvý krát, zdalo sa mi to ako celkom scestné pomenovanie. Ide o doslovný preklad angl. slovíčka overloading. Teraz sa ale môj názor na to pomenovane stále nezmenil :-) a stále hľadám vhodnejší preklad. Keďže ide o zaužívaný výraz, tak ho ale používajme aj my.
Podstatou preťažovania je, že môžeme mať metódy s rovnakým menom líšiace sa len počtom a typom vstupných premenných (nie výstupných).
Príklad 30.4
//-------------------------------------------------
using System;
class MainClass
{
private static int NaDruhu(int x)
{
return x * x;
}
private static float NaDruhu(float x)
{
return x * x;
}
public static void Main(string[] args)
{
Console.WriteLine(NaDruhu(5));
Console.WriteLine(NaDruhu(2.5689f));
}
} //_==_
//-------------------------------------------------
Príklad na stiahnutie: www.inet.sk/download/user/Priklad30.4_pretazovanie.zip
>>Čo bude nabudúce?
Pozrime sa na jednu zaujímavosť, čo C++ nemalo (len C++Builder to má, ale nie je to podľa štandardu) - vlastnosti - properties. Ďalej si ukáže špeciálny typ metód a to konštruktor a deštruktor.
>>Predchádzajúce diely
......
......
......
Michal Čižmár _==_
micitn@orangemail.sk