Hej! Idag ska vi prata om klasser i Java. Man kan säga att klasser utgör hörnstenen i Java-programmering. När du blir programmerare kommer nästan hela ditt jobb att vara att skriva dina egna klasser som har olika funktioner. Låt oss se vad det betyder och hur det fungerar. :) Java är som bekant ett objektorienterat programmeringsspråk. Alla program består av objekt som på ett eller annat sätt är relaterade till varandra. En klass är i grunden en mall för ett objekt. Det avgör hur objektet kommer att se ut och vilka funktioner det kommer att ha. Varje objekt är ett objekt av någon klass. Tänk på detta mycket enkla exempel:
public class Cat {
String name;
int age;
}
Låt oss säga att vi skriver ett program som involverar katter av någon anledning (vi har till exempel en veterinärklinik som erbjuder tillgång till ett onlinekonto). Vi har skapat en Cat- klass och deklarerat två variabler i den: String name och int age . Dessa medlemsvariabler kallas fält. I huvudsak är detta en mall för alla katter vi kommer att skapa i framtiden. Varje Cat- objekt kommer att ha två variabler: ett namn och en ålder.
public class Cat {
String name;
int age;
public static void main(String[] args) {
Cat smudge = new Cat();
smudge.age = 3;
smudge.name = "Smudge";
System.out.println("We created a cat named " + smudge.name + ". His age is " + smudge.age);
}
}
Så här fungerar det! Vi skapar en katt, ger den ett namn och ålder och visar allt på konsolen. Lätt som en plätt. :) Oftare än inte beskriver klasser saker och fenomen i den verkliga världen. En katt, ett bord, en person, en blixt, en sida i en bok, ett hjul – du skapar alla dessa saker i dina program med hjälp av individuella klasser. Låt oss nu fokusera på variablerna vi deklarerade i Cat -klassen. De kallas fält eller instansvariabler. Deras namn säger verkligen allt. Varje instans (eller objekt) av klassen Cat kommer att ha dessa variabler. Varje katt vi skapar kommer att ha sin egen namnvariabel och sin egen åldervariabel. Det här är vettigt - det är i princip hur det är med riktiga katter. :) Förutom instansvariabler finns det även klassvariabler (statiska variabler). Låt oss avsluta vårt exempel:
public class Cat {
String name;
int age;
static int count = 0;
public static void main(String[] args) {
Cat smudge = new Cat();
smudge.age = 3;
smudge.name = "Smudge";
count++;
Cat fluffy = new Cat();
fluffy.age = 5;
fluffy.name = "Fluffy";
count++;
System.out.println("We created a cat named " + smudge.name + ". His age is " + smudge.age);
System.out.println("We created a cat named " + fluffy.name + ". His age is " + fluffy.age);
System.out.println("Total number of cats = " + count);
}
}
Konsolutgång: Vi skapade en katt som heter Smudge. Hans ålder är 3. Vi skapade en katt som heter Fluffy. Hans ålder är 5 Totalt antal katter = 2 Nu har vår klass en ny variabel som heter count. Det är ansvarigt för att räkna de skapade katterna. Varje gång skapar vi en katt i huvudsakmetod ökar vi denna variabel med 1. Denna variabel deklareras med nyckelordet static. Det betyder att den tillhör klassen, inte till ett specifikt objekt i klassen. Vilket naturligtvis är vettigt: varje katts namn tillhör den specifika katten, men vi behöver en katträknare som gäller dem alla. Detta är precis vad nyckelordet static åstadkommer: det gör räknevariabeln till en enda variabel för alla katter. Obs: när vi visar variabeln använder vi inte smudge.count eller fluffy.count. Den tillhör varken Smudge eller Fluffy; den tillhör hela Cat- klassen. Det är därför det helt enkelt räknas. Du kan också skriva Cat.count. Det vore också korrekt. När vi visar namnvariabeln skulle vi inte göra följande:
public class Cat {
String name;
int age;
static int count = 0;
public static void main(String[] args) {
Cat smudge = new Cat();
smudge.age = 3;
smudge.name = "Smudge";
count++;
System.out.println("We created a cat named " + name + ". His age is " + smudge.age);
System.out.println("Total number of cats = " + count);
}
}
Detta är ett fel! Varje katt har sitt eget namn. Kompilatorn blir förvirrad här. "Skriv ett namn till konsolen? Vems namn?" :/"
Metoder
Förutom variabler har varje klass metoder. Vi kommer att prata om dem mer i detalj i en separat lektion, men de allmänna principerna är ganska enkla. Metoder definierar din klass funktionalitet, dvs vad objekt i din klass kan göra. Du är redan bekant med en av dessa metoder: main()- metoden. Men som du kanske minns är huvudmetoden statisk, vilket betyder att den tillhör hela klassen (logiken är densamma som med variabler). Standard, icke-statiska metoder kan dock endast anropas på specifika objekt som vi har skapat. Om vi till exempel vill skriva en kattklass måste vi veta vilka funktioner en katt i vårt program ska ha. På den premissen, låt oss skriva ett par metoder för vår katt:
public class Cat {
String name;
int age;
public void sayMeow() {
System.out.println("Meow!");
}
public void jump() {
System.out.println("Pounce!");
}
public static void main(String[] args) {
Cat smudge = new Cat();
smudge.age = 3;
smudge.name = "Smudge";
smudge.sayMeow();
smudge.jump();
}
}
Kolla in det! Nu är vår klass mycket närmare att likna en katt! Nu har vi inte bara en katt med ett namn ("Smudge") och en ålder (3). Han kan också säga mjau och hoppa! Vilken sorts katt skulle det vara utan den "funktionaliteten"? :) Vi tar ett specifikt objekt (smudge) och anropar dess metoder för sayMeow() och jump() . Låt oss titta på konsolen: Mjau! Slå till! En riktig katt! :)
Skapa dina egna klasser. Abstraktion
I framtiden kommer du att behöva skriva dina egna klasser. Vad behöver du tänka på när du skriver dem? Om vi pratar om variabler, måste du använda dig av något som kallas abstraktion. Abstraktion är en av de fyra grundläggande principerna för objektorienterad programmering. Det innebär att extrahera de viktigaste och mest betydelsefulla egenskaperna hos ett föremål, och omvänt, kasta bort de som är mindre eller obetydliga. Låt oss till exempel skapa ett arkivskåp för företagets anställda. För att skapa medarbetarobjekt har vi skrivit en Anställdklass. Vilka egenskaper är viktiga beskrivningar av en anställd för vårt företags arkivskåp? Namn, födelsedatum, SSN och anställds ID. Men det är osannolikt att vi kommer att behöva den anställdes längd, ögonfärg eller hårfärg för företagets personalrekord. Företag behöver inte denna information. Så i klassen Employee deklarerar vi följande variabler: String name , int age , int socialSecurityNumber och int employeeId. Och vi utelämnar onödig information (som ögonfärg). Vi skapar med andra ord en abstraktion. Men om vi gör ett arkivskåp för modellbyråer förändras situationen dramatiskt. En modells längd, ögonfärg och hårfärg är viktiga egenskaper, men hennes SSN är absolut irrelevant för oss. Så i klassen Model måste vi skapa följande variabler: String height , String hair , String eyes . Det är så abstraktion fungerar – det är enkelt! :)
Konstruktörer
Låt oss gå tillbaka till vårt kattexempel.
public class Cat {
String name;
int age;
public static void main(String[] args) {
Cat smudge = new Cat();
System.out.println("Here the program does something for 2 hours...");
smudge.age = 3;
smudge.name = "Smudge";
}
}
Titta igenom den här koden och försök ta reda på vad som är fel med vårt program. Vårt program hade en katt utan namn eller ålder i 2 timmar! Naturligtvis är detta i sig fel. Veterinärklinikens databas bör inte innehålla katter utan information. För närvarande är vår katt utlämnad till programmeraren. Vi litar på att han inte glömmer att ange namn och ålder, och att allt kommer att ordna sig. Om han glömmer, kommer databasen att ha ett problem: namnlösa katter. Hur kan vi lösa detta problem? Vi måste på något sätt förhindra att katter skapas utan namn och ålder. Det är här konstruktörer kommer till undsättning. Låt oss ge ett exempel:
public class Cat {
String name;
int age;
// Constructor for the Cat class
public Cat(String name, int age) {
this.name = name;
this.age = age;
}
public static void main(String[] args) {
Cat smudge = new Cat("Smudge", 5);
}
}
I huvudsak är en konstruktor en mall för objekt i en klass. I det här fallet anger vi att två argument, en String och en int , måste anges för varje kattobjekt . Om vi försöker skapa en namnlös katt nu kommer det inte att fungera.
public class Cat {
String name;
int age;
public Cat(String name, int age) {
this.name = name;
this.age = age;
}
public static void main(String[] args) {
Cat smudge = new Cat(); // Error!
}
}
Nu när klassen har en konstruktor vet Java-kompilatorn hur objekten ska se ut och tillåter inte att objekt skapas utan att ange argumenten. Låt oss nu undersöka nyckelordet detta, som du ser inuti konstruktorn. Det är också enkelt. Nyckelordet detta är för att indikera ett visst objekt. Koden i konstruktorn
public Cat(String name, int age) {
this.name = name;
this.age = age;
}
kan tolkas nästan ordagrant: "Namnet på den här katten (den vi skapar) = argumentet som skickats in för konstruktorns namnparameter. Åldern på denna katt (den vi skapar) = argumentet som skickas in för konstruktörens åldersparameter." När konstruktorn har körts kan du verifiera att alla nödvändiga värden har tilldelats vår katt:
public class Cat {
String name;
int age;
public Cat(String name, int age) {
this.name = name;
this.age = age;
}
public static void main(String[] args) {
Cat smudge = new Cat("Smudge", 5);
System.out.println(smudge.name);
System.out.println(smudge.age);
}
}
Konsolutgång: Smudge 5 När konstruktorn anropades:
Cat smudge = new Cat("Smudge", 5);
Detta är vad som faktiskt hände internt:
this.name = "Smudge";
this.age = 5;
Och värdena för argumenten som skickades till konstruktorn tilldelades smudge -objektet (det är vad detta syftar på i det här fallet). Faktum är att även om du inte deklarerar några konstruktörer i en klass, kommer den fortfarande att anropa en konstruktor! Men hur är det möjligt? О_О Eftersom alla Java-klasser har en så kallad standardkonstruktor. Det kräver inga argument, men det anropas varje gång du skapar något objekt av någon klass.
public class Cat {
public static void main(String[] args) {
Cat smudge = new Cat(); // The default constructor is invoked here
}
}
Vid första anblicken är detta kanske inte självklart. Vi skapade ett objekt, så vad? Var gör konstruktören något här? För att se det, låt oss uttryckligen skriva en tom konstruktor för Cat -klassen. Inuti den kommer vi att mata ut en fras till konsolen. Om frasen visas anropades konstruktorn.
public class Cat {
public Cat() {
System.out.println("A cat has been created!");
}
public static void main(String[] args) {
Cat smudge = new Cat(); // The default constructor is invoked here
}
}
Konsolutgång: En katt har skapats! Där är bekräftelsen. Standardkonstruktorn är alltid osynligt närvarande i dina klasser. Men du måste veta en sak till om det. Standardkonstruktorn tas bort från en klass när du skapar en konstruktor med argument. Faktum är att vi redan har sett bevis på detta ovan. Det stod i denna kod:
public class Cat {
String name;
int age;
public Cat(String name, int age) {
this.name = name;
this.age = age;
}
public static void main(String[] args) {
Cat smudge = new Cat(); // Error!
}
}
Vi kunde inte skapa en Cat utan namn och ålder, eftersom vi deklarerade en Cat- konstruktor med sträng- och int-parametrar. Detta gjorde att standardkonstruktorn omedelbart försvann från klassen. Så kom ihåg att om du behöver flera konstruktörer i din klass, inklusive en konstruktör utan argument, måste du deklarera det separat. Vår klinik vill göra goda gärningar och hjälpa hemlösa kattungar vars namn och ålder är okända. Då bör vår kod se ut så här:
public class Cat {
String name;
int age;
// For cats with owners
public Cat(String name, int age) {
this.name = name;
this.age = age;
}
// For street cats
public Cat() {
}
public static void main(String[] args) {
Cat smudge = new Cat("Smudge", 5);
Cat streetCat = new Cat();
}
}
Nu när vi har specificerat en explicit standardkonstruktor kan vi skapa båda typerna av katter. I konstruktorn kan du tilldela värden direkt. Du behöver inte alltid ta dem från argument. Till exempel skulle vi kunna märka alla gatukatter i databasen med "Gatukatt nr <count>" som mall. :
public class Cat {
String name;
int age;
static int count = 0;
public Cat() {
count++;
this.name = "Street cat No. " + count;
}
public Cat(String name, int age) {
this.name = name;
this.age = age;
}
public static void main(String[] args) {
Cat streetCat1 = new Cat();
Cat streetCat2 = new Cat();
System.out.println(streetCat1.name);
System.out.println(streetCat2.name);
}
}
Vi har en räknevariabel , som räknar våra gatukatter. Varje gång standardkonstruktorn exekveras ökar vi antalet med 1 och bifogar detta nummer till kattens namn. Argumentens ordning är mycket viktig för konstruktörer. Låt oss byta namn- och åldersargument som skickats till vår konstruktör.
public class Cat {
String name;
int age;
public Cat(int age, String name) {
this.name = name;
this.age = age;
}
public static void main(String[] args) {
Cat smudge = new Cat("Smudge", 10); // Error!
}
}
Vi fick ett fel! Konstruktören anger tydligt att när ett Cat- objekt skapas måste det skickas ett nummer och en sträng, i denna ordning. Så vår kod fungerar inte. Var noga med att komma ihåg och respektera denna regel när du deklarerar dina egna klasser:
public Cat(String name, int age) {
this.name = name;
this.age = age;
}
public Cat(int age, String name) {
this.age = age;
this.name = name;
}
Det här är två helt olika konstruktörer! Slutför nu ett par uppgifter för att stärka din förståelse av materialet. :)
Museet för antikviteter.
Din uppgift är att designa en artefaktklass .
Det finns tre typer av artefakter som förvaras på museet.
Vi vet ingenting om den första typen förutom serienumret som tilldelats av museet (till exempel: 212121).
För den andra typen känner vi till serienumret och kulturen som skapade det (till exempel: 212121, "Aztecs").
För den tredje typen känner vi till serienumret, kulturen som skapade den och århundradet den skapades i (till exempel: 212121, "Aztecs", 12).
Skapa en artefaktklass som beskriver antikviteterna som finns på museet, och skriv den uppsättning konstruktörer som krävs för klassen. Skapa sedan en artefakt av varje slag i metoden main() .
public class Artifact {
// Write your code here
public static void main(String[] args) {
// Write your code here
}
}
Dating webbsida
Låt oss skapa en användardatabas för en dejtingsajt.
Men här är problemet: du glömde den nödvändiga ordningen på argumenten och det finns ingen teknisk dokumentation tillgänglig.
Designa en användarklass som kommer att ha följande fält: namn ( String ), ålder ( kort ) och höjd ( int ).
Skapa lämpligt antal konstruktörer så att namn, ålder och höjd kan anges i valfri ordning.
public class User {
String name;
short age;
int height;
// Write your code here
public static void main(String[] args) {
}
}
För att förstärka det du lärde dig föreslår vi att du tittar på en videolektion från vår Java-kurs
GO TO FULL VERSION