Java-datatyper (med eksempler)

Java har mange datatyper og operationer, hvilket gør den velegnet til forskellige programmeringsopgaver. Disse er ret nyttige i alle aspekter af Java, uanset om du skriver et simpelt program eller udvikler en kompleks applikation eller software. I Java omfatter data de to kernekategorier af typer primitive data og datatyper, der ikke er primitive.

Javas datatyper

Javas variabler skal være af en bestemt datatype. Der er to grupper af datatyper:

• Byte
• kort
• int
• lang
• flyde
• dobbelt
• boolesk og
• char

Listen ovenfor er eksempler på primitive datatyper. På den anden side er Strings, Arrays og Classes eksempler på ikke-primitive datatyper.

Typer af primitive data

En primitiv datatype bestemmer begge typer af variable værdier og størrelse, som ikke har nogen ekstra funktioner. I Java udgør primitive datatyper et antal på otte:

Datatype	Datastørrelse	Forklaring
byte	1 byte	har hele tal fra -128 til 127
kort	2 bytes	har hele tal fra -32.768 til 32.767
int	4 bytes	har hele tal fra -2.147.483.648 til 2.147.483.647
lang	8 bytes	har hele tal fra -9,223,372,036,854,775,808 til 9,223,372,036,854,775,807
float	4 bytes	har tal, der er brøker. Nok til at gemme mellem 6 og 7 decimaler
dobbelt	8 bytes	Gemmer brøktal. Tilstrækkelig til at gemme 15 decimaler
boolesk	1 bit	Gemmer sande eller falske værdier
char	2 bytes	Gemmer et enkelt tegn/bogstav eller ASCII-værdier

Numre

Der er to slags primitive taltyper:

• Heltalstyper gemmer hele heltal, som enten er positive eller negative såsom 123 eller -456.
• Byte, short, int og long er alle gyldige typer.

Den numeriske værdi bestemmer, hvilken type du skal vælge. Flydende kommatyper repræsenterer tal med en brøkdel og en eller flere decimaler. Float og double er de to typer.

Selvom Java har flere numeriske typer, er de mest almindeligt anvendte for tal int (for hele tal) og dobbelt for flydende kommatal. Vi vil dog gennemgå hver enkelt i detaljer, mens du læser videre.

Heltalstyper

Byte

Fra -128 til 127 kan bytedatatypen indeholde hele værdier. Når du ved, at værdien vil være mellem -128 og 127, kan du bruge denne i stedet for int eller andre heltalstyper for at spare på hukommelsen:

byte numVal = 113;
System.out.println(numVal);

Kort

De fulde numre -32768 til 32767 kan gemmes i den korte datatype:

short numVal = 4389;
System.out.println(numVal);

Int

Heltal mellem -2147483648 og 2147483647 kan gemmes i int-datatypen. Derfor, når du opretter variabler med en numerisk værdi, er int-datatypen den ideelle datatype generelt.

int numVal = 100000;
System.out.println(numVal);

Lang

Fra -9223372036854775808 til 9223372036854775807 kan den lange datatype gemme hele tal. Når int er utilstrækkelig til at lagre værdien, udnyttes denne. Det er vigtigt at bemærke, at værdien skal afsluttes med et "L":

long numVal = 15000000000L;
System.out.println(numVal);

Typer af flydende point

Det ville være bedst at bruge en flydende kommatype, når du har brug for et decimaltal, såsom 9,99 eller 3,14515.

Flyd

Brøktal mellem 3.4e-038 og 3.4e+038 kan gemmes ved hjælp af float-datatypen. Det er vigtigt at bemærke, at værdien skal afsluttes med et "f":

float floatVal = 6.85f;
System.out.println(floatVal);

Dobbelt

Brøktal mellem 1.7e-308 og 1.7e+308 kan gemmes i den dobbelte datatype. Det er vigtigt at bemærke, at værdien skal slutte med et "d":

Er det bedre at bruge float eller double?

Præcisionen af ​​en flydende decimalværdi er antallet af cifre efter decimalkommaet, som værdien kan have. Præcisionen af ​​flydende variable er kun seks eller syv decimalcifre, men nøjagtigheden af ​​dobbeltvariable er omkring 15 cifre.
Som et resultat er det mere sikkert at bruge dobbelt til de fleste beregninger.

Numbers in Science

Et videnskabeligt tal med et "e" til at repræsentere ti potensen kan også være et flydende kommatal:

float floatVal = 35e3f;
double doubleVal = 12E4d;
System.out.println(floatVal);
System.out.println(doubleVal);

Booleans

Det boolske søgeord bruges til at angive en boolsk datatype, som kun kan tage værdierne sand eller falsk:

boolean isCodeUnderscoredLegit = true;
boolean isCodeEasy = false;
System.out.println(isCodeUnderscoredLegit); // Outputs true
System.out.println(isCodeEasy); // Outputs false

Betinget test bruger i vid udstrækning booleske værdier, som du vil lære mere om senere.

Tegn

Et enkelt tegn er gemt i tegndatatypen.
Enkelte anførselstegn, såsom 'Z' eller 'b', skal omgive tegnet:

char studentScore = 'A';
System.out.println(studentScore);

Du kan også bruge ASCII-værdier til at vise specifikke tegn:

char myVar1 = 65, myVar2 = 66, myVar3 = 67;
System.out.println(myVar1);
System.out.println(myVar2);
System.out.println(myVar3);

ASCII-tabelreferencen indeholder en komplet liste over alle ASCII-værdier.

Strings

En sekvens af tegn gemmes ved hjælp af datatypen Streng (tekst). Brug desuden dobbelte anførselstegn til at omgive strengværdier:

String helloCode = "Hello Codeunderscored";
System.out.println(helloCode);

Fordi String-typen er så udbredt og integreret med Java, omtales den nogle gange som "den specielle niende type."

Bare rolig, hvis du ikke er bekendt med udtrykket "objekt". Det vedrører et objekt, en streng i Java er en ikke-primitiv datatype. Metoder på String-objektet bruges til at udføre forskellige operationer på strenge.

Typer af ikke-primitive data

Fordi de refererer til ting, kaldes ikke-primitive datatyper referencetyper. Følgende er de grundlæggende skel mellem primitive og ikke-primitive datatyper:

• I Java er primitive typer foruddefinerede (det vil sige, at de allerede er blevet erklæret). Java specificerer ikke ikke-primitive typer, som programmøren konstruerer undtagen streng.
• Ikke-primitive typer kan på den anden side bruges til at kalde metoder, der udfører specifikke handlinger, hvorimod primitive typer ikke kan.
• Ikke-primitive typer kan være nul, hvorimod primitive typer altid har en værdi.
• Et lille bogstav begynder med en primitiv type, mens et stort bogstav begynder med et ikke-primitivt.
• Størrelsen af ​​en primitiv type bestemmes af datatypen, hvorimod ikke-primitive typer alle har samme størrelse.

Strenge, arrays, klasser, grænseflader og andre ikke-primitive typer er eksempler.

Grænseflader

Grænseflader er en anden tilgang til at implementere abstraktion i Java. En grænseflade er en "abstrakt klasse", der bruges til at sammensætte relaterede funktioner med tomme kroppe:

// interface
interface Human {
  public void humanSound(); // interface method (does not have a body)
  public void run(); // interface method (does not have a body)
}

Grænsefladen skal "implementeres" (lignende nedarvet) af en anden klasse med implements nøgleordet for at få adgang til grænsefladefunktionerne (i stedet for udvider). Klassen "implement" giver interfacemetodens brødtekst:

// Interface
interface Human {
  public void humanSound(); // interface method (does not have a body)
  public void sleep(); // interface method (does not have a body)
}

// Lady "implements" the Human interface
class Lady implements Human {
  public void humanSound() {
    // The body of humanSound() is provided here
    System.out.println("The lady screams: wee wee");
  }
  public void sleep() {
    // The body 's sleep() is provided here
    System.out.println("Zzz");
  }
}

class Main {
  public static void main(String[] args) {
    Lady theLady = new Lady();  // Create a Lady object
    theLady.humanSound();
    theLady.sleep();
  }
}

Grænsefladebemærkninger

Grænseflader, ligesom abstrakte klasser, kan ikke bruges til at konstruere objekter. For eksempel er det i eksemplet ovenfor ikke muligt at oprette et "Human" objekt i MyMainClass.

"Implement"-klassen giver kroppen til grænseflademetoder, der ikke har en. Det ville hjælpe med at tilsidesætte alle en grænseflades metoder, når den implementeres. Som standard er grænseflademetoder abstrakte og offentlige. Som standard er grænsefladeattributter også offentlige, statiske og endelige. En konstruktør er heller ikke tilladt i en grænseflade, da den ikke kan oprette objekter.

Hvornår skal du bruge grænseflader?

1) For at øge sikkerheden skal du skjule visse oplysninger og kun vise de mest kritiske aspekter af et objekt (grænseflade).

2) "Multiple inheritance" er ikke understøttet i Java (en klasse kan kun arve fra én superklasse).
Men fordi klassen kan implementere mange grænseflader, kan det gøres med grænseflader.
Bemærk:For at bruge flere grænseflader, brug et komma til at adskille dem (se eksempel nedenfor).

interface InterfaceOne {
  public void interfaceOneMethod(); // interface method
}

interface InterfaceTwo {
  public void interfaceTwoMethod(); // interface method
}

// InterfaceClass "implements" InterfaceOne and  InterfaceTwo
class InterfaceClass implements InterfaceOne, InterfaceTwo {
  public void interfaceOneMethod() {
    System.out.println("Some text..");
  }
  public void interfaceTwoMethod() {
    System.out.println("Some other text...");
  }
}

class Main {
  public static void main(String[] args) {
    InterfaceClass theObj = new InterfaceClass();
    theObj.interfaceOneMethod ();
    theObj.interfaceTwoMethod ();
  }
}

Java-objekter og -klasser

Javas primære fokus som computersprog er på objekter.

I Java er alt knyttet til klasser og objekter og deres egenskaber og metoder.
En computer er for eksempel et objekt i det virkelige liv. Computeren har egenskaber som vægt og farve og procedurer som start og nedlukning.

En klasse fungerer på samme måde som en objektkonstruktør eller en "blueprint" til at konstruere ting.

Oprettelse af en klasse

Brug udtrykket klasse til at oprette en klasse:

# Main.java
# Creation of a class named "Main" with a variable a:

public class Main {
  int a = 20;
}

Husk fra Java Syntax-begreberne, at en klasse altid skal begynde med et stort bogstav, og at java-filnavnet skal være det samme som klassenavnet.

Oprettelse af et nyt objekt

En klasse i Java bruges til at bygge et objekt. Vi har allerede oprettet Main-klassen, så vi kan nu oprette objekter. For at oprette et hovedobjekt skal du skrive klassenavnet og derefter objektnavnet efterfulgt af nøgleordet new:

Eksempel:Opret et "theObj"-objekt og udskriv værdien af ​​a:

public class Main {
  int a = 20;

  public static void main(String[] args) {
    Main theObj = new Main();
    System.out.println(theObj.a);
  }
}

Objekter i multipler

Du kan lave adskillige objekter af samme type:

public class Main {
  int a = 20;

  public static void main(String[] args) {
    Main theOneObj = new Main();  // Object 1
    Main theTwoObj = new Main();  // Object 2
    System.out.println(theOneObj.a);
    System.out.println(theTwoObj.a);
  }
}

Eksempel:Opret to hovedobjekter ved hjælp af flere klasser

Du kan også bygge et klasseobjekt og bruge det i en anden klasse. Det bruges ofte til at organisere klasser (den ene klasse indeholder alle egenskaber og metoder, mens den anden har funktionen main() (kode, der skal køres)).

Husk at java-filen skal have samme navn som klassen. Vi har oprettet to filer i samme mappe/mappe i dette eksempel:

// Main.java

public class Main {
int a = 5;
}

// Second.java

class Second {
  public static void main(String[] args) {
    Main theObj = new Main();
    System.out.println(theObj.a);
  }
}

javac Main.java
javac Second.java

Når du er færdig med at kompilere begge filer, vil du være i stand til at justere Second.java-filen som følger:

java Second.java

Arrays i Java

Arrays gemmer mange værdier i en enkelt variabel i stedet for at definere særskilte variabler for hvert element. For at erklære et array skal du bruge firkantede parenteser til at bestemme variabeltypen:

String[] computers;

Vi har nu erklæret en variabel, der vil indeholde en strengmatrix. Yderligere kan vi bruge en array-literal til at tilføje værdier til den ved at placere elementerne i en kommasepareret liste inden for krøllede klammeparenteser:

String[] computers = {"HP", "Lenovo", "DELL", "Chrome Book"};

Du kan lave en matrix af heltal som følger.

int[] numVal = {30, 40, 50, 60};

Adgang til et arrays elementer

Indeksnummeret bruges til at få adgang til et array-element. I computerens array ovenfor får denne erklæring værdien af ​​det første element:

String[] computers = {"HP", "Lenovo", "DELL", "Chrome Book"};
System.out.println(computers[0]);
// Outputs HP

Bemærk, at array-indekser begynder ved 0. Som et resultat er det første element [0]. Det andet element er [1], og så videre.

Foretag en ændring af et matrixelement

Se indeksnummeret for at ændre værdien af ​​et bestemt element:

computers[0] = "IBM";

String[] computers = {"HP", "Lenovo", "DELL", "Chrome Book"};
computers[0] = "IBM";
System.out.println(computers[0]);
// Now outputs IBM instead of HP

Længde af Array

Etablering af længden af ​​et array er et aspekt af længdeegenskaben i et array:

String[] computers = {"HP", "Lenovo", "DELL", "Chrome Book"};
System.out.println(computers.length);
// Outputs 4

Gentag over et array

For-løkken kan bruges til at sløjfe gennem array-elementerne, og length-egenskaben kan bruges til at bestemme, hvor mange gange løkken skal udføres. Alle elementer i computerens array udlæses i følgende eksempel:

String[] computers = {"HP", "Lenovo", "DELL", "Chrome Book"};
int i =0;
for (i; i < computers.length; i++) {
  System.out.println(computers[i]);
}

Derudover kan du med For-Each gå gennem et array. Der er også en "for-hver"-løkke, som kun bruges til at gå gennem array-elementer:

Syntaks

for (type variable : arrayname) {
  ...
}

Ved at bruge en "for-each"-løkke udskriver følgende eksempel alle medlemmer i køretøjsarrayet:

String[] computers = {"HP", "Lenovo", "DELL", "Chrome Book"};
for (String i : computers) {
  System.out.println(i);
}

Du forstår måske det foregående eksempel, når vi opdeler det som følger:udskriv værdien af ​​i for hvert strengelement (kaldet i – som i indeks) på computere. Når du sammenligner for-løkken og for-hver-løkken, vil du bemærke, at teknikken er nemmere at kode, kræver ingen tæller (da den bruger egenskaben length) og er mere læsbar.

Arrays med flere dimensioner

Et array af arrays er et multidimensionelt array. Tilføj hver matrix inden for sit eget sæt krøllede parenteser for at lave en todimensionel matrix:

int[][] numVals = { {11, 12, 13, 14}, {15, 16, 17} };

numVals er nu et array, der indeholder to arrays som elementer. For at komme til elementerne i numVals-arrayet skal du bruge to indekser:et for arrayet og et for hvert element i det. Dette eksempel bruger det tredje medlem (2) af numVals' andet array (1):

int[][] numVals = { {11, 12, 13, 14}, {15, 16, 17} };
int a = numVals[1][2];
System.out.println(a); // Outputs 7

For at erhverve elementerne i et todimensionelt array kan vi bruge en for-løkke inde i en anden for-løkke, selvom vi stadig skal pege på de to indekser:

public class Main {
  public static void main(String[] args) {
    int[][] numVals = { {11, 12, 13, 14}, {15, 16, 17} };
    for (int i = 0; i < numVals.length; ++i) {
      for(int j = 0; j < numVals[i].length; ++j) {
        System.out.println(numVals[i][j]);
      }
    }
  }
}

Strenge i Java

Tekst gemmes ved hjælp af strenge. En strengvariabel består af en gruppe tegn indkapslet i dobbelte anførselstegn:

Eksempel:Opret en strengvariabel med følgende værdi:

String greeting = "Codeunderscored";

Længde på strengen

En streng i Java er et objekt, som omfatter metoder, der kan udføre specifikke handlinger på strenge. For eksempel kan længden af ​​en streng opnås med length() metoden:

String txtVal = "Codeunderscored";
System.out.println("The length of the text string is: " + txtVal.length());

Yderligere strengmetoder

Der er adskillige strengfunktioner, såsom toUpperCase() og toLowerCase():

String txtVal = "Code underscored";
System.out.println(txtVal .toUpperCase()); // Outputs "CODE UNDERSCORED"
System.out.println(txtVal .toLowerCase()); // Outputs "code underscored"

At finde en karakter i en streng er en vanskelig opgave. Metoden indexOf() henter den første forekomst af en leveret tekst i en streng (inklusive mellemrum):

String txtVal = "Please find where 'locate' occurs!";
System.out.println(txtVal .indexOf("find")); // Outputs

Java begynder at tælle ved nul. 0 er det første sted i en streng, 1 er det andet, og to er det tredje.

Sammenkædende strenge

+-operatøren er ansvarlig for at forbinde to strenge. Det kaldes sammenkædning:

String prefixName = "Code";
String suffixName = "underscored";
System.out.println( prefixName + " " + suffixName);

For at lave et mellemrum mellem fornavn og efternavn på print, har vi placeret en tom tekst (" ") mellem dem. Du kan også sammenkæde to strenge med concat()-metoden:

String prefixName = "Code";
String suffixName = "underscored";
System.out.println(prefixName .concat(suffixName));

Karakterer med unikke kvaliteter

Fordi strenge skal være omgivet af anførselstegn, vil Java fejlfortolke denne streng og generere følgende fejl:

String txtVal = "Codeunderscored are the "Vikings" from the web.";

Backslash escape-karakteren er en glimrende måde at undgå dette problem på. Specialtegn konverteres til strengtegn ved hjælp af escape-tegnet omvendt skråstreg (). Derudover er der i Java mere end seks escape-sekvenser, der er gyldige som følger:

Escape-tegn	Resultat	Beskrivelse
\’	‘	Enkelt citat
\”	“	Dobbelt citat
\\		Omvendt skråstreg
\n		Ny linje
\r		Carriage Return
\t		Fane
\b		Tilbage
\f		Formularfeed

I en streng indsætter sekvensen \” et dobbelt anførselstegn:

String txt = "We are the so-called \"Vikings\" from the north.";

I en streng indsætter sekvensen \' et enkelt citat:

String txt = "It\'s alright.";

Følgende sekvens \ tilføjer en enkelt omvendt skråstreg til en streng:

String txt = "The character \ is called backslash.";

Tilføjelse af strenge og tal

Operatoren + bruges i Java til både tilføjelse og sammenkædning.

• Tal føjes til ligningen.
• Strenge er forbundet.

Når to tal lægges sammen, er resultatet et tal:

int a = 50;
int b = 30;
int c = a + b; // c will be 80 (an integer/number)

Kombination af to strenge fører til en strengsammenkædning:

String a = "50";
String b = "30";
String c = a + b; // c will be 5030 (a String)

Ved at kombinere et tal og en streng får du en strengsammenkædning:

String a = "50";
int b = 30;
String c = a + b; // c will be 5030 (a String)

Konklusion

Ethvert computersprogs mest afgørende grundlag er dets datatyper. Det er den mest vitale idé for enhver nybegynder. Datatypen er påkrævet for at udtrykke arten, arten og sæt af operationer, der er forbundet med den værdi, den lagrer.

Java-datatyper er utroligt fundamentale. Det er den første ting, du bør lære, før du går over til andre Java-koncepter.