S07L23 - Modificadores de acesso em Java sem herança

html


Understanding Access Modifiers in Java: A Comprehensive Guide
Sumário

Introdução ..........................................................1
Tabela de Access Modifiers ...............5
Public Access Modifier .........................7
Default Access Modifier ...................12
Protected Access Modifier ..............16
Private Access Modifier .........................20
Access Modifiers e Herança..24
Conclusão ...............................................................28


Introdução
No campo da programação Java, os access modifiers desempenham um papel fundamental na definição da visibilidade e acessibilidade de classes, métodos e variáveis. Entender esses modificadores é essencial para construir aplicações robustas e de fácil manutenção. Este guia explora os quatro principais access modifiers em Java—public, default, protected e private—explorando suas funcionalidades, casos de uso e implicações tanto em cenários de classes não herdadas quanto herdadas.
Os access modifiers não apenas impõem a encapsulamento, mas também melhoram a segurança ao restringir o acesso não autorizado a componentes sensíveis do seu código. Seja você um iniciante ou um desenvolvedor com conhecimento básico, dominar os access modifiers permitirá que você projete programas Java mais limpos e eficientes.

Tabela de Access Modifiers


Access Modifier
Class
Package
Subclass
Mundo


Public
Sim
Sim
Sim
Sim


Protected
Sim
Sim
Sim
Não


Default
Sim
Sim
Não
Não


Private
Sim
Não
Não
Não


Tabela 1: Access Modifier Visibility Matrix

Public Access Modifier
Visão Geral
O access modifier public é o modificador mais permissivo em Java. Quando uma class, method ou variable é declarada como public, torna-se acessível de qualquer lugar — dentro do mesmo package e de qualquer outro package.
Sintaxe e Uso




		
		
			
			
Java
			
			package org.studyeasy;

public class Other {
    public int x = 10;
    public String message() {
        return "Hello from the public method!";
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
				
						package org.studyeasy;
 
public class Other {
    public int x = 10;
    public String message() {
        return "Hello from the public method!";
    }
}
					
				
			
		


Conceitos Principais

Visibilidade: Acessível de todas as classes, independentemente do package.
Caso de Uso: Ideal para classes e métodos que precisam ser acessados universalmente, como classes utilitárias ou APIs.

Exemplo Explicado

Access Modifier	Class	Package	Subclass	Mundo
Public	Sim	Sim	Sim	Sim
Protected	Sim	Sim	Sim	Não
Default	Sim	Sim	Não	Não
Private	Sim	Não	Não	Não

No exemplo acima, a class Other e seus membros x e message são declarados como public. Isso significa que podem ser acessados de qualquer outra class, mesmo aquelas em packages diferentes.






		
		
			
			
Java
			
			package org.studyeasy;

public class Main {
    public static void main(String[] args) {
        Other other = new Other();
        System.out.println(other.x); // Outputs: 10
        System.out.println(other.message()); // Outputs: Hello from the public method!
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						package org.studyeasy;
 
public class Main {
    public static void main(String[] args) {
        Other other = new Other();
        System.out.println(other.x); // Outputs: 10
        System.out.println(other.message()); // Outputs: Hello from the public method!
    }
}
					
				
			
		


Saída:




		
		
			
			
Java
			
			10
Hello from the public method!
			
				
					
				
					1
2
				
						10
Hello from the public method!
					
				
			
		



Default Access Modifier
Visão Geral
Quando nenhum access modifier é especificado, Java aplica o nível de acesso default, também conhecido como package-private. Membros com acesso default são acessíveis apenas dentro do mesmo package.
Sintaxe e Uso




		
		
			
			
Java
			
			package org.studyeasy;

class Other {
    int x = 10;
    String message() {
        return "Hello from the default method!";
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
				
						package org.studyeasy;
 
class Other {
    int x = 10;
    String message() {
        return "Hello from the default method!";
    }
}
					
				
			
		


Conceitos Principais

Visibilidade: Acessível apenas dentro de classes que residem no mesmo package.
Caso de Uso: Adequado para classes e membros que não devem ser expostos fora do package, promovendo encapsulamento.

Exemplo Explicado

Neste exemplo, a class Other e seus membros x e message têm acesso default. Eles não podem ser acessados de classes fora do package org.studyeasy.






		
		
			
			
Java
			
			package org.anotherpackage;

import org.studyeasy.Other;

public class Main {
    public static void main(String[] args) {
        Other other = new Other(); // Compilation Error: Other is not public in org.studyeasy
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						package org.anotherpackage;
 
import org.studyeasy.Other;
 
public class Main {
    public static void main(String[] args) {
        Other other = new Other(); // Compilation Error: Other is not public in org.studyeasy
    }
}
					
				
			
		


Erro:




		
		
			
			
Java
			
			Cannot access class Other from package org.anotherpackage
			
				
					
				
					1
				
						Cannot access class Other from package org.anotherpackage
					
				
			
		



Protected Access Modifier
Visão Geral
O access modifier protected faz a ponte entre public e default. Membros protected são acessíveis dentro do próprio package e também em subclasses que residem em packages diferentes.
Sintaxe e Uso




		
		
			
			
Java
			
			package org.studyeasy;

public class Other {
    protected int x = 10;
    protected String message() {
        return "Hello from the protected method!";
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
				
						package org.studyeasy;
 
public class Other {
    protected int x = 10;
    protected String message() {
        return "Hello from the protected method!";
    }
}
					
				
			
		


Conceitos Principais

Visibilidade: Acessível dentro do mesmo package e em subclasses através de diferentes packages.
Caso de Uso: Ideal para métodos e variáveis que devem ser acessíveis às subclasses, restringindo o acesso de outras classes.

Exemplo Explicado




		
		
			
			
Java
			
			package org.studyeasy;

public class Main {
    public static void main(String[] args) {
        Other other = new Other();
        System.out.println(other.x); // Outputs: 10
        System.out.println(other.message()); // Outputs: Hello from the protected method!
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
				
						package org.studyeasy;
 
public class Main {
    public static void main(String[] args) {
        Other other = new Other();
        System.out.println(other.x); // Outputs: 10
        System.out.println(other.message()); // Outputs: Hello from the protected method!
    }
}
					
				
			
		


Saída:




		
		
			
			
Java
			
			10
Hello from the protected method!
			
				
					
				
					1
2
				
						10
Hello from the protected method!
					
				
			
		


Subclasse em Package Diferente:




		
		
			
			
Java
			
			package org.anotherpackage;

import org.studyeasy.Other;

public class SubClass extends Other {
    public void display() {
        System.out.println(x); // Accessible due to protected access
        System.out.println(message()); // Accessible due to protected access
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						package org.anotherpackage;
 
import org.studyeasy.Other;
 
public class SubClass extends Other {
    public void display() {
        System.out.println(x); // Accessible due to protected access
        System.out.println(message()); // Accessible due to protected access
    }
}
					
				
			
		



Private Access Modifier
Visão Geral
O access modifier private é o mais restritivo. Membros privados são acessíveis apenas dentro da class onde são declarados, garantindo encapsulamento completo.
Sintaxe e Uso




		
		
			
			
Java
			
			package org.studyeasy;

public class Other {
    private int x = 10;
    private String message() {
        return "Hello from the private method!";
    }
    
    public String getMessage() {
        return message(); // Accessing private method within the class
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
				
						package org.studyeasy;
 
public class Other {
    private int x = 10;
    private String message() {
        return "Hello from the private method!";
    }
    
    public String getMessage() {
        return message(); // Accessing private method within the class
    }
}
					
				
			
		


Conceitos Principais

Visibilidade: Acessível apenas dentro da class declaradora.
Caso de Uso: Ideal para variáveis e métodos sensíveis que não devem ser expostos ou modificados diretamente de fora da class.

Exemplo Explicado
Tentar acessar membros privados de outra class resulta em erros.




		
		
			
			
Java
			
			package org.studyeasy;

public class Main {
    public static void main(String[] args) {
        Other other = new Other();
        System.out.println(other.x); // Compilation Error: x has private access
        System.out.println(other.message()); // Compilation Error: message() has private access
        System.out.println(other.getMessage()); // Outputs: Hello from the private method!
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
				
						package org.studyeasy;
 
public class Main {
    public static void main(String[] args) {
        Other other = new Other();
        System.out.println(other.x); // Compilation Error: x has private access
        System.out.println(other.message()); // Compilation Error: message() has private access
        System.out.println(other.getMessage()); // Outputs: Hello from the private method!
    }
}
					
				
			
		


Erro:




		
		
			
			
Java
			
			x has private access in org.studyeasy.Other
message() has private access in org.studyeasy.Other
			
				
					
				
					1
2
				
						x has private access in org.studyeasy.Other
message() has private access in org.studyeasy.Other
					
				
			
		


Saída para getMessage():




		
		
			
			
Java
			
			Hello from the private method!
			
				
					
				
					1
				
						Hello from the private method!
					
				
			
		



Access Modifiers e Herança
Visão Geral
Os access modifiers influenciam significativamente como a herança se comporta em Java. Quando uma subclass herda de uma superclass, a acessibilidade dos membros da superclass na subclass depende de seus access modifiers.
Public e Protected na Herança

Public Members: Herdados e acessíveis na subclass sem restrições.
Protected Members: Herdados e acessíveis na subclass, mesmo se a subclass estiver em um package diferente.

Default e Private na Herança

Default Members: Herdados apenas se a subclass estiver no mesmo package.
Private Members: Não herdados; inacessíveis na subclass.

Exemplo Explicado




		
		
			
			
Java
			
			package org.studyeasy;

public class Parent {
    public int publicVar = 1;
    protected int protectedVar = 2;
    int defaultVar = 3;
    private int privateVar = 4;
}

package org.anotherpackage;

import org.studyeasy.Parent;

public class Child extends Parent {
    public void display() {
        System.out.println(publicVar); // Accessible
        System.out.println(protectedVar); // Accessible
        // System.out.println(defaultVar); // Inaccessible
        // System.out.println(privateVar); // Inaccessible
    }
}
			
				
					
				
					1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
				
						package org.studyeasy;
 
public class Parent {
    public int publicVar = 1;
    protected int protectedVar = 2;
    int defaultVar = 3;
    private int privateVar = 4;
}
 
package org.anotherpackage;
 
import org.studyeasy.Parent;
 
public class Child extends Parent {
    public void display() {
        System.out.println(publicVar); // Accessible
        System.out.println(protectedVar); // Accessible
        // System.out.println(defaultVar); // Inaccessible
        // System.out.println(privateVar); // Inaccessible
    }
}
					
				
			
		


Saída:




		
		
			
			
Java
			
			1
2
			
				
					
				
					1
2
				
						1
2
					
				
			
		


Explicação:

publicVar e protectedVar são acessíveis na Child.
defaultVar não é acessível porque a Child está em um package diferente.
privateVar nunca é acessível fora da Parent.


Conclusão
Os access modifiers são fundamentais para controlar o acesso e garantir a encapsulamento de dados em Java. Ao usar estrategicamente os modificadores public, default, protected e private, os desenvolvedores podem proteger seu código contra acesso e modificações não autorizados, conduzindo a aplicações mais seguras e de fácil manutenção.
Principais Pontos:

Public: Acessível de qualquer lugar.
Default: Acessível dentro do mesmo package.
Protected: Acessível dentro do mesmo package e subclasses.
Private: Acessível apenas dentro da class declaradora.
Entender access modifiers aumenta a segurança e integridade do código.
O uso adequado de access modifiers facilita uma melhor gestão da herança.

Mastering access modifiers capacita você a projetar aplicações Java robustas com controle de acesso claro e encapsulamento, estabelecendo a base para o desenvolvimento de software escalável e seguro.
Nota: Este artigo é gerado por IA.