A linguagem Java fornece muitos modificadores, divididos principalmente nas duas categorias a seguir:
Modificadores são usados para definir classes, métodos ou variáveis e geralmente são colocados na extremidade frontal de uma declaração. Vamos usar os seguintes exemplos para ilustrar:
classe pública classe classe nome {// ...} Private boolean myflag; final estático duas semanas duplas = 9,5; protegido final estático int largura de caixa = 42; public static void main (string [] argumentos) {// body}}Modificador de controle de acesso
No Java, os controles de acesso podem ser usados para proteger o acesso a classes, variáveis, métodos e construtores. O Java suporta 4 permissões de acesso diferentes.
O padrão, também conhecido como padrão, é visível dentro do mesmo pacote sem usar nenhum modificador.
Privado, especificado com o modificador privado, visível na mesma classe.
Comum, especificado pelo modificador público, visível para todas as classes.
Protegido, especificado com o modificador protegido, visível para classes e todas as subclasses dentro do mesmo pacote.
Modificador de acesso padrão - nenhuma palavra -chave é usada
Variáveis e métodos declarados por modificadores de acesso padrão são visíveis para classes dentro do mesmo pacote. Todas as variáveis na interface são declaradas implicitamente como final estático público, enquanto os métodos na interface são públicos por padrão.
Exemplo:
Conforme mostrado no exemplo a seguir, a declaração de variáveis e métodos pode ser sem modificadores.
String versão = "1.5.1"; Boolean ProcessOrder () {return true;}Modificador de acesso privado - privado
Os modificadores de acesso privado são o nível de acesso mais estrito; portanto, métodos, variáveis e construtores declarados como privados só podem ser acessados pela classe a que pertencem, e as classes e interfaces não podem ser declaradas como privadas.
As variáveis declaradas como tipo de acesso privado só podem ser acessadas por classes externas através de métodos públicos de getter na classe.
O uso do modificador de acesso privado é usado principalmente para ocultar os detalhes da implementação da classe e proteger os dados da classe.
A aula a seguir usa um modificador de acesso privado:
classe pública Logger {private String format; public String getFormat () {return this.Format; } public void setFormat (String format) {this.Format = format; }}No exemplo, a variável de formato na classe Logger é uma variável privada, para que outras classes não possam obter diretamente e definir o valor da variável. Para permitir que outras classes manipulem a variável, dois métodos públicos são definidos: getFormat () (retorna o valor do formato) e o setFormat (String) (define o valor do formato)
Modificador de acesso público - público
Classes, métodos, construtores e interfaces declaradas como públicas podem ser acessadas por qualquer outra classe.
Se várias classes públicas que estão acessando uma à outra forem distribuídas em diferentes pacotes, você precisará importar o pacote onde a classe pública correspondente está localizada. Devido à herança da classe, todos os métodos públicos e variáveis da classe podem ser herdados por suas subclasses.
As funções a seguir usam controle de acesso público:
public static void main (string [] argumentos) {// ...}O método principal () de um programa Java deve ser definido como público; caso contrário, o intérprete Java não poderá executar a classe.
Modificador de acesso protegido - protegido
Variáveis, métodos e construtores declarados como protegidos podem ser acessados por qualquer outra classe no mesmo pacote ou por subclasses em diferentes pacotes.
O modificador de acesso protegido não pode modificar classes e interfaces. Métodos e variáveis de membro podem ser declarados como protegidos, mas as variáveis de membro e os métodos de membro da interface não podem ser declarados como protegidos.
As subclasses podem acessar métodos e variáveis declaradas pelo modificador protegido, para que possam proteger classes não relacionadas de usar esses métodos e variáveis.
A seguinte classe pai usa o modificador de acesso protegido e a subclasse sobrecarrega o método OpenSpeaker () da classe pai.
classe AudioPlayer {protegido boolean OpenSpeaker (Speaker sp) {// Detalhes da implementação}} classe StreamingaudioPlayer {boolean openSpeaker (Speaker sp) {// Detalhes da implementação}}Se o método OpenSpeaker () for declarado como privado, outras aulas que não o Audioplayer não poderão acessar o método. Se o OpenSpeaker () for declarado público, todas as classes poderão acessar o método. Se queremos que o método seja visível apenas para uma subclasse da classe em que está localizado, declare o método como protegido.
Controle de acesso e herança
Observe as seguintes regras de herança:
Modificador que não é acesso
Para implementar outras funções, o Java também fornece muitos modificadores que não são de acesso.
O modificador estático é usado para criar métodos de classe e variáveis de classe.
O modificador final é usado para modificar classes, métodos e variáveis. A classe modificada pelo final não pode ser herdada, o método modificado não pode ser redefinido pela classe herdada e a variável modificada é uma constante e não pode ser modificada.
Modificador abstrato, usado para criar classes abstratas e métodos abstratos.
Modificadores sincronizados e voláteis são usados principalmente para programação de threads.
Modificador estático
A palavra -chave estática é usada para declarar variáveis estáticas independentes dos objetos. Não importa quantos objetos uma classe instancie, ele possui apenas uma cópia de sua variável estática. Variáveis estáticas também são chamadas de variáveis de classe. As variáveis locais podem ser declaradas como variáveis estáticas.
A palavra -chave estática é usada para declarar métodos estáticos independentes dos objetos. Os métodos estáticos não podem usar variáveis não estáticas da classe. O método estático obtém os dados da lista de parâmetros e calcula os dados.
O acesso a variáveis e métodos de classe pode ser acessado diretamente usando o ClassName.VariAbleName e ClassName.MethodName.
Conforme mostrado no exemplo a seguir, o modificador estático é usado para criar métodos de classe e variáveis de classe.
classe pública Instancecounter {private static int numinstances = 0; estático protegido int getCount () {return numInstances; } private estático void addInstance () {numInstances ++; } Instancecounter () {Instancecounter.addInstance (); } public static void main (string [] argumentos) {System.out.println ("Começando com" + Instancounter.getCount () + "Instâncias"); for (int i = 0; i <500; ++ i) {new Instancecounter (); } System.out.println ("criado" + Instancounter.getCount () + "Instâncias"); }}Os exemplos acima são executados e editados da seguinte forma:
Iniciado com 0 instâncias
Criou 500 instâncias
Modificador final
Variáveis finais:
As variáveis finais podem ser explicitamente inicializadas e só podem ser inicializadas uma vez. As referências a objetos declarados como final não podem apontar para diferentes objetos. Mas os dados no objeto final podem ser alterados. Em outras palavras, a referência ao objeto final não pode ser alterada, mas o valor interno pode ser alterado.
Os modificadores finais são geralmente usados juntamente com modificadores estáticos para criar constantes de classe.
Exemplo:
Public class Test {final int value = 10; // Abaixo está um exemplo declarando uma constante largura de caixa final estática pública int = 6; estático final string title = "gerente"; public void ChangeValue () {value = 12; // um erro será emitido}}Método final
O método final da classe pode ser herdado pela subclasse, mas não pode ser modificado pela subclasse.
O principal objetivo de declarar um método final é impedir que o conteúdo do método seja modificado.
Como mostrado abaixo, declare o método usando o modificador final.
public class Test {public final void ChanGename () {// Method Body}}Classe final
As aulas finais não podem ser herdadas e nenhuma classe pode herdar quaisquer recursos das classes finais.
Exemplo:
Public Final Class Test {// Class Body}Modificador abstrato
Classe abstrata:
Classes abstratas não podem ser usadas para instanciar objetos. O único objetivo de declarar classes abstratas é expandir a classe no futuro.
Uma classe não pode ser modificada por abstrato e final ao mesmo tempo. Se uma classe contiver métodos abstratos, a classe deverá ser declarada como uma classe abstrata, caso contrário, ocorrerá um erro de compilação.
Classes abstratas podem conter métodos abstratos e métodos não abstratos.
Exemplo:
classe abstrata caravana {preço duplo privado; Modelo de String Private; Ano de String Private; abstrato público vazio gofast (); // Método abstrato Public Abstract Void ChangeColor ();}Métodos abstratos
Um método abstrato é um método sem nenhuma implementação, e a implementação específica do método é fornecida por uma subclasse. Métodos abstratos não podem ser declarados como final e rigoroso.
Qualquer subclasse que herda uma classe abstrata deve implementar todos os métodos abstratos da classe pai, a menos que a subclasse também seja uma classe abstrata.
Se uma classe contiver vários métodos abstratos, a classe deve ser declarada como uma classe abstrata. Classes abstratas podem não conter métodos abstratos.
A declaração de um método abstrato termina com um semicolon, por exemplo: amostra abstrata pública ();
Exemplo:
classe abstrata public superclass {abstract void m (); // Método abstrato} classe Subclasse estende a superclass {// implemente o método abstrato void m () {.........}}Modificador sincronizado
O método declarado pela palavra -chave sincronizado só pode ser acessado por um thread ao mesmo tempo. O modificador sincronizado pode ser aplicado a quatro modificadores de acesso.
Exemplo:
public sincronizado void showDetails () {......}Modificador transitório
Quando um objeto serializado contém uma variável de instância modificada transitória, a máquina virtual Java (JVM) pula essa variável específica.
Esse modificador está incluído em uma declaração que define uma variável e é usada para pré -processar os tipos de dados de classes e variáveis.
Exemplo:
LIMITE DE TRANSIENTE PRÍNICO DO TRANSIENTE = 55; // não persistirá em Int B; // vai persistir
modificador volátil
As variáveis voláteis de membros modificadas são forçadas a reler o valor da variável de membro da memória compartilhada cada vez que são acessadas por um thread. Além disso, quando a variável do membro muda, o thread é forçado a escrever o valor de mudança de volta à memória compartilhada. Dessa maneira, a qualquer momento, dois threads diferentes sempre vêem o mesmo valor de uma determinada variável de membro. Uma referência volátil de objeto pode ser nula.
Exemplo:
public class MyRunnable implementa Runnable {Private Volatile Boolean Active; public void run () {Active = true; while (ativo) // linha 1 {// code}} public void stop () {Active = false; // linha 2}}Geralmente, o método run () é chamado em um thread e o método stop () é chamado em outro thread. Se o valor no ativo da linha 1 no buffer for usado, o loop não parará quando o ativo na linha 2 for definido como falso.
O exposto acima é todo o conteúdo deste artigo. Espero que o conteúdo deste artigo seja de ajuda para estudar ou trabalhar de todos. Eu também espero apoiar mais wulin.com!