武汉理工大学计算机学院软件1002班蒋韬
JA V A主要修饰符总结
修饰符是用于限定类型以及类型成员的申明的一种符号。我们此次主要讨论JAVA的访问修饰符。常见的访问修饰符有：
public：访问不受限制。
protected：访问仅限于包含类或从包含类派生的类型。只有包含该成员的类以及继承的类可以存取.
protected internal：访问仅限于当前程序集或从包含类派生的类型。
private：访问仅限于包含类型。只有包含该成员的类可以存取.
下面为了更直观的看出他们之间的区别，列出下表：
下面对上面提到的修饰符做下具体介绍：
一、存储与生命周期的修饰符
①Abstract
abstract修饰符可用来修饰类和实例成员方法
用abstract修饰的类表示抽象类，抽象类不能被实例化。没有用abstract修饰的类称为具体类，具体类可以被实例化。
用abstract修饰的方法表示抽象方法，抽象方法没有方法体。抽象方法用来描述系统具有什么功能，但不提供具体的实现。没有用abstract修饰的方法称为具体方法，具体方法必须要有方法体。
使用abstract修饰符需要遵守以下语法规则：
（1）抽象类中可以没有抽象方法，但包含了抽象方法的类必须被定义为抽象类。如果子类没有实现父类中所有的抽象方法，那么子类也必须被定义为抽象类，否则编译出错。
（2）没有抽象构造方法，也没有抽象静态方法。
abstract class Base {
abstract Base() {} //编译出错，构造方法不能是抽象的
static abstract void method1(); //编译出错，static和abstract修饰符不能
连用
static void method2() {...} //合法，抽象类中可以有静态方法
}
（3）抽象类中可以有非抽象的构造方法，创建子类的实例时可能会调用这些构造方法。抽象类不能被实例化，然而可以创建一个引用变量，其类型是一个抽象类，并让它引用非抽象的子类的一个实例。
（4）抽象类及抽象方法不能被final修饰符修饰。即，abstract与final不能连用。这是因为abstract与final的作用是恰恰相反的，如：抽象类只允许创建其子类，而final修饰的类不允许拥有子类；抽象方法必须被子类的具体方法来实现，而final修饰的方法不允许被子类方法覆盖。
注：为什么抽象类不允许被实例化？
在语义上，抽象类表示从一些具体类中抽象出来的类型。从具体类到
抽象类，这是一种更高层次的抽象。如：苹果类、香蕉类和桔子类是具体类，而水果类则是抽象类，在自然界并不存在水果类本身的实例，而只存在它的具体子类的实例。
Fruit fruit = new Apple(); //创建一个苹果对象，把它看做是水果对象
在语法上，抽象类中可以包含抽象方法，如果抽象类可以实例化，那么在访问抽象方法时将无法执行，因为抽象方法中根本就没有方法体。由此可见，Java 编译器不允许创建抽象类的实例是必要的。
abstract class Base {
public void method1() {...} //具体方法
public abstract void method2(); //抽象方法
}
Base base = new Base(); //假定Java编译器没有报错
base.method1();
base.method1(); //运行时Java虚拟机无法执行这个方法
②static
有时你希望定义一个类成员，使它的使用完全独立于该类的任何对象。通常情况下，类成员必须通过它的类的对象访问，但是可以创建这样一个成员，它能够被它自己使用，而不必引用特定的实例。在成员的声明前面加上关键字static(静态的)就能创建这样的成员。如果一个成员被声明为static，它就能够在它的类的任何对象创建之前被访问，而不必引用任何对象。你可以将方法和变量都声明为static。static 成员的最常见的例子是main( ) 。因为在程序开始执行时必须调用main() ，所以它被声明为static。
声明为static的变量实质上就是全局变量。当声明一个对象时，并不产生static 变量的拷贝，而是该类所有的实例变量共用同一个static变量。
声明为static的方法有以下几条限制：
它们仅能调用其他的static 方法。
它们只能访问static数据。
它们不能以任何方式引用this 或super（关键字super 与继承有关，在下一章中描述）。
如果你需要通过计算来初始化你的static变量，你可以声明一个static块，Static 块仅在该类被加载时执行一次。下面的例子显示的类有一个static方法，一些static变量，以及一个static 初始化块：
// Demonstrate static variables，methods，and blocks.
class UseStatic {
static int a = 3;
static int b;
static void meth(int x) {
System.out.println("x = " + x);
System.out.println("a = " + a);
System.out.println("b = " + b);
}
static {
System.out.println("Static block initialized.");
b = a * 4;
}
public static void main(String args[]) {
meth(42);
}
}
一旦UseStatic 类被装载，所有的static语句被运行。首先，a被设置为3，接着static 块执行(打印一条消息)，最后，b被初始化为a*4 或12。然后调用main()，main() 调用meth() ，把值42传递给x。3个println ( ) 语句引用两个static 变量a和b，以及局部变量x 。
注意：在一个static 方法中引用任何实例变量都是非法的。
下面是该程序的输出：
Static block initialized.
x = 42
a = 3
b = 12
在定义它们的类的外面，static 方法和变量能独立于任何对象而被使用。这样，你只要在类的名字后面加点号运算符即可。例如，如果你希望从类外面调用一个static方法，你可以使用下面通用的格式：
classname.method( )
这里，classname 是类的名字，在该类中定义static方法。可以看到，这种格式与通过对象引用变量调用非static方法的格式类似。一个static变量可以以同样的格式来访问——类名加点号运算符。这就是Java 如何实现全局功能和全局变量的一个控制版本。
下面是一个例子。在main() 中，static方法callme() 和static 变量b在它们的类之外被访问。
class StaticDemo {
static int a = 42;
static int b = 99;
static void callme() {
System.out.println("a = " + a);
}
}
class StaticByName {
public static void main(String args[]) {
StaticDemo.callme();
System.out.println("b = " + StaticDemo.b);
}
}
下面是该程序的输出：
a = 42
b = 99
static成员是不能被其所在class创建的实例访问的。
通常，在创建类的实例时，每个实例都会创建自己实例变量。但是在变量的声明中可以使用Static修饰符，它表明该成员变量属于类本身，独立于类产生的任何对象。这种成员变量称为静态变量（静态属性）。方法的声明中也可以使用static 修饰符，表明该方法从属于类本身。
静态属性和静态方法不需要创建实例就可以使用。
典型的例子是https://www.doczj.com/doc/7b4192204.html,ng包中的System类中的方法和变量。我们常用
System.out.println(“message”);
输出信息，并没有创建System的实例，是因为println方法声明为System类的静态方法，它不需创建实例就可以使用。
下面的例子会帮助你更深刻的理解Static修饰符。注意各个代码块的加载次序。 class Sample
{
static int s1=3;
static int s2;
static void display()
{
System.out.println("s1="+s1);
System.out.println("s2="+s2);
}
static
{
System.out.println("static block");
s2=s1+1;
}
public static void main(String args[])
{
Sample.display();
}
}
一旦这个类被调用，所有的静态变量都被初始化，s1被赋为3，然后运行static 块，这将打印出一段消息，并且把s2赋为s1+1，即4。然后解释器调用main成员函数，它调用了成员函数display，该函数输出s1和s2的信息。运行结果如下：
C:\>java Sample
static block
s1=3
s2=4
通过上面的例子还可以看出，一个静态成员函数可以通过它所属的类名来调用。
注意：
在静态成员函数中只能直接调用其它的静态成员函数或引用静态属性，否则会造成编译错误。静态成员函数中也不能使用this或者super，因为它们是和类的对象相关联的。
abstract修饰符表示所修饰的类没有完全实现，还不能实例化。如果在类的方法声明中使用abstract修饰符，表明该方法是一个抽象方法，它需要在子类实现。在下面的情况下，类必须是抽象类：
1.类中包含一个明确声明的抽象方法;
2.类的任何一个父类包含一个没有实现的抽象方法;
3.类的直接父接口声明或者继承了一个抽象方法，并且该类没有声明或者实现该抽象方法。
如下例所示：
abstract class A1
{
public int v1;
abstract void test();
}
abstract class A2 extends A1
{
public int v2;
}
class Sample extends A2
{
void test() { }
}
因为包含一个抽象方法test,类A1必须被声明为抽象类。它的子类A2继承了抽象方法test，但没有实现它，所以它也必须声明为抽象类。然而，A2的子类Sample因为实现了test，所以它不必声明为抽象的。
注意:
如果试图创建一个抽象类的实例就会产生编译错误;
如果一个类是非抽象类却包含一个抽象方法，就会产生编译错误;
构造函数和静态函数以及Final修饰的函数不能使用abstract修饰符;
接口缺省为abstract。
二、可访问修饰符
接口中的方法缺省都是Public和abstract的。
public：表明该成员变量和方法是共有的，能在任何情况下被访问。protected：必须在同一包中才能被访问。(说的比较简单，看个例子就明白了) 例①
class A
{
protected int weight;
protected int f( int a,int b )
{
// 方法体
}
}
假设B与A在同一个包中，则
class B
{
void g()
{
A a=new A();
A.weight=100;//合法
A.f(3,4); //合法
}
}
例②
在路径为a/b/c/test.java的文件中：
package a.b.c;
public class test{
public test() {
System.out.println(“We are creating test!");
}
void dotest(){
System.out.println(“We are doing test!");
}
}///:~
在路径为a/b/e/testtest.java的文件中：
import a.b.c.test;
public class testtest{
public static void main(String[] args) {
test x = new test();
x.dotext();//********************************
}
}///:~
运行testtest时，用*****************标记的语句会出错，而前一句不会出错。注意：什么是在同一个包中？
答：用package打包在一起的class ,叫在同一个包中。(不明白，举个例子) 例如：在JDK的src\java\io中，你会看到许多java类，第一句源代码都是package java.io;
没有使用package打包的，在同一目录下的类也会被视做同一个包。friendly：在这种情况下中，同protected。区别在第二和第三种情况中。
例①
class A
{
int weight ;
int f( int a,int b )
{
// 方法体
}
}
假设B与A在同一个包中，则
class B
{
void g()
{
A a=new A();
A.weight=100;//合法
A.f(3,4); //合法
}
}
对于成员老说：假如一个类的成员没有任何权限修饰，那么它门就是缺省包访问权限，用friendly来表示，注意friendly不是Java中的关键字，这里是个人喜欢的方式用它表示而已。同一个包内其它类可以访问，但包外就不可以。对于同一个文件夹下的、没有用package的classes，Java会自动将这些classes初见为隶属于该目录的default package，可以相互调用class中的friendly成员。如以下两个class分别在同一个文件夹的两个文件中，固然没有引进package，但隶属于相同的default package。
class Sundae{
//以下两个方法缺省为friendly
Sundae(){}
V oid f() {System.out.println(“Sundae.f()”);
}
public class IceCream{
public static void main(String[] args){
Sundae x = new Sundae();
x.f();
}
}
对于类来说：同一个包中的类可以用。总之，类只可以声明为public或者friendly。private: 只能在本类中访问。
例①
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);
}
}
PS：实际上，把重要的数据修饰为private，然后写一个public的函数访问它，正好体现了OOP的封装特性，是OOP安全性的体现。
对于对于成员来说：只能在该成员隶属于的类中访问。
class Sundae{
private Sundae(){}//只能在Sundae class中被调用
Sundae(int i) {}
static Sundae makASundae() {
return new Sundae();
}
}
public class IceCream{
public static void main(String[] args){
// Sundae class中构造函数Sundae()是private，
// 所以不能用它进行初始化
//Sundae x = new Sundae();
Sundae y = new Sundae(1);//Sundae(int)是friendly，可以在此调用
Sundae z = Sundae.makASundae();
}
}
对于类来说：类不可以声明为private。
protected：
对于对于成员来说：相同包中的类可以访问（包访问权限）；基类通过protected把基类中的成员的访问权限赋予派生类不是所有类（派生类访问权限）。
例子：package c05.local;
import pack1.Cookie;
//留意：在这里ChocolateChip继续了类Cookie,按道理bite()方法也在
//ChocolateChip中，可以用x.bite直接调用，但是不可以的，由于类ChocolateChip
//和Cookie类不在一个包中，各自具有包访问权限，为了能够使用x.bite()必须要把
//Cookie方法的访问权限换成public或者protected，但是一旦换成public 所有的人就
//可以访问了，这样达不到隐私的要求，所以设置成protected最好，既可以顺利访问，也可以
//避免外面的类调用，保护好隐私的作用
public class ChocolateChip extends Cookie {
public ChocolateChip() {
System.out.println("ChocolateChip constructor");
}
public static void main(String[] args) {
ChocolateChip x = new ChocolateChip();
x.bite(); // Can't access bite
}
} ///:~
package pack1;
public class Cookie {
public Cookie()
{
System.out.println("Cookie constructor");
}
protected void bite(){System.out.println("bite");}
}
对于类来说：类不可以声明为protected
二访问权限修饰符修饰类
1，不能用protected和private修饰类。
2，用friendly修饰的类叫友好类，在另外一个类中使用友好类创建对象时，要保证它们在同一包中。
三访问权限修饰符与继承
这里的访问修饰符指的是修饰成员变量和方法。可以分为两种情况：
1，子类与父类在同一包中
此时只有声明为private的变量与方法不能被继承(访问)。
class Father
{
private int money ;
int weight=100;
}
class Son extends Father
{
viod f()
{
money=10000;// 非法
weight=100; // 合法
}
}
2,子类与父类不在同一包中
此时private与friendly均不能被继承(访问)，protected与public可以。
Father.java
package 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。对于类的权限修饰，下面有更好的解释：
Class类的访问权限：
public：可以供所有的类访问。
默认：默认可以称为friendly但是，java语言中是没有friendly这个修饰符的，这样称呼应该是来源于c++。默认的访问权限是包级访问权限。
即假如写了一个类没有写访问权限修饰符，那么就是默认的访问权限，同一个包下的类都可以访问到，即使可以实例化该类
（当然假如这个类不具有实例化的能力除外，比如该类没有提供public的构造函数）。
说明：
1、每个编译单元（类文件）都仅能有一个public class
2、public class的名称（包含大小写）必须和其类文件同名。
3、一个类文件(*.java)中可以不存在public class。
这种形式的存在的场景：假如我们在某个包内撰写一个class，仅仅是为了配合同包内的其他类工作，而且
我们不想再为了撰写说明文档给客户（不一定是现实意义的客户，可能是调用这个类的类）看而伤脑筋，而且有可能过一段时间之后
有可能会彻底改变原有的做法，并完全舍弃旧版本，以全新的版本代替。
4、class不可以是private和protected。
5、假如不希看那个任何产生某个class的对象，可以将该类得所有构造函数设置成private。但是即使这样也可以天生该类的对象，就是class的static的成员（属性和方法）可以办到。
补充：final修饰符
一、Java中final修饰符既可以修饰类、方法，也可以修饰变量，基本规则如下：１）用final修饰的类不能被扩展，也就是说不可能有子类；
２）用final修饰的方法不能被替换或隐藏：
①使用final修饰的实例方法在其所属类的子类中不能被替换（overridden）；
②使用final修饰的静态方法在其所属类的子类中不能被重定义（redefined）而隐藏（hidden）；
３）用final修饰的变量最多只能赋值一次，在赋值方式上不同类型的变量或稍有不同：
①静态变量必须明确赋值一次（不能只使用类型缺省值）；作为类成员的静态变量，赋值可以在其声明
中通过初始化表达式完成，也可以在静态初始化块中进行；作为接口成员的静态变量，赋值只能在其
声明中通过初始化表达式完成；
②实例变量同样必须明确赋值一次（不能只使用类型缺省值）；赋值可以在其声明中通过初始化表达式
完成，也可以在实例初始化块或构造器中进行；
③方法参数变量在方法被调用时创建，同时被初始化为对应实参值，终止于方法体（body）结束，在此
期间其值不能改变；
④构造器参数变量在构造器被调用（通过实例创建表达式或显示的构造器调用）时创建，同时被初始化
为对应实参值，终止于构造器体结束，在此期间其值不能改变；
⑤异常处理器参数变量在有异常被try语句的catch子句捕捉到时创建，同时被初始化为实际的异常对象
，终止于catch语句块结束，在此期间其值不能改变；
⑥局部变量在其值被访问之前必须被明确赋值；
示例一：
interface IncludeFinalInterface{
//接口中定义的变量都是public static final的
int staticVar = 2009; //作为接口成员的变量，其赋值只能在声明中完成
}
class IncludeFinal{
static final int staticVar;
final int instanceVar;
IncludeFinal(){
instanceVar = 9; //实例变量的赋值还可以在构造器中进行
}
IncludeFinal(final boolean sameAsStatic){
instanceVar = sameAsStatic ? staticVar : 9;
// sameAsStatic = false;//不能编译，final修饰的构造器参数变量在构造器体中不能被再次赋值
static final void showStaticVar(){
System.out.println("IncludeFinal.staticVar = " + staticVar);
}
final void showInstanceVar(){
System.out.println("IncludeFinal.instatnceVar = " + instanceVar);
}
void show(final boolean showStatic){
if( showStatic )
showStaticVar();
else
showInstanceVar();
// showStatic = false; //不能编译，final修饰的方法参数变量在方法体中不能被再次赋值
}
static void demoExceptionHandlerParameter(){
try{
System.out.println(10/0);
}
catch(final ArithmeticException ae){
ae.printStackTrace();
// ae = null;//不能编译，final修饰的异常处理器参数变量在catch语句块中不能被再次赋值
}
}
static void showLocalVar(){
final int localVar;
localVar = 209; //局部变量在其值被访问之前必须被明确赋值，
//当然在其声明中同时指定一个初始化值似乎是一个更好的选择System.out.println("LocalVar = " + localVar);
}
static{ //除在声明中同时初始化外，作为类成员的静态变量，其赋值还可以在静态初始化块中进行
staticVar = 2009;
}
// { //实例变量的赋值还可以在实例初始化块中进行
// instanceVar = 9;
// }
}
public class FinalTest extends IncludeFinal {
// static void showStaticVar(){ //编译错误，不能重定义父类中用final修饰的静态方法
// System.out.println("FinalTest.staticVar = " + staticVar);
// void showInstanceVar(){ //编译错误，不能替换父类中用final修饰的实例方法// System.out.println("FinalTest.instatnceVar = " + instanceVar);
// }
public static void main(String[] args){
showStaticVar();
demoExceptionHandlerParameter();
showLocalVar();
new IncludeFinal(false).show(false);
}
}
运行结果：
IncludeFinal.staticVar = 2009
https://www.doczj.com/doc/7b4192204.html,ng.ArithmeticException: / by zero
at IncludeFinal.demoExceptionHandlerParameter(FinalTest.java:32)
at FinalTest.main(FinalTest.java:61)
LocalVar = 209
IncludeFinal.instatnceVar = 9
二、关于final变量的进一步说明：
１）定义：blank final变量是其声明中不包含初始化表达式的final变量。
２）对于引用类型变量，final修饰符表示一旦赋值该变量就始终指向堆中同一个对象，不可改变，但是其
所指对象本身（其状态）是可以改变的；不象C++中的const，在Java中没有办法仅通过一个final就可
声明一个对象的不变性（immutability）。
３）常变量（constant variable）：
①定义：常变量是用编译时常量表达式初始化的带有final修饰符的基本类型或字符串类型变量；
②无论静态变量还是实例变量，如果它是常变量，则其引用在编译时会被解析成该常变量所表示的值，
在class文件中并不存在任何对常变量域的引用；也正是基于此，当在源代码中修改某个常变量域的
初始值并重新编译后，该改动并不为其他class文件可见，除非对他们也重新编译。
示例二：
public class ConstantVariable {
static final int staticVar = 10 + 8; //静态变量staticVar是一个常变量
final int instanceVar = 100 + 8; //实例变量instanceVar也是一个常变量
//静态变量notConstantVariable不是常变量，因为其初始化表达式不是编译时常量表达式
static final int notConstantVariable = (int)(Math.random() * 10);
}
public class Test {
public static void main(String[] args){
//对类ConstantVariable中常变量staticVar的引用
System.out.println("staticVar = " + ConstantVariable.staticVar);
//对类ConstantVariable中常变量instanceVar的引用
System.out.println("instanceVar = " + new ConstantVariable().instanceVar);
//对类ConstantVariable中静态变量notConstantVariable的引用
System.out.println("notConstantVariable = " + ConstantVariable.notConstantVariable);
}
}
运行结果：
staticVar = 18
instanceVar = 108
notConstantVariable = 2
Test.class文件的反编译结果：
import java.io.PrintStream;
public class Test
{ //从该文件很容易验证，当在ConstantVariable.java中修改常变量的值并重新编译后，类Test的运行结果不会受任何影
//响，除非把Test.java文件也重新编译一遍
public Test(){}
public static void main(String args[]){
//对常变量ConstantVariable.staticVar的引用在编译后直接被其值“18”替换System.out.println("staticVar = 18");
(new ConstantVariable()).getClass();
//对类ConstantVariable中常变量instanceVar的引用在编译后直接被其值“108”替换
System.out.println((new StringBuilder("instanceVar = ")).append(108).toString());
//ConstantVariable.notConstantVariable不是常变量，所以其引用得以保持
System.out.println(
(new StringBuilder("notConstantVariable = ")).
append(ConstantVariable.notConstantVariable).
toString()
);
}
}
４）用final修饰的参数变量，虽然并不为所有人喜欢，但它的确为编译器提供了附加的信息，一方面可以
增强其错误检测能力，另一方面也有助于其对代码的优化。
５）final修饰符与其他修饰符共同出现时，书写顺序可参考下面一行：Annotation public protected private abstract static final synchronized native transient volatile strictfp
附注：有关编译时常量表达式的具体定义，可参考ＪＬＳ中的相关章节（§15.28）。
第一组 1.下列不可作为java语言修饰符的是（D） A) a1 B) $1 C) _1 D) 11 2.有一段java 应用程序，它的主类名是a1，那么保存它的源文件名可以是（A） Ａ) a1.java B) a1.class C) a1 D) 都对 3.整型数据类型中，需要内存空间最少的是（D） A) short B) long C) int D) byte 4. Java 类可以作为（C） A) 类型定义机制 B) 数据封装机制 C) 类型定义机制和数据封装机制 D) 上述都不对 5.在创建对象时必须（C） A) 先声明对象，然后才能使用对象 B) 先声明对象，为对象分配内存空间，然后才能使用对象 C) 先声明对象，为对象分配内存空间，对对象初始化，然后才能使用对象 D) 上述说法都对 6.在调用方法时，若要使方法改变实参的值，可以（B） A) 用基本数据类型作为参数 B) 用对象作为参数 C) A和B都对 D) A和B都不对 7. Java中（C） A) 一个子类可以有多个父类，一个父类也可以有多个子类 B) 一个子类可以有多个父类，但一个父类只可以有一个子类 C) 一个子类可以有一个父类，但一个父类可以有多个子类 D) 上述说法都不对 8.Java语言具有许多优点和特点，哪个反映了Java程序并行机制的特点？（B） A) 安全性B) 多线性C) 跨平台D) 可移植 9. Character流与Byte流的区别是（C） A) 每次读入的字节数不同B) 前者带有缓冲，后者没有 C) 前者是字符读写，后者是字节读写D) 二者没有区别，可以互换使用
10.以下声明合法的是（ D ） A、default String s； B、public final static native int w( ) C、abstract double d； D、abstract final double hyperbolicCosine( ) 11.关于以下application的说明，正确的是（ C ） 1．class StaticStuff 2．{ 3．static int x=10； 4．static { x+=5；} 5．public static void main（String args[ ]） 6．{ 7．System.out.println(“x=”+ x); 8．} 9．static { x/=3;} 10. } A、4行与9行不能通过编译，因为缺少方法名和返回类型 B、9行不能通过编译，因为只能有一个静态初始化器 C、编译通过，执行结果为：x=5 D、编译通过，执行结果为：x=3 12.关于以下程序代码的说明正确的是（ D ） 1．class HasStatic{ 2．private static int x=100； 3．public static void main(String args[ ]){ 4．HasStatic hs1=new HasStatic( ); 5．hs1.x++; 6．HasStatic hs2=new HasStatic( ); 7．hs2.x++; 8．hs1=new HasStatic( ); 9．hs1.x++; 10．HasStatic.x- -; 11．System.out.println(“x=”+x); 12．} 13．} A、5行不能通过编译，因为引用了私有静态变量 B、10行不能通过编译，因为x是私有静态变量 C、程序通过编译，输出结果为：x=103 D、程序通过编译，输出结果为：x=102 13.以下选项中循环结构合法的是（ C ） A、while (int i<7) { i++;
final关键字可用于修饰类，变量和方法，final关键字有点类似c#里的sealed关键字（如果大家学过C#就知道），它用于表示它修饰的类，方法和变量不可改变。 final变量 final修饰变量时，表示该变量一旦获得了初始值就不可改变，final既可修饰成员变量（包括类变量和实例变量），也可以修饰局部变量，形参。严格来说final修饰的变量不要被改变，一旦获得初始值之后，该final变量的值就不能被重新赋值。 因为final变量获得初始值之后不能被重新赋，因此final修饰成员变量和修饰局部变量时有一定的不同：下面我将会写到有哪些方面的不同，还有就是为什么会不同。 final修饰成员变量 成员变量是随类初始化或对象初始化而初始化的。当类初始化时，系统会为该类属性分配内存，并分配默认值；当创建对象时，系统会为该对象的实例属性分配内存，并分配默认值。也就是说，当执行静态初始化块时可以对类属性赋初始值，当执行普通初始块，构造器时可对实例属性赋初始值。因此，成员变量的初始值可以在定义该变量时指定默认值，可以在初始化块，构造器中指定初始值，否则，成员变量的初始值将是由系统自动分配的初始值。 对于final修饰的成员变量而言，一旦有了初始值之后，就不能重新赋值，因此不可以在普通方法中对成员变量重新赋值。成员变量只能在定义该成员变量时指定默认值，或者在静态初始化块，初始化块，构造器中为成员变量指定初始值，如果既没有在定义成员变量时指定初始值，也没有在初始化块，构造器中为成员变量指定初始值，那么这些成员变量的值将一直是0，\u0000，false null这些成员变量也就失去了存在的意义。 因此当使用final修饰成员变量的时候，要么在定义成员变量时候指定初始值，要么
java中的类修饰符、成员变量修饰符、方法修饰符。 类修饰符： public（访问控制符），将一个类声明为公共类，他可以被任何对象访问，一个程序的主类必须是公共类。 abstract，将一个类声明为抽象类，没有实现的方法，需要子类提供方法实现。 final，将一个类生命为最终（即非继承类），表示他不能被其他类继承。 friendly，默认的修饰符，只有在相同包中的对象才能使用这样的类。 成员变量修饰符： public（公共访问控制符），指定该变量为公共的，他可以被任何对象的方法访问。 private（私有访问控制符）指定该变量只允许自己的类的方法访问，其他任何类（包括子类）中的方法均不能访问。 protected （保护访问控制符）指定该变量可以别被自己的类和子类访问。在子类中可以覆盖此变量。 friendly ，在统一报中的类可以访问，其他包中的类不能访问。 final，最终修饰符，指定此变量的值不能变。 static（静态修饰符）指定变量被所有对象共享，即所有实例都可以使用该变量。
transient（过度修饰符）指定该变量是系统保留，暂无特别作用的临时性变量。 volatile（易失修饰符）指定该变量可以同时被几个线程控制和修改。 方法修饰符： public（公共控制符） private（私有控制符）指定此方法只能有自己类等方法访问，其他的类不能访问（包括子类） protected（保护访问控制符）指定该方法可以被它的类和子类进行访问。 final，指定该方法不能被重载。 static，指定不需要实例化就可以激活的一个方法。 synchronize，同步修饰符，在多个线程中，该修饰符用于在运行前，对他所属的方法加锁，以防止其他线程的访问，运行结束后解锁。 native，本地修饰符。指定此方法的方法体是用其他语言在程序外部编写的。
基本语法 编写Java程序时，应注意以下几点： ?大小写敏感：Java是大小写敏感的，这就意味着标识符Hello与hello是不同的。 ?类名：对于所有的类来说，类名的首字母应该大写。如果类名由若干单词组成，那么每个单词的首字母应该大写，例如 MyFirstJavaClass 。 ?方法名：所有的方法名都应该以小写字母开头。如果方法名含有若干单词，则后面的每个单词首字母大写。 ?源文件名：源文件名必须和类名相同。当保存文件的时候，你应该使用类名作为文件名保存（切记Java是大小写敏感的），文件名的后缀为.java。（如果文件名和类名不相同则会导致编译错误）。 ?主方法入口：所有的Java 程序由public static void main(String []args)方法开始执行。 Java标识符 Java所有的组成部分都需要名字。类名、变量名以及方法名都被称为标识符。 关于Java标识符，有以下几点需要注意： ?所有的标识符都应该以字母（A-Z或者a-z）,美元符（$）、或者下划线（_）开始 ?首字符之后可以是字母（A-Z或者a-z）,美元符（$）、下划线（_）或数字的任何字符组合 ?关键字不能用作标识符 ?标识符是大小写敏感的 ?合法标识符举例：age、$salary、_value、__1_value ?非法标识符举例：123abc、-salary
Java修饰符 像其他语言一样，Java可以使用修饰符来修饰类中方法和属性。主要有两类修饰符： ?访问控制修饰符: default, public , protected, private ?非访问控制修饰符: final, abstract, strictfp 在后面的章节中我们会深入讨论Java修饰符。 Java变量 Java中主要有如下几种类型的变量 ?局部变量 ?类变量（静态变量） ?成员变量（非静态变量） Java数组 数组是储存在堆上的对象，可以保存多个同类型变量。在后面的章节中，我们将会学到如何声明、构造以及初始化一个数组。 Java枚举 Java 5.0引入了枚举，枚举限制变量只能是预先设定好的值。使用枚举可以减少代码中的bug。 例如，我们为果汁店设计一个程序，它将限制果汁为小杯、中杯、大杯。这就意味着它不允许顾客点除了这三种尺寸外的果汁。 实例
java访问权限修饰符public protected default private用法总结 首先声明：java中，default这个修饰符并没有显式的声明，在成员变量和方法前什么修饰符也不用，默认的就是default。为了条理清晰，分三种不同情况来总结。 一访问权限修饰符修饰成员变量和方法 public：表明该成员变量和方法是共有的，能在任何情况下被访问。 protected：必须在同一包中才能被访问。(说的比较简单，看个例子就明白了) eg:class A { protected int weight; protected int f( int a,int b ) { // 方法体 } } 假设B与A在同一个包中，则 class B { void g() { A a=new A(); A.weight=100;//合法 A.f(3,4); //合法 } } 特别说明：什么是在同一个包中？ 答：用package打包在一起的class ,叫在同一个包中。(不明白，举个例子) eg:在JDK的src\java\io中，你会看到许多java类，第一句源代码都是package java.io; 没有使用package打包的，在同一目录下的类也会被视做同一个包。 default：在这种情况下中，同protected。区别在第二和第三种情况中。 eg: class A { int weight ; int f( int a,int b ) { // 方法体 } }
假设B与A在同一个包中，则 class B { void g() { A a=new A(); A.weight=100;//合法 A.f(3,4); //合法 } } private:只能在本类中访问。 eg: 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); } } PS：实际上，把重要的数据修饰为private，然后写一个public的函数访问它，正好体现了OOP的封装特性，是OOP安全性的体现。 二访问权限修饰符修饰类 1，不能用protected和private修饰类。 2，用default修饰的类叫友好类，在另外一个类中使用友好类创建对象时，要保证它们在同一包中。 三访问权限修饰符与继承 这里的访问修饰符指的是修饰成员变量和方法。可以分为两种情况： 1，子类与父类在同一包中 此时只有声明为private的变量与方法不能被继承(访问)。
Java 修饰符 Java语言提供了很多修饰符，主要分为以下两类： 访问修饰符 非访问修饰符 修饰符用来定义类、方法或者变量，通常放在语句的最前端。我们通过下面的例子来说明：public class className { // ... } private boolean myFlag; static final double weeks = 9.5; protected static final int BOXWIDTH = 42; public static void main(String[] arguments) { // 方法体} 访问控制修饰符 Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持4 种不同的访问权限。 ? default (即缺省，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。 ? ? private : 在同一类内可见。使用对象：变量、方法。注意：不能修饰类（外部类）
? ? public : 对所有类可见。使用对象：类、接口、变量、方法 ? ? protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。注意：不能修饰类（外部类）。 ? 我们可以通过以下表来说明访问权限： 访问控制 修饰符当前类同一包内子孙类(同一包) 子孙类(不同包) 其他包 public Y Y Y Y Y protected Y Y Y Y/N（说明）N default Y Y Y N N private Y N N N N 默认访问修饰符-不使用任何关键字 使用默认访问修饰符声明的变量和方法，对同一个包内的类是可见的。接口里的变量都隐式声明为public static final,而接口里的方法默认情况下访问权限为public。
Java中主要修饰符的使用(周双) 武汉理工大学计算机学院软件sy1001班周双（0121010680234） Java中定义了6个常用修饰符：public、protected、private、abstract、static、final。 访问控制符：公开级别：public；受保护级别：protected；默认级别：friendly （一般不指明）；私有级别：private。类只能使用public和默认级别修饰。其中类的属性和方法可以使用上述4个访问修符；局部变量不可以使用访问修饰符；常用的方法是将类的属性设为private，而将类的方法设为public。 abstract修饰符：abstract修饰符可以用来修饰类和成员方法：用abstract修饰抽象类，表示该类不可以被实例化。相对应的则称为具体类。用abstract修饰的方法成为抽象方法，该方法没有方法体。抽象方法用来描述系统具有什么功能。 final 修饰符：final修饰符表示不可以改变的含义。final修饰符可以用来修饰类，成员方法，和成员变量。用final修饰类，表示该类不可以被继承；用final 修饰成员方法，表示该方法不可以被覆盖（override）；用final修饰变量，表示一旦赋值就不可以被改变。注意，final变量必须被显式初始化。对于实例变量可以在定义时或在构造方法中进行初始化。而类变量(static变量)必须在定义时进行初始化。对于final修饰的引用类型，那么该变量在其生命周期中只能指向同一个对象，但可以改变对象的值。
Static修饰符：static成员变量表示静态变量，可以直接通过类名来访问。static 成员方法表示静态方法，可以直接通过类名来访问。由于static方法中，只可以访问静态变量和方法，所以要想访问一个实例变量或方法，则必须要先得到相应的对象的引用，才能访问其变量和方法。 一、类的修饰符 Java程序在定义类时，除恶额使用class关键字标识外，还可以在在class之前增加若干类的修饰符来修饰限定所定义的类的特性。类的修饰符分为访问控制符和非访问控制符两大类，下面主要讨论类的费访问控制符。 1.1抽象类 凡是用abstract修饰符修饰的类被称为抽象类。抽象类就是没有具体对象的概念类。比如电话卡有很多类型，磁卡、IC卡、IP卡、200卡、300卡、校园201卡。不同种类的卡有各自的特点，例如磁卡和IC卡没有卡号和密码；使用200卡每次通话要多扣除0.1元的附加费等。同时它们也拥有一些共同的特点，如每张卡都有剩余的金额，都有通话的功能。为此，可以定义一种集合了所有种类的电话卡的公共特点的抽象电话卡如下： Abstract class PhoneCard { double balance; void performDial() {
1.下列不可作为j a v a语言修饰符的是（D） A) a1 B) $1 C) _1 D) 11 2.有一段java 应用程序，它的主类名是a1，那么保存它的源文件名可以是（A） Ａ) a1.java B) a1.class C) a1 D) 都对 3.整型数据类型中，需要内存空间最少的是（D） A) short B) long C) int D) byte 4. Java 类可以作为（C） A) 类型定义机制 B) 数据封装机制 C) 类型定义机制和数据封装机制 D) 上述都不对 5.在创建对象时必须（C） A) 先声明对象，然后才能使用对象 B) 先声明对象，为对象分配内存空间，然后才能使用对象 C) 先声明对象，为对象分配内存空间，对对象初始化，然后才能使用对象 D) 上述说法都对 6.在调用方法时，若要使方法改变实参的值，可以（B） A) 用基本数据类型作为参数 B) 用对象作为参数 C) A和B都对 D) A和B都不对 7. Java中（C） A) 一个子类可以有多个父类，一个父类也可以有多个子类 B) 一个子类可以有多个父类，但一个父类只可以有一个子类 C) 一个子类可以有一个父类，但一个父类可以有多个子类 D) 上述说法都不对 8.Java语言具有许多优点和特点，哪个反映了Java程序并行机制的特点？（B） A) 安全性B) 多线性C) 跨平台D) 可移植 9. Character流与Byte流的区别是（C） A) 每次读入的字节数不同B) 前者带有缓冲，后者没有 C) 前者是字符读写，后者是字节读写D) 二者没有区别，可以互换使用 10.以下声明合法的是（ D ） A、default String s； B、public final static native int w( ) C、abstract double d； D、abstract final double hyperbolicCosine( ) 11.关于以下application的说明，正确的是（ C ） 1．class StaticStuff 2．{ 3．static int x=10； 4．static { x+=5；} 5．public static void main（String args[ ]） 6．{
1. Java中的访问控制 表1-1 （1）在java中有public、protected、private三种显示的修饰符用于控制可见性，package不是显示的修饰符，它是隐含的，即如果在类、变量等前没加显示的可见性修饰符，那它就是package级别的。如果在类的定义中没有指定package，那么java会把它放在缺省包中，一般来说这个缺省的包就是当前目录。 （2）在子类中的方法如果重载了父类的方法，那么该方法的可见级别应更底或者相同，如父类中的方法是public，那么子类中方法必须是public。 （3）在java中，一般来说，变量成员最好是private，对它们的访问可以通过public的方法，在这些方法中可以做些控制以保证数据的一致性。这些方法名一般以get和set做为前缀。 2. 包 包名一般为小写，而类名的第一个字母一般为大写，这样在引用时，可以明显的分辨出包名和类名。如果在类的定义之前没有使用package定义包名，那么该类就属于缺省的包。 2.1 Hello Package 首先通过一个简单的package的定义来学习package的使用： package testPackage; public class Test { public static void main(String args[]) { mNode node = new mNode();
node.print("hello"); } } 说明： （1）使用package关键字指明类所在的包； （2）package语句必须在文件的最前面； （3）编译时可使用javac –d . Test.java自动产生包需要目录； （4）可以使用java testPackage.Test来执行编译后的代码； 2.2 包的几个作用： （1）可以更好的组织类，包与文件夹类似，文件夹可以将不同的文件放在同一个文件夹中，而包也可以将不同的类文件放在同一包中； （2）减少类名的冲突问题，这也与文件夹类似，同一文件夹中的文件不能重名，不同文件中的文件可以重名，同一包中的类名不能重复，不同包中的类名可以重复； （3）对包中的类起了一定的保护作用，详见java的访问控制； 2.3 import的使用 （1）直接引用指定的类，如import java.util.Vector； （2）引用一个包中的多个类，如import java.awt.*。更确切的说，它并不是引用java.awt 中的所有类，而只引用定义为public的类，并且只引用被代码引用的类，所以这种引用方法并不会降低程序的性能； （3）*号代替类名，在不能代替包名，如import java.awt.*，只引用java.awt下的类，而不引用java.awt下的包； （4）import java.awt.F*，这种使用方法是错误的； （5）import语句在所有类定义之前，在package定义之后； （6）import只告诉编译器及解释器哪里可以找到类、变量、方法的定义，而并没有将这些定义引入代码中； 2.4 包中类的使用 有以下几种机制可以使用包中的类： （1）如果要使用的类是属于https://www.doczj.com/doc/7b4192204.html,ng包的，那么可以直接使用类名来引用指定的类，而不需要加上包名，因为包https://www.doczj.com/doc/7b4192204.html,ng不用显示使用import，它是缺省引入的； （2）如果要使用的类在其它包（https://www.doczj.com/doc/7b4192204.html,ng除外）中，那么可以通过包名加上类名来引用该
Java的类一些常识 “1、请解释Java语言的跨平台特性。 解析：虽然不知道什么是跨平台也可以使用Java语言进行编程，但是对于一个Java编程员来说，理解跨平台特性能够更深入掌握Java语言，所以企业中往往要求应聘者至少理解这个特性。 参考答案：Java的跨平台特性也被称为可移植性、平台无关性，或者一次编写处处运行。他的意思就是如果用Java语言编写一个应用，那么就可以在不同平台上运行，而不需要为不同平台单独运行开发。之所以能实现跨平台的特性。主要得益于Java虚拟机（JVM），JVM解释器在运行Java应用时根据当前平台进行解释，解释成符合当前平台规范的机器码，所以可以实现同样的应用在不同平台上都能运行。 “2、请列举JAVA语言的主要特点 解析：了解一门语言，往往从熟悉该语言的主要特点开始入手，所以企业也常常通过应聘者对JAVA语言特点的掌握程度而判断其语言基础是否扎实。 参考答案：JAVA语言有很多特点，主要包括：①跨平台性：一个应用可以不经过修改直接运行到不同的平台上。②面向对象：JAVA语言是一门面向对面的语言，可以使用对象的属性和行为，可以使用面向对象的思想进行分析设计，并实现整个应用。③解释执行JAVA应用时，JVM中的解释器将解释类文件，生成符合当前平台的字节码。④自动回收：JAVA 应用中的垃圾回收是自动进行的，JVM中的后台线程将监视内存中数据的使用，当内存中的数据不再被引用时，将被作为垃圾回收，而不需要程序员动手回收。 “3、请说明一个JAVA类中主要包含哪几个元素？并说明每种元素的作用。 解析：无论简单还是复杂的JAVA应用，都是由若干个类组成，所以类是JAVA应用的组成单位。了解一个类中包含的主要元素能够对类有一个清晰的认识。一个类中往往会有五种元素，即属性、方法、构造方法、块以及内部类、其实块和内部类比较少见。 参考答案：JAVA类中主要包含属性、方法、构造方法、块以及内部类。
1.下列不可作为java语言修饰符的是（D） A) a1 B) $1 C) _1 D) 11 2.有一段java 应用程序，它的主类名是a1，那么保存它的源文件名可以是（A） Ａ) a1.java B) a1.class C) a1 D) 都对 3.整型数据类型中，需要内存空间最少的是（D） A) short B) long C) int D) byte 4. Java 类可以作为（C） A) 类型定义机制 B) 数据封装机制 C) 类型定义机制和数据封装机制 D) 上述都不对 5.在创建对象时必须（C） A) 先声明对象，然后才能使用对象 B) 先声明对象，为对象分配内存空间，然后才能使用对象 C) 先声明对象，为对象分配内存空间，对对象初始化，然后才能使用对象 D) 上述说法都对 6.在调用方法时，若要使方法改变实参的值，可以（B） A) 用基本数据类型作为参数 B) 用对象作为参数 C) A和B都对 D) A和B都不对 7. Java中（C） A) 一个子类可以有多个父类，一个父类也可以有多个子类 B) 一个子类可以有多个父类，但一个父类只可以有一个子类 C) 一个子类可以有一个父类，但一个父类可以有多个子类 D) 上述说法都不对 8.Java语言具有许多优点和特点，哪个反映了Java程序并行机制的特点？（B） A) 安全性B) 多线性C) 跨平台D) 可移植 9. Character流与Byte流的区别是（C） A) 每次读入的字节数不同B) 前者带有缓冲，后者没有 C) 前者是字符读写，后者是字节读写D) 二者没有区别，可以互换使用 10.以下声明合法的是（ D ） A、default String s； B、public final static native int w( ) C、abstract double d； D、abstract final double hyperbolicCosine( ) 11.关于以下application的说明，正确的是（ C ） 1．class StaticStuff 2．{ 3．static int x=10； 4．static { x+=5；} 5．public static void main（String args[ ]） 6．{ 7．System.out.println(“x=”+ x); 8．} 9．static { x/=3;}
java中的修饰符 static 表示静态，它可以修饰属性，方法和代码块。 1，static修饰属性（实例变量）（类变量），这个属性就可以用类名.属性名来访问，这个属性成为本类的类变量，为本类对象所共有。这个属性全类公有。（共有的类变量与对象无关，只和类有关）。 例： Java代码 1.public class Test{ 2.private static int testnum; 3./* 4.如果实力变量前加上了static修饰符那么，这个变量叫做类变量 5.*/ 6.…… 7.} 类加载的过程，类本身是保存在文件中（字节码文件保存着类的信息）的，java 通过I/O流把类的文件（字节码文件）读入JVM（java虚拟机），这个过程称为类的加载。JVM（java虚拟机）通过类路径（CLASSPATH）来找要加载的字节码文件。 类变量，在加载时自动初始化，初始化规则和实例变量相同。 注意：类中的实例变量在创建对象时被初始化，static修饰的属性，类变量，在类加载时创建并进行初始化，类加载的过程只进行一次。类变量只会被创建并初始化一次。 2，static修饰方法（静态方法），使这个方法成为整个类所公有的方法，用 类名.方法名访问。 例： Java代码 1.public class Test{ 2.private static int num; 3.public int testage; 4.public static int test（）{ 5.num++; 6.Test t=new Test(); 7.t.age 8./* 9.在静态方法中只能防问静态属性,但是可以通过一上的
Java 默认修饰符总结 1.类（class） 可见性修饰符：public—在所有类中可见，在其他包中可以用import导 入。 缺省—就是没有修饰符，在同一个包中的类中可见，在其他包中不能用 import导入。 修饰符：final—终态类，表示该类不能被继承 abstract—抽象类，不能新建对象 2.变量（variable） Java中变量有两种，方法变量和字段变量 方法变量只能用一个修饰符：final—表示常量，不能修改 下面是字段变量的修饰符 可见性修饰符：public—在任何类中可见 protected—在子类中或同一个包中可见 private—只在本类中可见，子类中也不可见 缺省—在同一个包中可见，子类不在一个包中，子类中也不可见 修饰符：static—静态变量，被类的所有实例共享 final—常量，定义后不能修改 *transient—告诉编译器，在类对象序列化的时候，此变量不需 要持久保存 *volatile—指出可能有多个线程修改此变量，要求编译器优化以 保证对此变量的修改能够被正确的处理 这两带*的不是很常用，但也是Java的修饰符，我也不是很清楚 3.方法(method) 可见性修饰符：public—在任何类中可见 protected—在子类中或同一个包中可见 private—只在本类中可见，子类中也不可见 缺省—在同一个包中可见，子类不在一个包中，子类中也不可见修饰符：static—静态方法，并不需要创建类的实例就可以访问静态方法final—常方法，所有子类不能覆盖该方法，但可以重载 abstract—抽象方法，在抽象类中没有实现的方法 native—本地方法，参见Java Native Interface(JNI) synchronized —在多线程中，synchronized方法调用时，其他所有方法不能调
1. 下列不可作为java语言修饰符的是（D） A) a1 B) $1 C) _1 D) 11 2. 有一段java 应用程序，它的主类名是a1，那么保存它的源文件名可 以是（A） Ａ) a1.java B) a1.class C) a1 D) 都对 3. 整型数据类型中，需要内存空间最少的是（D） A) short B) long C) int D) byte 4. Java 类可以作为（C） A) 类型定义机制 B) 数据封装机制 C) 类型定义机制和数据封装机制 D) 上述都不对 5. 在创建对象时必须（C） A) 先声明对象，然后才能使用对象 B) 先声明对象，为对象分配内存空间，然后才能使用对象 C) 先声明对象，为对象分配内存空间，对对象初始化，然后才能使用对象 D) 上述说法都对 6. 在调用方法时，若要使方法改变实参的值，可以（B） A) 用基本数据类型作为参数 B) 用对象作为参数 C) A和B都对 D) A和B都不对 7. Java中（C） A) 一个子类可以有多个父类，一个父类也可以有多个子类 B) 一个子类可以有多个父类，但一个父类只可以有一个子类 C) 一个子类可以有一个父类，但一个父类可以有多个子类 D) 上述说法都不对 8. Java语言具有许多优点和特点，哪个反映了Java程序并行机制的特点？（B） A) 安全性 B) 多线性 C) 跨平台 D) 可移植
9. Character流与Byte流的区别是（C） A) 每次读入的字节数不同 B) 前者带有缓冲，后者没有C) 前者是字符读写，后者是字节读写 D) 二者没有区别，可以互换使用 10. 以下声明合法的是（ D ） A、default String s； B、public final static native int w( ) C、abstract double d； D、abstract final double hyperbolicCosine( ) 11. 关于以下application的说明，正确的是（ C ） 1． class StaticStuff 2． { 3． static int x=10； 4． static { x =5；} 5． public static void main（String args[ ]） 6． { 7．System.out.println(“x=” x); 8． } 9． static { x/=3;} 10. } A、4行与9行不能通过编译，因为缺少方法名和返回类型 B、9行不能通过编译，因为只能有一个静态初始化器 C、编译通过，执行结果为：x=5 D、编译通过，执行结果为：x=3
1.就高级程序的编译过程来讲，可分为编译型和解释型两种。下面涉及解释型语言的是 （D）。 A.C B.C++ C.Fortran D.Java 2.方法头中static修饰符的含义是（C） A.方法体为空 B.定义的方法没有形参 C.该方法属于类的方法 D.方法的返回值不能参加算术运算 3.创建对象使用到的关键字运算符是（C） A.static B.public C.new D.protected 4.MAX_LENGTH是int型public成员变量,变量值保持为常量100，用简短语句定义这 个变量。（D） A.public int MAX_LENGTH=100 B.final int MAX_LENGTH=100 C.final public int MAX_LENGTH=100 D.public final int MAX_LENGTH=100 5.下面哪个单词是Java语言的关键字（B） A.Float B.this C.string D.unsigned 6.在Java中，要处理JButton类对象的事件，以下各项中，哪个是可以处理这个事件的接 口（D） A.FocusListener https://www.doczj.com/doc/7b4192204.html,ponentListener C.WindowListener D.ActionListener 7.JVM的含义是（D）。 A.Java编译器 B.Java运行环境 C.Java开发环境 D.Java虚拟机 8.算术表达式1+2/3-4*5的值为。（B） A.1 B.-19 C.-5 D.0 9.以下关于继承的叙述正确的是（A）。 A.在Java中类只允许单一继承 B.在Java中一个类只能实现一个接口 C.在Java中一个类不能同时继承一个类和实现一个接口 D.在Java中接口只允许单一继承 10.下列程序中不正确的语句是（C）。 public class Takecare{ int a=90;① static float b=10.98f;② public static void main(String args[]){ float c=a+b;③ System.out.println("c="+c);④ } } A.① B.② C.③ D.④ 11.以下有关构造方法的说法，正确的是：（A）。 A.一个类的构造方法可以有多个 B.构造方法在类定义时被调用 C.构造方法只能由对象中的其它方法调用 D.构造方法可以和类同名，也可以和类名不同 12.在使用interface声明一个接口时，只可以使用（D）修饰符修饰该接口。 A.private B.protected C.private protected D.public
Java中的常用关键字 才发现Java中的好多关键字都不知道什么意思，特转一遍过来。 Java保留关键字 Java语言有51个关键字，其中const和goto虽然被保留但未使用。你不能使用保留关键字来命名类、方法或变量。 一、保留关键字 1、数据类型： Boolean int long short byte float double char class interface 2、流程控制： if else do while for switch case default break continue return try catch finally 3、修饰符： public protected private final void static strictfp abstract transient synchronized volatile native 4、动作： package import throw throws extends implements this Super instanceof new 5、保留字： true false null goto const 二、访问修饰符： 访问修饰符：public , protected , private * 只能应用于类的成员变量。（局部变量只能在函数的范围内可见，不能使用访问修饰符） * 能够用来修饰类本身。（protected , private 不能用于顶级类，只能用于内部类） * 能够应用于成员方法和构造函数。 下面是一个例子：
package Examples; public class HelloWorld02{ //以下定义了三个了类成员变量 public String str1="Hello"; //可被你程序中的任何其他代码访问 protected String str2="World!"; //程序中同一包的成员和不同包中的该类子类可以访问 private String str3=" "; //仅该类中的成员可以访问 String str=str1+str3+str2; //不使用修饰符的话，变量的访问控制在所在包内为public， // 不能被所在包外的代码存取 //以下定义了三个使用不同修饰符和不同参数的构造方法。 public HelloWorld(){ System.out.println(str); } protected HelloWorld(long l){ System.out.print("Use \"protected\" constructor! And l is ["+l+"] "); System.out.println(str); } private HelloWorld(float f){ System.out.print("Use \"private\" constructor! And f is ["+f+"] "); System.out.println(str); } //声明构造方法为void类型是合法的.不过因为没有返回值,所以不能用来创建新对象. public void HelloWorld(){ System.out.println(str +" Use the void constructor!"); } public static void main(String[] args){
一、选择题 1.下列关于Java语言特性的描述中，错误的是（） A.支持多线程操作 B.Java程序与平台无关 C.Java是一门网络语言 D.支持单继承与多继承 2．下列关于构造方法的特点的描述中，错误的是（） A．不可重载B．方法名同类名C．无返回类型D．系统自动调用3．用在方法的定义处，以指明该方法不返回任何值的关键字是（）A．static B．string C．void D．public 4．以下哪个不是Java的原始数据类型（） A. int B. Boolean C. float D. char 5．在类的修饰符中，规定只能被同一包的类所使用的修饰符是（） A、private B、public C、默认 D、protected 9．JA V A是一门（）的程序设计语言 A．面向过程B．面向对象C．结构化D．基于对象 10．抽象方法（） A. 可以有方法体 B. 是没有方法体的方法 C. 可以出现在非抽象类中 D. 抽象类中的方法都是抽象方法 11．关于构造函数的说法哪个正确?（） A. 一个类只能有一个构造函数 B. 一个类可以有多个不同名的构造函数 C. 构造函数与类同名 D.构造函数不能被重载 12．下列是系统提供的常用的类，是所有类的父类的类是（）。 A、Math B、Object C、System D、String 13．下列哪个选项是合法的标识符？（） A. 123 B. _name C. class D. 1first 14.下列关于运行字节码文件的命令行参数的描述中，正确的是（）。 A、数组args[]的大小与命令行参数的个数无关 B、第一个命令行参数被存放在args[1]中 C、命令行的命令字被放在args[0]中 D、第一个命令行参数（紧跟命令字的参数）被存放在args[0]中 15．Try{ } Catch{ } 代码块用来监视和处理（） A. 语法错误 B.没有声明的变量 C.编译时错误 D.运行时异常 16. 下列选项中，属于Java语言的关键字的是（）。 A. goto B. malloc C. extend D. FALSE 17.JA V A提供了下列基本数据类型（） A. 整型浮点型字符型 B. 整型浮点型字符型布尔型 C. 整型字符串实数 D. 整型浮点型布尔型 18.下列关于接口的描述中，错误的是（）。 A、接口实际上是由常量和抽象方法构成的特殊类。 B、一个类只允许实现一个接口。 C、定义接口使用的关键字是interface。 D、在实现接口的类中通常要给出接口中定义的抽象方法的具体实现。 19. 在成员变量的修饰符中，规定只允许该类自身访问的修饰符是（）。 A、private B、public C、默认 D、protected 20. 下列元素经过排序的集合类是（）。
java 修饰符全解 1、类的修饰符分为：可访问控制符和非访问控制符两种。 可访问控制符是：公共类修饰符public 非访问控制符有：抽象类修饰符abstract ；最终类修饰符final 1 ）公共类修饰符public ：Java 语言中类的可访问控制符只有一个：public 即公共的。每个Java 程序的主类都必须是public 类作为公共工具供其它类和程序使用的应定义为public 类。 2 ）抽象类修饰符abstract ：凡是用abstract 修饰符修饰的类，被称为抽象类。所谓抽象类是指这种类没有具体对象的一种概念类。这样的类就是Java 语言的abstract 类。 3 ）最终类修饰符final ：当一个类不可能有子类时可用修饰符final 把它说明为最终类。被定义为final 的类通常是一些有固定作用、用来完成某种标准功能的类。 4 ）类缺省访问控制符：如果一个类没有访问控制符，说明它具有缺省的访问控制符特性。此时，这个类只能被同一个包中的类访问或引用。这一访问特性又称为包访问性。 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 虚拟机认定该暂时性变量不属于永久状态，以实现