Java主要修饰符

更新时间：2024-02-26 17:10:01 阅读量：综合文库文档下载

说明：文章内容仅供预览，部分内容可能不全。下载后的文档，内容与下面显示的完全一致。下载之前请确认下面内容是否您想要的，是否完整无缺。

武汉理工大学《Java程序设计基础》作业软件工程1004班牛洋 0121010680409

Java主要修饰符

摘要：Java修饰符是Java中很重要的一部分，本文总结了Java主要修饰符

的作用及用法，并通过具体的例子对其进行了说明及应用，使在Java的学习中对修饰符有更系统的认识。

关键词：private

public protected 1

static final abstract

武汉理工大学《Java程序设计基础》作业软件工程1004班牛洋 0121010680409

1权限访问修饰符

Java中常用的权限访问修饰符主要有以下三个：private public protected，这三个修饰符都可以用来修饰类，方法和字段。通常来说，类的成员被修饰为private,类的方法被修饰为public，接口的抽象方法的访问修饰符都被指定为pubilc.

1.1私有访问修饰符

用private修饰的域和方法只能被同一个类中的成员方法所访问，而不能被其他任何类(包括该类的子类)访问。

要注意的是同一个类的不同对象是可以访问对方的private域或private方法。这是因为访问保护是控制在类的级别上，而不是在对象的级别上。

private访问控制符提供了最高的类成员保护级别。凡是限定在类内部使用的域和方法就应该用private修饰，使它们不被其他类所见，体现了类的封装和信息隐藏。

1.2默认访问控制符

如果在类的定义中，域和方法前没有指定访问控制符，则域和方法具有包访问性，即可被处于同一个包中的所有类（的方法）所访问。它们也被称为“包有元”成员。

1.3保护访问控制符

类中限定为protected的成员可以被这个类本身、它的子类（包括同一个包及不同包中的子类）以及同一个包中的所有其他类来访问。

该访问控制符较之默认访问控制符又放宽了一些，主要是允许它的子类都可以访问（即使在不同的包内）

1.4公共访问控制符

类中被限定为public的成员可以被所有的类访问

1.5访问修饰符通常的定义方式

(1)类和类成员都采用默认访问控制（包内访问）

(2)类比成员的访问范围宽。成员在类的范围内，根据各自的用途设置不同的访问控制。

如果一个类中定义了常用的操作，希望能作为公共工具供其他类和程序使用，则应把类本身和这些方法都定义成为public，这也是Java的主类必须是public的原因。

由于public修饰符完全对外公开，可能会造成安全性和数据封装性下降，所以一般应减少public的使用。

为了使对象具有良好的封装性，一般将类的实例域设计成为私有，为了使其他类和对象能够访问私有域，本类必须提供访问私有域的方法（公共方法）。

武汉理工大学《Java程序设计基础》作业软件工程1004班牛洋 0121010680409

权限修饰符的用法，总结为下表：修饰符包外子类 public protected default public yes no no no yes yes no no 包内 yes yes yes no 类内 yes yes yes yes

2static修饰符

static用来修饰内部类，方法，字段。修饰内部类说明该内部类属于外部类而不属于外部类的某个实例。修饰字段说明该字段属于类而不属于类实例。修饰方法说明该方法属于类而不属于类实例。

通过一个简单的例子来说明static的用法。 package com.java; public class fun {

public static void f() {

System.out.println(\ } }

package com.java; public class Sum {

public static void main(String []args) { fun.f(); } }

显然，程序的运行结果是输出1。在这段代码里两次出现了用static声明的方法，此方法是类的方法，而不是类的成员的方法，因此在使用这些方法的时候可以不必先通过创建类的对象来使用方法，而可以直接通过类来使用。如果把第一个fun类里面f()方法的修饰符static去掉，则在Sum类中主方法的代码应改为：

fun s = new fun(); s.f();

如果用了static声明f()方法，又要使用fun类的对象来使用该方法，则要在代码中加上@SuppressWarnings(\

要注意的是Java不能像C/C++一样在方法中使用static声明变量，例如在上述代码的f()方法中加上static int i = 0;就会报错，报错为：

武汉理工大学《Java程序设计基础》作业软件工程1004班牛洋 0121010680409

Exception in thread \ Illegal modifier for parameter i; only final is permitted

at com.java.fun.f(fun.java:4)

at com.java.Sum.main(Sum.java:6))

在Java代码中多次使用的main()方法就是静态方法，这是为了系统在没有任何实例化对象之前就可以运行一个应用程序。

由于static方法是属于整个类的，它在内存中的代码段将随着类的定义而分配和装载，不被任何一个对象专有，它不能操纵和处理属于某个对象的成员变量，而只能处理整个类的成员变量，也就是static方法只能处理static域。在类的定义中，凡是涉及针对一个具体对象的方法必须是非静态的，调用方法时应采用“对象名.方法名”；而不涉及到具体对象的方法必须是静态的，调用方法时应采用“类名.方法名”

3final修饰符

final的意思是不可变,相当于C++中的const，它可以修饰类、字段、方法。修饰类后类不能被扩展（extends），也就是不能被继承。修饰字段后字段的值不能被改变，因此如果有final修饰字段，应该对字段进行手动初始化。修饰方法后该方法不能被改变，也就是重写。

3.1不能为用final声明的变量多次赋值

下述的代码： package com.java; public class Sum { public static void main(String []args) { final int i = 0; i = 0;

System.out.println(i); } }

该代码由于为用final声明的变量i重新赋值，则报错为：

Exception in thread \java.lang.Error: Unresolved compilation problem: The final local variable i cannot be assigned. It must be blank and not using a compound assignment at com.java.Sum.main(Sum.java:5)

3.2为了防止变量或函数的返回值被修改，应尽可能多地使用final修饰方法与变量

在类定义中，凡是final修饰符所修饰的方法，是功能和内部语句不能被更

武汉理工大学《Java程序设计基础》作业软件工程1004班牛洋 0121010680409

改的方法，它可以防止子类对父类的关键方法的错误重定义，保证了程序的安全性与正确性。

3.3不能继承被final声明的类

package com.java; public final class fun { }

package com.java;

public class Sum extends fun { public static void main(String []args) { System.out.println(\ } }

上述代码中由于Sum类试图继承用final修饰的fun类，因此会报错，报

错为：

The type Sum cannot subclass the final class fun Sum.java /sun/src/com/java line 2 Java Problem

如果要继承fun类，fun类就不能被final修饰，应去掉final修饰符。

3.4不能重写用final修饰的方法

package com.java; public class fun {

public void functionOne() { System.out.println(\ }

public final void functionTwo() { System.out.println(\ } }

package com.java;

public class Sum extends fun { public void functionOne() { super.functionOne(); System.out.println(\ }

public void functionTwo() { super.functionTwo(); }

public static void main(String []args) { Sum s = new Sum(); s.functionOne(); s.functionTwo(); }

武汉理工大学《Java程序设计基础》作业软件工程1004班牛洋 0121010680409

}

如上述代码所示，fun类里有functionOne和functionTwo两个方法，其中functionTwo被修饰为final，在Sum类中试图重写两个方法，重写方法一是可以的，重写方法二时就会报错，报错为：

Cannot override the final method from fun Sum.java /sun/src/com/java line 7 Java Problem

去掉functionTwo的final修饰符程序就可以正常运行，运行结果截图如下：

4 abstract修饰符

abstract是抽象的意思，用来修饰类和方法，修饰类后，该类为抽象类，不能被实例化，必需进行扩展。修饰方法后，该方法为抽象方法必须被子类重写。

用abstract修饰符修饰的类就是抽象类。抽象类就是没有具体对象的概念类，这种类实际是一种经过优化了的概念组织方式，这种组织方式使得所有的概念层次分明，简洁洗练，非常符合人类日常的思维习惯，它是模仿人类思维模式的产物。使用抽象类的优点是可以利用类的公共属性来提高开发和维护程序的效率。要注意的是abstract和final修饰符不能同时修饰一个类，因为abstract类自身没有具体的对象，需要派生出子类后再创建子类的对象，而final类不能有子类，这样abstrct final类就无法使用，也就没有意义了，下面的代码就说明了这一点。

package com.java;

public abstract final class fun { }

package com.java;

public class Sum extends fun { }

试图编译上述代码，报错如下所示：

The class fun can be either abstract or final, not both fun.java /sun/src/com/java line 2 Java Problem

The type Sum cannot subclass the final class fun Sum.java /sun/src/com/java line 2 Java Problem

这说明abstrct和final不能连用。

武汉理工大学《Java程序设计基础》作业软件工程1004班牛洋 0121010680409

修饰符abstrct修饰的抽象方法是一种仅有方法头，而没有具体的方法体和操作实现的方法，至于抽象方法的实现，则在其子类中完成。但要注意的是，子类在继承父类的抽象方法并对其进行重新定义时，要是重新定义后的方法和原方法的返回值和参数都相同。特别要注意的是，所有的抽象方法都必须存在于抽象类之中。一个非抽象类中实现抽象方法是非法的，也就是说，一个抽象类的子类如果不是抽象类，则它必须为父类中所有的抽象方法书写方法体。不过抽象类不一定还能拥有抽象方法，它可以包含非抽象的方法。下述例子来简述抽象方法的使用。

package com.java;

public abstract class fun { public abstract void f() { System.out.println(\ } }

编译上述代码报错为：

Abstract methods do not specify a body fun.java /sun/src/com/java line 3 Java Problem

则抽象方法不能含有方法体。 package com.java; public class fun {

public abstract void f(); }

编译上述代码报错为：

The abstract method f in type fun can only be defined by an abstract class fun.java /sun/src/com/java line 3 Java Problem

The type fun must be an abstract class to define abstract methods fun.java /sun/src/com/java line 2 Java Problem

可见，抽象方法一定要定义在抽象类中。 package com.java;

public class Sum extends fun { }

试图编译上述代码，报错为：

The type Sum must implement the inherited abstract method fun.f() Sum.java /sun/src/com/java line 2 Java Problem

可见抽象类的非抽象子类一定要为抽象类中的抽象方法写方法体。若要将上述代码修改正确，则有以下两种方法，一是将Sum定义为抽象类，二是在Sum类中实现f()方法。

武汉理工大学《Java程序设计基础》作业软件工程1004班牛洋 0121010680409

5Java主要修饰符的应用实例截图

下面以Android计算器为例，在具体的实例中说明Java修饰的使用，以下是实验结果截图(使用Android2.2模拟器)，源代码见附录。

武汉理工大学《Java程序设计基础》作业软件工程1004班牛洋 0121010680409

附录

（Android计算器的制作主要运用了逆波兰表达式求值等内容）

1主类

package com.java;

import android.app.Activity;

import android.content.pm.ActivityInfo; import android.graphics.Color; import android.os.Bundle; import android.view.View; import android.widget.Button; import android.widget.EditText;

public class CalculatorOfAndriodActivity extends Activity { /** Called when the activity is first created. */ // @Override

private static Button buttonOfCalcu[] = new Button[20];

String str = new String();

boolean isNotEqual = true;

private static void setColor() { for (int i = 0; i < 20; i++) { buttonOfCalcu[i].setBackgroundColor(Color.LTGRAY); } }

public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); final EditText edit = (EditText) findViewById(R.id.edittext); buttonOfCalcu[0] = (Button) findViewById(R.id.zero); buttonOfCalcu[1] = (Button) findViewById(R.id.one); buttonOfCalcu[2] = (Button) findViewById(R.id.two); buttonOfCalcu[3] = (Button) findViewById(R.id.three); buttonOfCalcu[4] = (Button) findViewById(R.id.four); buttonOfCalcu[5] = (Button) findViewById(R.id.five); buttonOfCalcu[6] = (Button) findViewById(R.id.six); buttonOfCalcu[7] = (Button) findViewById(R.id.seven); buttonOfCalcu[8] = (Button) findViewById(R.id.eight); buttonOfCalcu[9] = (Button) findViewById(R.id.nine);

武汉理工大学《Java程序设计基础》作业软件工程1004班牛洋 0121010680409

buttonOfCalcu[10] = (Button) findViewById(R.id.point); buttonOfCalcu[11] = (Button) findViewById(R.id.add); buttonOfCalcu[12] = (Button) findViewById(R.id.sub); buttonOfCalcu[13] = (Button) findViewById(R.id.multi); buttonOfCalcu[14] = (Button) findViewById(R.id.div); buttonOfCalcu[15] = (Button) findViewById(R.id.back); buttonOfCalcu[16] = (Button) findViewById(R.id.clean); buttonOfCalcu[17] = (Button) findViewById(R.id.left); buttonOfCalcu[18] = (Button) findViewById(R.id.right); buttonOfCalcu[19] = (Button) findViewById(R.id.equal); setColor();

buttonOfCalcu[0].setOnClickListener(new View.OnClickListener() { });

public void onClick(View v) { // TODO Auto-generated method stub setColor(); buttonOfCalcu[0].setBackgroundColor(Color.YELLOW); if (isNotEqual) { str += \ } else { str = \ isNotEqual = true; } edit.setText(str); }

buttonOfCalcu[1].setOnClickListener(new View.OnClickListener() { });

public void onClick(View v) { // TODO Auto-generated method stub setColor(); buttonOfCalcu[1].setBackgroundColor(Color.YELLOW); if (isNotEqual) { str += \ } else { str = \ isNotEqual = true; } edit.setText(str); }

武汉理工大学《Java程序设计基础》作业软件工程1004班牛洋 0121010680409

buttonOfCalcu[2].setOnClickListener(new View.OnClickListener() { });

public void onClick(View v) { // TODO Auto-generated method stub setColor(); buttonOfCalcu[2].setBackgroundColor(Color.YELLOW); if (isNotEqual) { str += \ } else { str = \ isNotEqual = true; } edit.setText(str); }

buttonOfCalcu[3].setOnClickListener(new View.OnClickListener() { });

public void onClick(View v) { // TODO Auto-generated method stub setColor(); buttonOfCalcu[3].setBackgroundColor(Color.YELLOW); if (isNotEqual) { str += \ } else { str = \ isNotEqual = true; } edit.setText(str); }

buttonOfCalcu[4].setOnClickListener(new View.OnClickListener() {

public void onClick(View v) { // TODO Auto-generated method stub setColor(); buttonOfCalcu[4].setBackgroundColor(Color.YELLOW); if (isNotEqual) { str += \ } else { str = \ isNotEqual = true;

武汉理工大学《Java程序设计基础》作业软件工程1004班牛洋 0121010680409

} });

}

edit.setText(str);

buttonOfCalcu[5].setOnClickListener(new View.OnClickListener() { });

public void onClick(View v) { // TODO Auto-generated method stub setColor(); buttonOfCalcu[5].setBackgroundColor(Color.YELLOW); if (isNotEqual) { str += \ } else { str = \ isNotEqual = true; } edit.setText(str); }

buttonOfCalcu[6].setOnClickListener(new View.OnClickListener() { });

public void onClick(View v) { // TODO Auto-generated method stub setColor(); buttonOfCalcu[6].setBackgroundColor(Color.YELLOW); if (isNotEqual) { str += \ } else { str = \ isNotEqual = true; } edit.setText(str); }

buttonOfCalcu[7].setOnClickListener(new View.OnClickListener() {

public void onClick(View v) { // TODO Auto-generated method stub setColor(); buttonOfCalcu[7].setBackgroundColor(Color.YELLOW); if (isNotEqual) {

武汉理工大学《Java程序设计基础》作业软件工程1004班牛洋 0121010680409

});

}

str += \} else { str = \ isNotEqual = true; }

edit.setText(str);

buttonOfCalcu[8].setOnClickListener(new View.OnClickListener() { });

public void onClick(View v) { // TODO Auto-generated method stub setColor(); buttonOfCalcu[8].setBackgroundColor(Color.YELLOW); if (isNotEqual) { str += \ } else { str = \ isNotEqual = true; } edit.setText(str); }

buttonOfCalcu[9].setOnClickListener(new View.OnClickListener() { });

public void onClick(View v) { // TODO Auto-generated method stub setColor(); buttonOfCalcu[9].setBackgroundColor(Color.YELLOW); if (isNotEqual) { str += \ } else { str = \ isNotEqual = true; } edit.setText(str); }

buttonOfCalcu[10].setOnClickListener(new View.OnClickListener() {

public void onClick(View v) {

武汉理工大学《Java程序设计基础》作业软件工程1004班牛洋 0121010680409

// TODO Auto-generated method stub setColor(); buttonOfCalcu[10].setBackgroundColor(Color.YELLOW); isNotEqual = true; str += '.';

edit.setText(str); } }); buttonOfCalcu[11].setOnClickListener(new View.OnClickListener() { public void onClick(View v) { // TODO Auto-generated method stub setColor(); buttonOfCalcu[11].setBackgroundColor(Color.BLUE); isNotEqual = true; str += \ edit.setText(str); } }); buttonOfCalcu[12].setOnClickListener(new View.OnClickListener() { public void onClick(View v) { // TODO Auto-generated method stub setColor(); buttonOfCalcu[12].setBackgroundColor(Color.BLUE); isNotEqual = true; str += \ edit.setText(str); } }); buttonOfCalcu[13].setOnClickListener(new View.OnClickListener() { public void onClick(View v) { // TODO Auto-generated method stub setColor(); buttonOfCalcu[13].setBackgroundColor(Color.BLUE); isNotEqual = true; str += \ edit.setText(str); } });

武汉理工大学《Java程序设计基础》作业软件工程1004班牛洋 0121010680409

buttonOfCalcu[14].setOnClickListener(new View.OnClickListener() { });

public void onClick(View v) { // TODO Auto-generated method stub setColor(); buttonOfCalcu[14].setBackgroundColor(Color.BLUE); isNotEqual = true; str += \ edit.setText(str); }

buttonOfCalcu[15].setOnClickListener(new View.OnClickListener() { });

public void onClick(View v) { // TODO Auto-generated method stub setColor(); buttonOfCalcu[15].setBackgroundColor(Color.RED); if (str.length() > 0) str = new String(str.toCharArray(), 0, str.length() - 1); edit.setText(str); isNotEqual = true; }

buttonOfCalcu[16].setOnClickListener(new View.OnClickListener() { });

public void onClick(View v) { // TODO Auto-generated method stub setColor(); buttonOfCalcu[16].setBackgroundColor(Color.RED); str = \ edit.setText(str); }

buttonOfCalcu[17].setOnClickListener(new View.OnClickListener() {

public void onClick(View v) { // TODO Auto-generated method stub setColor(); buttonOfCalcu[17].setBackgroundColor(Color.YELLOW); if (isNotEqual) {

武汉理工大学《Java程序设计基础》作业软件工程1004班牛洋 0121010680409

str += \ } else { str = \ isNotEqual = true; } edit.setText(str); } }); buttonOfCalcu[18].setOnClickListener(new View.OnClickListener() { public void onClick(View v) { // TODO Auto-generated method stub setColor(); buttonOfCalcu[18].setBackgroundColor(Color.YELLOW); if (isNotEqual) { str += \ } else { str = \ isNotEqual = true; } edit.setText(str); } }); buttonOfCalcu[19].setOnClickListener(new View.OnClickListener() { public void onClick(View v) { // TODO Auto-generated method stub setColor(); buttonOfCalcu[19].setBackgroundColor(Color.RED); isNotEqual = false; str = FunctionOfCal.calculator(FunctionOfCal .changeToReserve(str)); edit.setText(str); } }); }

protected void onResume() {

if(getRequestedOrientation()!=ActivityInfo.SCREEN_ORIENTATION_PORTRAIT)

武汉理工大学《Java程序设计基础》作业软件工程1004班牛洋 0121010680409

{

setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);

}

super.onResume(); } }

2功能类

package com.java;

import java.util.Stack;

public class FunctionOfCal {

public static int levelOfSymbol(char ch) { int level = -1; switch (ch) { case '+': case '-': level = 0; break; case '*': case '/': level = 1; break; } return level; }

public static boolean isSymbol(char ch) { boolean flag; if (ch == '+' || ch == '-' || ch == '*' || ch == '/') { flag = true; } else { flag = false; } return flag; }

public static boolean isSymbol(final String s) { boolean flag; if (s.length() == 1 && isSymbol(s.charAt(0))) {

武汉理工大学《Java程序设计基础》作业软件工程1004班牛洋 0121010680409

}

flag = true; } else { flag = false; }

return flag;

public static boolean isNumber(char ch) { boolean flag; if (ch == '0' || ch == '1' || ch == '2' || ch == '3' || ch == '4' || ch == '5' || ch == '6' || ch == '7' || ch == '8' || ch == '9') { flag = true; } else { flag = false; } return flag; }

public static String changeToReserve(String sour) { final int MAX = 1000; char vTrans[] = new char[MAX]; Stack stOperat = new Stack(); char ch; int k = 0, pos = 0; ch = sour.charAt(pos); while (pos < sour.length()) { if (isNumber(ch) || ch == '.') { if (pos > 0 && (isSymbol(sour.charAt(pos - 1)) || sour .charAt(pos - 1) == '(')) { if (k >= 1 && vTrans[k - 1] != '#') { vTrans[k++] = '#'; } } vTrans[k++] = ch; pos++; } if (ch == '(') { stOperat.push(ch); pos++; } if (ch == ')') { while (stOperat.peek() != '(') {

武汉理工大学《Java程序设计基础》作业软件工程1004班牛洋 0121010680409

if (k >= 1 && vTrans[k - 1] != '#') { vTrans[k++] = '#'; } vTrans[k++] = stOperat.peek(); stOperat.pop(); } stOperat.pop(); pos++; } if (isSymbol(ch)) { if (pos > 0 && isNumber(sour.charAt(pos - 1))) { vTrans[k++] = '#'; } while (!stOperat.isEmpty() && levelOfSymbol(ch) levelOfSymbol(stOperat.peek())) { if (k >= 1 && vTrans[k - 1] != '#') { vTrans[k++] = '#'; } vTrans[k++] = stOperat.peek(); stOperat.pop(); } stOperat.push(ch); pos++; } if (pos < sour.length()) { ch = sour.charAt(pos); } } while (!stOperat.isEmpty()) { if (k >= 1 && vTrans[k - 1] != '#') { vTrans[k++] = '#'; } vTrans[k++] = stOperat.peek(); stOperat.pop(); } vTrans[k] = '#'; String dest = new String(vTrans, 0, vTrans.length); return dest; }

public static double calcu(double s, double t, char op) { double result = 0; switch (op) {

武汉理工大学《Java程序设计基础》作业软件工程1004班牛洋 0121010680409

}

case '+': result = s + t; break; case '-': result = s - t; break; case '*': result = s * t; break; case '/': result = s / t; break; }

return result;

public static String calculator(String sPost) { String[] strTrans = sPost.split(\ }

Stack stCalcu = new Stack();

for (int i = 0; i < strTrans.length - 1; i++) { if (!isSymbol(strTrans[i])) { stCalcu.push(strTrans[i]); } else { double s = Double.valueOf(stCalcu.pop()); double r = Double.valueOf(stCalcu.pop()); stCalcu.push(Double.toString(calcu(r, s, strTrans[i].charAt(0)))); } }

return stCalcu.peek();

3其他（此处附上布局文件及注册文件）

android:id=\

武汉理工大学《Java程序设计基础》作业软件工程1004班牛洋 0121010680409

android:layout_width=\ android:layout_height=\

android:id=\

android:layout_width=\ android:layout_height=\ android:gravity=\

android:id=\ android:layout_width=\ android:layout_height=\