第三章 Java语言面向对象的特征.doc.deflate1
第三章Java语言面向对象的特征
2.选择题
3-1 下列对封装性的描述中，错误的是( B ).
A.封装体包含了属性和行为
B.封装体中的属性和行为的访问权限是相同的
C.被封装的某些信息在封装体外是不可见的
D.封装使得抽象的数据类型提高了可重用性
3-2 下列关于继承性的描述中，错误的是（C）
A.一个类可以同时生成多个子类
B.子类继承了父类的所有成员
C. Java语言支持单重继承和多重继承
D. Java语言通过接口可使子类使用多个父类的成员
3-3 下列对多态性的描述中，错误的是（A）
A. Java语言允许运算符重载
B. Java语言允许方法重载
C. Java语言允许变量覆盖
D.多态性提高了程序的抽象性和简洁性
3-4 在类的修饰符中，规定只能被同一包类所使用的修饰符是（B）
A. public
B.默认
C. final
D. abstract
3-5 在成员变量的修饰符中，规定只能被同一包类所使用的修饰符是（B）
A. private
B. public
C.默认
D. protected
3-6 在成员方法的访问控制修饰符中，规定访问权限包含该类自身，同包的其他类和其他包的该类子类的修饰符是（D）
A. public
B. private
C.默认
D. protected
3-7 下列关于构造方法的特点的描述中，错误的是（A）
A.不可重载
B.方法名同类名
C.无返回类型
D.系统自动调用
3-8 下列关于静态方法的特点的描述中，错误的是（D）
A.在类体内说明静态方法使用关键字static
B.静态方法只能处理静态变量或调用静态方法
C.静态方法不占用对象的内存空间，非静态方法占用对象的内存空间
D.静态方法只能用类名调用
3-9 下列对静态初始化器的描述中，错误的是（C）
A.静态初始化器是用来对类进行初始化的，而不是对某个对象初始化
B.静态初始化器是由关键字static 和一对花括号组成的语句组
C.静态初始化器不同于构造方法，它不是方法
D.静态初始化器在产生新对象时，是由系统自动调用的
3-10 下列关于抽象类的描述中，错误的是（C）
A.抽象类是用修饰符abstract 说明的
B.抽象类是不可以定义对象的
C.抽象类是不可以有构造方法的
D.抽象类通常要有它的子类
3-11 下列关于类的继承性的描述中，错误的是（D）
A.继承是在已有类的基础上生成新类的一种方法
B.子类继承父类的所有成员
C. Java 语言要求一个子类只有一个父类
D.父类中成员的访问权限在子类中将被改变
3-12 下列关于子类继承父类的成员的描述中，错误的是（A）
A.子类中继承父类中的所有成员都可以直接访问
B.子类中定义有与父类同名变量时，子类继承父类的操作中，使用继承父类的变量；子
类执行自己的操作中，使用自己定义的变量
C.当子类中出现成员方法头与父类方法头相同的方法时，子类成员方法覆盖父类中的成
员方法
D.方法重载是编译时处理的，而方法覆盖是在运行时处理的
3-13 下列关于接口的描述中，错误的是（B）
A.接口实际上是由变量和抽象方法构成的特殊类
B.一个类只允许继承一个接口
C.定义接口使用的关键字是interface
D.在继承接口的类中通常要给出接口中定义的抽象方法的具体实现
3-14 下列关于包的描述中，错误的是（A）
A.包是一种特殊的类
B.包是若干个类的集合
C.包是使用package 语句创建的
D.包有有包名包和无名包两种
3-15 下列常用包中，存放用户图形界面类库的包是（A）
A. java.awt
B. https://www.360docs.net/doc/9d5972194.html,ng
C. java.util
D.java.io
3-16 下列是系统提供的常用的类，所有类的父类的类是（B）
A. Math
B. Object
C. System
D. String
3.判断题
3-1 类是一种类型，也是对象的模板。（对）
3-2 Java语言只支持单重继承，不支持多重继承。（对）
3-3 类中说明的方法可以定义在类体外。（错）
3-4 class 不是定义类的唯一关键字。（错）
3-5 某类的对象可以作为另一个类的成员。（对）
3-6 在类体内说明成员变量时不允许赋初值。（错）
3-7 最终变量就是Java 语言中的符号常量。（对）
3-8 静态变量的引用只能使用对象。（错）
3-9 静态方法只能处理静态变量。（对）
3-10 抽象方法是一种只有说明而无具体实现的方法。（对）
3-11 最终方法是不能被当前子类重新定义的方法。（对）
3-12 Java语言中，方法调用一律都是传址的引用调用。（错）
3-13 非静态方法中不能引用静态变量。（错）
3-14 静态初始化器是在构造方法被自动调用之前运行的。（对）
3-15 抽象方法仅有方法头，而无方法体。（对）
3-16 抽象方法一定出现在抽象类中。（对）
3-17 最终类，最终方法和最终变量的修饰符都用final 。（对）
3-18 创建对象时系统将调用适当的构造方法给对象初始化。（对）
3-19 使用运算符new 创建对象时，赋给对象的值实际上是一个地址值。（对）
3-20 使用构造方法只能给非静态成员变量赋初值。（对）
3-21 创建对象时，该对象占用的内存空间除了非静态的成员变量外，还有非静态的成员方法。（对）
3-22 Java 语言中，对象成员的表示只使用运算符“.”。（对）
3-23 Java 语言中，对象赋值实际上是同一个对象具有两个不同的名字，因为他们都有同一个地址值。（对）
3-24 对象可作方法参数，对象数组不能作方法参数。（错）
3-25 Java语言中，所创建的子类都应有一个父类。（对）
3-26 Java语言中，类的继承是可以传递的。（对）
3-27 Java语言中，构造方法是可以继承的。（错）
3-28 子类中构造方法应包含自身类的构造方法和直接父类的构造方法。（对）
3-29 调用this 或super 的构造方法的语句必须放在第一条语句。（对）
3-30 子类对象可以直接赋值给父类对象；而父类对象不可以赋值给子类对象。（错）
3-31 子类中所继承父类的成员都可以在子类中访问。（错）
3-32 成员方法的重载和覆盖是一回事。（错）
3-33 一个类可以实现多个接口。接口可以实现“多重继承”。（对）
3-34 实现接口的类不能是抽象类。（对）
4.填空题
3-1 对象具有3大要素，它们分别是（对象名），（对象类型），（对象值）。这3大要素分别用（同标识符），（类名），（默认值或初值）表示。
3-2 定义类时，通常要使用的关键字有（class），（extends），（implements）。
3-3 成员变量的定义格式如下：（[<修饰符>]）<变量类型><变量名>（=<初值>）；
3-4 成员变量的非访问控制修饰符有（static），（final），（volatile）。
3-5 在成员方法的定义中可省略的部分有（修饰符），（参数表），（异常类名列表）。
3-6 Java 语言中，重载方法的选择是在（编译）时进行的，系统根据（参数个数），（参数类型），（参数顺序）寻找匹配方法。
3-7 没有子类的类称为（最终类），不能被子类重载的方法称为（最终方法），不能被改变值的量称为常量，又称为（最终变量）。
3-8 创建一个对象时，通常要包含3项内容：（说明对象），给对象分配空间，（对象初始化）。3-9 系统规定int型变量默认值为（0），浮点型变量的默认值为（0.0），布尔型变量的默认值为（false）。
3-10 Java语言中，定义子类时，使用关键字（extends）来给出父类名。如果没有指出父类，则该类的默认父类为（object类）。
3-11 系统规定：表示当前类的构造方法用（this（）），表示直接父类的构造方法用（super （））。
3-12 接口中默认的成员变量的修饰符为（final），默认的成员方法的修饰符是（final）。
3-13 实现接口中的抽象方法时，必须使用（完全相同）方法头，并且还要用（public）修饰符。
3-14 包名与子包名之间用（.）分隔。加载包的关键字是（import）。
3-15 字符串类又包含两大类，它们是（String）和（StringBuffer）.
5.分析程序的输出结果题
3-1 Exer3_1.java
class A
{
int x,y,z,sum;
A(int i,int j,int k)
{
x=i;
y=j;
z=k;
sum=x+y+z;
}
boolean sameA(A al)
{
if((al.x==x)&(al.y==y)&(al.z==z))
return true;
else
return false;
}
boolean sameS(A al)
{
if(al.sum==sum)
return true;
else
return false;
}
}
class Exer3_1
{
public static void main(String args[])
{
A a=new A(2,5,8);
A b=new A(2,5,8);
A c=new A(5,8,2);
System.out.println(a,sameA(b));
System.out.println(a,sameA(c));
System.out.println(a,sameA(b));
System.out.println(a,sameA(c));
}
}
输出结果如下：
true
false
true
true
3-2 Exer3_2.java
class B
{
void meth(int i)
{System.out.println("Int:"+i);}
void meth(double i)
{System.out.println("Double:"+i);} }
class Exer3_2
{
public static void main(String args[])
{
int i=8;
double d=6.8;
short s=10;
float f=5.3f;
byte b=9;
char c='a';
B ob=newB();
ob.meth(i);
ob.meth(d);
ob.meth(s);
ob.meth((int)f);
ob.meth(b);
ob.meth(c);
}
}
输出结果如下：
Int:8
Double: 6.8
Int:10
Int:5
Int:9
Int:97
3-3 Exer3_3.java
class C
{
int c;
C(int a)
{
c=0;
for(int i=0;i<=a;i++)
c+=i;
}
C(Cb)
{c=b.c;}
}
class Exer3_3
{
public static void main(String args[])
{
C c1=new C(6);
C c2=new C(new C(4));
System.out.println("c1:"+c1.c);
System.out.println("c2"+c2.c);
}
}
输出结果如下：
c1:21
c2:10
3_4 Exer3_4.java
class D
{
static int d=100;
static int meth()
{
int s=d*10;
return(s);
}
D(int i)
{d=i;}
}
class Exer3_4
{
public static void main(String args[])
{
System.out.println("d.meth:"+D.d);
D dd=new D(10);
System.out.println("d:"+D.d);
System.out.println("dd:"+dd.d);
System.out.println("d.meth:"+D.meth());
System.out.println("d.meth:"+dd.meth());
System.out.println("d:"+D.d);
D.d=500;
System.out.println("d.meth:"+D.meth());
}
}
输出结果如下：
d.meth:100
d:10
dd:10
d.meth:100
d.meth:100
d:10
d.meth:5000
3_5 Exer3_5.java
class E
{
double h,w;
void show()
{System.out.println("width="+w+",height="+h);} }
class T extends E
{
double area()
{return w*h;}
}
class Exer3_5
{
public static void main(String args[])
{
T t1=new T();
T t2=new T();
t1.w=8.0;
t1.h=5.0;
t2.w=12.0;
t2.h=16.0;
t1.show();
System.out.println("t1:area="+t1.area());
t2.show();
System.out.println("t2:area="+t2.area());
}
}
输出结果如下：
Width= 8.0 , height=5.0
t1:area=40.0
width=12.0,height=16.0
t2:area=192.0
3-6 Exer3_6.java
class A
{
A()
{System.out.println("class A");}
}
class B extends A
{
int b;
B(int i)
(b=i);
}
class C extends B
{
private int c;
C(int i,int j)
{
super(j);
c=i;
}
int return c()
{return c;}
}
class Exer3_6
{
public static void main(String args[])
{
C c=new C(5,18);
System.out.println("c:"+c.b*c.return c());
}
}
输出结果如下：
class A
c:90
3-7 Exer3_7.java
class A
{
void show()
{System.out.println("class A");}
}
class B extends A
{
void show()
{System.out.println("class B");}
}
class C extends B
{
void show()
{System.out.println("class C");}
}
class Exer3_7
{
public static void main(String argsp[])
{
A a=new A();
B b=new B();
C c=new C();
A x=new A();
x=a;
x.show();
x=b;
x.show();
x=c;
x.show();
}
}
输出结果如下：
class A
class B
class C
3-8 Exer3_8.java
abstract class Shap
{
private double w,h;
Shap(double i)
{w=h=i;}
Shap(double i,double j)
{w=i,h=j;}
Shap(Shap s)
{
w=s.w;
h=s.h;
}
double getw()
{return w;}
double geth()
{return h;}
abstract double area(); }
class Rest extends Shap
{
Rect(double i)
{super(i);}
Rect(double i,double j)
{super(i,j);}
Rect(Rect r)
{super(r);}
double area()
{return getw()*geth();}
}
class Exer3_8
{
public static void main(String args[])
{
Shap s[]=new Shap[3];
s[0]=new Rect(8.0);
s[1]=new Rect(5.0,6.0);
s[2]=new Rect(new Rect(12.0,4.0));
for(int i=0;i System.out.println("s["+i+"]area="+s[i].area()); } } 输出结果如下： s[0]area=64.0 s[1]area=30.0 s[2]area=48.0 3-9 addre.java(在子目录address下) package address; public class addre { private String s1,s2,s3; public addre(String str1,String str2,String str3) { s1=str1; s2=str2; s3=str3; } public void show() { System.out.print(s1); System.out.print("\t"+s2); System.out.println("\t"+s3); } } Exer3_9.java import address.*; class Exer3_9 { public static void main(String args[]) { addre s[]=new addre[2]; s[0]=new addre("PKU","building 44","room 109"); s[1]=new addre("PKU","building 54","room 209"); for(int i=0;i s[i].show(); } } 输出结果如下： PKU building 44 room 109 PKU building 54 room 209 3-10 Exer3_10.java interface Series { int getVal(); } class R1 implements Series { int val; R1() {val=0;} public int getVal() { val++ return val; } } class R2 implements Series { int val; R2() {val=0;} public int getVal() { val+=2; return val; } } class Exer3_10 { public static void main(String args[]) { R1 r1=new R1(); R2 r2=new R2(); Series s; for(int i=0;i<3;i++) { s=r1; System.out.println("r1:"+s.getVal()); s=r2; System.out.println("r2:"+s.getVal()); } } } 输出结果如下： r1:1 r2:2 r1:2 r2:4 r1:3 r2:6 3.5 测试题 1.单选题 3-1 定义类时使用的关键字是（）。 A. class B. struct C. unin D. array 3-2 下列关于方法的描述中，错误的是（）。 A.方法只有类的成员方法，再无其他方法 B.方法可以重载和内联 C.对象作为方法参数时，参数传递的是对象地址值 D.方法的返回值是通过return来实现的 3-3 在下列关于静态成员的描述中，错误的是（）。 A.静态成员有成员变量和方法两种 B.静态成员的修饰符是static C.静态成员可以使用类名访问，也可使用对象名访问 D.静态方法可以访问静态成员变量也可以访问非静态成员变量 3-4 在下列关于类的继承的描述中，错误的是（）。 A.子类只允许一个父类 B.一个父类只能生成一个子类 C.继承不改变成员访问权限 D.私有成员和构造方法不能继承 3-5 在下列关于方法的重载和覆盖的描述中，错误的是（）。 A.方法重载是指在同一个类中允许出现方法参数，个数，顺序不同而方法名相同的若干 方法； B.方法覆盖是指在父类和子类之间出现的方法头相同而方法体不同的多个方法 C.方法重载是在编译时进行选择的 D.方法覆盖也是在编译时进行选择的 2.判断题 3-1 调用默认构造方法时，对象成员变量将获取默认值。 3-2 对象可以作另类的成员，也可以作数组元素。 3-3 Java语言的多态性仅表现在方法的重载上。 3-4 一个类可以同时实现多个接口，接口是在编译时处理的。3-5 可以创建包，一个包中只能有一个类。 3-6 Object类是所有类的父类。 3-7 System类中所有成员都是static的。 3-8 String类和StringBuffer类是不同的。 3.分析程序结果题 3-1 分析下列程序的输出结果。 程序内容如下： import java.io.*; class A { static int a=100; static int Twoa() {return 2*a;} } public class test3_1 { public static void main(String args[]) { System.out.println("a="+A.a); System.out.println("2*a="+A.Twoa()); A.a=10; System.out.println("2*a="+A.Twoa()); } } 3-2 分析下列程序的输出结果。 程序内容如下： import java.io.*; class B { int b1,b2; B() {b1=b2=0;} B(int i) {b1=b2=i;} B(int i,int j) {b1=i;b2=j;} B(B b) {b1=b.b1;b2=b.b2;} void print() {System.out.println(b1+","+b2);} } public class test3_2 { public static void main(Sting args[]) { B b[]=new B[4]; b[0]=new B(); b[1]=new B(4,8); b[2]=new B(b[1]); b[3]=new B(7); for(int i=0;i<4;i++) b[i].print(); } } 3-3 分析下列程序的输出结果。 程序内容如下： import java.io.*; class C { int c; C(int i) {c=i;} int getc() {return c;} } class D extends C { int c; D(int i,int j) {super(i);c=j;} void print() {System.out.println(super.c+c);} } public class test3_3 { public static void main(String args[]) { C c=new C(16); System.out.println(c.getc()); D d=new D(3,9); d.print(); } } 3-4 分析下列程序的输出结果。 程序内容如下： import java.io.*; abstract class E { String name=new String(); E(Sting s) {name=s;} abstract void print(); } class F extends E { F(String s) {super(s);} void print() {System.out.println(name);} } public class test3_4 { public static void main(String args[]) { F f[]=new F[3]; f[0]=new F("Ma"); f[1]=new F("Hu"); f[2]=new F("Li"); for(int i=0;i<3;i++) f[i].print(); } } 3-5 分析下列程序的输出结果。 程序内容如下： import java.io.*; class A { void print() {} } class B extends A { void print() {System.out.println("In B";)} } class C extends A { void print() {System.out.println("In C");} } class D extends A { void print() {System.out.println("In D");} } class E extends A { void print() {System.out.println("In E");} } public class test3_5 { public static void main(String args[]) { A a[]=new A[5]; a[0]=new B(); a[1]=new C(); a[2]=new D(); a[3]=new E(); a[4]=new F(); for(int i=0;i<5;i++) if(a[i]instanceof C||a[i]instanceof D||a[i]instanceof E) a[i].print(); } } Java语言的特点和实现机制 (总分：30.00，做题时间：90分钟) 一、{{B}}选择题{{/B}}(总题数：11，分数：22.00) 1.在Java语言中有多种实现的机制，下列______技术属于垃圾回收机制。 （分数：2.00） A.字节编译 B.内存跟踪√ C.语法检查 D.堆栈上/下溢检查 解析： 2.下列______不属于面向对象程序设计的基本要素。 （分数：2.00） A.类 B.方法 C.对象 D.安全√ 解析： 3.保证Java语言可移植性的特征是______。 （分数：2.00） A.面向对象 B.安全性 C.分布式计算 D.可跨平台√ 解析： 4.下列描述中不正确的一项是______。 （分数：2.00） A.C抖不是纯面向对象的，它兼容C语言 B.Java是纯面向对象语言，不兼容以往的任何语言 C.在Java语言中，使用对象时必须先声明 D.Java语言和C++一样有指针√ 解析： 5.下列选项中，不是Java语言特点的是______。 （分数：2.00） A.可移植性 B.面向对象 C.单线程√ D.体系结构中立 解析： 6.关于Java中的指针，下列说法正确的是______。 （分数：2.00） A.Java摒弃了指针√ B.Java摒弃了指针和数组 C.新版本Java中会有指针 D.Java保留了指针 解析： 7.Java语言具有许多优点和特点，下列选项中______是通过Java虚拟机实现的特点。（分数：2.00） A.分布式 B.多线程 C.安全性 D.可移植√ 解析： 8.下列______不是面向对象程序设计方法的特点。 （分数：2.00） A.继承 B.抽象 C.多态 D.结构化√ 解析： 9.关于Java语言的内存回收机制，下列选项中正确的一项是______。 （分数：2.00） A.Java程序允许用户使用指针来释放内存 B.Java程序要求用户必须手工创建一个线程来释放内存 C.内存回收线程负责释放无用内存√ D.内存回收线程不能释放内存对象 解析： 10.下列关于Java语言和C++语言之间差别的描述中，不正确的一项是______。（分数：2.00） A.Java虽然提供了安全机制，但是还是没有C++安全√ B.Java的内存管理基于C++的内存管理 C.Java没有指针，但是C++的指针最灵活 D.Java没有全局变量，但是C++有全局变量 解析： 11.Java语言属于______。 （分数：2.00） A.面向过程的语言 B.面向对象的语言√ C.面向机器的语言 D.面向操作系统的语言 解析： 二、{{B}}填空题{{/B}}(总题数：4，分数：8.00) 12.Java编译器产生的文件扩展名是 1。 （分数：2.00） 填空项1:__________________ （正确答案：.class） 解析： 13.运行字节码的三个步骤是 1、校验代码、执行代码。 （分数：2.00） 填空项1:__________________ （正确答案：类的装入） 解析： 14.Java程序解释执行过程中代码的装入是由 1完成。 （分数：2.00） 填空项1:__________________ （正确答案：类装载器） 解析： 15.在Java语言的体系结构中，JVM的上层是______和______，它们都具有扩展性。（分数：2.00） 填空项1:__________________ （正确答案：Java基本类库基本API） java语言特点： 1、简单 2、面向对象 3、分布性 4、可移植行 5、解释性语言 6、安全性 7、健壮性 8、多线程 9、高性能 10、动态 package demo; 包包名 public class Test 公共的类类名 public static void main(String[] args) 公共的静态的无返回值方法名参数类型参数名称 System.out.print(“1”);输出语句 System.out.println(“2”);输出语句换行 import java.util.Scanner; Scanner sc=new Scanner(System.in);创建输入对象 int i=sc.nextInt();获得输入的值 nextDouble(),next(),nextByte()... hasNextInt();判断输入的是否是int类型数字，是返回true 不是返回false // 小类型数据转到大类型，自动类型转换 // 大类型转小类型，强制类型转换 八大基本数据类型 byte short int long float double char boolean 所占字节 1 2 4 8 4 8 2 1 （在内存的存储空间） 二进制位数8 16 32 64 32 64 16 8 默认值： 分支语句 if(条件1){ 执行代码1 }else if(条件2){ 执行代码2 }else{ 条件1和条件2都不满足就执行此处代码 } String a="y""y".equals(a); 两个String类型值对比 final 最终的常量职能赋值一次，之后不可更改 static final int PA = 300;// 全局常量 final double PI=3.14;//局部常量量不需要static static int a = 10;// 全局变量 全局变量（成员变量）整个类中有效 局部变量方法体内有效 // 怎么创建类:1、创建类名2、创建属性3、创建方法?// 定义属性:类型属性名称 // 自定义方法:public void add(int a,int b){} // 设置属性:School s=new School(); https://www.360docs.net/doc/9d5972194.html,="南大" // 调用方法: https://www.360docs.net/doc/9d5972194.html,(); // static修饰的方法可以直接用类名.方法名()调用 // 无返回值的方法用void修饰，不需要return // 有返回值的方法需要用return int[] a = new int[5];// 声明数组，并给定数组长度 int[] b = new int[] { 1, 2, 3 };// 声明数组并给数组赋值 int[] c = { 1, 2, 3 };// 直接给数组赋值 int[] arr = { 2, 5, 77, 99, 30, 58, 23 }; // 只要输出数组中的最大值 int max = arr[0];// 打擂台算法 for (int i = 1; i < arr.length; i++) { if (max < arr[i]) { max = arr[i]; } } import java.util.Arrays; Arrays.sort(int[] a);// 数组排序方法，升序 第1章 Java语言概述 一、判断题 1．Java语言是一种解释执行的语言，这个特点是Java语言的一个缺点。（F）2．Java源程序的文件名一定要与文件中某个类的名称一致。（T） 3．Java语言采用面向对象的思想编程，具有跨平台、分布式、多线程等优点。（T） 4．Java中的标识符和关键字都是区分大小写的，如果把声明类的class写成Class或者CLASS，编译会出错。（T） 5．Java源程序编写好之后，以文件的形式保存在硬盘或U盘上，源文件的名字可以随便取，它不一定与程序的主类名一致。（F） 6．在JDK命令行开发工具中，用编译程序javac.exe编译生成的文件是二进制可执行文件。（F） 7．Java程序可以分为Java Application和Java Applet两类。（T） 8.Java虚拟机可以在Microsoft Windows系列、Linux、UNIX、Mac OS等操作系统下执行Java字节码程序。（T） 9．javac是Java编译器，用来将Java源程序编译成Java字节码的程序。字节码文件名和源文件名相同，扩展名是class。（T） 10．appletviewer是Java小应用程序（Applet）浏览器，可以执行HTML文件 中的JavaApplet。它是个模拟浏览器，可以显示Applet的运行结果。（T） 二、选择题 1．Java工具JDK中用来运行Applet程序的命令是（D）。 A.java B.javac C.applet D.appletviewer 2．列说法不正确的是（B）。 A.一个Java源程序经过编译后，得到的文件扩展名一定是class B.一个Java源程序编译通过后，得到的结果文件数也只有一个 C.一个Java源程序编译通过后，得到的结果文件数可能有多个 D.一个Java源程序编译通过后，不一定能用Java解释器执行 3．编译Ja源程序文件将产生相应的字节码文件，这些字节码文件的扩展名为（B）。 A.java B.class C.html D.exe 4．安装JDK时，为了能方便地编译和运行程序，应该设置环境变量变量的名称是（C）。 A.JAVAHOME B.java C.path C.classpath 5．Java编译程序的文件名是（C）。 A.java.exe 第一章 1.Java语言的特点和优势：Java:一种简单的，面向对象的，分布式的，解释型的，强壮的，安全的，体系结构中立的，可移植的，高性能的，多线程的，动态的语言。 2.Java虚拟机及Java的跨平台原理 JVM(虚拟机)的运行过程： 1）代码的装入 2) 代码的校验 3) 代码的执行(有两种方式) (1)即时编译方式(JIT)：解释器先将字节码编译成机器码，然后再执行该机器码。 (2)解释执行方式：解释器通过每次解释并执行一小段代码来完成Java字节码的所有操作。 3、Windows下JDK的安装： 安装目录： bin目录中常用命令介绍 －javac.exe：Java源文件编译工具 Javac Hello。Java －java.exe：Java字节码解释程序 Java Hello 4、Path设置 C:\Java\jdk1.6.0_14\lib\tools.jar； C:\Java\jdk1.6.0_14\lib/dt.jar； 5、Classpath设置 classpath=.;c:\myjava； 6、用记事本编写java程序源代码 public class HelloWorld { public static void main(String[] args) { System.out.println(“Hello World!”); } } 7、Applet没有main()方法作为Java解释器的入口，我们必须编写HTML文件，将Applet 嵌入其中，然后用支持java的浏览器或者appletviewer来运行。 第二章 1、Java是严格区分大小写的 例：不能将class写成Class。Boy和boy是不同的标识符。 Java是一种自由格式的语言 程序代码分为结构定义语句和功能执行语句。 功能执行语句的最后必须用分号（;）结束。 一条语句可以写在若干行上。可以任意编排。 单词、字符串不能分开写在两行上，注意中英文标点 2、Java中的标识符 标识符是用来标识类、变量名、方法名等的有效字符序列。 －凡是自己可以起名字的地方都叫标识符，都遵守标识符的命名规则。 Java标识符命名规则 ?－标识符由字母、数字、下划线“_”和美元符“$”组成。 ?－标识符应以字母、下划线“_”和美元符“$”开头。 ?－Java标识符对大小写敏感，长度无限制。 ?－Java标识符取名应做到“见名知意”，且不能与Java语言的关键字重名。不能以数字开头 3、Java中的标识符 Java约定： ―类名的首字母大写。 ―变量名和方法名的首字母小写。 ―常量名全部字母大写。 ―运用驼峰标识。 Java语言程序设计及试题答案 一、单选题（共20分，每小题1分） 1、下面哪一个不是java语言的特点（）。 （A）面向对象（B）安全性高 （C）与平台无关（D）复杂多变 2、下面的哪一个标识符是合法可用的（）。 （A）2abcd （B）int （C）var# （D）abcd123 3、在基本数据类型中，整型（int）位长为（）。 （A）8 （B）16 （C）32 （D）64 4、Java中的所有对象都是在运行时动态创建的，创建新对象可用的关键字为（）。（A）new （B）string （C）byte （D）true 5、继承是指新的类获得已有类的属性和行为，称新类为已有类的（）。 （A）子类（B）父类（C）对象（D）实体 6、读下面的程序： public _______clock { int hour; int minute; int second; public void settime （int newh, int newm,int news） {hour=newh; minute=newm; second=news; } } 划线位置应选择的关键字为（）。 （A）new （B）class （C）system （D）out 7、读下面的三个程序段： public class Circle { int radius; } public class Rectangle{ double width=10.128; double height=5.1245; } public （7）ShaperTester { public static void （8）（String args[]）{ Circle x; Rectangle y; x=（9）Circle（）; y=（9）Rectangle（）; System.out.println（x+””+y）; } 1、简述java语言的特点? 1.2 Java语言是目前使用最为广泛的网络编程语言之一 (1分) 具有面向对象 (1分) 与平台无关性 (1分) 多线程性 (1分) 动态性等特点 (1分) 2、简述Java程序的开发过程？ 1.3 （1）使用一个文字编辑器，编写源文件。（1分） （2）使用java编译器，编译源文件得到字节码文件。（2分） （3）运行java程序，分两种java应用程序必须通过java解释器来解释执行，java小应用程序必须使用解释器和浏览器运行程序。（2分） 3、 java源文件的命名规则是什么？ 1.3 如果源文件中有多个类，那么只能有一个类是public类（1分） 如果有一个类是public类，源文件的名字必须与这个类的名字完全相同，扩展名是java （2分） 如果源文件没有public类，源文件的名字只要和某个类的名字相同，并且扩展名是java （2分） 4、怎样区分应用程序和小应用程序？ 1.4 一个java应用程序必须且只有一个类含有main方法,这个类称为应用程序的主类，其main方法必须被说明为public static void (2.5分) 一个Java Applet小应用程序不再需要main方法，但必须有一个类扩展了Applet类，即它是Applet类的主类。（2.5分） 5、 Java中共有哪些基本数据类型？ 2.2 基本类型共有8种，分四类分别是（1分） 逻辑型（1分） 字符型（1分） 整型（1分） 浮点型（1分） 6、 Java中数据类型分别用什么符号来表示的？ 2.2 逻辑型用boolean 表示（1分） 字符型用char表示（1分） 整型共有4种分别是 byte、short、long、int （2分） 浮点型共两种float和double （1分） 7、简答标示符的概念及定义原则？ 2.1 标示符是用来标识类名、变量名、方法名、类型名等有效字符序 1.1java语言主要有以下特点：1.强类型。 2.编译和解释：java语言是一种高级编程语言，用 java语言编写的源程序在计算机上运行需经过编译和解释执行两个严格区分的阶段。3. 自动无用内存回收功能。4.面向对象。5.与平台无关。6.安全性。7.分布式计算。8.多线程。 1.2Java程序的执行过程：Java的编译程序先将java源程序翻译成与机器无关的字节码 （bytecode），运行时，java的运行系统装载和链接需要执行的类，并做必要的优化后，解释执行字节码程序。 1.3Java程序的跨平台主要是指字节码文件可以在任何具有Java虚拟机的计算机或者电子设 备上运行。 1.4这两种程序的主要区别是：小应用程序只能在与java兼容的容器中运行，可以嵌入在 HTML网页内，在网络上发布，当网页被浏览时，在浏览器中运行。小应用程序的运行还受到严格的安全限制，例如，它不能访问用户计算机上的文件。Java应用程序没有这些限制，也不支持网页嵌入和下载运行。java小应用程序和应用程序在代码编写上也有很大的差异。一个小应用程序必须定义成一个Applet类的子类，应用程序可以是Applet 类的子类，也可以不是。应用程序必须在一个类中定义一个main（）方法，该方法代表应用程序的入口。而小应用程序不必定义main（）方法，它的执行由Applet类中定义的多个方法控制。 1.5javac命令编译Java程序，java命令执行Java程序 4、合法标识符：Applet ,miles, Test,apps、x、y 、$4、radius；java关键字：class、public、 int 5、符号常量的好处主要在于两个方面： 一方面，标识往往有一定的含义，所以符号常量比字面常量含义更清楚； 二方面：修改符号常量值比逐个修改字面常量的值要方便得多，也因此而减少了同一常量其值不一致的机会。 值为20的int型常量：final int SIZE =20; Java语言的工作原理及特点 1. Java是一门怎样的语言 Sun公司出品了Java，它对Java语言有专门的描述： “Java is a simple, object-oriented, distributed, interpreted, robust, secure, architecture neutral, portable, high-performance, multithreaded, and dynamic language.” 它告诉你Java是简单的、面向对象的、分布式的、解释的、健壮的、安全的、结构中立的、轻便的、高性能的、多线程的动态语言。所有这些形容词恰恰指明了Java语言的特点和工作原理。 2. 跨平台特性 关于Java程序，有一句口号式的经典描述—“Write once, Run anywhere”，其中文意思是“一次编写，到处运行”。这指的正是Java语言跨平台的特性。 Java源代码被编译成一种结构中立的中间文件格式，在机器上能直接执行这种中间代码，不管机器是什么型号的，操作系统是哪种。但有一个必要的前提：那台运行Java程序的机器上需要预先安装Java运行系统。Java运行系统又称为Java虚拟机（简称JVM），它可以从https://www.360docs.net/doc/9d5972194.html,网站免费下载，不同的操作系统需要安装对应的JVM版本。而Java 的跨平台特性即通过JVM实现。 图1-1演示了Java程序的跨平台特性。 图1-1 “一次编写，到处运行” 3. 完全面向对象 Java语言是一门面向对象的语言，它比C++等语言新，一张白纸上可以画最美好的图画，20世纪90年代初它就是这样一张白纸，以James Gosling为首的Green项目团队给它画的那幅画是完全面向对象，一切皆为对象。 什么是对象呢？对象是可存储数据的变量和可提供操作的方法的集合。对象的核心就是两项：变量和方法。每个对象在内存中都占据独立的空间，每个对象都拥有类型，对象从类型创建而来。 在本书中，面向对象程序设计从第二篇开始细述。 4. 多线程 Java中提供了专门的类，可方便地用于多线程编程。 多线程是这样一种机制，它允许在程序中并发执行多个指令流，每个指令流都称为一个线程，彼此间互相独立。 多线程的程序可同时执行多个任务，多线程程序具有更好的交互性、实时性。 5. 内存垃圾自动回收 在C++中，对象所占的内存在程序结束运行之前一直被占用，在明确释放之前不能分配给其他对象；而在Java中，JVM的一个系统级线程可以监督对象，它可以发现对象何时不再被使用，原先分配给该对象的内存即成为了垃圾，JVM系统线程会释放该内存块，对象即被销毁，内存垃圾就被自动回收。 事实上，除了释放没用的对象，Java垃圾收集也可以清除内存碎片。JVM将经过碎片整理后的内存分配给新的对象。 6. 简洁有效 Java语言的语法大多基于C++，但Java更加严谨、简洁。这体现在如下方面： Java去除了C++中一些难以理解、容易混淆的因素，如头文件、指针、结构体等；避免了赋值语句与逻辑运算语句的混淆；避免了隐藏变量带来的困惑，如“if(a = 3)…;”，在C++中是没问题的，而在Java中是错误的；取消了多重继承这一复杂的继承机制。 Java提供了对内存的自动管理：内存分配、内存释放。 Java提供了丰富的类库，有利于软件开发的高效和标准化。 7. 健壮且安全 简述Java语言的特点 1、Java语言是简单的 Java 语言的语法与C语言和C++语言很接近，使得大多数程序员很容易学习和使用Java。另一方面，Java丢弃了C++中很少使用的、很难理解的、令人迷惑的那些特性，如操作符重载、多继承、自动的强制类型转换。特别地，Java语言不使用指针，并提供了自动的废料收集，使得程序员不必为内存管理而担忧。 2、Java语言是一个面向对象的 Java 语言提供类、接口和继承等原语，为了简单起见，只支持类之间的单继承，但支持接口之间的多继承，并支持类与接口之间的实现机制（关键字为implements）。Java语言全面支持动态绑定，而C++语言只对虚函数使用动态绑定。总之，Java语言是一个纯的面向对象程序设计语言。 3、Java语言是分布式的 Java 语言支持Internet应用的开发，在基本的Java应用编程接口中有一个网络应用编程接口（java net），它提供了用于网络应用编程的类库，包括URL、URLConnection、Socket、ServerSocket等。Java的RMI(远程方法激活)机制也是开发分布式应用的重要手段。 4、Java语言是健壮的 Java的强类型机制、异常处理、废料的自动收集等是Java程序健壮性的重要保证。对指针的丢弃是Java的明智选择。Java的安全检查机制使得Java 更具健壮性。 5、Java语言是安全的 Java 通常被用在网络环境中，为此，Java提供了一个安全机制以防恶意代码的攻击。除了Java语言具有的许多安全特性以外，Java对通过网络下载的类具有一个安全防范机制（类ClassLoader），如分配不同的名字空间以防替代本地的同名类、字节代码检查，并提供安全管理机制（类SecurityManager）让Java应用设置安全哨兵。 Java的特点 1).可移植性 可移植性，又称跨平台性、平台无关性、或者“一次编写，处处运行”，可以说是Java 语言最为闪光的特点，在任何场合介绍Java语言，都少不了介绍这一特征。可移植性的意思是开发Java应用，无需为不同平台开发不同的程序，只要开发一次，就可以在任何平台运行。 2).面向对象的语言 Java是一门面向对象OO（Object Oriented）的语言，也就是说，Java程序都是以对象作为基本组成单元。面向对象语言都有三大特征：封装、继承、多态。 3).自动垃圾回收 本子相当于硬盘，时不时可以翻看一下；脑袋相当于内存，太满了就塞不下了；而这里的垃圾回收就是释放那些不再使用的数据所占用的内存。 众所周知，内存的有效使用对于程序设计是非常重要的。对于不再被使用的数据，就应该及时释放其占据的内部，以提高内存使用效率，被称为“垃圾回收”。Java语言的垃圾回收采用后台线程自动完成，不需要程序员通过代码完成，称为“自动垃圾回收”。后台线程将跟踪并检查内存使用情况，对于不再被引用的数据，自动进行内存释放。然而，值得注意的是，虽然Java语言有自动垃圾回收机制，但是并不能保证不会出现内存泄露的问题。如果源代码的结构或算法等有问题，也同样可能出现内存泄露。 4).鲁棒性 鲁棒性又称健壮性（Robustness）。Java在编译和运行时，都要对可能出现的问题进行检查，以消除错误的产生。Java提供自动垃圾回收机制来进行内存管理，防止程序员在管理内存时容易产生的错误；通过异常处理机制，帮助程序员正确地处理异常，以防止系统的崩溃。 5).简单性 Java语言取消了指针，内存管理通过后台线程自动进行，不再使用goto语句，不支持多继承。这些特性都保证了Java的简单性。 第1xxJava语言概述 一、判断题 1．Java语言是一种解释执行的语言，这个特点是Java语言的一个缺点。（F） 2．Java源程序的文件名一定要与文件中某个类的名称一致。（T） 3．Java语言采用面向对象的思想编程，具有跨平台、分布式、多线程等优点。 （T） 4．Java中的标识符和关键字都是区分大小写的，如果把声明类的class写成Class或者CLASS，编译会出错。（T） 5．Java源程序编写好之后，以文件的形式保存在硬盘或U盘上，源文件的名字可以随便取，它不一定与程序的主类名一致。（F） 6．在JDK命令行开发工具中，用编译程序javac.exe编译生成的文件是二进制可执行文件。（F） 7．Java程序可以分为Java Application和Java Applet两类。（T） 8.Java虚拟机可以在MicrosoftWindows系列、Linux、UNIX、MacOS等操作系统下执行Java字节码程序。（T） 9．javac是Java编译器，用来将Java源程序编译成Java字节码的程序。字节码文件名和源文件名相同，扩展名是class。（T） 10．appletviewer是Java小应用程序（Applet）浏览器，可以执行HTML文件中的JavaApplet。它是个模拟浏览器，可以显示Applet的运行结果。（T） 二、选择题 1．Java工具JDK中用来运行Applet程序的命令是（D）。 A.java B.javac C.applet D.appletviewer 2．列说法不正确的是（B）。 A.一个Java源程序经过编译后，得到的文件扩展名一定是class B.一个Java源程序编译通过后，得到的结果文件数也只有一个 C.一个Java源程序编译通过后，得到的结果文件数可能有多个 D.一个Java源程序编译通过后，不一定能用Java解释器执行 3．编译Ja源程序文件将产生相应的字节码文件，这些字节码文件的扩展名为（B）。 A.java B.class C.html D.exe 4．安装JDK时，为了能方便地编译和运行程序，应该设置环境变量的名称是（C）。 A.JAVAHOME B.java C.path C.classpath 5．Java编译程序的文件名是（C）。Java语言的特点和实现机制
java语言特点
1 Java语言概述答案
Java语言的特点和优势
Java语言程序设计 及 试题答案
Java语言程序设计(一)复习资料--Java简答题
java语言主要有以下特点
Java语言的工作原理及特点
简述Java语言的特点
Java语言的特点
1 Java语言概述答案