第3章 修饰符.docx
《第3章 修饰符.docx》由会员分享，可在线阅读，更多相关《第3章 修饰符.docx（47页珍藏版）》请在冰点文库上搜索。
第3章修饰符
第三章修饰符
考点01修饰符基础
规则01：
Java语言共提供了10种修饰符。
分别是public、protected、private、final、abstract、static、native、transient、synchronized和volatile。
规则02：
Java语言中各个修饰符所能应用的对象是不同的。
下面列出了Java修饰符及其可应用的对象（Y-Yes、N-No）：
修饰符
类
属性
方法
构造器
代码块
public
Y
Y
Y
Y
N
protected
N
Y
Y
Y
N
（default）
Y
Y
Y
Y
Y
private
N
Y
Y
Y
N
final
Y
Y
Y
N
N
abstract
Y
N
Y
N
N
static
N
Y
Y
N
Y
native
N
N
Y
N
N
transient
N
Y
N
N
N
synchronized
N
N
Y
N
Y
volatile
N
Y
N
N
N
此处的类指顶层类，而非内部类：
修饰符default不是Java语言中规定的合法修饰符。
规则03：
Java语言中对修饰符的出现顺序无特殊要求，即出现在同一个修饰符对象前的多个修饰符之间的前后顺序可任意排列。
如果用于修饰符方法，则必须做放置在方法返回类型前。
示例01:
：
请问，以下哪些论述是正确的？
请选择一个正确答案：
（1）如果源文件中存在import语句，则必须放置在所有非注释语句之前。
（2）private成员变量可以被同一包中的所有类访问。
（3）一个abstract类可以被声明为final类。
（4）方法内定的本地变量不能被声明为static变量。
答案：
（4）
详解：
本题考查的核心是修饰符。
选项
（1）错误，如果文件中存在import语句，则必须放置在所有非注释语句之前，package语句之后。
选项
（2）错误，private成员变量只能被类自身成员访问，其子类都不能访问。
选项（3）错误，因为abstract修饰符意味着需要被重新实现，而final修饰符意味着不能重新改变，因此二者不能联合使用。
示例02：
请问，以下哪些论述是正确的？
请选择所有正确答案：
（1）一个abstract类不能被实例化。
（2）一个final方法的使用非Java的其他语言实现，代码体位于本地机上.
（3）一个static变量表明该变量只有一个副本。
（4）一个ptivate方法表明该方法可以被同一包中的其他类访问。
答案：
（1）、（3）
详解：
本题考查的核心是修饰符。
选项
（2）错误，一个native方法使用非Java的其他语言实现，代码体位于本地机上。
选项（4）错误，一个ptivate方法表明该方法只能被类自身成员访问。
示例03：
请问，以下哪些修饰符可用于修饰方法？
请选择所有正确答案：
（1）transient
（2）volatile
（3）private
（4）protected
（5）final
答案：
（3）（4）（5）
详解：
本题考查的核心是修饰符。
选项
（1）、
（2）错误，transient和volatile修饰符只能用于修饰变量，不能用于修饰类和方法。
示例04：
请问，以下哪些修饰符可用于修饰顶层类？
请选择所有正确答案：
（1）private
（2）protected
（3）transient
（4）public
（5）final
答案：
（4）（5）
详解：
本题考查的核心是修饰符。
选项
（1）、
（2）错误，因为顶层类是一个公共类。
选项（3）错误，因为transient关键字只能用于修饰变量，不能用于修饰类和方法。
示例05：
请问，以下哪些描述是正确的？
请选择一个正确答案：
（1）一个顶层类可以被private修饰。
（2）一个方法可以被transient修饰。
（3）一个构造器可以被volatile修饰。
（4）一个局部变量可以被final修饰。
答案：
（4）
详解：
本题考查的核心是修饰符。
选项
（1）错误，因为顶层类必须是一个公共类。
选项
（2）错误，因为关键字transient只能用于修饰变量，不能用于修饰类和方法。
选项（3）错误，因为关键字volatile只能用于修饰变量，不能用于修饰类和方法。
示例06：
给出一条语句，请问以下哪些有关该语句的描述是正确的？
privatestaticinti=3;
请选择所有正确答案：
（1）变量i在被初始化后，其值不能再改变。
（2）变量i只能被静态方法改变。
（3）变量i的值被所有其所在的类实例共享。
（4）变量i只能被其他所在类访问。
答案：
（3）、（4）
详解：
本题考查的核心是修饰符。
选项
（1）错误，只有被final修饰符修饰的变量其值一旦初始化不能再改变。
选项
（2）错误，变量i不仅被static修饰符修饰，而且还被private修饰符修饰，因此其值只能被所属类的静态方法改变。
考点02访问修饰符
规则01：
Java语言提供了3种用来控制访问权限的访问修饰符，分别为public、protected和private。
并且规定一个属性前最多只能有一个访问修饰符存在。
规则02：
public是Java语言中对访问限制最宽的修饰符，被其修饰的类、属性、方法不仅可以跨类访问，而且允许跨包访问。
规则03：
protected的访问范围介于public和private之间，被其修饰的类、属性、方法只能被类本身的方法以及子类的方法访问，即使子类在不同的包中也可以访问该变量。
其他与声明变量的类无继承关系的类方法是不能访问该变量的。
规则04：
private是Java语言中对访问限制最宽的修饰符，被其修饰的类、属性、方法只能被该类的对象访问，其子类不能访问，也更不允许跨包访问。
规则05：
Java中除了和修饰符外，还存在第四种修饰符，即不加任何访问关键字的默认访问模式。
它只允许同包内进行访问，不同包之间不允许相互访问。
规则06：
在Java语言中，规定一个非内部类，即顶层类的访问修饰符只能使用public，而不能把private和protected修饰符应用于顶层类。
规则07：
一个JavaApplet被修饰为public，意为该小应用程序可以被浏览器直接实例化。
规则08：
Java应用程序的主方法main（）被public修饰，意为该方法可以被任意JVM调用，作为应用程序的执行入口，如果应用程序的main（）没有被public修饰，则不会产生编译错误，但是该应用程序会因为JVM找不到执行入口而无法被运行。
示例01：
给出以下代码，请问以下哪些描述的正确的？
publicclassA{
AO{
}
}
请选择使用正确答案：
（1）类A可以被其他包中的类访问。
（2）类A不可以被其他包中的类访问。
（3）类A不可以被其他包中的类继承。
（4）类A可以被其他包中的类访问和继承。
（5）代码编译错误，因为公共类的构造器也必须是公共的。
答案：
（1）（4）
详解：
本题考查的核心是修饰符public。
选项
（2）错误，因为被public修饰的任何类（包括其他包中的类）都可以访问它。
选项（3）错误，因为被public修饰的类可以被任何类继承。
选项（5）错误，因为公共类的构造器并不要求必需也是公共的，甚至也可以被private修饰符修饰。
示例02：
请问，以下哪些修饰符可以使其修饰的变量只能对同包类或子类有效？
请选择一个正确答案：
（1）public
（2）private
（3）protected
（4）无访问修饰符
答案：
（3）
详解：
本题考查的核心是修饰符protected。
根据protected的定义，被protected修饰的变量只能被本身的方法以及子类的方法访问，即使子类在不同的包中也可以访问该变量，其他与声明变量的类无继承关系的类方法是不能访问该变量。
4个选项中，只有选项（3）的protected访问修饰符定义适合题目要求。
示例03：
请问，以下哪些修饰符可以使变量对于任何其他类都是不可视的，包括子类？
请选择一个正确答案：
（1）private
（2）public
（3）transient
（4）final
（5）abstact
答案：
（1）
详解：
本题考查的核心是private。
根据private的定义，被其修饰的变量只能被该类的对象实例访问，其子类不能访问，也更不允许跨包访问，4个选项中，只有选项
（1）的private访问修饰符定义适合题目要求。
示例04：
给出以下代码，请问如何声明secret使其为一个只读变量？
publicclassExample{
publicintsecret;
}
请选择一个正确答案：
（1）声明secret变量为private。
（2）声明Example类为private。
（3）声明secret变量为private，并且建立一个用于获取secret变量值的getSecret（）方法。
（4）声明secret变量transient。
（5）声明secret变量为static。
答案：
（3）
详解：
本题考查的核心是封装的概念，为了实现封装，即只给外部提供一个接口，隐藏内部实现细节，除了需将变量声明为私有变量外，还需提供一个用于读取该变量的方法。
示例05：
给出以下代码，请问哪些是有关该方法声明的正确描述？
voidmyMethod（Strings）{
}
请选择所有正确答案：
（1）myMethob（）方法是一个静态方法。
（2）myMethob（）方法没有返回值。
（3）myMethob（）方法是一个抽象方法。
（4）myMethob（）方法不能被所在的包之外的类访问。
答案：
（2）（4）
详解：
本题考查的核心是默认访问修饰符。
Java中除了public、protected和private三种访问修饰符外，还存在第四种访问修饰符，即不加任何访问关键字的默认访问模式。
它只允许同包内进行访问，不同包之间不许访问。
由于myMethod（）方法前无任何访问修饰符，所以该方法不能被所在包之外的类访问。
因此选项（4）正确。
示例06：
给出以下代码，请问该程序的运行结果是什么？
classA{
privateintx=o;
staticinty=1;
protectedintq=2;
}
classBextendsA{
voidmethod（）{
System.out.println（x）;
System.out.println（y）;
System.out.println（q）;
}
}
请选择所有正确答案：
（1）程序编译错误，因为类B不能访问变量x。
（2）程序编译成功，打印输出012。
（3）程序编译错误,因为不能继承一个具有私有变量的类。
（4）程序编译错误，如果移走System.out.println（x）这条语句，可使编译程序通过。
（5）程序编译错误,因为变量x未在类B中定义。
答案：
（1）（4）（5）
详解：
本题考查的核心是默访问修饰符 private。
选项
（1）正确，根据private的定义，被其修饰的变量只能被该类的对象实例访问，其子类不能访问，更不允许跨包访问。
在示例中，子类B不能访问在父类中定义的私有变量x。
如果去掉产生编译错误的System.out.println（x）语句，可使编译通过，所以选项（4）正确。
同理，选项（5）也正确，如果类B必需访问变量x，只能重新定义。
考点03final
规则01：
final关键字用于类、方法、变量前，表明该关键字修饰的对象具有不可变的特性。
规则02：
final关键字用于基本数据类型变量前，表明该关键字修饰的变量为一个常量，其值在以后的使用中，只能被读取，而不能被改变。
一个被声明为final的变量就是一个常量，在使用前必须要被初始化，否则机会产生编译错误。
规则03：
final关键字用于引用类型变量前，同final关键字修饰的基本数据类型变量一样，该变量一旦被分配给一个值就不能再改变。
该变量一旦引用一个对象后，也就不能再引用其它对象，不能再把其他对象句柄赋值给他。
但是，可以改变一个final变量引用对象的内容。
规则04：
final关键字用于方法声明前，该final方法的不可变特性体现在不能被子类重载，但可以被过载。
因为重载是对同一个方法的重新定义，而过载实质上是不同方法拥有同一名称而已。
规则05：
final关键字用于类名前，表明该类不能再被其他类扩展，即不能被其他类继承。
因为被声明为final的类，其所有方法都默认为final，因此无法对其进行重载，自然无法子类化。
示例01：
请问，以下那些修饰符用于声明一个常量？
请选择一个正确答案：
（1）static
（2）final
（3）abstract
（4）public
答案：
（2）
详解：
本题考查的核心是常量的声明。
在Java中，要想声明一个变量为常量，只需在其前加上final修饰符即可。
final的含义就是不可变的意思，即一个final变量一旦被分配给一个值，其值就不可能再改变。
示例02：
给吃以下代码，请问该程序运行的结果是什么？
publicclassExample{
finalintx=0;
Example（）{
x=1;
}
finalintaMethod（）{
returnx;
}
}
请选择所有正确答案：
（1）代码编译错误,因为非final类中存在final方法。
（2）代码编译成功。
（3）代码编译错误,因为代码中对一个final变量x有改变其值的操作。
（4）代码编译错误,如果去掉变量x前的final修饰符，可使代码编译通过。
（5）代码编译错误,因为final修饰符只能修饰方法不能修饰变量，因此语句finalintx=0错误。
答案：
（3）（4）
详解：
本题考查的核心是final修饰符。
选项
（1）错误，因为一个包含final方法和final变量的类，并不需要该类被定义为final类。
选项
（2）错误，因为不能给一个已初始化的final变量赋值。
选项（5）错误，因为final修饰符既可修饰类，也可修饰方法和属性。
示例03：
给出以下代码，请问该程序的运行结果是什么？
classAextendsInteger{
intx=0;
}
请选择一个正确的答案：
（1）代码编译成功。
（2）代码编译错误。
因为Integer类是final类，不能被继承。
（3）代码编译成功。
因为类A没有方法和构造器。
（4）代码编译成功。
但运行时会抛出ArithmeticException异常。
答案：
（2）
详解：
本题考查的核心是final类。
final关键字用于类名前，表明该类不能再被其他类扩展,即不能被其他类继承。
因为被声明为final的类，其所有方法都默认为final，因此无法对其进行重载，自然无法子类化。
示例中对final类Integer类继承，会引起编译错误。
示例04：
请问以下哪个类不能被子类继承？
请选择一个正确答案：
（1）classA{}
（2）abstractfinalclassA{}
（3）nativeclassA{}
（4）finalclassA{}
答案：
（4）
详解：
本题考查的核心是final类。
凡是用final关键字作为类修饰符的类，均不能子类化。
被声明为final的类，其所有方法都默认为final，因此无法对其进行重载，自认无法子类化，所以只有选项（4）正确。
示例05：
给出以下代码，请问改程序的运行结果是什么？
classExample{
publicstaticvoidmain（String[]args）{
Cc=newC（）；
c.e（）；
}
}
classP{
finalvoidmethodP（）{
…
}
}
classCextendsP{
voide（）{
methodP（）;
}
}
请选择一个正确的答案：
（1）代码编译错误，因为P类不是final类。
（2）代码编译错误，因为子类C不能调用父类P中的final方法methodP（）。
（3）代码编译成功。
（4）代码编译成功，但运行时会抛出NoSMuchethodException异常。
答案：
（3）
详解：
本题考查的核心是final类和方法。
只有被final修饰的类才不能子类化，即不能被子类扩展。
在本例中，C子类可以继承P父类，被final修饰的方法不能被子类重载，但可以被子类调用。
本实例程序编译成功，运行期无异常抛出。
示例06：
给出以下代码，请问该程序的运行结果是什么？
publicclassExample{
finalintx;
publicExample（）{
System.out.println（x+10）;
}
publicstaticvoidmain（Stringargs[]）{
Exampleex=newExample（）;
}
}
请选择一个正确答案：
（1）代码编译错误。
（2）运行期异常。
（3）打印输出10
（4）打印输出0
答案：
（1）
详解：
本题考查的核心是final变量。
一个被声明为final的变量就是一个常量，在使用前必须被初始化，否则会产生编译错误。
在示例中，final变量x被打印语句访问前，未被初始化，所以引起编译错误。
示例07：
给出以下代码，请问该程序的运行结果是什么？
classBase{
Stringstr;
publicBase（）{
}
publicBase（Strings）{
str=s；
}
}
publicclassSubextendBase{
publicstaticvoidmain（Stringargs[]）{
finalBaseb=newBase（”Hello”）；
b=newBase（”Howareyou”）
b.str=“Howisgoing”；
System.out.println（“Greetingis:
”+b.str）；
}
}
请选择一个正确答案：
（1）代码编译错误。
（2）运行期异常。
（3）打印输出Hello
（4）打印输出Howisgoing
答案：
（1）
详解：
本题考查的核心是final变量。
一个final变量其实质就是一个变量，因此一旦被创建，就不能再改变。
如果该final变量是一个引用型变量，则其不能再引用其他对象。
在本示例中，引用型final变量b由于已经初始化指向对象Base（“Hello”），就不能再指向新的对象Base（“Howareyou”），所以会产生编译错误。
考点04abstract
规则01：
abstract关键字只能用于修饰类和方法，不能修饰变量，因为该关键字表明的是未实现的含义，变量不存在未实现的概念。
规则02：
一个抽象方法的定义，除了在方法名前加abstract关键字外，该方法还不能有方法体，即方法名后不能有花括号{}。
注意方法体为空和无方法体是两个概念，方法体为空指方法名后存在花括号{}，只是花括号{}内无内容，而无方法体是指方法名后就不存在花括号{}。
规则03：
一个抽象类的定义是通过使用关键字abstract放置在表示类关键字class的前面来标识的。
一般而言，一个抽象类至少应定义一个抽象方法，但是并不是必须定义一个抽象方法，类体中也可以不存在抽象方法。
规则04：
当一个类中存在一个以上的抽象方法时，该类必须被声明为抽象类，否则会发生编译错误。
规则05：
当子类继承了一个抽象类时，必须实现该抽象类中定义的全部抽象方法，否则必须被声明为抽象类。
规则06：
当类实现了一个接口，但并没有实现该接口中的所有方法时，该类必须被声明为抽象类，否则会发生编译错误。
规则07：
一个抽象类，由于其表明的是未完全实现的概念，因此不能被实例化。
当试图调用一个抽象类的构造器来创建该类的一个实例时，会产生编译错误。
示例01：
请问，抽象方法是否可以被static修饰符修饰？
请选择一个正确答案：
（1）是
（2）否
答案：
（2）
详解：
本题考查的核心是抽象方法的表示语法。
abstract修饰符表示的是未实现，static修饰符表示的是生命期归属于类。
因此，不能将static修饰符用于修饰一个抽象方法。
示例02：
请问，以下哪些是抽象方法的正确形式？
请选择一个正确答案：
（1）abstractvoidExample（）
（2）abstractvoidExample（）{}
（3）staticabstractvoidExample（）
（4）finalabstractvoidExample（）
（5）方法不能定义为抽象的，只有变量可以是抽象的。
答案：
（1）
详解：
本题考查的核心是抽象方法的表示。
选项
（2）错误，Java中规定，抽象方法不能有方法体，即使方法体为空，但存在也不行。
选项（3）错误，不能将static和abstract修饰符联合使用。
选项（4）错误，final修饰符表示的是常量，不变的意思，而abstract修饰符表示的是未实现，需要被实现、改变，因此不能将final和abstract修饰符联合使用。
选项（5）错误，方法和类可以定义为抽象的，变量则不可以定义为抽象的。
示例03：
请问，以下哪些是正确的抽象方法的形式？
请选择一个正确答案：
（1）publicabstractmethod（）；
（2）publicabstractvoidmethod（）；
（3）publicvoidabstractMethod（）；
（4）publicvoidmethod（）{abstract;}
（5）publicabstractvoidmethod（）{}
答案：
（2）
详解：
本题考查的核心是抽象方法的表示。
选项
（1）错误，因为缺少返回值类型表明。
选项（3）错误，因为abstract修饰符的位置应在返回值类型声明前。
选项（4）、（5）错误，因为抽象方法不能有方法体。
示例04：
给出以下代码，请问该程序的运行结果是什么？
publicabstractclassAbstractClass{
publicAbstractClass（）{
System.out.println（
“thisisanabstractclassconstructor!
”）；
}
publicvoidaMethod（）{
System.out.printIn（
“Thisisinthemethodintheabstractclass”）；
}
}
请选择一个正确答案：
（1）代码编译失败，因为抽象类不能有构造器。
（2）代码编译失败，因为抽象类的方法不能有返回值类型声明。
（3）代码编译失败，因为当类不存在抽象方法时，是不能定义为抽象类的。
（4）代码编译成功，并且因为该类实际上不是抽象类，因此可以被实例化。
（5）代码编译成功，但不能被实例化。
可以被扩展为非抽象类，子类的构造器可以调用抽象父类的构造器。
（6）代码编译成功，但不能被实例化。
可以被扩展为非抽象类，子类的构造器不可以调用抽象父类的构造器。
答案：
（5）
详解：
本
升级会员 