Java访问权限修饰符用法总结 ( public, protected, friendly, private等修饰符

 

权限修饰符概述：

 

 

java访问权限修饰符（特殊情况除外）

作用域	当前类	同一package	子孙类	其他package
public	√	√	√	√
protected	√	√	√	×
friendly	√	√	×	×
private	√	×	×	×

不写时默认为friendly

 

 

首先声明：java中，friendly这个修饰符并没有显式的声明，在成员变量和方法前什么修饰符也不用，默认的就是friendly。为了条理清晰，分三种不同情况来总结。

1.         访问权限修饰符修饰成员变量和方法

1)         public：表明该成员变量和方法是共有的，能在任何情况下被访问。

2)         protected：必须在同一包中才能被访问。

3)         friendly：在一个包中或者子类中才能被访问。

4)         private: 只能在本类中访问。

        实际上，把重要的数据修饰为private，然后写一个public的函数访问它，正好体现了OOP的封装特性，是OOP安全性的体现。   

 

2.         访问权限修饰符修饰类 

1)         不能用protected和private修饰类。

2)         用friendly修饰的类叫友好类，在另外一个类中使用友好类创建对象时，要保证它们在同一包中。

  

3.         访问权限修饰符与继承

   这里的访问修饰符指的是修饰成员变量和方法。可以分为两种情况：

1)         子类与父类在同一包中

    此时只有声明为private的变量与方法不能被继承(访问)。

2)         子类与父类不在同一包中

此时private与friendly均不能被继承(访问)， protected与public可以。所以，访问权限修饰符权限从高到低排列是public, protected, friendly, private。

 

 

 

结合代码分析权限修饰符：

 

 

首先声明：java中，friendly这个修饰符并没有显式的声明，在成员变量和方法前什么修饰符也不用，默认的就是friendly。

　　为了条理清晰，分三种不同情况来总结。

　　一 访问权限修饰符修饰成员变量和方法

　　public：表明该成员变量和方法是共有的，能在任何情况下被访问。

　　protected：必须在同一包中才能被访问。(说的比较简单，看个例子就明白了)

Java代码

　　class A

　　{

　　 protected int weight ;

　 protected int f( int a,int b   )

　　 {

　　 // 方法体

　 }

　　}

　　假设B与A在同一个包中，则

Java代码

　　class B

　　{

　　 void g()

　　 {

　　 A a=new A();

　　 A.weight=100;//合法

　　 A.f(3,4);    //合法

　　 }

　　}

　　特别说明：什么是在同一个包中？

　　答：用package打包在一起的class ,叫在同一个包中。(不明白，举个例子)

　　eg:在JDK的src\java\io中，你会看到许多java类，第一句源代码都是package java.io;

　　没有使用package打包的，在同一目录下的类也会被视做同一个包。

　　friendly：在这种情况下中，同protected。区别在第二和第三种情况中。

Java代码

　　class A

　　{

　　 int weight ;

　　 int f( int a,int b   )

　　 {

　　 // 方法体

　　 }

　　}

 

 

 

　　假设B与A在同一个包中，则

Java代码

　　class B

　　{

　　 void g()

　　 {

　　 A a=new A();

　　 A.weight=100;//合法

　　 A.f(3,4);    //合法

　　 }

　　}

　　private: 只能在本类中访问。

Java代码

　　class   Test

　　{

　　 private int money;

　　 Test()

　　 {

　　 money=2000;

　　 }

　　 private int getMoney()

　　 {

　　 return money;

　　 }

　　 public  static  void main(String args[])

　　 {

　　 Test te=new  Test();

　　 te.money=3000;             //合法

　　 int m=te.getMoney();       //合法

　　 System.out.println("money="+m);

　　 }

　　}

　　PS： 实际上，把重要的数据修饰为private，然后写一个public的函数访问它，正好体现了OOP的封装特性，是OOP安全性的体现。

　　二  访问权限修饰符修饰类

　　1，不能用protected和private修饰类。

　　2，用friendly修饰的类叫友好类，在另外一个类中使用友好类创建对象时，要保证它们在同一包中。

　　三   访问权限修饰符与继承

　　这里的访问修饰符指的是修饰成员变量和方法。可以分为两种情况：

　　1，子类与父类在同一包中

　　此时只有声明为private的变量与方法不能被继承(访问)。

Java代码

　　class Father

　　{

　　 private int money ;

　　 int weight=100;

　　}

　　class Son extends Father

　　{

　　 viod f()

　　 {

　　 money=10000;//   非法

　　 weight=100; //   合法

　　 }

　　}

 

 

 

 

　　2,子类与父类不在同一包中

　　此时private与friendly均不能被继承(访问)， protected与public可以。

　　Father.java

Java代码

　　package com.aaa

　　public class Father

　　{

　　 int height ;

　　 protected  int money=120;

　　 public int weight;

　　 protected int getMoney()

　　 {

　　 return money;

　　 }

　　 void setMoney(int newMoney)

　　 {

　　 money=newMoney;

　　 }

　　}

　　Son.java

Java代码

　　package com.bbb

　　import com.aaa.Father;

　　public class Son extends Father

　　{

　　 void f()

　　 {

　　 money=10000;//合法

　　 //height=170;//非法，height为friendly修饰的变量

　　 System.out.println(money);//输出结果是10000

　　 //setMoney(300);          //非法

　　 int number=getMoney();    //合法

　　 System.out.println(number);//输出结果是10000

　　 }

　　 public  static  void main(String args[])

　　 {

　　 Son sss=new Son();

　　 sss.f();

　　 }

　　}

 

所以，访问权限修饰符权限从高到低排列是public  ,protected  ,friendly, private。

 

 

评论

1 楼 yuanyanger 2014-11-03  

第一幅表格中friendly的子孙类是个“叉”，然后你在下面解释是：“3) friendly：在一个包中或者子类中才能被访问。”，这不矛盾吗，friendly类到底能不能被子孙类访问啊。你是把（2）和（3）的解释写反了吧