logo

Nieprymitywne typy danych w Javie

Typy danych definiują typ danych przechowywanych w zmiennej. Typ określa rodzaj danych (różne rozmiary i wartości).

Język programowania Java ma dwa typy typów danych

  1. Nieprymitywne typy danych

    W przeciwieństwie do prymitywnych typów danych, nie są one predefiniowane. Są to typy danych zdefiniowane przez użytkownika, tworzone przez programistów. Te typy danych służą do przechowywania wielu wartości.

    ramka tkinter

    Rozważmy na przykład tablica przechowująca grupę wartości. Klasa jest także typem pierwotnym, w którym przechowywane są różne metody i zmienne. Dlatego są one również nazywane tzw zaawansowane typy danych w Jawie.

    Ilekroć zdefiniowany jest nieprymitywny typ danych, odnosi się on do lokalizacji pamięci, w której dane są przechowywane w pamięci sterty, tj. odnosi się do lokalizacji pamięci, w której umieszczony jest obiekt. Dlatego też nazywana jest także zmienna nieprymitywnego typu danych przywoływany typ danych Lub po prostu zmienna odniesienia do obiektu .

    Zmienna odniesienia do obiektu znajduje się w pamięci stosu, a obiekt, na który wskazuje, zawsze znajduje się w pamięci sterty. Stos przechowuje wskaźnik do obiektu na stercie.

    W programowaniu w języku Java wszystkie nieprymitywne typy danych nazywane są po prostu obiektami tworzonymi przez utworzenie instancji klasy.

    Kluczowe punkty:

    1. Wartość domyślna dowolnej zmiennej referencyjnej to null.
    2. Ilekroć przekazujemy do metody nieprymitywny typ danych, przekazujemy adres obiektu, w którym przechowywane są dane.

    Rodzaje nieprymitywnych typów danych

    W Javie istnieje pięć typów nieprymitywnych typów danych. Są one następujące:

    1. Klasa
    2. Obiekt
    3. Strunowy
    4. Szyk
    5. Interfejs

    1. Klasa i obiekty:

    A klasa w Javie jest typem danych zdefiniowanym przez użytkownika, tj. jest tworzony przez użytkownika. Działa jako szablon dla danych, które składają się ze zmiennych składowych i metod.

    Jakiś obiekt jest zmienną klasy, która może uzyskać dostęp do elementów klasy, tj. metod i zmiennych.

    Przykład:

    typy danych Java

    W poniższym przykładzie tworzymy klasę zawierającą zmienne i metody ( dodaj() i sub() ). Tutaj uzyskujemy dostęp do metod za pomocą obiektu klasy obj .

    ClassExample.java

     public class ClassExample { // defining the variables of class int a = 20; int b = 10; int c; // defining the methods of class public void add () { int c = a + b; System.out.println('Addition of numbers is: ' + c); } public void sub () { int c = a - b; System.out.println('Subtraction of numbers is: ' + c); } // main method public static void main (String[] args) { // creating the object of class ClassExample obj = new ClassExample(); // calling the methods obj.add(); obj.sub(); } } 

    Wyjście:

     Addition of numbers is: 30 Subtraction of numbers is: 10 

    2. Interfejs:

    Jakiś interfejs jest podobny do klasy, jednak jedyną różnicą jest to, że jego metody są domyślnie abstrakcyjne, tj. nie mają treści. Interfejs zawiera tylko końcowe zmienne i deklaracje metod. Nazywa się ją także klasą w pełni abstrakcyjną.

    wielopostaciowość

    Uwaga: Jeśli klasa implementuje interfejs, musi implementować wszystkie metody tego interfejsu. Jeśli nie, musimy zadeklarować klasę jako abstrakcyjną.

    Przykład:

    W poniższym przykładzie tworzymy interfejs CalcInterface za pomocą dwóch metod abstrakcyjnych ( pomnóż() i podziel() ). W tym przypadku klasa InterfaceExample implementuje interfejs i dodatkowo definiuje metody tego interfejsu. Następnie obiekt klasy służy do uzyskania dostępu do tych metod.

    Przykład interfejsu.java

     interface CalcInterface { void multiply(); void divide(); } public class InterfaceExample implements CalcInterface { // defining the variables of class int a = 10; int b = 20; int c; // implementing the interface methods public void multiply() { int c = a * b; System.out.println('Multiplication of numbers is: ' + c); } public void divide() { int c = a / b; System.out.println('Division of numbers is: ' + c); } // main method public static void main (String[] args) throws IOException { InterfaceExample obj = new InterfaceExample(); // calling the methods obj.multiply(); obj.divide(); } } 

    3. Ciąg:

    Łańcuch reprezentuje sekwencję znaków, na przykład „Javatpoint”, „Witaj świecie” itp. Łańcuch jest klasą języka Java.

    Poniżej przedstawiono jeden ze sposobów utworzenia ciągu znaków i zapisania w nim wartości:

     String str = 'You're the best'; 

    Tutaj zmienna typu String ul ma wartość „Jesteś najlepszy”. Kliknij tutaj, aby dowiedzieć się więcej na temat Ciąg w Javie .

    Przykład:

    klucz ins

    W poniższym przykładzie tworzymy ciąg znaków z wartością. Tutaj używamy jednej z metod klasy String, podciąg() który wypisuje określoną indeksowaną część ciągu.

    StringExample.java

     public class StringExample { public static void main(String[] args) { // creating a string and initializing it String str = 'Hello! This is example of String type'; // applying substring() on above string String subStr = str.substring(0,14); // printing the string System.out.println(subStr); } } 

    Wyjście:

     Hello! This is 

    4. Tablica:

    Jakiś szyk to typ danych, który może przechowywać wiele jednorodnych zmiennych, tj. zmiennych tego samego typu w sekwencji. Są one przechowywane w sposób indeksowany, zaczynając od indeksu 0. Zmienne mogą być pierwotnymi lub nieprymitywnymi typami danych.

    słuchaj portu

    Poniższy przykład pokazuje, jak zadeklarować tablicę pierwotnego typu danych wew :

     int [ ] marks; 

    Poniższy przykład pokazuje, jak zadeklarować tablicę nieprymitywnego typu danych:

     Student [ ] students; 

    Gdzie, Student to nazwa klasy, a [ ] tworzy tablicę obiektów studenci .

    Przykład:

    W poniższym przykładzie tworzymy dwie podstawowe tablice, w których jedna jest inicjowana, a druga deklarowana (wejście jest odczytywane od użytkownika). Ponadto drukujemy tę tablicę za pomocą pętli for.

    ArrayExample.java

     // importing required packages import java.io. * ; import java.util. * ; public class ArrayExample { public static void main(String[] args) throws IOException { int i; Scanner sc = new Scanner(System. in ); // declaring and initializing an array int arr[] = {1, 2, 3, 6, 9}; // defining another array arr1 int arr1[] = new int[5]; // reading values from the user System.out.println(&apos;Enter the numbers (size = 5) :&apos;); for (i = 0; i <5; i++) { arr1[i]="sc.nextInt();" } system.out.println('previous array with initialized size is: '); for (i="0;" i < 5; system.out.print(arr[i] + ' system.out.println('
    the new we have entered is:'); system.out.print(arr1[i] pre> <p> <strong>Output:</strong> </p> <pre> Enter the numbers (size = 5) : 56 43 22 1 7 Previous array with initialized size is: 1 2 3 6 9 The new array we have entered is: 56 43 22 1 7 </pre> <h2>Difference between Primitive and Non-primitive Data types in Java</h2> <ol class="points"> <li>In Java, the primitive data types are system defined however we have to create and define the non-primitive data types.</li> <li>In primitive data type, variables can store only one value at a time. However in non-primitive data types, either multiple values of the same type or different type or both can be stored.</li> <li>All the data for primitive type variables are stored on the stack whereas, for reference types, the stack holds a pointer to the object on the heap.</li> <li>A primitive type starts with a lowercase letter, while non-primitive types start with an uppercase letter.</li> <li>The size of a primitive type depends on the data type, while non-primitive types have all the same size.</li> </ol> <hr></5;>

    Różnica między pierwotnymi i nieprymitywnymi typami danych w Javie

    1. W Javie prymitywne typy danych są definiowane przez system, jednak musimy utworzyć i zdefiniować inne typy danych.
    2. W przypadku pierwotnego typu danych zmienne mogą przechowywać tylko jedną wartość na raz. Jednak w przypadku nieprymitywnych typów danych można przechowywać wiele wartości tego samego typu, innego typu lub obu.
    3. Wszystkie dane dla zmiennych typu pierwotnego są przechowywane na stosie, natomiast dla typów referencyjnych stos przechowuje wskaźnik do obiektu na stercie.
    4. Typ pierwotny zaczyna się od małej litery, podczas gdy typy nieprymitywne zaczynają się od dużej litery.
    5. Rozmiar typu pierwotnego zależy od typu danych, podczas gdy typy inne niż pierwotne mają ten sam rozmiar.