Который сделал бы файл Класса больше? импорт java.awt.*, или набор или единственные операторы импорта? [дубликат]

Честно, почему Вы заботитесь о размере Вашего файла класса?

Это - лучшая практика для явного включения всех классов, необходимых вместо того, чтобы делать "импорт foo.bar.*".

Это делает Ваш код более читаемым, и более удобным в сопровождении.

Java import оператор не добавляет размера к файлу класса. Это позволяет компилятору выводить то, к чему относятся имена во время компиляции.

Единственная разница строка

import java.util.*;

делает то, что можно записать:

Set<String> set;

вместо:

java.util.Set<String> set;

Нет, нет никакого различия вообще.

Согласно Спецификациям виртуальной машины Java, Второму Выпуску, Главе 5: Загрузка, Соединение и Инициализация говорят следующее:

Виртуальная машина Java динамично загружается (§2.17.2), ссылки (§2.17.3), и инициализирует (§2.17.4) классы и интерфейсы. Загрузка является процессом нахождения двоичного представления класса или интерфейсного типа с конкретным именем и созданием класса или интерфейса от того двоичного представления. Соединение является процессом посещения урока или интерфейса и объединения его в состояние во время выполнения виртуальной машины Java так, чтобы это могло быть выполнено.

Во время компиляции нет никакого соединения классов, поэтому, с помощью подстановочных знаков для importлуг не имеет никакого значения. Другие классы не включены вместе в получающееся class файл.

На самом деле, если Вы смотрите на байт-код class файл (через javap или такой дизассемблер), Вы не найдете никого import операторы, таким образом имея более или менее числа import операторы в Вашем источнике не будут влиять на размер class файл.

Вот простой эксперимент: Попытайтесь писать программу и скомпилировать с imports использование подстановочных знаков и другого с явным импортом. Получающееся class файл должен быть тем же размером.

Используя явный import операторы на определенных классах, возможно, менее читаемы (и неприятны, если Вы не используете IDE как Eclipse, который запишет это для Вас), но позволит Вам иметь дело с перекрытиями имен классов в двух пакетах.

Например, существует a List класс в обоих java.util и java.awt пакеты. Путем импорта обоих пакетов будет конфликт для названного класса List:

import java.util.*;
import java.awt.*;

// ... snip ... //

List l;    // which "List" are we talking about?

Только импортируя определенные классы Вам нужно, этих конфликтов можно было несколько избежать:

import java.util.Hashmap;
import java.awt.List;

// .. snip ... //
List l;    // Now we know for sure it's java.awt.List

Конечно, если необходимо было использовать обоих java.util.List и java.awt.List затем Вам не повезло; необходимо будет явно использовать их полностью определенные имена классов.

если Вы интересуетесь созданием размера меньшего класса, игровое соревнование по созданию java4k имеет некоторые подсказки, например, эта страница http://www.ahristov.com/tutorial/java4k-tips/java4k-tips.html

Никакое изменение вообще в сгенерированном файле класса.

Импорт только имеет влияние на компилятор (который мог бы взять немного дольше, если это должно индексировать много каталогов), и, конечно, на исходном коде (который является IMO, более удобным в сопровождении, когда Вы видите точно, какие классы используются).

Я думаю, что Java только включает тот материал, в котором Вы действительно нуждаетесь... Таким образом, не будет никакого различия в заключительной скомпилированной версии с помощью один или другой путь.

Во-первых, обязательно посмотрите на мою статью "Import on Demand is Evil!":

http://javadude.com/articles/importondemandisevil.html

Вы никогда не должны использовать * синтаксис! Это может заставить Вашу программу прекращать компилировать, когда код добавляется к другой библиотеке!

Теперь вот то, как импорт действительно работает:

Когда Вы говорите

import a.b.c.Foo;

все это делает, говорят компилятору, что при высказывании "Нечто" Вы действительно имеете в виду "a.b.c. Foo". Компилятор затем заменит все происшествия Foo с a.b.c. Foo в сгенерированном байт-коде.

Когда Вы говорите

import a.b.c.*;

это говорит компилятор, "когда Вы видите символ XXX, Вы не распознаете, проверяете, чтобы видеть, существует ли a.b.c. XXX", Если найдено, компилятор заменит XXX a.b.c. XXX в сгенерированном байт-коде.

Если больше чем один "*" импорт будет соответствовать неизвестному символу, то Вы получите ошибку компилятора для неоднозначности.

Нет никакого различия, столь же установленного в предыдущих сообщениях, однако как предпочтение я использую строгий импорт, поскольку я нахожу, что он делает, по-моему, код более приятным читать

В дополнении к более ранним ответам единственная разница, которую необходимо видеть, - то, что компиляция должна быть немного быстрее, когда Вы явно говорите то, что Вы хотите importредактор, вместо того, чтобы дать подстановочный знак, который может включать тысячи (в тысячи) ненужных пакетов и классов.