Import pacote.*; incha o código?

em tese, não muda nada no processamento, já que, estando o .jar que contém as classes referenciadas, a única diferença que o import faz é isso:

import java.util.Scanner; ... Scanner input = new Scanner... /* agora sem import: */ java.util.Scanner input = new java.util.Scanner...

o que incha é puxar um monte de jar e drivers pro projeto

entao… mas assim…

import java.util.*;

é mais pesado que

import. java.util.Scanner;

???

denisspitfire:

entao… mas assim…

import java.util.*;

é mais pesado que

import. java.util.Scanner;

???

imports não tem a ver com performance, você está considerando como se ao fazer um import, você estivesse incluindo código em seu arquivo, mas não é assim. import statements servem basicamente pra dizer “Quando eu digitar ‘Scanner’, estou me referindo à java.util.Scanner, ok?”.

ok… mas outra duvida…
e se for em pacotes??? ele joga TUDO oque tem no pacote? ou só oque ele vai usar no código?

não muda nada, digamos que aí no seu exemplo é meio difícil de imaginar, mas pensa como se fosse um pacote que não fosse naturalmente já importado para o projeto (classes que não são do Java).
se seu projeto pode acessar o pacote java.util, significa que TODO o pacote já tá “inchando” seu projeto (no caso não incha, porque ele fica dentro da JRE mesmo, não do projeto)
o .* não muda nada, PORÉM, recomendo fazer uma a uma pra poder saber todas as classes que estão sendo usadas naquela classe só pelo import:

import java.util.*; // não sei o que você vai usar daqui import java.util.Scanner; import java.util.ArrayList; // agora eu sei quais classes você vai usar

denisspitfire:

ok… mas outra duvida…
e se for em pacotes??? ele joga TUDO oque tem no pacote? ou só oque ele vai usar no código?

isso aqui é OO, não estruturada =x
o include do C++ sim, joga todas as linhas do outro arquivo dentro do seu arquivo. O import só faz referência ao pacote, e isso só muda pro compilador, não em runtime

vlw… agora sim entendi.

Mephy:

isso aqui é OO, não estruturada =x
o include do C++ sim, joga todas as linhas do outro arquivo dentro do seu arquivo. O import só faz referência ao pacote, e isso só muda pro compilador, não em runtime

O include do C++ faz copy&paste, mas isso antes de enviar para o compilador. É uma fase chamada pré-compilação.
O compilador também só incluirá o que realmente tiver sido usado pelo programador.

ViniGodoy:

Mephy:

isso aqui é OO, não estruturada =x
o include do C++ sim, joga todas as linhas do outro arquivo dentro do seu arquivo. O import só faz referência ao pacote, e isso só muda pro compilador, não em runtime

O include do C++ faz copy&paste, mas isso antes de enviar para o compilador. É uma fase chamada pré-compilação.
O compilador também só incluirá o que realmente tiver sido usado pelo programador.

se você tem cinco arquivos que utilizam a função cout do arquivo iostream.h, cada arquivo vai ter um cout identicamente programado, pesando um cout a cada arquivo (isso programando C++ estruturadamente em diferentes arquivos, em OO dá pra manobrar isso), e claro também, isso pode variar de acordo com o compilador utilizado
essa era exatamente a dúvida aqui, já que o import do Java não faz a mesma coisa, independente de em quantos arquivos a mesma classe de um pacote externo seja chamado

acho que já pode colocar um resolvido aí no tópico né .-.

Não vai. No início de cada header, existe uma diretiva que impede a ínclusão múltipla.

#if !defined(__IOSTREAM_H__) #define __IOSTREAM_H__ //Código do header aqui #endif

A primeira linha pode variar (assim como o nome da macro):

#ifndef __IOSTREAM_H__

Ou pode simplesmente conter um:

#pragma once

Isso garante que a classe só será importada uma vez. De qualquer forma, isso gera um baita arquivão .cpp, que só depois é enviado para o compilador.
Além disso, os imports são feitos apenas sobre os cabeçalhos das funções (.h), e não sobre sua implementação (.cpp).
O compilador até pode encontrar duas definições iguais em alguns casos, mas ele as fará se referirem a mesma coisa. Os .cpps sempre são incluídos apenas uma vez só, mesmo durante o processo de pré-compilação.

O compilador então rastreia todas as chamadas de função do programador e deixa na compilação final apenas as funções e métodos de classe utilizados.
Essa última característica torna o código do C++ até mesmo menos inchado que o do Java.

É uma diferença bastante grande. No C++, não existe import. Essa é uma instrução da fase de pré-processamento. No Java, o import é realizado pelo compilador.

Mas, realmente, se você der um import no *, o compilador Java também irá referenciar a biblioteca inteira, mas irá no final, só enviar para o bytecode as classes que forem efetivamente utilizadas.
E não importa quantas classes façam o import, tudo será importado uma vez só. Do jeito que esperamos e gostaríamos que fosse feito.