java修饰符的使用.docx

Java主要修饰符的使用
作者：
武汉理工大学计算机科学与技术学院软件工程1002班 岳广
学号 0121*****0212

1. 基本介绍
1.1类的修饰符分为：可访问控制符和非访问控制符两种。
可访问控制符是：公共类修饰符 public
非访问控制符有：抽象类修饰符 abstract ；最终类修饰符 final

1 ）公共类修饰符 public ： Java 语言中类的可访问控制符只有一个： public 即公共的。每个 Java 程序的主类都必须是 public 类作为公共工具供其它类和程序使用的应定义为 public 类。
2 ）抽象类修饰符 abstract ：凡是用 abstract 修饰符修饰的类，被称为抽象类。所谓抽象类是指这种类没有具体对象的一种概念类。这样的类就是 Java 语言的 abstract 类。
3 ） 最终类修饰符 final ：当一个类不可能有子类时可用修饰符 final 把它说明为最终类。被定义为 final 的类通常是一些有固定作用、用来完成某种标准功能的类。
4 ）类缺省访问控制符：如果一个类没有访问控制符，说明它具有缺省的访问控制符特性。此时，这个类只能被同一个包中的类访问或引用。这一访问特性又称为包访问性。

1.2域的控制修饰符也分为：可访问控制符和非访问控制符两类。
可访问控制符有 4 种：公共访问控制符： public ；私有访问控制符： private ；保护访问控制符： protected ；私有保护访问控制符： private protected
非访问控制符有 4 种：静态域修饰符： static ；最终域修饰符： final ；易失 ( 共享 ) 域修饰符： volatile ；暂时性域修饰符： transient

1 ）公共访问控制符 public ：用 public 修饰的域称为公共域。如果公共域属于一个公共类，则可以被所有其它类所引用。由于 public 修饰符会降低运行的安全性和数据的封装性，所以一般应减少 public 域的使用。
2 ）私有访问控制符 private ： 用 private 修饰的成员变量 ( 域 ) 只能被该类自身所访问，而不能被任何其它类 ( 包括子类 ) 所引用。
3 ）保护访问控制符 protected ：用 protected 修饰的成员变量可以被三种类所引用：①该类自身；②与它在同一个包中的其它类；③在其它包中的该类的子类。使用修饰符 protected 的主要作用是允许其它包中它的子类来访问父类的特定属性。
4 ）私有保护访问控制符 private protected ：用修饰符 private protected 修饰的成员变量可以被该类本身或该类的子类两种类访问和引用。
5 ）静态域修饰符 static ：用 static 修饰的成员变量仅属于类的变量，而不属于任何一个具体的对象，静态成员变量的值是保存在类的内存区域的公共存储单元，而不是保存在某一个对象的内存区间。任何一个类的对象访问它时取到的都是相同的数据；任何一个类的对象修改它时 , 也都是对同一个内存单元进行操作。
6 ）最终域修饰符 final ：最终域修饰符 final 是用来定义符号常量的。一个类的域 ( 成员变量 ) 如果被修饰符 final 说明，则它的取值在程序的整个执行过程中都是不变的。
7 ）易失 ( 共享 ) 域修饰符 volatile ：易失 ( 共享 ) 域修饰符 volatile 是用来说明这个成员变量可能被几个线程所控制和修改。也就是说在程序运行过程中，这个成员变量有可能被其它的程序影响或改变它的取值。因此，在使用中要注意这种成员变量取值的变化。通常 volatile 用来修饰接受外部输入的域。
8 ）暂时性域修饰符 transient ：暂时性域修饰符 transient 用来定义一个暂时性变量。其特点是：用修饰符 transient 限定的暂时性变量，将指定 Java 虚拟机认定该暂时性变量不属于永久状态，以实现不同对象的存档功能。否则，类中所有变量都是对象的永久状态的一部分，存储对象时必须同时保存这些变量。

1.3方法的控制修饰符也分为：可访问控制符和非访问控制符两类。
可访问控制符有 4 种：公共访问控制符： public ；私有访问控制符： private ；保护访问控制符： protected ；私有保护访问控制符： private protected
非访问控制符有 5 种：抽象方法控制符： abstract ；静态方法控制符： static ；最终方法控制符： final ；本地方法控制符： native ；同步方法控制符： synchronized

1 ）抽象方法控制符 abstract ：用修饰符 abstract 修饰的方法称为抽象方法。抽象方法是一种仅有方法头，没有方法体和操作实现的一种方法。
2 ）静态方法控制符 static ：用修饰符 static 修饰的方法称为静态方法。静态方法是属于整个类的类方法；而不使用 static 修饰、限定的方法是属于某个具体类对象的方法。 由于 static 方法是属于整个类的，所以它不能操纵和处理属于某个对象的成员变量，而只能处理属于整个类的成员变量，即 static 方法只能处理 static 的域。
3 ）最终方法控制符 final ：用修饰符 final 修饰的方法称为最终方法。最终方法是功能和内部语句不能更改的方法，即最终方法不能重载。这样，就固定了这个方法所具有的功能和操作，防止当前类的子类对父类关键方法的错误定义，保证了程序的安全性和正确性。所有被 private 修饰符限定为私有的方法，以及所有包含在 final 类 ( 最终类 ) 中的方法，都被认为是最终方法。
4 ）本地方法控制符 native ：用修饰符 native 修饰的方法称为本地方法。为了提高程序的运行速度，需要用其它的高级语言书写程序的方法体，那么该方法可定义为本地方法用修饰符 native 来修饰；
5 ）同步方法控制符 synchronized ：该修饰符主要用于多线程共存的程序中的协调和同步。

2. Java中各种修饰符与访问修饰符的说明
2.1类：

访问修饰符
名称
说明
备注
public
可以被所有类访问（使用）
public类必须定义在和类名相同的同名文件中
package
可以被同一个包中的类访问（使用）
默认的访问权限，可以省略此关键字，可以定义在和public类的同一个文件中

修饰符
名称
说明
备注
final
使用此修饰符的类不能够被继承

abstract
如果要使用abstract类，之前必须首先建一个继承abstract类的新类，新类中实现abstract类中的抽象方法。
类只要有一个abstract方法，类就必须定义为abstract，但abstract类不一定非要保护abstract方法不可
2.2变量：
访问修饰符
名称
说明
备注
public
可以被任何类访问

protected
可以被同一包中的所有类访问
可以被所有子类访问
子类没有在同一包中也可以访问
private
只能够被当前类的方法访问

缺省
无访问修饰符
可以被同一包中的所有类访问
如果子类没有在同一个包中，也不能访问

修饰符
名称
说明
备注
static
静态变量（又称为类变量，其它的称为实例变量）
可以被类的所有实例共享。
并不需要创建类的实例就可以访问静态变量
final
常量，值只能够分配一次，不能更改
注意不要使用const，虽然它和C、C++中的const关键字含义一样
可以同static一起使用，避免对类的每个实例维护一个拷贝
transient
告诉编译器，在类对象序列化的时候，此变量不需要持久保存
主要是因为改变量可以通过其它变量来得到，使用它是为了性能的问题
volatile
指出可能有多个线程修改此变量，要求编译器优化以保证对此变量的修改能够被正确的处理

2.3方法：
访问修饰符
名称
说明
备注
public
可以从所有类访问

protected
可以被同一包中的所有类访问
可以被所有子类访问
子类没有在同一包中也可以访问
private
只能够被当前类的方法访问

缺省
无访问修饰符
可以被同一包中的所有类访问
如果子类没有在同一个包中，也不能访问

修饰符
名称
说明
备注
static
静态方法（又称为类方法，其它的称为实例方法）
提供不依赖于类实例的服务
并不需要创建类的实例就可以访问静态方法
final
防止任何子类重载该方法
注意不要使用const，虽然它和C、C++中的const关键字含义一样
可以同static一起使用，避免对类的每个实例维护一个拷贝
abstract
抽象方法，类中已声明而没有实现的方法
不能将static方法、final方法或者类的构造器方法声明为abstract
native
用该修饰符定义的方法在类中没有实现，而大多数情况下该方法的实现是用C、C++编写的。
参见Sun的Java Native接口（JNI），JNI提供了运行时加载一个native方法的实现，并将其于一个Java类关联的功能
synchronized
多线程的支持
当一个此方法被调用时，没有其它线程能够调用该方法，其它的synchronized方法也不能调用该方法，直到该方法返回

2.4接口：
访问修饰符
名称
说明
备注
public
所有

无访问修饰符（默认）
同一个包内

3.面向对象的特征
3.1抽象：
就是忽略一个主题中与当前目标无关的那些方面，以便更充分地注意与当前目标有关的方面。抽象包括两个方面，一是过程抽象，二是数据抽象。
抽象方法是没有方法体的方法。抽象方法有两种，一种是被abstract修饰的方法，一种是接口(被interface修饰的类)中的方法。被abstract或interface被修饰的类都属于抽象类。被abstract修饰的抽象类中可以有抽象方法，也可以没有抽象方法；可以有具体的方法(有方法体的方法)，也可以没有具体的方法。
抽象方法必须存在抽象类中。抽象类是不能被自身通过关键字new来实例化的。

3.2封装：
是把过程和数据包围起来，对数据的访问只能通过已定义的界面。说简单点封装就是将属性私有化(private)，提供公有的方法访问私有属性。每一个私有属性创建一对取值(get私有属性名)方法和赋值(set私有属性名)方法。

3.3方法的重载(Overload)：
在同一个类中如果有几个方法名相同，但参数的类型、个数和顺序不一致时，这几个方法互为重载。方法重载与访问修饰符和返回值类型无关。

3.4继承：
对象的一个新类可以从现有的类中派生，这个过程称为类继承。新类继承了原始类的特性，新类称为原始类的派生类（子类），而原始类称为新类的基类（父类）。派生类可以从它的基类那里继承方法和实例变量，并且类可以修改或增加新的方法使之更适合特殊的需要。
子类类名后跟“extends 要继承的父类类名”。

3.5多态性：
指允许不同类的对象对同一消息作出响应。多态性包括参数化多态性和包含多态性。

4.示例
4.1 public protected default private 组
范围
private
default
protected
public
同一类
√
√
√
√
同一包中的类

√
√
√
不同包中的子类

√
√
其他包中的类

√

程序代码：
package test;

class PublicClass {
public String publicVariable = "publicVariable" ;
private String privateVar = "private var";
protected String protectedVar ="protected var";
String defaultVar="defaultVar";

private void showPrivate(){
System.out.println("Nobody will access!");
}

public void showPublic(){
System.out.println("showPublic method!");
}

public void showProtected(){
System.out.println("Show protected method!");
}

void showDefault(){
System.out.println("Show default method!");
}
}

package test;

class Test {
private String var =" private variable in class-Test!";
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Test t = new Test();
PublicClass pClass = new PublicClass();
//另外一个类中的共有属性和方法是可以被外界所访问的
System.out.println("可以访问到的资源属性:"+pClass.publicVariable);//可访问
pClass.showPublic(); // 可访问
/*
*以下两条编译错误，在另外一个类中的私有方法是访问不到的
**/
//System.out.println("可以访问到的资源属性:"+pClass.privateVariable ); //不能访问
// pClass.showPrivate(); //不能访问
//私有变量自己可以访问
System.out.println("私有变量自己可以访问"+t.var);
//protected 成员可以被该类的成员和子类的成员访问。
// 还可以被同一个包中内的其他类成员访问
System.out.println("可以访问到的资源属性:"+pClass.protectedVar);//可访问
pClass.showProtected();//可访问
System.out.println("可以访问到的资源属性:"+pClass.defaultVar);//可访问
pClass.showDefault();//可访问
}
}

运行截图：

4.2 final 修饰符
1)当final用于基本数据类型时，final让其值(value)保持不变，但是当用于object reference时，final仅让reference保持不变。

程序代码:
public class Test {

/**
* @param args
*/
private final int li_int=12;
private final InClass inClass1=new InClass(5);
private final InClass inClass2=new InClass(8);
public void modifiedFinal(int a){
//下面语句出现编译错误，不能修改final基本类型的值
//li_int = a;
//下面语句出现编译错误，不能将已经初始化的final变量指向另一个对象
//inClass1=inClass2;
//下面语句成功，虽然引用不能改变但final变量引用的对象本身内容是可以改变的
inClass1.mod(a);
}
class InClass{
int li_a=0;
public InClass(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.inClass1.li_a);
}

}

运行截图：

2)当声明参数为final时，可以保证该参数不能再被指向它处，当参数是基本数据类型时，就意味着值不能改变。

程序代码:
public class Test3 {

/**
* @param args
*/
private int li_int=12;
private InClass inClass1=new InClass(5);
private InClass inClass2=new InClass(8);
public void modifiedFinal(final int a,final InClass in){
//下面语句出现编译错误，不能修改final基本类型的值
//a = 15;
//下面语句出现编译错误，不能将已经初始化的final变量指向另一个对象
//in=inClass2;
//下面语句成功，虽然引用不能改变但final变量引用的对象本身内容是可以改变的
in.mod(a);
}
class InClass{
int li_a=0;
public InClass(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.InClass in=test3.new InClass(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 class 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 class 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) 当把一个class声明为final时，也就决定了此class将不能被继承（比如String类，此类为final类，具体可以参见其实现java.lang.String）。final classes的methods可以是final，也可以是非final的；其中的数据成员可以是final的也可以不是，他们将服从final data的原则。

程序代码:
public final class 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 class Test7 extends Test6{
private int li_int=0;
}

运行截图：
1）无Test7时：

2) 有Test7时：

出错

4.3 static 关键字
static代码块也叫静态代码块，是在类中独立于类成员的static语句块，可以有多个，位置可以随便放，它不在任何的方法体内，JVM加载类时会执行这些静态的代码块，如果static代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次。

程序代码:
public class 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");
}
}
运行截图：

5.参考资料
（1）
（2）
（3）《Java语言程序设计》 清华大学出版社 马皓 编著

6.附录
杨辉三角作业代码：
import java.util.Scanner;

public class Triangle {

/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
int n;
System.out.println("请输入要输出的杨辉三角的行数:");
Scanner a = new Scanner(System.in);
n=a.nextInt();
output(n);

}

static void output(int n){ //输出杨辉三角
int i,j;
for(i=0;i<=n;i++){ //表示行数

for(j=0;j<=i;j++){ //表示每行的第几个元素

System.out.print(get(i,j)+"\t");
}

System.out.println();
}
}

static int get(int i,int j){//的到每一个元素的值
if (j==0||i==j){
return 1;
}
else{

return get(i-1,j-1)+get(i-1,j); //调用自身

}

}

}

时间：
2012年10月6日
19