Modificador Java

O Java oferece muitos modificadores, divididos principalmente em dois tipos:

• modificadores de acesso

• Modificadores não de acesso

Os modificadores são usados para definir classes, métodos ou variáveis, geralmente no início da sentença. Vamos explicar com o seguinte exemplo:

public　class　ClassName　{
　　　//　...
}
private　boolean　myFlag;
static　final　double　weeks　=　9.5;
protected　static　final　int　BOXWIDTH　=　42;
public static void main(String[] arguments) {
　　　//　corpo do método
}

modificadores de controle de acesso

No Java, os modificadores de controle de acesso podem ser usados para proteger o acesso a classes, variáveis, métodos e construtores. O Java suporta 4 tipos diferentes de permissões de acesso.

• default (ou padrão, sem escrever nada): Visível dentro do mesmo pacote, sem usar nenhum modificador. Usado para: classes, interfaces, variáveis, métodos.

• private : Visível dentro da mesma classe. Usado para: variáveis, métodos. Anotação: Não pode modificar a classe (classe externa)

• public : Visível para todas as classes. Usado para: classes, interfaces, variáveis, métodos

• protected : Visível para todas as classes dentro do mesmo pacote e para todas as subclasses. Usado para: variáveis, métodos. Anotação: Não pode modificar a classe (classe externa)。

Podemos explicar os direitos de acesso com a seguinte tabela:

Controle de acesso

modificador de acesso padrão-Não usar nenhuma palavra-chave

As variáveis e métodos declarados com o modificador de acesso padrão são visíveis para todas as classes dentro do mesmo pacote. As variáveis dentro de uma interface são implicitamente declaradas como public static final, enquanto os métodos dentro de uma interface têm permissão de acesso público por padrão.

Como exemplo, a declaração de variáveis e métodos pode não usar nenhum modificador.

package　defaultPackage;
class　Logger　{
　　　　void　message(){
　　　　　　　　System.out.println("This　is　a　message");
　　　　}
}

Aqui, a classe Logger tem o modificador de acesso padrão. E esta classe é visível para todas as classes do pacote defaultPackage. Mas, se tentarmos usar a classe Logger em outro pacote além do defaultPackage, teremos um erro de compilação.

modificador de acesso privado-private

O modificador de acesso privado é o nível mais rigoroso de acesso, portanto, aqueles que são declarados como private os métodos, variáveis e construtores só podem ser acessados pela classe que os contém, e as classes e interfaces não podem ser declaradas como private。

As variáveis declaradas como de acesso privado só podem ser acessadas por classes externas através dos métodos getter públicos da classe.

A utilização do modificador de acesso private é principalmente usada para ocultar os detalhes de implementação da classe e proteger os dados da classe.

A classe a seguir usa o modificador de acesso privado:

public class Logger {
　　　private String format;
　　　public String getFormat() {
　　　　　　return this.format;
　　　}
　　　public void setFormat(String format) {
　　　　　　this.format = format;
　　　}
}

No exemplo, a variável format da classe Logger é uma variável privada, então outras classes não podem obter e definir diretamente o valor dessa variável. Para permitir que outras classes operem sobre essa variável, foram definidos dois métodos publicos: getFormat() (que retorna o valor de format) e setFormat(String) (que define o valor de format).

modificador de acesso público-public

Classes, métodos, construtores e interfaces declarados como public podem ser acessados por qualquer outra classe.

Se várias classes publicas que se acessam mutuamente estiverem distribuídas em diferentes pacotes, é necessário importar o pacote onde a classe pública está localizada. Devido à herança, todos os métodos e variáveis públicos de uma classe podem ser herdados por suas subclasses.

As seguintes funções usam controle de acesso público:

public static void main(String[] arguments) {
　　　//　...
}

O método main() do programa Java deve ser configurado como público, senão, o interpretador Java não será capaz de executar a classe.

modificador de acesso protegido-protected

protected deve ser analisado e explicado a partir de dois pontos:

• A classe filha e a classe base estão no mesmo pacoteVariáveis, métodos e construtores declarados como protected podem ser acessados por qualquer outra classe dentro do mesmo pacote;

• A classe filha e a classe base não estão no mesmo pacotePortanto, na classe filha, o exemplo da classe filha pode acessar os métodos protected herdados da classe base, mas não pode acessar métodos protected de exemplos da classe base.

protected pode modificar membros de dados, métodos de construtor, métodos membros,Não pode ser usado para modificar classes (exceto classes internas).。

As variáveis e métodos de uma interface não podem ser declarados como protected.

A classe filha pode acessar métodos e variáveis declarados com protected, assim protegendo que classes não relacionadas utilizem esses métodos e variáveis.

A classe pai usa o modificador de acesso protected, e o método openSpeaker() da classe pai foi sobrescrito.

class AudioPlayer {
　　　protected boolean openSpeaker(Speaker sp) {}}
　　　　　　//　Detalhes da implementação
　　　}
}
　
class StreamingAudioPlayer extends AudioPlayer {
　　　protected boolean openSpeaker(Speaker sp) {}}
　　　　　　//　Detalhes da implementação
　　　}
}

Se declaramos o método openSpeaker() como private, nenhum outro método além de AudioPlayer será capaz de acessar o método.

Se declaramos openSpeaker() como public, todas as classes poderão acessar o método.

Se quisermos que o método seja visível apenas para a subclasse da classe onde está declarado, declaramos o método como protected.

Protected é o mais difícil de entender entre os modificadores de permissão de membros da classe Java.

Controle de acesso e herança

Atenção às seguintes regras de herança de métodos:

• Métodos declarados como public na classe pai também devem ser publicos na subclasse.

• Métodos declarados como protected na classe pai devem ser declarados como protected ou public na subclasse, não podem ser declarados como private.

• Métodos declarados como private na classe pai não podem ser herdados.

Modificadores não de acesso

Para implementar outras funcionalidades, o Java também oferece muitos modificadores não de acesso.

Modificador static, usado para modificar métodos e variáveis de classe.

Modificador final, usado para modificar classes, métodos e variáveis. A classe marcada como final não pode ser herdada, o método marcado como final não pode ser redefinido pela classe herdada, e a variável marcada como final é uma constante, não pode ser modificada.

Modificador abstract, usado para criar classes e métodos abstratos.

Modificadores synchronized e volatile, usados principalmente para programação de threads.

Modificador static

• Variáveis estáticas:

  A palavra-chave static é usada para declarar variáveis estáticas independentes do objeto, independentemente de quantos objetos de uma classe forem instanciados, suas variáveis estáticas têm apenas uma cópia. Variáveis estáticas também são chamadas de variáveis de classe. As variáveis locais não podem ser declaradas como variáveis static.

• Métodos estáticos:

  A palavra-chave static é usada para declarar métodos estáticos independentes do objeto. Os métodos estáticos não podem usar variáveis não estáticas da classe. Os métodos estáticos recebem dados da lista de parâmetros, então calculam esses dados.

O acesso a variáveis de classe e métodos pode ser feito diretamente usando classname.variablename e classname.methodname acesso.

Como exemplo a seguir, o modificador static é usado para criar métodos e variáveis de classe.

public class InstanceCounter {
　　　private static int numInstances = 0;
　　　protected static int getCount() {}}
　　　　　　return numInstances;
　　　}
　
　　　private static void addInstance() {
　　　　　　numInstances++;
　　　}
　
　　　InstanceCounter() {
　　　　　　InstanceCounter.addInstance();
　　　}
　
　　　public static void main(String[] arguments) {
　　　　　　System.out.println("De ")　+
　　　　　　InstanceCounter.getCount()　+　"instâncias começando");
　　　　　　for (int i = 0; i <　500;　++i){
　　　　　　　　　new InstanceCounter();
　　　　　　　　　　}
　　　　　　System.out.println("Criado "　+
　　　　　　InstanceCounter.getCount()　+　"instâncias");
　　　}
}

O resultado da execução do exemplo acima é como follows:

começando com 0 instâncias
criar　500 instância

modificador final

Variável final：

Final significa "último, definitivo", uma vez que a variável é atribuída, não pode ser reatribuída. As variáveis anotadas com final devem ter um valor inicial explícito.

O modificador final geralmente é usado com o modificador static para criar constantes de classe.

public class Test{
　　final int value =　10;
　　//　A seguir está um exemplo de declaração de constante
　　public static final int BOXWIDTH =　6;
　　static final String TITLE = "Manager";
　
　　public void changeValue(){
　　　　　value =　12;　//Produzirá um erro
　　}
}

Método final

Os métodos finais da classe pai podem ser herdados pelos subclasses, mas não podem ser sobrescritos pelos subclasses.

O principal objetivo da declaração do método final é evitar que o conteúdo do método seja modificado.

Como mostrado a seguir, o modificador final é usado para declarar métodos.

public class Test{
　　　　public final void changeName(){
　　　　　　　//　corpo do método
　　　　}
}

Classe final

A classe final não pode ser herdada, nenhuma classe pode herdar qualquer característica da classe final.

public final class Test {
　　　//　corpo da classe
}

modificador abstract

Classe abstrata：

A classe abstrata não pode ser usada para exemplificar objetos, o único propósito da declaração da classe abstrata é para futura expansão da classe.

Uma classe não pode ser marcada simultaneamente com abstract e final. Se uma classe contiver métodos abstratos, então essa classe deve ser declarada como classe abstrata, senão ocorrerá erro de compilação.

A classe abstrata pode conter métodos abstratos e não abstratos.

abstract class Caravan{
　　　private double price;
　　　private String model;
　　　private String year;
　　　public abstract void goFast();　//método abstrato
　　　public abstract void changeColor();
}

método abstrato

Métodos abstratos são métodos que não têm implementação, e sua implementação específica é fornecida pela subclasse.

Métodos abstratos não podem ser declarados como final e static.

Qualquer subclasse que herda de uma classe abstrata deve implementar todos os métodos abstratos da classe pai, a menos que a subclasse também seja abstrata.

Se uma classe contiver vários métodos abstratos, então essa classe deve ser declarada como classe abstrata. A classe abstrata pode não conter métodos abstratos.

A declaração de método abstrato termina com um ponto e vírgula, por exemplo:public abstract sample();。

public abstract class SuperClass{
　　　　abstract void m();　//método abstrato
}
　
class SubClass extends SuperClass{
　　　　　//implementar método abstrato
　　　　　　void m(){
　　　　　　　　　　......
　　　　　　}
}

modificador synchronized

O método declarado com a palavra-chave synchronized pode ser acessado por apenas uma thread ao mesmo tempo. O modificador synchronized pode ser aplicado aos quatro modificadores de acesso.

public synchronized void showDetails(){
......
}

modificador transient

Quando um objeto serializado contém uma variável marcada com transient, o Java Virtual Machine (JVM) pula essa variável específica.

Este modificador está incluído na declaração de definição de variável, usado para pré-processar o tipo de dados de classe e variável.

public transient int limit =;　55;　　　//　não persiste
public int b;　//　persistência

modificador volatile

Os membros de variável marcados com volatile são forçados a serem lidos novamente da memória compartilhada a cada vez que são acessados por uma thread. Além disso, quando um membro de variável muda de valor, a thread é forçada a escrever o novo valor de volta na memória compartilhada. Dessa forma, em qualquer momento, duas threads diferentes sempre verão o mesmo valor de um membro de variável.

Uma referência a um objeto volatile pode ser null.

public class MyRunnable implements Runnable
{
　　　　private volatile boolean active;
　　　　public void run()
　　　　{
　　　　　　　　active = true;
　　　　　　　　while (active)　//　Linha 1
　　　　　　　　{
　　　　　　　　　　　　//　Código
　　　　　　　　}
　　　　}
　　　　public void stop()
　　　　{
　　　　　　　　active = false;　//　Linha 2
　　　　}
}

Em geral, em uma thread que chama o método run () (na thread iniciada por Runnable), em outra thread chama o método stop (). Se Linha 1 Se o valor de active no buffer for usado, então na Linha 2 O valor de active é false, a iteração não será interrompida.

Mas no código acima, usamos o modificador volatile para active, então a iteração será interrompida.