Análise de perguntas e respostas de entrevistas para desenvolvedor Java. Parte 5

Olá Olá! Hoje, os desenvolvedores Java estão em alta demanda. Claro que não posso te fornecer uma vaga, mas tentarei te ajudar a adquirir novos conhecimentos e preencher algumas lacunas. Portanto, continuamos analisando mais de 250 perguntas de entrevistas para desenvolvedores Java. Links para partes anteriores da análise estão no final do artigo.

39. O que são modificadores de acesso em Java? Nomeie-os. Para que são usados?

Descrevi anteriormente modificadores de acesso na pergunta sobre elementos de encapsulamento Java. Mas vou lembrá-lo de qualquer maneira. Modificadores de acesso em Java são palavras-chave que descrevem o nível de acesso concedido a um componente Java específico. Os modificadores de acesso podem ser:

• público — um elemento com este modificador será acessível publicamente. Aqueles. campos e métodos, classes declaradas com o modificador public são visíveis para outras classes tanto do pacote atual quanto de pacotes externos;
• protegido - um elemento com este modificador estará acessível de qualquer lugar na classe atual do pacote atual ou em classes descendentes, mesmo que estejam em outros pacotes;
• default ou modificador ausente - este modificador é usado implicitamente quando o modificador de acesso não é especificado. É semelhante ao anterior, exceto que a visibilidade é permitida em classes descendentes que estão em outros pacotes;
• private é o mais privado de todos os modificadores, permitindo acesso ao elemento apenas dentro da classe atual.

40. Cite a principal característica dos métodos estáticos e variáveis

Uma formulação muito estranha - “métodos variáveis”. Certamente isso se refere a métodos comuns e não estáticos. Então, a principal diferença é que os métodos estáticos pertencem à classe e, de fato, para eles não é necessário criar uma instância desta classe: ela só pode ser chamada usando o tipo de classe. Por exemplo, temos um método estático para acariciar o gato:

public class CatService {
   public static void petTheCat(Cat cat) {
       System.out.println("Погладить кота - " + cat.getName());
   }

Não precisamos de uma instância da classe CatService para chamá-lo :

Cat cat = new Cat(7, "Bobi");
CatService.petTheCat(cat);

Embora os métodos comuns estejam vinculados a (pertençam a) um objeto, e para chamá-los, você deve ter uma instância (objeto) na qual o método será chamado. Por exemplo, um gato tem um método não estático - miar:

class Cat {
   public void mew() {
       System.out.println("Meow! Meow! Meow!");
   }

Para chamar esse método, precisamos de uma instância específica do gato:

Cat cat = new Cat(7, "Bobi");
cat.mew();

41. Quais são as principais restrições aos métodos estáticos e “variáveis”?

Como eu disse anteriormente, a principal limitação de um método regular é que sempre deve haver alguma instância na qual o método será chamado. Mas um método estático não exige isso, mas não pode se referir à referência this - aos elementos do objeto atual - já que o objeto atual não existe para ele.

42. O que significa a palavra-chave estática? Um método estático pode ser substituído ou sobrecarregado?

Um elemento designado pela palavra-chave static não pertence a um objeto da classe, mas sim à classe, e é carregado quando a própria classe é carregada. Os elementos estáticos são os únicos para todo o programa e os elementos regulares são os únicos para um objeto específico. Estática pode ser:

• campos de classe;
• bloco de inicialização de classe;
• método de classe;
• classes internas de uma classe (no entanto, isso ainda é uma tautologia).

Um método estático não pode ser substituído: pertence à classe e não é herdado, mas ao mesmo tempo pode ser sobrecarregado.

43. Um método pode ser estático e abstrato ao mesmo tempo?

Já mencionei isso no artigo anterior: um método não pode ser abstrato e estático ao mesmo tempo. A abstração de um método significa que ele deve ser substituído no sucessor. Ao mesmo tempo, um método estático pertence à classe e não pode ser substituído: isso causará uma contradição, que o compilador verá e começará a xingar. Se você tiver essa situação, pense seriamente na correção da arquitetura do seu aplicativo (afinal, há claramente algo errado com ele).

44. É possível usar métodos estáticos no meio dos regulares? Vice-versa? Por que?

Métodos estáticos podem ser usados ​​em métodos regulares, pois nada impede isso. Ao mesmo tempo, a situação inversa é impossível: um método estático não pode usar um método regular sem ter uma referência a uma instância específica desta classe. E como lembramos, a referência this não está disponível para membros da classe estática: pode haver quantos objetos específicos da classe você quiser, e cada um deles terá uma referência para si mesmo dentro - this . E como então você entende qual link específico você precisa seguir? Mas de jeito nenhum. Portanto, elementos estáticos não podem referir-se a elementos não estáticos, sem referência a um objeto específico. Na verdade, um método estático só pode usar um método não estático se tiver uma referência a um objeto específico. Por exemplo, aquele que veio como argumento:

public static void petTheCat(Cat cat) {
   System.out.println("Погладить кота - " + cat.getName());
}

Aqui vemos que o método estático petTheCat chama o método normal e não estático do objeto Cat - getName .

45. O que é interface? Pode haver uma interface final?

Como lembramos, não existe herança múltipla em Java. As interfaces são uma espécie de alternativa a isso. A interface parece uma classe muito simplificada. Eles definem funcionalidades sem uma implementação específica, que é implementada por classes que implementam (implementam) essas interfaces. Exemplo de interface:

public interface Animal {
    void voice();
}

Um exemplo de implementação de interface por uma classe:

class Cat implements Animal {

   @Override
   public void voice() {
       System.out.println("Meow! Meow! Meow!");
   }
}

A principal coisa que você precisa saber sobre o uso de interfaces é:

1. Os métodos de interface devem conter apenas um cabeçalho, sem um corpo de método específico, ou seja, deve ser abstrato (mas sem usar a palavra-chave abstract ). A exceção a isso são os métodos estáticos e padrão, que requerem um corpo de método.
2. Uma classe pode implementar muitas interfaces (como eu disse, esta é uma alternativa à herança múltipla), que são escritas separadas por vírgulas: a classe Lion implementa Animal, Wild .
3. As interfaces são criadas usando a palavra-chave- interface .
4. Ao implementar uma interface por uma classe, a palavra-chave é implements .
5. Uma classe que implementa uma interface específica deve implementar todos os seus métodos abstratos ou deve declarar-se abstrata.
6. O principal objetivo do uso de interfaces é implementar o polimorfismo (a capacidade dos objetos de assumir muitas formas).
7. Como regra, os modificadores de acesso para métodos não são escritos na interface: eles são públicos por padrão e outros modificadores que não sejam públicos não podem ser especificados. Desde Java 9, você pode usar modificadores privados para métodos.
8. Variáveis ​​de interface são static final por padrão , ou seja, constantes: elas sempre precisam ser inicializadas diretamente na interface.
9. Você não pode criar um objeto de interface.

A resposta à questão de saber se as interfaces podem ser finais é obviamente que não. Afinal, a própria essência das interfaces é ser implementada. E como todos lembramos muito bem, final no nível da classe o torna não herdável e, no caso de uma interface, não implementável. Por que precisamos de uma interface que não pode ser implementada e usada? Isso mesmo - não há necessidade! E o compilador pensa assim)) O significado só apareceu com a introdução de métodos estáticos nas interfaces com Java 8, mas isso não mudou o fato de que a interface não pode ser final. Falei sobre interfaces, muito superficialmente, porque... este é um tópico amplo. Leia mais sobre isso nos artigos sobre interfaces em Java e a diferença entre classes abstratas e interfaces .

46. ​​​​Onde posso inicializar campos estáticos?

Campos estáticos podem ser inicializados:

• diretamente na declaração, através do sinal de igual = ;
• em um bloco de inicialização estático;
• em um bloco de inicialização não estático, mas você deve entender que toda vez que um objeto for criado, este campo será substituído por este bloco de inicialização;
• no construtor da classe. Cada vez que este construtor for chamado (ou seja, quando um objeto for criado através deste construtor), este campo será sobrescrito;
• em métodos estáticos;
• em métodos não estáticos;
• em classes internas estáticas e não estáticas, locais e anônimas.

47. O que são aulas anônimas?

Classes anônimas são classes que não possuem tipo próprio. Do que estou falando? Quando falamos sobre interfaces, mencionei que você não pode criar um objeto de interface: você só pode criar um objeto de uma classe que implemente a interface. E se você não quiser implementar uma interface em uma classe, mas ainda precisar de um objeto do tipo interface? E muito provavelmente, este será um caso único de uso deste objeto. E você não precisa criar uma classe de implementação completa. Como você vai fazer isso? Certo! Através de uma aula anônima! Digamos que temos alguma interface Animal :

public final interface Animal {
   public void voice();
}

Se quisermos instanciar esta interface através de uma classe anônima:

Animal cat = new Animal() {
   @Override
   public void voice() {
       System.out.println("Meow! Meow! Meow!");
   }
};

E então você pode usar com segurança esse objeto e seu método implementado - voice . Ou seja, uma classe anônima implementa essa interface e todos os seus métodos abstratos aqui e agora. Caso contrário, não seremos capazes de criar um objeto de interface/classe abstrata, uma vez que existem métodos não implementados/abstratos. Como mencionei, classes anônimas são usadas não apenas para implementar métodos abstratos de uma interface, mas também para implementar métodos abstratos de uma classe abstrata. Essa abordagem é boa para situações em que um objeto é usado uma única vez ou uma determinada implementação de métodos é necessária apenas uma vez, e não há necessidade de criar uma classe separada que implementará a classe/interface abstrata necessária. Mas observo também que o uso de classes anônimas é uma ocorrência rara no trabalho: via de regra, ainda é dada preferência às classes normais. Você pode ler mais sobre classes anônimas neste artigo .

48. O que são classes primitivas?

Quanto a mim, esta é uma questão muito estranha e, talvez, uma armadilha, porque em Java não existem classes primitivas: exceto talvez o conceito de tipos primitivos, que já consideramos anteriormente. Como lembramos, existem 8 tipos primitivos em Java - byte , short , int , long , float , double , char , boolean .

49. Qual é a classe “wrapper”?

O principal problema do uso de tipos primitivos em Java é que eles ainda não são classes e Java ainda é uma linguagem OOP. Ou seja, os programas escritos nesta linguagem são reduzidos à interação entre objetos. Bem, os primitivos não são objetos. Eles não possuem métodos, nem mesmo os padrões da classe Object . Bem, e se precisássemos usar um primitivo como chave em Map ? Então você precisa chamar o método hashCode . Você também pode chamar o método equals lá . E então? Pode haver muitos, muitos momentos em que deveria haver uma classe, e não uma primitiva, o que torna as primitivas inutilizadas e elementos indesejáveis ​​no programa, porque isso destrói a própria ideia de OOP. Mas nem tudo é tão ruim quanto parece. Afinal, Java possui o conceito de wrapper primitivo. Cada tipo primitivo possui uma classe analógica:

• byte -> Byte.class
• curto -> Curto.class
• int -> Inteiro.class
• longo -> Long.class
• flutuar -> Float.class
• duplo -> Duplo.class
• char -> Personagem.class
• booleano -> Boolean.class

Esta é uma representação de tipos simples, mas na forma de classes completas com vários métodos diversos e funcionais. Para uso conveniente dessas classes, foram introduzidos os conceitos de autoboxing e unboxing. Autoboxing - conversão automática de um tipo primitivo em uma classe analógica, se necessário (por exemplo, int para Integer ). Unboxing é o processo inverso do anterior: converter automaticamente uma classe wrapper primitiva em um tipo primitivo (por exemplo, Integer para int ). Graças à introdução de classes wrapper primitivas e aos processos de autoboxing e unboxing , os tipos primitivos foram capazes de se tornar membros completos da linguagem OOP - Java. Para saber mais sobre este tema, recomendo fortemente a leitura deste artigo .

50. O que é classe aninhada? Quando é usado?

Classe aninhada é uma classe interna que é membro de outra classe. Em Java, existem 4 tipos de classes internas: 1. Classe interna Este tipo de classe é declarado diretamente no corpo de outra classe. Uma classe interna aninhada pode acessar qualquer campo ou método privado de uma instância da classe externa. Como exemplo, vamos criar um zoológico no qual teremos um animal - uma zebra:

public class Zoo {
   class Zebra {
       public void toFeed(String food) {
           System.out.println("Дать зебре - " + food);
       }
   }
}

Nada complicado, certo? Vamos dar uma olhada em um exemplo de criação de um objeto de classe interna:

Zoo.Zebra zebra = new Zoo().new Zebra();
zebra.toFeed("яблоко");

Como você já viu, é imperativo criar um objeto da classe framing, com base na referência da qual você pode criar um objeto da classe interna. Também gostaria de observar que uma classe interna aninhada não pode ter métodos estáticos ou campos estáticos. Isso ocorre porque uma classe interna está implicitamente associada ao objeto de sua classe externa e não pode declarar nenhum método estático dentro de si. 2. Classes aninhadas estáticas Esta classe é semelhante à anterior, só que possui um modificador de acesso estático próximo à declaração da classe. Como esse tipo de classe não tem acesso aos campos não estáticos da classe externa, é mais parecido com a parte estática da classe externa do que com uma classe interna. Nesse caso, os dados da classe têm acesso a todos os membros estáticos da classe externa, mesmo os privados. Exemplo de uma classe aninhada estática:

public class Zoo {
   static class Zebra {
       public void toFeed(String food) {
           System.out.println("Дать зебре - " + food);
       }
   }
}

O método de criação é um pouco diferente do anterior:

Zoo.Zebra zebra = new Zoo.Zebra();
zebra.toFeed("яблоко");

Aqui não precisamos de um objeto de uma classe externa para criar um objeto de uma classe estática aninhada. Na classe externa, precisamos apenas de seu tipo para que possamos encontrar a localização da classe aninhada. 3. Classes locais Classes locais são classes declaradas dentro do corpo de um método, sendo possível a criação e utilização de um objeto de uma classe local exclusivamente dentro deste método. Exemplo:

public class Zoo {
   public void toFeed(String animal, String food) {
       switch(animal){
           case "зебра":
               class Zebra {
                   void toFeedZebra(String food) {
                       System.out.println("Дать зебре - " + food);
                   }
               }
               Zebra zebra = new Zebra();
               zebra.toFeedZebra(food);
               ...

Exemplo de uso:

Zoo zoo = new Zoo();
zoo.toFeed("зебра", "яблоко");

Sem ver o código do método toFeed , você nem suspeitaria da existência de uma classe local, não é? Uma classe local não pode ser static ou transient , mas pode ser marcada como abstrata ou final (somente OR, pois o uso desses dois modificadores causará conflito). 4. Classes anônimas Já falamos sobre classes anônimas acima e, como você lembra, elas podem ser criadas a partir de duas fontes - interfaces e classes. Razões para usar Classes internas estáticas e não estáticas são usadas porque às vezes é melhor incorporar classes pequenas dentro de classes maiores e mantê-las juntas: desta forma elas terão maior coesão e um propósito comum. Na verdade, o uso de classes aninhadas aumenta o encapsulamento do código. A razão para escolher classes locais pode ser que uma determinada classe seja usada exclusivamente dentro de um único método. Nesse caso, é necessário espalhar o código pela aplicação? Não. Mas ao mesmo tempo acrescentarei que na minha prática nunca vi o uso de classes locais, porque a necessidade deles é altamente controversa. Bem, a razão para usar classes anônimas pode ser que uma implementação específica de uma interface ou classe abstrata será necessária apenas uma vez, portanto não há necessidade de criar uma classe separada e completa com uma implementação para isso. Em vez disso, de forma simples, implementamos o(s) método(s) que precisávamos através de uma classe anônima, usamos esse objeto e esquecemos dele (bem, o coletor de lixo se lembrou dele). Este e este artigo irão ajudá-lo a estudar as aulas internas com mais detalhes .

51. Quais modificadores de acesso uma classe pode ter?

Como lembramos, existem diferentes tipos de classes e diferentes modificadores de acesso são aplicáveis ​​a elas:

• uma classe externa pode ter o modificador de acesso public ou não ter modificador (modificador padrão);
• a classe interna suporta todos os 4 modificadores de acesso;
• classe estática aninhada suporta todos os modificadores de acesso, exceto protected , porque este modificador implica herança, o que contradiz o membro estático da classe (elementos estáticos não são herdados);
• uma classe local só pode ter um modificador padrão (ou seja, nenhum modificador);
• classe anônima : se não houver declaração de tipo de classe, não haverá nenhum modificador de acesso.

É aqui que vamos parar hoje. Vejo você em breve!