public,private,protected访问权限在Java,C++中的解析

Java中

Java中的访问权限有public,private,protected和默认的包访问权限

如果类中的属性方法没有显示的指明访问权限，则具有包访问权限，我喜欢称它为packeged权限，很多人也称它为friendly访问权限，而packaged和friendly这两个关键字在实际中都是不存在的。

详细解释，我引别人的一篇博客，说明：

java访问权限修饰符public protected friendly private用法总结

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

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

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

class A {
protected int weight;

protected int f(int a, int b) {
// 方法体
}
}

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

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。区别在第二和第三种情况中。

class A {
int weight;

int f(int a, int b) {
// 方法体
}
}

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

class B {
void g() {
A a = new A();
A.weight = 100;// 合法
A.f(3, 4); // 合法
}
}

private: 只能在本类中访问。

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的变量与方法不能被继承(访问)。

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

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
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。

C++中

由于不存在包的概念，因此，protected与java中的protected有所不同，Java中的protected不但，子对象可以访问，而且包里的其它地方，也可以显示的通过子对象调用，如

package pack1

public class A{

protected int a;

}

package pack1

public class B{

public static void main(String[] args){

System.out.println(a);

}

}

上述代码是没有问题的，但如果B与Ａ不在同一个包中，则不能访问。因此，在Java中，protected在可见性在与packaged权限类似，而只是在继承性上，没有对包划界，packaged权限不允许子象访问其它包内父对象的包访问权限的属性。

在C++里，protected属性有严格的定义，即只具有垂直的访问权限，只有其自身与其后代可以访问，限一个类的protected属性，只有其内部与子对象内部可以访问，而在其它地方是不可见的，为了说明这个问题，见以下代码：

class A{
protected:
int a;
protected:
void print(){
cout<<"A protected method"<<endl;
}
};
class B:public A{
protected:
void test(){
cout<<"test A"<<endl;
}
};
int main(){
B b;
b.test();
//b.print();
}

上述代码是无法编译的，因为b.test()在main里是不可见的，main无法访问b的protected方法，即使方法是通过子对象来调用的，如果把B中的protected方法改为public，则代码可以，编译成功，编译成功后，在B中可以房问父类的protected属性．

下表列出了Ｃ＋＋三种继承对属性的访问情况：

　　　　　　　　　　　public属性 protected属性 private属性

public继承 public protected 不可见

protected继承 protected protected 不可见

private继承　　　　　 private private 不可见

原文地址：http://www.cnblogs.com/cucmehp/archive/2008/10/28/1321106.html