Modificadores em Java
Haverá uma série de modificadores Java cobertos para atender às necessidades dos alunos de forma mais eficiente.
Modificadores Java
Quando se trata de modificadores Java , você provavelmente está bastante familiarizado com a palavra-chave pública que aparece na maioria dos exemplos:
public class Main
Os modificadores Java , como public, são modificadores de acesso que controlam o acesso a classes, atributos, métodos e construtores .
Os modificadores podem ser divididos em duas categorias:
- Modificadores de acesso – controla o nível de acesso
- Modificadores de não acesso - fornece outra funcionalidade em vez de controlar o nível de acesso
Índice-
Modificadores de acesso em Java
Os modificadores de classe Java public e default podem ser usados para classes :
| modificador | Visão geral | Tente |
|---|---|---|
public |
O acesso à classe é possível a partir de qualquer outra classe. | Tente |
| padrão | Classes no mesmo pacote só podem acessar a classe. Na ausência de um modificador, este será usado. O capítulo Pacotes contém mais informações sobre pacotes. |
Tente |
No caso de atributos , métodos e construtores, escolha um dos seguintes:
| modificador | Visão geral | Tente |
|---|---|---|
public |
Todas as turmas têm acesso ao código. | Tente |
private |
Uma classe declarada é o único lugar onde o código pode ser acessado. | Tente |
| padrão | O acesso ao código é limitado ao mesmo pacote. Na ausência de um modificador, este é usado. | Tente |
protected |
No mesmo pacote e subclasses, o código é acessível. O capítulo sobre herança discute subclasses e superclasses com mais detalhes. | Tente |
Abaixo está uma breve tabela que explica a funcionalidade dos modificadores de acesso do Java .
| Modificadores de acesso | Dentro da classe | Dentro do Pacote | Pacote Externo (somente subclasse) | Pacote Externo |
|---|---|---|---|---|
| Privado | Y | N | N | N |
| Padrão | Y | Y | N | N |
| Protegido | Y | Y | Y | N |
| Público | Y | Y | Y | Y |
Modificadores de não acesso
Você pode usar um modificador abstract ou final para classes:
| modificador | Visão geral | Tente |
|---|---|---|
final |
Uma classe não pode ser herdada por outra classe se contiver o modificador final. | Tente |
abstract |
Os objetos não podem ser criados usando a classe com um modificador abstrato (para acessar uma classe abstrata, ela deve ser herdada de outra classe). | Tente |
Você pode usar um dos seguintes atributos ou métodos :
| modificador | Visão geral |
|---|---|
final |
Não é possível substituir ou modificar atributos e métodos. |
static |
Ao invés de pertencer a um objeto, atributos e métodos pertencem a uma classe. |
abstract |
Utilizável apenas em classes abstratas e só pode ser implementado em métodos. Não há corpo para o método, por exemplo abstract void read();. As subclasses (a classe herdada) fornecem o corpo. |
transient |
Ao serializar um objeto, os atributos e métodos são ignorados |
synchronized |
Só pode haver um thread acessando um método por vez. |
volatile |
O valor de um atributo não é armazenado em cache localmente, mas é lido da “memória principal”. |
Final
Quando se trata de modificadores Java , declare os atributos como finais se não quiser que eles substituam os valores existentes:
Example:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
public class Main {
final int mrx = 410;
final String ample = "Final";
public static void main(String[] args) {
Main my_Object = new Main();
my_Object.mrx = 1020; // The final variable cannot be re-assigned a new value, so an error will be generated
my_Object.ample="Modified"; // The final variable cannot be re-assigned a new value, so an error will be generated
System.out.println(my_Object.mrx);
System.out.println(my_Object.ample);
}
}
Example:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class Main {
final int minutes_in_an_hour=60; // Assigning values to the variable
public static void main(String[] args) {
Main my_object=new Main();
my_object.minutes_in_an_hour=23; // not possible to assign/ modify value of the variable as final keyword is assigned.
System.out.println(my_object.minutes_in_an_hour);
}
}
Estático
Se se trata de modificadores Java , um método estático pode ser invocado sem inicializar um objeto da classe.
Para ilustrar a diferença entre métodos estáticos e públicos , aqui está um exemplo:
Example:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
public class Main {
// Static method is created here
static void mrx_method(String mrx_bloodgroup){
System.out.println("Blood Group: "+mrx_bloodgroup);
}
public void print_mrx_num(int mrx_limit){ // The public print_method is initialized here which prints numbers upto the limit given by user
for(int m_r=1;m_r<=mrx_limit;m_r++){
System.out.println(m_r);
}
}
// Main method
public static void main(String[ ] args) {
mrx_method("B+"); // Make a call to the static method
// power_calculator(); An error will be generated as an output
Main my_Object = new Main(); // An object of Main Class is created here
my_Object.print_mrx_num(6); // The public method is called by using object of the class
}
/* Outputs =
Blood Group: B+
1
2
3
4
5
6
*/
}
Example:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
public class Main {
// Static method
static void mrx_method(int mrx,int ample){
System.out.println("Product: "+(mrx*ample));
}
// Public method
public void ample_method(){
System.out.println("Sum: "+(40+23));
}
public static void main(String[ ] args) {
mrx_method(10,20); // Make a call to the static method
// ample_method() An error will be generated as an output
Main my_Object = new Main(); // An object of Main Class is created here
my_Object.ample_method(); // The public method is called by using object of the class
}
// Output 1: Product: 200
// Output 2: Sum: 63
}
Abstrato
Quando se trata de modificadores Java , métodos abstratos pertencem a classes abstratas e não possuem corpos.
As subclasses fornecem o corpo:
Example:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
// Code is extracted from filename: Main.java
// an abstract class is created below
abstract class Main {
public String f_name = "Elon Musk";
public int age = 51;
public abstract void bio(); // an abstract method is created with does not have a body
}
// Subclass (inherit from Main)
class Information extends Main {
public String date_of_birth= "June 28, 1971";
public void bio() { // Here is the abstract method's body
System.out.println("Elon Musk is the Owner of Tesla Cars");
}
}
// End code from filename: Main.java
// Code from Second filename: Second.java
class Second {
public static void main(String[] args) {
// A new object of the Information class will be created (which inherits attributes and methods from Main).
Information myObj = new Information();
System.out.println("Name: " + myObj.f_name);
System.out.println("Age: " + myObj.age);
System.out.println("Date of Birth: " + myObj.date_of_birth);
myObj.bio(); // an abstract method is called here
}
//
// Output:
//
// Name: Elon Musk
// Age: 51
// Date of Birth: June 28, 1971
// Elon Musk is the Owner of Tesla Cars
//
}
Example:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
// an abstract class is created below
abstract class Abstract_class {
public String mrx_name = "Abstract_Class";
public abstract void sum(); // an abstract method is created with does not have a body
}
// Subclass (inherited from Abstract_class)
class Third extends Abstract_class{
public void sum() { // Abstract method body is defined here
System.out.println("Sum: "+(12+21));
}
}
// End code from filename: Third.java
// Code from Second filename: Second.java
class Second {
public static void main(String[] args) {
// A new object of the Information class will be created (which inherits attributes and methods from Main).
Third my_Obj = new Third();
System.out.println("Topic: "+my_Obj.mrx_name);
my_Obj.sum(); // an abstract method is only called here
}
// Output : Sum: 33
// Output: Topic: Abstract_Class
}
Nós valorizamos o seu feedback.
+1
+1
+1
+1
+1
+1
+1
