JAVA的两种成员变量

一、填空题1、Java提供“包”来管理类名空间。

“包”实际上提供了一种_命名机制_和可见性限制机制。

2、使用createScreenCapture() 方法可以复制屏幕的一个矩形区域。

3、Final关键字修饰变量，则该变量_常量_。

Final修饰方法，则该方法_不允许其子类覆盖_。

Final修饰类，则该类_不会再被扩展_。

5、Java程序分两种，_ Java Application _和_Java Applet_。

6、final 关键字表明一个对象或变量在初始化不能修改。

7、在Java语言中，_ RandomAccessFile_文件允许对文件内容的随机读写。

8、一个Java的图形用户界面的最基本组成部分是_组件（Component）_。

9、java的特点：简单、面向对象、平台无关、多线程、安全、动态。

二、判断题1、在Java语言中，常量true、false、null都是使用小写。

y2、Package语句必须放在程序的第一句。

y3、因为Java不支持多继承，所以定义类时implements关键字后面只能说明一个接口名。

N4、我们把客观世界的实体称为问题空间的对象。

N5、一个Java类可以有多个父类。

N6、抽象类必须被继承。

Y7、在Java中声明变量时必须指定一个类型。

Y8、传统的结构化程序设计方法是产生60年代末开始的软件危机的原因。

N9、当通过实现Listener接口完成事件处理时，要同时实现该接口中的所有方法。

10、对多线程的支持是Java的一大特点。

Y三、选择题1、信息资源放在Web服务器后，需要把它的地址告诉大家，这就是b 的功能。

A.WWWB.URLC.BBSD.TCP/IP2、以下关于Applet的生命周期方法的说法哪个是不正确的？（d ）A、init()B、start()C、stop()D、main()4、AWT中的Canvas类在使用时必须被（d ）。

A．载入B．封装C．继承D．重载5、Java语言中的super关键字是（c ）A．指向父类的指针B．父类的标识符C．对父类的引用D．指向父类对象的指针6、下列特点不属于Java语言的选项是（b ）。

JAVA基础之局部变量与全局变量以及成员变量的区别局部变量
定义：在⽅法内定义的变量称为“局部变量”或“临时变量”，⽅法结束后局部变量占⽤的内存将被释放。

全局变量
定义：全局变量，⼜称“外部变量”，它不是属于哪个⽅法，作⽤域从定义的地址开始到源⽂件结束。

注意事项：
当局部变量与全局变量重名时，起作⽤的是局部变量。

成员变量
定义：在类体的变量部分中定义的变量，也称为字段。

区别：
java中没有全局变量的定义，这是C中的
例：
class Demo{
int x;// ⾮静态成员变量，⼜称为属性，对该类不同的对象来说，属性是不同的
static int y;// 静态成员变量，⼀个类中只有⼀个该变量，该类不同的对象共享同⼀个静态成员变量
public static void main(String[] args){
int m = 0;// 局部变量，是⽅法内部定义的变量，只在⽅法内部可见，在该⽅法结束后，由垃圾回收器⾃动回收
}
}。

成员变量、实例变量、类变量和局部变量区别
⼀、成员变量、实例变量、类变量和局部变量区别
1：：变量电议部分所定义的变量被称为类的。

也就是说在整个类中都有效，类中的⽅法可以直接调⽤成员变量使⽤。

然⽽成员变量⼜分为实例成员变量（简称）和类变量（简称）
1.1：：就是我们正常定义的变量，⽐如int a； a就是
1.2：：定义前要加上Static ⽐如static int a；这个a就是静态变量，当在变量定义前加上static的时候就代表着该变量在使⽤的时候有⼀处改变则各个⽤到这个变量的地⽅，该变量都发⽣改变，就是所谓的⼀处改变处处改变，静态变量的⽣存期为整个，但是只能在定义该变量的函数内使⽤该变量。

退出该函数后，尽管该变量还继续存在，但不能使⽤它。

2：：在⽅法体中定义的变量和⽅法的参数称。

也就是说只在定义它的⽅法内有效，⽽⽅法外部的其他⽅法⽆法使⽤局部变量。

当局部变量名字与成员变量名字相同，则成员变量被隐藏，即这个成员变量在这个⽅法内暂时失效，以局部变量定义的为准。

⼆.长提到的⽅法有，类⽅法，实例⽅法。

就是名字和类名相同，⽽且没有类型。

类⽅法和实例⽅法的区别就是类⽅法前⾯有static修饰，⽽实例⽅法没有static修饰。

实例⽅法既能对类变量操作，也能对实例变量操作，⽽类⽅法只能对类变量进⾏操作。

JAVA篇：修饰符与接⼝、类、⽅法、成员变量、局部变量、⽅法块或许这是⼀个⽐较轻松简单的知识点，因为只是简单地做⼀个总览对⽐⽽已。

这周⽐较忙，祝我⾃⼰好运。

有关接⼝(interface)的修饰符，其实⼀般⽤public，也可以不加修饰词（default），或者是使⽤private修饰的声明在类的内部的内部接⼝。

不存在protected修饰的接⼝。

⽽接⼝内部可以有⽤public static final修饰的静态常量，除此之外只存在public修饰的⽅法（接⼝中⽆修饰词的⽅法也默认是public）了。

⽆论是接⼝还是接⼝中的⽅法的abstract修饰词都是隐含的，不必显式地修饰在接⼝或者⽅法前⾯。

类的访问限制修饰词与接⼝⼀样，但是还可以有⾮访问限制修饰词abstract(抽象类)和final(不可继承的类)。

类的成员变量可以被四种访问修饰词修饰，同时也可以被static(静态变量),final(常量),transtient(有关序列化特殊标识变量,具体还需要进⾏了解), volatie(线程共享变量)。

类⽅法除了访问限制修饰符，还可使⽤static（静态⽅法）,final(不可改变的⽅法),abstract(抽象的),native(⾮java实现的),synchronized(线程同步),类构造⽅法只可使⽤访问限制修饰符修饰，局部变量只能使⽤final定义常量,⽅法块可以使⽤static定义静态⽅法块和使⽤synchronized 定义线程同步的⽅法块。

java的接⼝、类1、接⼝(interface) 在java中，接⼝是⼀个抽象类型，是抽象⽅法的集合，接⼝通常以interface来声明，接⼝只能包含抽象⽅法和以static\final修饰的变量，⼀个接⼝可以继承（extends）另⼀个接⼝。

接⼝只包含要实现的⽅法，⽽类描述对象的属性和⽅法，两者实现类似但是概念不同。

java提供了类和接⼝之间的实现机制，接⼝不可被实例化，只能被实现（implements），实现接⼝的类必须实现接⼝中全部的抽象⽅法，否则该类必须使⽤abstract声明为抽象类。

专接本辅导java第三章《面向对象编程基础》补充0.类变量与实例变量区别（类方法与实例方法的区别见习题解答第12题改错）java类的成员变量有两种：一种是被static关键字修饰的变量，叫类变量或者静态变量；另一种没有static修饰，为实例变量。

在语法定义上的区别：静态变量前要加static关键字，而实例变量前则不加。

在程序运行时的区别：实例变量属于某个对象的属性，必须创建了实例对象，其中的实例变量才会被分配空间，才能使用这个实例变量。

静态变量不属于某个实例对象，而是属于类，所以也称为类变量，只要程序加载了类的字节码，不用创建任何实例对象，静态变量就会被分配空间，静态变量就可以被使用了。

总之，实例变量必须创建对象后才可以通过这个对象来使用，静态变量则可以直接使用类名来引用。

例如，对于下面的程序，无论创建多少个实例对象，只在类被第一次装置时初始化一次staticVar变量和sum变量，并且每创建一个实例对象，就会执行一次构造函数；但是，每创建一个实例对象，就会分配一个instanceVar，即可能分配多个instanceVar，并且每个instanceVar的值都只自加了1次。

public class类变量与实例变量{public static int staticVar = 0;//类变量初始化，只会在类装载时进行一次！！public int instanceVar = 0;//实例变量初始化public static int sum=1;public类变量与实例变量()//构造方法{staticVar++;instanceVar++;sum=sum+5;System.out.println("staticVar = "+staticVar+",instanceVar="+instanceVar);System.out.println("sum = "+sum);}public static void main(String []args){类变量与实例变量对象1=new类变量与实例变量();类变量与实例变量对象2=new类变量与实例变量();类变量与实例变量对象3=new类变量与实例变量();}}运行结果：staticVar = 1,instanceVar=1sum = 6staticVar = 2,instanceVar=1sum = 11staticVar = 3,instanceVar=1sum = 16再如下面的程序，涉及static块：class Value{static int c=0;static int d;Value(){c=15;d=65;}Value(int i){c=i;d=c-1;}static void inc(){c++;}}public class Count {Value v0=new Value();//调用无参构造函数建立Value类非静态对象v0，类Count和类Value是has-a关系Value v=new Value(10);//调用有参构造函数建立Value类非静态对象vstatic Value v1,v2;//声明Value类的static对象v1,v2//static Value v1=new Value(),v2=new Value();//声明v1、v2并引用新建立的Value类对象static{//★声明static块，其初始化工作会先于任何其它非static块及非static变量而不管其在源程序书写中出现的先后次序！System.out.println("static块中println语句执行结果:"+"\n"+"v0和v是非静态内部类对象，v1和v2是静态内部类对象（请与教材P58例3.18对比），只有声明没有具体指向某对象时：v1.c="+v1.c+" v2.c="+v2.c+" v1.d="+v1.d+" v2.d="+v2.d);v1=new Value(30);//对象v1引用新建立的Value类对象System.out.println("static块中执行完“v1=new Value(30)之后：”v1.c="+v1.c+" v2.c="+v2.c+" v1.d="+v1.d+" v2.d="+v2.d);v2=new Value(15);//对象v2引用新建立的Value类对象System.out.println("static块中执行完“v2=new Value(15)之后：”v1.c="+v1.c+" v2.c="+v2.c+" v1.d="+v1.d+" v2.d="+v2.d);System.out.println("特别说明：因此时还没有建立Count类对象（Count 类和Value类是has-a关系，前者是外部类，后者是内部类）故非静态对象v0和v无法引用！"+"\n");}public static void main(String[] args) {Count ct1=new Count();//建立Count类（外部类）对象Count ct2=new Count();System.out.print("在main方法中，现在建立Count类（外部类）对象，");System.out.println("ct1的在ct2之前创建！分别指向两个Count类对象，Count类和Value类是has-a关系！"+"\n"+"以下是main方法体中println语句执行结果：");System.out.println("v0是无参构造内部类非静态对象，ct1.v0.c="+ct1.v0.c+" ct1.v0.d="+ct1.v0.d+" ct2.v0.c="+ct2.v0.c+"ct2.v0.d="+ct2.v0.d);// 非静态内部类对象只能通过外部类对象名访问System.out.println("v是有参构造内部类非静态对象，ct1.v.c="+ct1.v.c+" ct1.v.d="+ct1.v.d+" ct2.v.c="+ct2.v.c+" ct2.v.d="+ct2.v.d);// 非静态内部类对象只能通过外部类对象名访问System.out.println("v1是有参构造内部类静态对象，Count.v1.c="+Count.v1.c+" count.v1.d="+Count.v1.d);//静态内部类对象可以通过外部类名访问System.out.println("v2是有参构造内部类静态对象，Count.v2.c="+Count.v2.c+" count.v2.d="+Count.v2.d);Value.inc();//通过类名调用类方法System.out.println("调用类方法inc()之后Count.v1.c="+Count.v1.c+" Count.v1.d="+Count.v1.d);//引用类变量既可以通过类名也可以通过对象名System.out.println("调用类方法inc()之后Count.v2.c="+Count.v2.c+" count.v2.d="+Count.v2.d);Count.v2.inc();//通过类名调用类方法，这种写法不妥！System.out.println("调用类方法v1.inc()之后Count.v1.c="+Count.v1.c+" Count.v1.d="+Count.v1.d);//引用类变量既可以通过类名也可以通过对象名System.out.println("调用类方法v1.inc()之后Count.v2.c="+Count.v2.c+" count.v2.d="+Count.v2.d);ct1.v0.c++;//this.v0.c++;//错误，★不能在静态上下文中使用this关键字:！因为Value是Count的内部类，只能使用其外部类的对象ct2.v0.c++;System.out.println("顺序执行语句：ct1.v0.c++;ct2.v0.c++;后，ct1.v0.c="+ct1.v0.c+" ct2.v0.c="+ct2.v0.c);// 非静态内部类对象只能通过外部类对象名访问}}上面这个程序的行动结果如下：static块中println语句执行结果:v0和v是非静态内部类对象，v1和v2是静态内部类对象（请与教材P58例3.18对比），只有声明没有具体指向某对象时：v1.c=0 v2.c=0 v1.d=0 v2.d=0static块中执行完“v1=new Value(30)之后：”v1.c=30 v2.c=30 v1.d=29 v2.d=29static块中执行完“v2=new Value(15)之后：”v1.c=15 v2.c=15 v1.d=14 v2.d=14特别说明：因此时还没有建立Count类对象（Count类和Value类是has-a关系，前者是外部类，后者是内部类）故非静态对象v0和v无法引用！在main方法中，现在建立Count类（外部类）对象，ct1的在ct2之前创建！分别指向两个Count类对象，Count类和Value类是has-a关系！以下是main方法体中println语句执行结果：v0是无参构造内部类非静态对象，ct1.v0.c=10 ct1.v0.d=9 ct2.v0.c=10 ct2.v0.d=9v是有参构造内部类非静态对象，ct1.v.c=10 ct1.v.d=9 ct2.v.c=10 ct2.v.d=9 v1是有参构造内部类静态对象， Count.v1.c=10 count.v1.d=9v2是有参构造内部类静态对象， Count.v2.c=10 count.v2.d=9调用类方法inc()之后 Count.v1.c=11 Count.v1.d=9调用类方法inc()之后 Count.v2.c=11 count.v2.d=9调用类方法v1.inc()之后 Count.v1.c=12 Count.v1.d=9调用类方法v1.inc()之后 Count.v2.c=12 count.v2.d=9顺序执行语句：ct1.v0.c++;ct2.v0.c++;后，ct1.v0.c=14 ct2.v0.c=14以上运行结果中，有五点值得注意：一是static变量和static块是在类第一次装载时被初始化一次，并供类的所有对象共享，故static变量和static块中内容最先被初始化（早于main方法）。

在Java中，（）关键字用来终止循环语句。

A.returnB.breakC.continueD.extends正确答案：B此题目考查的是Java中Java中的关键字。

return关键字在java中用于结束方法的执行，返回结果给调用方，所以选项A是错误的。

break关键字可以用在switch语句中也可以用在循环语句中，用在switch语句中用于跳出switch，用在循环语句中用于跳出循环。

所以选项B是正确的。

continue关键字用于跳过循环体中剩余语句而进入下一次循环，所以选项C是错误的。

extends关键字是用于继承的，所以选项D是错误的。

下面（）赋值语句不会出现编译错误。

A.float f=3.9;B.char c="z";C.byte b=257;D.int i=10;正确答案：D本题考查几种数据类型字面量值选项A，错误，float类型变量赋值必须以ｆ或Ｆ结尾，否则java中，3.9为double 类型，会有损失精度的编译错误选项B，错误，char类型的字面量值使用''(单引号)，不是双引号选项C，错误，byte类型取值范围是127~-128 选项D，正确，整数默认类型为int类型在java中，关于变量说法错误的是（）。

A.实例变量是类的成员变量B.实例变量用关键字static修饰C.方法中定义的局部变量在方法被执行时创建D.局部变量在使用之前必须被初始化正确答案：B这里考的是实例变量和局部变量。

在java中，成员变量分两种，一种为实例变量，一种为静态变量。

实例变量定义在类中，是类的成员变量，在创建对象时存储在堆中，是属于对象的，所以选项A是正确的。

静态变量定义在类中，由static修饰，与类的信息一并存储在方法区中，所以选项B是错误的。

Java中的局部变量是定义在方法中的，当方法被调用的时候存储在栈中，没有默认值，必须自行设定初始值，所以选项C和选项D是正确的。

在。

java中，静态成员变量的初始化方式有两种，下面听杭州达内小编为你解析，分别是在声明时直接初始化和使用静态初始化块。

本文主要通过一个例子讲解第一中的实现方式。

与实例变量的直接初始化方式相似，如果静态成员变量在声明时就能够确定其值，那么就可以使用这种方式。

静态成员变量旨在类加载时被初始化一次，由类的所有对象所共享。

请看下面的例子：
1.public class Pen{
2.private static int penNum="0";
3.public Pen(){
4.penNum++;
5.}
6.public static int getPenNum(){
7.return penNum;
8.}
9.}
10.class TestPen{
11.public statec void main(String{}args){
12.Pen pen1=new Pen();
13. System.out.println(Pen.getPenNum());
14.Pen pen2=new Pen();
15.System.out.println(Pen.getPenNum());
16.}
17.}
Pen类中的静态成员变量penNum用来记录创建对象的个数，采用声明时直接初始化方式（第2行）。

创建对象的时候会自动调用构造器，这里在构造器总递增其值（第4行）。

在TestPen类中创建了两个Pen类的对象，并在创建后就输出对象的个数，由此证明静态成员变量与创建多少个类的对象无关，只在类加载时执行唯一的一次初始化。

运行结果为：
1
2。

Java填空题1一个Java源程序是由若干个类组成。

2class是Java的关键字，用来定义类。

3Java应用程序中有多个类时，java命令后的类名必须是包含了main方法的那个类的名字。

4一个Java应用程序必须且只有一个类含有main方法。

5在一个Java应用程序中main方法必须被说明为public static void。

6Java中所有程序都使用方法，应用程序以main方法开始。

7Java源文件中有多个类，但只能有一个类是public类。

8Java源程序编译后生成的字节码文件扩展名为class。

9用来标识类名、变量名、方法名、类型名、数组名、文件名的有效字符序列称为标识符。

10Java语言规定标识符由字母、下划线、美元符号和数字组成，并且第一个字符不能是数字。

11关键字就是Java语言中已经被赋予特定意义的一些单词，不可以把这类词作为名字来用。

12使用关键字boolean来定义逻辑变量。

13关键字就是Java语言中已经被赋予特定意义的一些单词。

14结构化程序设计的基本数据类型包括逻辑类型、整数类型、字符类型、浮点类型。

15Java中byte型数组在内存中的存储形式是补码。

16对于int型变量，内存分配4个字节。

17对于byte型变量，内存分配1个字节。

18对于long型变量，内存分配8个字节。

19对于short型变量，内存分配2个字节。

20结构化程序设计的基本数据类型包括整数类型、逻辑类型、字符类型、浮点类型。

21使用关键字char来定义字符变量。

22结构化程序设计的基本数据类型包括字符类型、逻辑类型、整数类型、浮点类型。

23java中，浮点型变量的类型有float和double两种。

24对于float型变量，内存分配4个字节。

25对于double型变量，内存分配8个字节。

26结构化程序设计的基本数据类型包括字符类型、逻辑类型、整数类型、浮点类型。

27Java使用Unicode字符集。

java中的类变量和实例变量java中的变量分为1.局部变量；2.成员变量: 分为a.类变量, b.实例变量。

1.局部变量：局部变量声明在⽅法、构造⽅法或者语句块中；局部变量在⽅法、构造⽅法、或者语句块被执⾏的时候创建，当它们执⾏完成后，变量将会被销毁；访问修饰符不能⽤于局部变量；局部变量只在声明它的⽅法、构造⽅法或者语句块中可见；局部变量是在栈上分配的。

局部变量没有默认值，所以局部变量被声明后，必须经过初始化，才可以使⽤。

2.成员变量成员变量是定义在类中，⽅法体之外的变量。

这种变量在创建对象的时候实例化。

成员变量可以被类中⽅法、构造⽅法和特定类的语句块访问。

a.类变量:类变量也称为静态变量，在类中以 static 关键字声明，但必须在⽅法之外。

⽆论⼀个类创建了多少个对象，类只拥有类变量的⼀份拷贝。

静态变量除了被声明为常量外很少使⽤。

常量是指声明为public/private，final和static类型的变量。

常量初始化后不可改变。

静态变量储存在静态存储区。

经常被声明为常量，很少单独使⽤static声明变量。

静态变量在第⼀次被访问时创建，在程序结束时销毁。

与实例变量具有相似的可见性。

但为了对类的使⽤者可见，⼤多数静态变量声明为public类型。

默认值和实例变量相似。

数值型变量默认值是0，布尔型默认值是false，引⽤类型默认值是null。

变量的值可以在声明的时候指定，也可以在构造⽅法中指定。

此外，静态变量还可以在静态语句块中初始化。

静态变量可以通过：ClassName.VariableName的⽅式访问。

类变量被声明为public static final类型时，类变量名称⼀般建议使⽤⼤写字母。

如果静态变量不是public和final类型，其命名⽅式与实例变量以及局部变量的命名⽅式⼀致。

b.实例变量：实例变量声明在⼀个类中，但在⽅法、构造⽅法和语句块之外；当⼀个对象被实例化之后，每个实例变量的值就跟着确定；实例变量在对象创建的时候创建，在对象被销毁的时候销毁；实例变量的值应该⾄少被⼀个⽅法、构造⽅法或者语句块引⽤，使得外部能够通过这些⽅式获取实例变量信息；实例变量可以声明在使⽤前或者使⽤后；访问修饰符可以修饰实例变量；实例变量对于类中的⽅法、构造⽅法或者语句块是可见的。