首先声明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); // 合法
}
}
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);
}
}
实际上,把重要的数据修饰为private,然后写一个public的函数访问它,正好体现了OOP的封装特性,是OOP安全性的体现。
二、访问权限修饰符修饰类
1. 不能用protected和private修饰类。2. 用friendly修饰的类叫友好类,在另外一个类中使用友好类创建对象时,要保证它们在同一包中。
三、访问权限修饰符与继承
这里的访问修饰符指的是修饰成员变量和方法。可以分为两种情况:
1. 子类与父类在同一包中
此时只有声明为private的变量与方法不能被继承(访问)。
Java代码
class Father {
private int money;
int weight = 100;
}
class Son extends Father {
void f() {
money = 10000; // 非法
weight = 100; // 合法
}
}
2. 子类与父类不在同一包中
此时private与friendly均不能被继承(访问),protected与public可以。
Father.javapackage 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。