Olá!
Eu gostaria de tirar uma dúvida com relação a qualificadores de acesso.
Percebi que package e protected são iguais.
Alguém poderia me dar um exemplo mostrando a diferença?
Obrigado!
Ola amigo!
Ate onde sei o protected deixa o atributo visivel para todas as classes do package. Logo nao seria a mesma coisa…
Se eu tivesse um atributo private e a classe estivesse dentro de um package X, classes que estivessem nesse mesmo pacote nao conseguiriam acessa-la… Ou seja, o package meio que “validaria” o protected…
Quando iniciei, me perguntava a diferença entre protected e o tipo padrao (sem setar tipo), ja que se optar pela segunda opçao as variaveis e metodos tambem podem ser acessadas por classes do mesmo pacote. A diferença entre estes dois ultimos se da no quesito de acessos à subclasses: protected’s podem ser acessados por subclasses, ja default’s nao podem…
espero ter ajudado!
Bons estudos!
[]'s
[quote=lucasgcp]Ola amigo!
Ate onde sei o protected deixa o atributo visivel para todas as classes do package. Logo nao seria a mesma coisa…
Se eu tivesse um atributo private e a classe estivesse dentro de um package X, classes que estivessem nesse mesmo pacote nao conseguiriam acessa-la… Ou seja, o package meio que “validaria” o protected…
Quando iniciei, me perguntava a diferença entre protected e o tipo padrao (sem setar tipo), ja que se optar pela segunda opçao as variaveis e metodos tambem podem ser acessadas por classes do mesmo pacote. A diferença entre estes dois ultimos se da no quesito de acessos à subclasses: protected’s podem ser acessados por subclasses, ja default’s nao podem…
espero ter ajudado!
Bons estudos!
[]'s[/quote]
Olá!
Então, também li muito isso, mas no Eclipse, não está tendo essa restrição. Olha um exemplo:
package pk1;
public class C1
{
void f1()
{
System.out.println("C1");
}
}
class C2 extends C1
{
public static void main(String []args)
{
C1 c = new C1();
c.f1();
}
}Estou acessando o método f1(), de qualificador package, através da classe filha C2, sem nenhum problema.
Se eu usar polimorfismo, fazendo na main a substituição por: C1 c = new C2();, funcionará perfeitamente tb.
Creio que teria uma certa redundancia. Porque vejamos:
-
a classe C2 esta à herdar a classe C1, sendo assim tecnicamente os atributos default’s nao poderiam ser acessados…
-
mas as duas classes tambem estao no mesmo pacote, sendo assim os artibutos defaut’s poderiam ser acessados de qualquer classe que pertendence ao pacote…
Quando tiver uma folguinha aqui no serviço tento montar um exemplo…
Não deixa visivel para todas as classes do pacote, deixa visivel para todas as classes que herdam, as classes do pacote não tem nada haver, se deixar como private nem os filhos veem, se deixa como public você pode acessar diretamente como se fosse um static mas não o atributo sem a classe.
protected = pacote e subclasses
package = so pacote
[]'s
WooW
Tem razao RenanRosa!!
Pra falar verdade nem tinha visto que escrevi isso…
vlW!
[quote=lucasgcp]WooW
Tem razao RenanRosa!!
Pra falar verdade nem tinha visto que escrevi isso…
vlW![/quote]
kkkkkkkkkk
da nada 
é normal isso.
apenas mudou de classe pra package
[quote=alex.brito]protected = pacote e subclasses
package = so pacote
[]'s[/quote]
Alex, de acordo com o Deitel (comprei na faculdade), membros protected também têm acesso pacote.
Não deixa visivel para todas as classes do pacote, deixa visivel para todas as classes que herdam, as classes do pacote não tem nada haver, se deixar como private nem os filhos veem, se deixa como public você pode acessar diretamente como se fosse um static mas não o atributo sem a classe.[/quote]
Olha o seguinte:
package pk1;
public class C1
{
protected void f1()
{
System.out.println("C1");
}
}
package pk2;
import pk1.C1;
public class C2 extends C1
{
public static void main(String []args)
{
C1 c = new C1();
c.f1(); //não enxerga!
}
}
Estando em pacotes diferentes, um filho tenta acessar a função do pai que tem qualificador de acesso protected. Não é visível.
public class C2 extends C1
{
public static void main(String []args)
{
C1 c = new C1();
c.f(); //não enxerga!
}
}
O “c.f()” foi erro de digitaçao na hora de copiar pra ca certo?
Sim, foi erro. Já arrumei!
Não deixa visivel para todas as classes do pacote, deixa visivel para todas as classes que herdam, as classes do pacote não tem nada haver, se deixar como private nem os filhos veem, se deixa como public você pode acessar diretamente como se fosse um static mas não o atributo sem a classe.[/quote]
Olha o seguinte:
package pk1;
public class C1
{
protected void f1()
{
System.out.println("C1");
}
}
package pk2;
import pk1.C1;
public class C2 extends C1
{
public static void main(String []args)
{
C1 c = new C1();
c.f1(); //não enxerga!
}
}
Estando em pacotes diferentes, um filho tenta acessar a função do pai que tem qualificador de acesso protected. Não é visível.[/quote]
só corrgiindo, esqueci de colocar que TODAS AS CLASSES DO PACOTE 
[quote=ECO2004][quote=alex.brito]protected = pacote e subclasses
package = so pacote
[]'s[/quote]
Alex, de acordo com o Deitel (comprei na faculdade), membros protected também têm acesso pacote.[/quote]
Mas foi o que eu disse, não ???
ou me expressei mal … sorry
http://download.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html
[]'s
pera ai, eu me embananei todo, agora que to entendendo, não sabia que apenas as classes que herdam de classes do mesmo pacote podem acessar metodos protected.
pra mim todas que herdam podem acessar atributos protected.
[quote=ECO2004]
Olha o seguinte:
package pk1;
public class C1
{
protected void f1()
{
System.out.println("C1");
}
}
package pk2;
import pk1.C1;
public class C2 extends C1
{
public static void main(String []args)
{
C1 c = new C1();
c.f1(); //não enxerga!
}
}
Estando em pacotes diferentes, um filho tenta acessar a função do pai que tem qualificador de acesso protected. Não é visível.[/quote]
Quase chegou lá! O problema aqui foi porque os membros protected podem ser acessados apenas DE DENTRO DE UMA INSTANCIA da classe filha. Você tentou acessar “de fora”, ou seja, chamar o método do objeto “c” a partir de uma referência. Mesmo estando em uma classe filha não dá.
Experimente o seguinte:
package pk1;
public class C1
{
protected void f1()
{
System.out.println("C1");
}
}
package pk2;
import pk1.C1;
public class C2 extends C1
{
public static void main(String []args)
{
C1 c = new C1();
c.metodoQueUsaOProtectedDaClasseMae();
}
void metodoQueUsaOProtectedDaClasseMae() {
super.f1(); // Aqui pode porque eu estou dentro da instancia, chamando do proprio objeto
// Tambem poderia ser simplesmente f1() , só coloquei o super para ficar mais claro que vem da superclasse
}
}
[quote=RenanRosa]pera ai, eu me embananei todo, agora que to entendendo, não sabia que apenas as classes que herdam de classes do mesmo pacote podem acessar metodos protected.
pra mim todas que herdam podem acessar atributos protected.[/quote]
Mas não é…
Por isso que, pra mim, protected e package são o mesmo. Só funcionam se estiverem no mesmo pacote! E se estiverem no mesmo pacote, tanto faz se é package ou protected.
[quote=gomesrod][quote=ECO2004]
Olha o seguinte:
package pk1;
public class C1
{
protected void f1()
{
System.out.println("C1");
}
}
package pk2;
import pk1.C1;
public class C2 extends C1
{
public static void main(String []args)
{
C1 c = new C1();
c.f1(); //não enxerga!
}
}
Estando em pacotes diferentes, um filho tenta acessar a função do pai que tem qualificador de acesso protected. Não é visível.[/quote]
Quase chegou lá! O problema aqui foi porque os membros protected podem ser acessados apenas DE DENTRO DE UMA INSTANCIA da classe filha. Você tentou acessar “de fora”, ou seja, chamar o método do objeto “c” a partir de uma referência. Mesmo estando em uma classe filha não dá.
Experimente o seguinte:
package pk1;
public class C1
{
protected void f1()
{
System.out.println("C1");
}
}
package pk2;
import pk1.C1;
public class C2 extends C1
{
public static void main(String []args)
{
C2 c = new C2();
c.metodoQueUsaOProtectedDaClasseMae();
}
void metodoQueUsaOProtectedDaClasseMae() {
super.f1(); // Aqui pode porque eu estou dentro da instancia, chamando do proprio objeto
// Tambem poderia ser simplesmente f1() , só coloquei o super para ficar mais claro que vem da superclasse
}
}
[/quote]
Pô, cara!!! Dá hora! Não tinha sacado essa! Não era tão trivial assim.
Brigadão…
Ou seja, os metodos protecteds podem sim ser acessados pelos filhos (falando em classe, não instancia dentro do filho)
achei que eu tava ficando doido