JAVA修饰符小论文
武汉理工大学软件1003班廖浪
一．Public（公共的）
带有public的修饰符的类，称为公共类，是访问修饰最宽的修饰词，公共类可以被任何包中的类使用。由public修饰的变量或方法称为公共变量，可被任何包中的任何类访问，只有确认任何外部访问都不会带来不良后果的情况下才将成员声明为公共的。公共变量对任何类都是可见的，不具有数据保护功能。
示例程序：
cla test {
public void dotest()
{
System.out.println(\"We are doing test\");
} }
public cla testtest {
public static void main(String[] args)
{
test x=new test();
x.dotest();
} }
运行截图：
代码分析：
因为test类中的dotest函数是public声明的，所以在testtest类中可以自由调用。
二．Private私有的
带有private修饰符的类，称为私有类，是访问限制最窄的修饰词，只能被该类的对象访问，其子类不能访问，更不能跨包访问。由private修饰的变量称为私有变量，只能被声明它的类使用，拒绝任何外部类的访问。私有变量是不公开的，它们得到了最好的保护，这是对类进行封装时使用的主要方法。此处为声明private变量、方法的类可与访问它自己
示例程序： cla Sundae
{
private Sundae() {}
static Sundae makeASundae()
{
return new Sundae();
} } public cla IceCream { public static void main(String[] args) {
Sundae x = new Sundae(); x.Sundae(); } }
运行截图：
代码分析：
Sunade类中的Sunade函数被声明为private，所以在类IceCream中不能调用Sunade函数，如果调用编译时就会出错，如图所示。
三．Protect（受保护的）
有protected修饰符的类，称为保护类，能被该类的对象与子类访问，即使子类在不同包中也可以。
由protected修饰的变量称为受保护变量，可被声明它的类和派生的子类以及同一个包中的类访问。这就像一个大家庭，家庭成员的秘密可以被其他成员分享，也包括一些亲朋好友，但不想让外界知道。
此处为声明有protected成员、方法的类，读者可以看到，声明它的类可以访问它。
示例程序：
cla door { protected String color ; protected void openDoor() { System.out.println(\"protected 类型的成员变量，只能在不同包外
的子类访问到！\"); } } public cla wood_Door extends door { public static void main(String[] args) { wood_Door wd = new wood_Door (); wd.openDoor(); } }
程序截图：
代码分析：
door 的成员变量方法 openDoor 修饰为 protected 类型，只能通过在不同包下的子类来访问。如果 wood_Door 在同一个包下，那么和 public 类型是一样的了。如果其他类要访问 door 的方法，方法 openDoor 是访问不到的，因为对其他类而言相当于 private 类型的。
四：static（静态）
Static声明的成员变量被视为类的成员变量，而不能把它当作实例对象的成员变量。换句话说，静态变量是类固有的，可以直接引用，其他成员变量仅仅在被声明、生成实例对象后才存在，才可以被引用。基于这样的事实，也把静态变量称为类变量，非静态变量称为实例变量。方法也相应称呼。
示例程序：
public cla Test { private static int a;
private int b;
static {
Test.a=1;
System.out.println(a);
Test t=new Test();
t.f();
t.b=10;
System.out.println(t.b);
}
static {
Test.a=2;
System.out.println(a);
} /**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
}
static {
Test.a=3;
System.out.println(a);
}
public void f(){
System.out.println(\"dove\");
} } 运行截图：
代码分析：
static代码块也叫静态代码块，是在类中独立于类成员的static语句块，可以有多个，位置可以随便放，它不在任何的方法体内，JVM加载类时会执行这些静态的代码块。
五．Final final 修饰符
1)当final用于基本数据类型时，final让其值(value)保持不变，但是当用于object reference时，final仅让reference保持不变。
程序代码: public cla Test {
/** * @param args */ private final int li_int=12; private final InCla inCla1=new InCla(5); private final InCla inCla2=new InCla(8); public void modifiedFinal(int a){ //下面语句出现编译错误，不能修改final基本类型的值
//li_int = a; //下面语句出现编译错误，不能将已经初始化的final变量指向另一个对象
//inCla1=inCla2; //下面语句成功，虽然引用不能改变但final变量引用的对象本身内容是可以改变的
inCla1.mod(a); } cla InCla{ int li_a=0; public InCla(int a){ li_a=a; } public int mod(int b){ li_a=b; return li_a; } } public static void main(String args[]){ Test test1=new Test(); test1.modifiedFinal(100);
System.out.println(test1.inCla1.li_a); } }
运行截图：
2)当声明参数为final时，可以保证该参数不能再被指向它处，当参数是基本数据类型时，就意味着值不能改变。
程序代码: public cla Test3 {
/** * @param args */ private int li_int=12; private InCla inCla1=new InCla(5); private InCla inCla2=new InCla(8); public void modifiedFinal(final int a,final InCla in){ //下面语句出现编译错误，不能修改final基本类型的值
//a = 15; //下面语句出现编译错误，不能将已经初始化的final变量指向另一个对象
//in=inCla2; //下面语句成功，虽然引用不能改变但final变量引用的对象本身内容是可以改变的
in.mod(a); } cla InCla{ int li_a=0; public InCla(int a){ li_a=a; } public int mod(int b){ li_a=b; return li_a; } } public static void main(String args[]){ int a=100; //内部类初始化
Test3 test3=new Test3(); Test3.InCla in=test3.new InCla(30); System.out.println(in.li_a); test3.modifiedFinal(a,in); System.out.println(in.li_a); } }
3) final methods: 可以锁住该method，不让继承类改变其意义（不允许子类覆写）；允许编译器对此method作为inline method调用。
程序代码: public cla Test4 {
/** * @param args */ private final int li_int=0; public final int pub_fi_mod(){ return li_int; } protected final int pro_fi_mod(){ return li_int; } private final int pri_fi_mod(){ return li_int; } private int pri_mod(){ return li_int; } } public cla Test5 extends Test4{ private int li_i=100; //下面的方法编译出错，不能覆盖final方法，只针对public和protected，子类中方法与父类中private的方法名相同不是覆盖，与父类中同方法名的方法没有任何关系（除了名字相同）。
/* public int pub_fi_mod(){ return li_i; } protected int pro_fi_mod(){ return li_i; }*/ private final int pri_fi_mod(){ return li_i; } private int pri_mod(){ return li_i; } public static void main(String args[]){ System.out.println(new Test5().pri_mod()); } } 4) 当把一个cla声明为final时，也就决定了此cla将不能被继承（比如String类，此类为final类，具体可以参见其实现java.lang.String）。final claes的methods可以是final，也可以是非final的；其中的数据成员可以是final的也可以不是，他们将服从final data的原则。
程序代码: public final cla Test6{ private final int li_int=0; public int li_a=123; public final int mod(){ return li_int; } public int pri_mod(){ return li_a; } public static void main(String args[]){ System.out.println(new Test6().pri_mod()); } }
//Test6是final类，所以Test7不能继承 public cla Test7 extends Test6{ private int li_int=0; }
