Кофе-брейк #190. Как преобразовать Integer в String. Статические и нестатические внутренние классы в Java

Статья из группы Random

Как преобразовать Integer в String

Источник: FreeCodeCamp Это руководство подскажет вам несколько способов преобразования целого числа (integer) в строку (string). Кофе-брейк #190. Как преобразовать Integer в String. Статические и нестатические внутренние классы в Java - 1Для преобразования переменных из одного типа данных в другой, в языке Java используются различные методы. В случае с конвертацией Integer в String можно применить один из перечисленных ниже способов:
  • Использование метода Integer.toString().
  • Использование метода String.valueOf().
  • Использование метода String.format().
  • Использование класса DecimalFormat.

Как преобразовать целое число в строку в Java с помощью Integer.toString()

Метод Integer.toString() принимает целое число для преобразования в качестве параметра. Пример синтаксиса:

Integer.toString(INTEGER_VARIABLE)
Пример кода:

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
    }
}
В данном примере мы создали целое число age и присвоили ему значение 2. Чтобы преобразовать переменную age в строку, мы передали ее в качестве параметра методу Integer.toString(): Integer.toString(age). Затем мы сохранили это новое строковое значение в строковой переменной с именем AGE_AS_STRING. И наконец, мы объединили новую строковую переменную с другими строками: "The child is " + AGE_AS_STRING + " years old". Теперь возникает вопрос: возникнет ли ошибка, если мы просто соединим переменную age с этими другими строками без какого-либо преобразования?

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
    }
}
Вывод получился такой же, как и в примере, где нам нужно было преобразовать целое число в строку. Но как мы узнаем, действительно ли преобразование типов сработало? Для этого мы можем проверить типы переменных, используя объект getClass(). Примерно вот так:

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
    }
}
Теперь мы можем убедиться, что при создании переменной age она была Integer, а после преобразования типа стала String.

Как преобразовать целое число в строку в Java с помощью String.valueOf()

Метод String.valueOf() также принимает переменную, которую нужно преобразовать в строку, в качестве параметра.

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
    }
}
Приведенный выше код аналогичен коду в предыдущем разделе:
  1. Мы создали целое число (integer) с названием age.
  2. Мы передали целое число age в качестве параметра метода String.valueOf(): String.valueOf(age).
Теперь можно проверить, работает ли преобразование типов с использованием объекта getClass():

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

Как преобразовать целое число в строку в Java с помощью String.format()

Метод String.format() принимает два параметра: спецификатор формата и форматируемую переменную. Вот пример:

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
        
    }
}
В этом примере мы передали методу String.format() два параметра: "%d" и age. "%d" — это спецификатор формата, указывающий, что форматируемая переменная является целым числом. age, который является вторым параметром, будет преобразован в строку и сохранен в переменной AGE_AS_STRING. Также можно проверить типы переменных до и после преобразования:

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

Как преобразовать целое число в строку в Java с помощью DecimalFormat

Класс DecimalFormat используется для форматирования десятичных чисел в Java. Его можно применять по-разному, но сейчас мы будем использовать его для преобразования целого числа в строку. Перед вами пример:

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
        
    }
}
Давайте разберем этот код:
  1. Чтобы иметь возможность использовать класс DecimalFormat в конкретном примере, мы импортировали его: import java.text.DecimalFormat;.
  2. Мы создали целочисленную переменную age.
  3. Затем мы создали новый объект класса DecimalFormat с названием DFormat.
  4. Используя объекта метода format(), мы преобразовали age в строку: DFormat.format(age);.

Заключение

В этой статье мы говорили о преобразовании целых чисел в строки в Java. Вы увидели примеры кода с использованием трех разных методов: Integer.toString(), String.valueOf(), String.format(), а также класса DecimalFormat. В каждом из примеров показан процесс преобразования и проверка типа данных переменной до и после преобразования.

Статические и нестатические внутренние классы в Java

Источник: Medium Благодаря этой статье вы узнаете, в чем состоят различия между статическими и нестатическими внутренними классами в Java. В Java нестатические внутренние классы (non-static inner classes, также известные как внутренние классы или внутренние объекты) имеют неявную ссылку на окружающий экземпляр (enclosing instance) внешнего класса. Это означает, что они имеют доступ к переменным экземпляра и методам внешнего класса и могут использоваться для создания нескольких экземпляров внутреннего класса, связанных с разными экземплярами внешнего класса. Давайте рассмотрим следующий код:

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
Здесь у класса Outer есть внутренний класс Inner, у которого имеется метод printX. А он, в свою очередь, печатает значение x из окружающего экземпляра Outer. Код создает два экземпляра Outer (outer1 и outer2) и два экземпляра Inner (inner1 и inner2), каждый из которых связан с разным экземпляром Outer. Когда printX вызывает inner1 и inner2, он печатает значение x из соответствующего экземпляра Outer. Поскольку нестатические внутренние классы имеют неявную ссылку на окружающий экземпляр, им требуется дополнительная память для хранения этой ссылки. Это означает, что они менее эффективно используют память, чем статические внутренние классы, которые не имеют неявной ссылки на включающий экземпляр и не требуют для этой цели дополнительной памяти. С другой стороны, статические внутренние классы не могут получить доступ к переменным или методам экземпляра внешнего класса, поэтому их возможности ограничены. Они полезны, когда вы хотите определить класс, тесно связанный с внешним классом и не нуждающийся в доступе к его переменным или методам экземпляра. Нестатические внутренние классы (также известные как внутренние классы или внутренние объекты) полезны, когда вы хотите определить класс, который тесно связан с другим классом и имеет доступ к переменным экземпляра и методам внешнего класса.

Использование нестатических внутренних классов

Вот несколько ситуаций, когда вы можете захотеть использовать нестатический внутренний класс:
  1. Когда внутреннему классу необходимо получить доступ к переменным экземпляра или методам внешнего класса, которые не являются static. Поскольку нестатические внутренние классы имеют неявную ссылку на окружающий экземпляр внешнего класса, они могут напрямую обращаться к нестатическим переменным и методам экземпляра.

  2. Когда вы хотите определить несколько экземпляров внутреннего класса, связанных с разными экземплярами внешнего класса. Например, вы можете захотеть создать нестатический внутренний класс Button для класса Dialog, где каждый экземпляр Button связан с другим экземпляром Dialog и может получить доступ к переменным экземпляра и методам экземпляра Dialog.

  3. Когда вы хотите определить класс, который используется только в контексте внешнего класса и не предназначен для независимого использования. Доступ к нестатическим внутренним классам возможен только из внешнего класса, поэтому они более инкапсулированы и менее подвержены непреднамеренному использованию.

Использование статических внутренних классов

Мы можем использовать статические внутренние классы, если нам не нужен доступ к каким-либо переменным экземпляра или методам внешнего класса, и по этой причине им не нужно иметь неявную ссылку на окружающий экземпляр внешнего класса. Это делает их более эффективными с точки зрения использования памяти, чем нестатические внутренние классы, которые имеют неявную ссылку на окружающий экземпляр. Допустим, нам нужно спроектировать график, который содержит траектории (edges) и точки пересечения (nodes). Классы Node и Edge тесно связаны с классом Graph и используются только в контексте объекта Graph. Определение их как статических внутренних классов дает понять, что они являются частью класса Graph и не предназначены для независимого использования.

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;
        }
    }
    
}
Статические внутренние классы не могут получить доступ к переменным или методам экземпляра Вот пример, иллюстрирующий тот факт, что статические внутренние классы не могут получить доступ к переменным или методам экземпляра внешнего класса:

class Outer {
    private int x;
static class Inner {
        public void printX() {
            System.out.println(x);  // compilation error: cannot access x
        }
    }
}
В этом примере класс Outer имеет приватную переменную экземпляра x и статический внутренний класс Inner. У класса Inner есть метод printX, который пытается получить доступ к значению x из окружающего экземпляра Outer. Однако этот код не будет компилироваться, поскольку статические внутренние классы не могут получить доступ к переменным или методам экземпляра внешнего класса. Чтобы получить доступ к переменным экземпляра или методам внешнего класса из статического внутреннего класса, вы можете:
  1. Создать переменные или методы экземпляра static. Это позволит внутреннему классу обращаться к ним, используя имя внешнего класса (например, Outer.x).

  2. Передать экземпляр внешнего класса внутреннему классу и сохранить его в поле. Затем внутренний класс может получить доступ к переменным экземпляра или методам внешнего класса через это поле.

Вот пример, который показывает, как это сделать:

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
В данном примере у класса Outer есть нестатический метод setX, который задает значение x, и статический внутренний класс Inner с полем outer типа Outer. У класса Inner есть конструктор, который принимает экземпляр Outer и сохраняет его в поле outer. Затем метод printX класса Inner может получить доступ к полю x экземпляра outer, используя нотацию outer.x.
Комментарии (1)
ЧТОБЫ ПОСМОТРЕТЬ ВСЕ КОММЕНТАРИИ ИЛИ ОСТАВИТЬ КОММЕНТАРИЙ,
ПЕРЕЙДИТЕ В ПОЛНУЮ ВЕРСИЮ
Alexandr М Уровень 2
19 января 2023
Не плохая статья, но что за беда с фигурными скобками? Закрытых больше, чем открытых, из-за этого не понятно во внутреннем или внешнем классе идет запись. Ну и объявление новых экземпляров класса до вольно не читабельно на мой взгляд)