Przerwa kawowa #190. Jak przekonwertować liczbę całkowitą na ciąg. Statyczne i niestatyczne klasy wewnętrzne w Javie

Jak przekonwertować liczbę całkowitą na ciąg

Źródło: FreeCodeCamp W tym samouczku dowiesz się kilku sposobów konwersji liczby całkowitej na ciąg znaków. Aby przekonwertować zmienne z jednego typu danych na inny, język Java wykorzystuje różne metody. W przypadku konwersji Integer na String możesz skorzystać z jednej z poniższych metod:

• Korzystanie z metody Integer.toString() .
• Korzystanie z metody String.valueOf() .
• Korzystanie z metody String.format() .
• Korzystanie z klasy DecimalFormat .

Jak przekonwertować liczbę całkowitą na ciąg znaków w Javie za pomocą Integer.toString()

Metoda Integer.toString() przyjmuje liczbę całkowitą do konwersji jako parametr. Przykładowa składnia:

Integer.toString(INTEGER_VARIABLE)

Przykładowy kod:

class IntToStr {
    public static void main(String[] args) {

        int age = 2;
        String AGE_AS_STRING = Integer.toString(age);

        System.out.println("The child is " + AGE_AS_STRING + " years old");
        // The child is 2 years old
    }
}

W tym przykładzie utworzyliśmy wiek całkowity i przypisaliśmy mu wartość 2 . Aby zamienić zmienną age na ciąg znaków, przekazaliśmy ją jako parametr do metody Integer.toString(): Integer.toString(age) . Następnie zapisaliśmy tę nową wartość ciągu w zmiennej łańcuchowej o nazwie AGE_AS_STRING . Na koniec połączyliśmy nową zmienną łańcuchową z innymi ciągami: „Dziecko ma „ + AGE_AS_STRING + „ lat” . Teraz pytanie brzmi: czy wystąpi błąd, jeśli po prostu połączymy zmienną wieku z innymi ciągami znaków bez żadnej konwersji?

class IntToStr {
    public static void main(String[] args) {

        int age = 2;

        System.out.println("The child is " + age + " years old");
        // The child is 2 years old
    }
}

Wynik jest taki sam jak w przykładzie, w którym musieliśmy przekonwertować liczbę całkowitą na ciąg znaków. Ale skąd mamy wiedzieć, czy konwersja typu rzeczywiście zadziałała? W tym celu możemy sprawdzić typy zmiennych za pomocą obiektu getClass() . Coś takiego:

class IntToStr {
    public static void main(String[] args) {

        int age = 2;

        String AGE_AS_STRING = Integer.toString(age);


        System.out.println(((Object)age).getClass().getSimpleName());
        // Integer

        System.out.println(AGE_AS_STRING.getClass().getSimpleName());
        // String
    }
}

Teraz możemy sprawdzić, czy w momencie tworzenia zmiennej age była to liczba całkowita , a po konwersji typu stała się ona ciągiem znaków .

Jak przekonwertować liczbę całkowitą na ciąg znaków w Javie za pomocą String.valueOf()

Metoda String.valueOf() jako parametr przyjmuje również zmienną, która ma zostać przekonwertowana na ciąg znaków.

class IntToStr {
    public static void main(String[] args) {

        int age = 2;

        String AGE_AS_STRING = String.valueOf(age);

        System.out.println("The child is " + AGE_AS_STRING + " years old");
        // The child is 2 years old
    }
}

Powyższy kod jest podobny do kodu z poprzedniej sekcji:

1. Stworzyliśmy liczbę całkowitą zwaną wiekiem .
2. Przekazaliśmy wiek całkowity jako parametr do metody String.valueOf(): String.valueOf(age) .

Teraz możesz sprawdzić, czy konwersja typów działa, używając obiektu getClass() :

System.out.println(((Object)age).getClass().getSimpleName());
// Integer

System.out.println(AGE_AS_STRING.getClass().getSimpleName());
// String

Jak przekonwertować liczbę całkowitą na ciąg znaków w Javie za pomocą String.format()

Metoda String.format() przyjmuje dwa parametry: specyfikator formatu i zmienną, która ma zostać sformatowana. Oto przykład:

class IntToStr {
    public static void main(String[] args) {

        int age = 2;

        String AGE_AS_STRING = String.format("%d", age);

        System.out.println("The child is " + AGE_AS_STRING + " years old");
        // The child is 2 years old

    }
}

W tym przykładzie do metody String.format() przekazaliśmy dwa parametry : „%d” i age . „%d” jest specyfikatorem formatu wskazującym, że formatowana zmienna jest liczbą całkowitą. wiek , który jest drugim parametrem, zostanie przekonwertowany na ciąg znaków i zapisany w zmiennej AGE_AS_STRING . Możesz także sprawdzić typy zmiennych przed i po konwersji:

System.out.println(((Object)age).getClass().getSimpleName());
// Integer

System.out.println(AGE_AS_STRING.getClass().getSimpleName());
// String

Jak przekonwertować liczbę całkowitą na ciąg znaków w Javie przy użyciu DecimalFormat

Klasa DecimalFormat służy do formatowania liczb dziesiętnych w Javie. Można go używać na wiele różnych sposobów, ale na razie użyjemy go do konwersji liczby całkowitej na ciąg znaków. Oto przykład:

import java.text.DecimalFormat;

class IntToStr {
    public static void main(String[] args) {

        int age = 2;

        DecimalFormat DFormat = new DecimalFormat("#");


        String AGE_AS_STRING = DFormat.format(age);

        System.out.println("The child is " + AGE_AS_STRING + " years old");
        // The child is 2 years old


        System.out.println(((Object)age).getClass().getSimpleName());
        // Integer

        System.out.println(AGE_AS_STRING.getClass().getSimpleName());
        // String

    }
}

Spójrzmy na ten kod:

1. Aby móc wykorzystać klasę DecimalFormat w konkretnym przykładzie, zaimportowaliśmy ją: import java.text.DecimalFormat; .
3. Stworzyliśmy zmienną całkowitą age .
4. Następnie utworzyliśmy nowy obiekt DecimalFormat o nazwie DFormat .
5. Używając metody format() obiektu , przekonwertowaliśmy wiek na ciąg znaków: DFormat.format(wiek); .

Wniosek

W tym artykule rozmawialiśmy o konwersji liczb całkowitych na ciągi znaków w Javie. Widziałeś przykłady kodu wykorzystującego trzy różne metody: Integer.toString() , String.valueOf() , String.format() i klasę DecimalFormat . Każdy przykład pokazuje proces konwersji oraz sprawdzanie typu danych zmiennej przed i po konwersji.

Statyczne i niestatyczne klasy wewnętrzne w Javie

Źródło: Medium W tym artykule poznasz różnice pomiędzy statycznymi i niestatycznymi klasami wewnętrznymi w Javie. W Javie niestatyczne klasy wewnętrzne (znane również jako klasy wewnętrzne lub obiekty wewnętrzne) mają ukryte odniesienie do otaczającej instancji klasy zewnętrznej. Oznacza to, że mają dostęp do zmiennych i metod instancji klasy zewnętrznej i można ich używać do tworzenia wielu instancji klasy wewnętrznej, które są powiązane z różnymi instancjami klasy zewnętrznej. Spójrzmy na następujący kod:

class Outer {
    private int x;
 class Inner {
        public void printX() {
            System.out.println(x);
        }
    }
}
Outer outer1 = new Outer();
outer1.x = 5;
Outer.Inner inner1 = outer1.new Inner();
inner1.printX(); // prints 5
Outer outer2 = new Outer();
outer2.x = 10;
Outer.Inner inner2 = outer2.new Inner();
inner2.printX(); // prints 10

Tutaj klasa Outer ma klasę wewnętrzną Inner , która ma metodę printX . A to z kolei wypisuje wartość x z otaczającej instancji Outer . Kod tworzy dwie instancje Outer ( external1 i external2 ) oraz dwie instancje Inner ( internal1 i inside2 ), każdą powiązaną z inną instancją Outer . Gdy printX wywołuje internal1 i inside2 , wypisuje wartość x z odpowiedniej instancji Outer . Ponieważ niestatyczne klasy wewnętrzne mają ukryte odniesienie do otaczającej instancji, wymagają dodatkowej pamięci do przechowywania tego odniesienia. Oznacza to, że są mniej wydajne pod względem pamięci niż statyczne klasy wewnętrzne, które nie mają ukrytego odniesienia do otaczającej ich instancji i nie wymagają do tego dodatkowej pamięci. Z drugiej strony statyczne klasy wewnętrzne nie mają dostępu do zmiennych ani metod instancji klasy zewnętrznej, więc ich możliwości są ograniczone. Są przydatne, gdy chcesz zdefiniować klasę, która jest ściśle powiązana z klasą zewnętrzną i nie potrzebuje dostępu do zmiennych ani metod jej instancji. Niestatyczne klasy wewnętrzne (znane również jako klasy wewnętrzne lub obiekty wewnętrzne) są przydatne, gdy chcesz zdefiniować klasę, która jest ściśle powiązana z inną klasą i ma dostęp do zmiennych instancji i metod klasy zewnętrznej.

Używanie niestatycznych klas wewnętrznych

Oto kilka sytuacji, w których możesz chcieć użyć niestatycznej klasy wewnętrznej:

1. Kiedy klasa wewnętrzna potrzebuje dostępu do zmiennych instancji lub metod klasy zewnętrznej, które nie są statyczne . Ponieważ niestatyczne klasy wewnętrzne mają ukryte odniesienie do otaczającej instancji klasy zewnętrznej, mogą uzyskać bezpośredni dostęp do zmiennych i metod instancji niestatycznej.

2. Gdy chcesz zdefiniować wiele instancji klasy wewnętrznej powiązanych z różnymi instancjami klasy zewnętrznej. Na przykład możesz chcieć utworzyć niestatyczną klasę wewnętrzną Button dla klasy Dialog , w której każda instancja Button jest powiązana z inną instancją Dialog i może uzyskać dostęp do zmiennych i metod instancji Dialog .

3. Gdy chcesz zdefiniować klasę, która jest używana tylko w kontekście klasy zewnętrznej i nie jest przeznaczona do użycia niezależnie. Dostęp do niestatycznych klas wewnętrznych można uzyskać tylko z klasy zewnętrznej, dzięki czemu są one bardziej hermetyzowane i mniej podatne na niezamierzone użycie.

Używanie statycznych klas wewnętrznych

Statycznych klas wewnętrznych możemy używać, jeśli nie potrzebujemy dostępu do żadnych zmiennych instancji ani metod klasy zewnętrznej i z tego powodu nie muszą one mieć ukrytego odniesienia do otaczającej instancji klasy zewnętrznej. Dzięki temu są one bardziej wydajne pod względem pamięci niż niestatyczne klasy wewnętrzne, które mają ukryte odniesienie do otaczającej instancji. Załóżmy, że musimy zaprojektować wykres zawierający trajektorie (krawędzie) i punkty przecięcia (węzły). Klasy Node i Edge są ściśle powiązane z klasą Graph i są używane wyłącznie w kontekście obiektu Graph . Zdefiniowanie ich jako statycznych klas wewnętrznych jasno pokazuje, że są one częścią klasy Graph i nie są przeznaczone do użycia niezależnie.

public class Graph {

    Map <String, Node> nodeMap;

    public Graph () {
        nodeMap = new HashMap<>();
    }

    static class Node {
        String name;
        List <Edge> edgeList;

        public Node(String name) {
            this.name = name;
            edgeList = new ArrayList();
        }
    }

    static class Edge {
        Node source;
        Node Destination;
        String type;

        public Edge(Node source, Node destination, String type) {
            this.Destination = destination;
            this.source = source;
            this.type = type;
        }
    }

}

Statyczne klasy wewnętrzne nie mają dostępu do zmiennych instancji ani metod. Oto przykład ilustrujący fakt, że statyczne klasy wewnętrzne nie mają dostępu do zmiennych instancji ani metod klasy zewnętrznej:

class Outer {
    private int x;
static class Inner {
        public void printX() {
            System.out.println(x);  // compilation error: cannot access x
        }
    }
}

W tym przykładzie klasa Outer ma prywatną zmienną instancji x i statyczną klasę wewnętrzną Inner . Klasa Inner posiada metodę printX , która próbuje uzyskać dostęp do wartości x z otaczającej ją instancji Outer . Jednak ten kod nie zostanie skompilowany, ponieważ statyczne klasy wewnętrzne nie mają dostępu do zmiennych ani metod instancji klasy zewnętrznej. Aby uzyskać dostęp do zmiennych instancji lub metod klasy zewnętrznej ze statycznej klasy wewnętrznej, możesz:

1. Utwórz statyczne zmienne lub metody instancji . Umożliwi to klasie wewnętrznej odwoływanie się do nich przy użyciu nazwy klasy zewnętrznej (np. Outer.x ).

2. Przekaż instancję klasy zewnętrznej do klasy wewnętrznej i zapisz ją w polu. Klasa wewnętrzna może następnie uzyskać dostęp do zmiennych instancji lub metod klasy zewnętrznej za pośrednictwem tego pola.

Oto przykład pokazujący, jak to zrobić:

class Outer {
    private int x;
public void setX(int x) {
        this.x = x;
    }
    static class Inner {
        Outer outer;
        public Inner(Outer outer) {
            this.outer = outer;
        }
        public void printX() {
            System.out.println(outer.x);
        }
    }
}
Outer outer = new Outer();
outer.setX(5);
Outer.Inner inner = new Outer.Inner(outer);
inner.printX();  // prints 5

W tym przykładzie klasa Outer ma niestatyczną metodę setX , która ustawia wartość x , oraz statyczną klasę wewnętrzną Inner z polem zewnętrznym typu Outer . Klasa Inner posiada konstruktor, który pobiera instancję Outer i przechowuje ją w polu zewnętrznym . Metoda printX klasy Inner może następnie uzyskać dostęp do pola x instancji zewnętrznej przy użyciu notacji external.x .