Poslední aktualizace: leden 2020
Přestože tlačítko odložení je pravděpodobně nejčastěji používaným tlačítkem na budíku, je to i jednoduché Budík třída potřebuje několik dalších funkcí. Můžete například chtít určit, jak dlouho budík zůstane v režimu odložení. Chcete-li přidat takovou funkci, musíte pochopit, jak Java ovládá data.
Vývojáři používají proměnné v Javě uchovávat data, přičemž všechny proměnné mají datový typ a název. Datový typ určuje hodnoty, které může proměnná obsahovat. V tomto kurzu se dozvíte, jak integrální typy obsahují celá čísla, typy s plovoucí desetinnou čárkou reálná čísla a typy řetězců obsahují řetězce znaků. Pak začnete používat proměnné instance ve svých třídách Java.
Proměnné a primitivní typy
Volala primitivní typy, typy s integrovanou a plovoucí desetinnou čárkou jsou nejjednodušší datové typy v Javě. Následující program ilustruje integrální typ, který může obsahovat jak kladná, tak záporná celá čísla. Tento program také ilustruje komentáře, které dokumentují váš kód, ale nijak to neovlivňují.
/ * * Toto je také komentář. Kompilátor ignoruje vše od * prvního / * až po „hvězdné lomítko“, které končí komentář. * * Tady je "hvězdné lomítko", které končí komentář. * / public class IntegerTest {public static void main (String [] args) {// Zde je deklarace proměnné int s názvem anInteger, // kterou dáte počáteční hodnotu 100. int anInteger = 100; // Deklarovat a inicializovat anInteger System.out.println (anInteger); // Výstupy 100 // Pomocí primitivních typů můžete také provádět aritmetiku pomocí // standardních aritmetických operátorů. anInteger = 100 + 100; System.out.println (anInteger); // Výstupy 200}} Java také používá typy s plovoucí desetinnou čárkou, které mohou obsahovat reálná čísla, což znamená čísla, která obsahují desetinné místo. Zde je ukázkový program:
public class DoubleTest {public static void main (String [] args) {// Zde je deklarace dvojité proměnné zvané aDouble. // Také dáte aDouble počáteční hodnotu 5,76. double aDouble = 5,76; // Deklarovat a inicializovat aDouble System.out.println (aDouble); // Výstupy 5,76 // Můžete také provádět aritmetiku s typy s plovoucí desetinnou čárkou. aDouble = 5,76 + 1,45; System.out.println (aDouble); // Výstupy 7,21}} Zkuste spustit výše uvedené programy. Nezapomeňte, že je musíte nejprve zkompilovat:
javac * .java java IntegerTest java DoubleTest
Java používá čtyři integrální typy a dva typy s plovoucí desetinnou čárkou, které obsahují různé rozsahy čísel a zabírají různé množství úložného prostoru, jak je uvedeno v tabulkách níže.
Integrální typy
| TYP | Byte | Krátký | Int | Dlouho |
|---|---|---|---|---|
| SIZE (bity) | 8 | 16 | 32 | 64 |
| ROZSAH | -128 až 127 | -32 768 až 32 767 | -2 147 483 648 až 2 147 483 647 | -263 až 263-1 |
Typy s plovoucí desetinnou čárkou (formát IEEE 754)
| TYP | Jednoduchá plovoucí desetinná čárka | Dvojitá přesnost s plovoucí desetinnou čárkou |
|---|---|---|
| SIZE (bity) | 32 | 64 |
| ROZSAH | +/- 1,18x10-38 až +/- 3,4x1038 | +/- 2,23x10-308 až +/- 1,8x10308 |
A typ řetězce drží řetězce a zpracovává je odlišně od způsobu, jakým integrované a plovoucí desetinné čárky zpracovávají čísla. Jazyk Java zahrnuje a Tětiva třída, která představuje řetězce. Řetězec deklarujete pomocí typu Tětivaa inicializujte jej uvozovkou řetězce, posloupností znaků obsažených v uvozovkách, jak je uvedeno níže. Můžete také kombinovat dva řetězce pomocí + operátor.
// Fragment kódu // Deklarace proměnných typu String, // a inicializace s citovaným řetězcem „Hello“. Řetězec s = "Dobrý den"; // Zřetězení řetězce v s s citovaným řetězcem "World" String t = s + "World"; System.out.println (t); // Výstupy Ahoj světe
Variabilní rozsah
Kromě typu, rozsah je také důležitou charakteristikou proměnné. Rozsah určuje, kdy je proměnná vytvořena a zničena a kde má vývojář přístup k proměnné v rámci programu. Místo ve vašem programu, kde deklarujete proměnnou, určuje její rozsah.
Zatím jsem diskutoval lokální proměnné, které obsahují dočasná data, která používáte v rámci metody. Deklarujete místní proměnné uvnitř metod a máte k nim přístup pouze z těchto metod. To znamená, že můžete načíst pouze lokální proměnné anInteger, ve kterém jste použili IntegerTest, a aDouble, ve kterém jste použili DoubleTest, z hlavní metody, ve které byly deklarovány, a nikde jinde.
Místní proměnné můžete deklarovat v rámci jakékoli metody. Níže uvedený příklad kódu deklaruje místní proměnnou v AlarmClock snooze () metoda:
veřejná třída AlarmClock {public void snooze () {// Čas odložení v milisekundách = 5 s dlouhý snoozeInterval = 5000; System.out.println ("ZZZZZ pro:" + snoozeInterval); }} Můžete se dostat do snoozeInterval pouze z podřimovat() metoda, kterou jste deklarovali snoozeInterval, jak je znázorněno zde:
veřejná třída AlarmClockTest {public static void main (String [] args) {AlarmClock aClock = new AlarmClock (); aClock.snooze (); // To je stále v pořádku. // Další řádek kódu je CHYBA. // Mimo metodu snooze nemůžete přistupovat k snoozeInterval. snoozeInterval = 10 000; }} Parametry metody
A parametr metody, který má rozsah podobný místní proměnné, je dalším typem proměnné. Parametry metody předávají argumenty do metod. Když deklarujete metodu, zadáte její argumenty v seznamu parametrů. Při volání metody předáte argumenty. Parametry metody fungují podobně jako místní proměnné v tom, že leží v rozsahu metody, s níž jsou spojeny, a lze je použít v celé metodě. Na rozdíl od místních proměnných však parametry metody získají hodnotu od volajícího, když volá metodu. Zde je modifikace budíku, která vám umožní vejít do snoozeInterval.
veřejná třída AlarmClock {public void snooze (long snoozeInterval) {System.out.println ("ZZZZZ pro:" + snoozeInterval); }} veřejná třída AlarmClockTest {public static void main (String [] args) {AlarmClock aClock = new AlarmClock (); // Při volání metody předejte interval odložení. aClock.snooze (10 000); // Odložit na 10 000 ms. }} Členské proměnné: Jak objekty ukládají data
Místní proměnné jsou užitečné, ale protože poskytují pouze dočasné úložiště, jejich hodnota je omezená. Vzhledem k tomu, že jejich doby života pokrývají délku metody, ve které jsou deklarovány, místní proměnné se porovnávají s poznámkovým blokem, který se objeví pokaždé, když obdržíte telefonní hovor, ale zmizí, když zavěsíte. Toto nastavení může být užitečné pro zapisování poznámek, ale někdy potřebujete něco trvalejšího. Co má programátor dělat? Enter členské proměnné.
Členské proměnné - z nichž jsou dvě, instance a statický - tvoří součást třídy.
Variabilní rozsah a životnost
Vývojáři implementují proměnné instance tak, aby obsahovaly data užitečná pro třídu. Proměnná instance se liší od místní proměnné v povaze jejího rozsahu a její životnosti. Celá třída tvoří rozsah proměnné instance, nikoli metodu, ve které byla deklarována. Jinými slovy, vývojáři mají přístup k proměnným instance kdekoli ve třídě. Životnost proměnné instance navíc nezávisí na žádné konkrétní metodě třídy; to znamená, že jeho životnost je životnost instance, která jej obsahuje.
Instance jsou skutečné objekty, které vytvoříte z plánu, který navrhnete v definici třídy. Deklarujete proměnné instance v definici třídy, což ovlivní každou instanci, kterou vytvoříte z podrobného plánu. Každá instance obsahuje tyto proměnné instance a data uchovávaná v proměnných se mohou lišit od instance k instanci.
Zvažte Budík třída. Předávání snoozeInterval do podřimovat() metoda není skvělý design. Představte si, že musíte na budíku zadávat interval odložení, kdykoli budete hledat tlačítko odložení. Místo toho stačí dát celý budík a snoozeInterval. Doplníte to proměnnou instance v Budík třída, jak je uvedeno níže:
veřejná třída AlarmClock {// Zde deklarujete snoozeInterval. Díky tomu je proměnnou instance. // Zde také inicializujete. dlouhý m_snoozeInterval = 5000; // Čas odložení v milisekundách = 5 s. public void snooze () {// K m_snoozeInterval se stále můžete dostat metodou AlarmClock //, protože jste v rozsahu třídy. System.out.println ("ZZZZZ pro:" + m_snoozeInterval); }} K proměnným instance můžete přistupovat téměř kdekoli ve třídě, která je deklaruje. Chcete-li být technicky zdatní, deklarujete proměnnou instance v rámci rozsah třídya můžete jej načíst téměř odkudkoli v tomto rozsahu. Prakticky vzato, můžete přistupovat k proměnné kdekoli mezi první složenou závorkou, která začíná třídu, a závěrečnou závorkou. Protože také deklarujete metody v rozsahu třídy, mohou také přistupovat k proměnným instance.
Můžete také přistupovat k proměnným instance mimo třídu, pokud existuje instance a máte proměnnou, která odkazuje na instanci. Chcete-li načíst proměnnou instance prostřednictvím instance, použijte operátor tečky společně s instancí. To nemusí být ideální způsob, jak získat přístup k proměnné, ale prozatím ji doplňte pro ilustrativní účely:
veřejná třída AlarmClockTest {public static void main (String [] args) {// Vytvořte dva hodiny. Každý má svůj vlastní m_snoozeInterval AlarmClock aClock1 = nový AlarmClock (); AlarmClock aClock2 = nový AlarmClock (); // Změňte aClock2 // Brzy uvidíte, že existují mnohem lepší způsoby, jak toho dosáhnout. aClock2.m_snoozeInterval = 10 000; aClock1.snooze (); // Odložit s intervalem aClock1 aClock2.snooze (); // Odložit s intervalem aClock2}} Vyzkoušejte tento program a uvidíte to aClock1 stále má svůj interval 5 000 while aClock2 má interval 10 000. Každá instance má opět svá vlastní data instance.
Nezapomeňte, že definice třídy je pouze plán, takže proměnné instance ve skutečnosti neexistují, dokud nevytvoříte instance z plánu. Každá instance třídy má vlastní kopii proměnných instance a podrobný plán definuje, jaké budou tyto proměnné instance.
JavaWorld Zapouzdření
Zapouzdření je jedním ze základů objektově orientovaného programování. Při použití zapouzdření uživatel interaguje s typem prostřednictvím vystaveného chování, nikoli přímo s interní implementací. Prostřednictvím zapouzdření skryjete podrobnosti implementace typu. V Javě se enkapsulace v zásadě promítá do tohoto jednoduchého pokynu: „Nepřistupujte přímo k datům svého objektu; použijte jeho metody.“
To je základní myšlenka, ale usnadňuje nám to život programátorům. Představte si například, že jste chtěli poučit a Osoba předmět vstát. Bez zapouzdření by vaše příkazy mohly znít asi takto: „No, myslím, že budete muset napnout tento sval tady v přední části nohy, uvolnit tento sval tady v zadní části nohy. Hmmm - musíte se ohnout taky pas. Které svaly jiskří ten pohyb? Je třeba je utáhnout, uvolnit. Jejda! Zapomněl jsem na druhou nohu. Sakra. Dívej se na to - nepřekláněj se ... U zapouzdření byste prostě museli vyvolat postav se() metoda. Docela snadné, ano?
Některé výhody zapouzdření:
- Abstrakce detailu: Uživatel interaguje s typem na vyšší úrovni. Pokud používáte
postav se()metodou, již nemusíte znát všechny svaly potřebné k zahájení tohoto pohybu. - Izolace od změn:Změny v interní implementaci nemají na uživatele vliv. Pokud si člověk podvrtne kotník a bude na chvíli závislý na hůlce, uživatelé stále vyvolávají pouze
postav se()metoda. - Správnost:Uživatelé nemohou libovolně měnit vnitřek objektu. Mohou dokončit pouze to, co jim dovolíte v metodách, které píšete.
Zde je krátký příklad, ve kterém zapouzdření jasně pomáhá s přesností programu:
// Špatné - nepoužívá zapouzdření veřejnou třídu Osoba {int m_age; } public class PersonTest {public static void main (String [] args) {Person p = new Person (); p.m_age = -5; // Hej - jak může mít někdo minus 5 let? }} // Lepší - používá zapouzdření veřejné třídy Osoba {int m_age; public void setAge (int age) {// Zkontrolujte, zda je věk větší než 0. Budu hovořit více o // pokud příkazy v jiném čase. if (věk> 0) {m_age = věk; }}} public class PersonTest {public static void main (String [] args) {Person p = new Person (); p.setAge (-5); // Nyní nebude mít žádný účinek. }} I tento jednoduchý program ukazuje, jak se můžete dostat do problémů, pokud máte přímý přístup k interním datům tříd. Čím větší a složitější program, tím důležitější je zapouzdření. Pamatujte také, že mnoho programů začíná v malém a poté rostou tak, aby vydržely neomezeně dlouho, takže je důležité, abyste je navrhovali správně hned od začátku. Aplikovat zapouzdření na Budík, stačí vytvořit metody pro manipulaci s intervalem odložení.
Poznámka o metodách
Metody mohou vrátit hodnoty, které volající používá. Chcete-li vrátit hodnotu, deklarujte nevratný návratový typ a použijte a vrátit se prohlášení. The getSnoozeInterval () ilustruje to metoda uvedená v níže uvedeném příkladu.
