java面向对象编程、类的封装、接口和基本类库练习题
面向对象编程基本知识练习
一、判断题
1.不需要定义类，就能创建对象。（）
2.构造方法用于给类的private 实例变量赋值。（）
3.对象一经声明就可以立即使用。（）
4.在定义变量和方法时，必须清楚地在其面前标上访问权限修饰符。（）
5.Java 程序中的参数传递都是把参数值传递给方法定义中的参数。（）
6.在类定义中，成员访问权限修饰符不能多次出现。（）
7.new 操作符动态地为对象按其指定的类型分配内存，并返回该类型的一个引用。（）
8.类的方法通常设为public，而类的实例变量一般也设为public。（）
9.构造方法在创建对象时被调用。（）
10.通过点运算符与类对象的引用相连，可以访问此类的成员。（）
11.声明为protected 的类成员只能被此类中的方法访问。（）
12.同一个类的对象使用不同的内存段，但静态成员共享相同的内存空间。（）
13.类的成员变量可以放在类体的任意位置。（）
14.声明为protected 的类成员可以被此类作用域中的任何对象访问。（）
15.没有返回值的方法可以用void 来表示，也可以不加。（）
二、选择题
1. 下面对对象概念描述错误的是：( )
A 操作是对象的动态属性
B 任何对象都必须有继承性
C 对象间的通讯靠消息传递
D 对象是属性和方法的封装体
2．编译并运行下面的程序，运行结果为：( )
public class A
{
public static void main(String[] args)
{
A a=new A()；
a.method(8)；
}
void method(int i)
{
System.out.println(“int：“+i)；
}
void method(long i)
{
System.out.println(“long：“+i)；
}
}
A 程序可以编译运行，输出结果为int：8
B 程序可以编译运行，输出结果为long：8
C 程序有编译错误，因为两个method()方法必须定义为静态(static)的
D 程序可以编译运行，但没有输出
3．下面关于类的说法不正确的是：（）
A 类是Java 语言中的一种复合数据类型
B 类中不包含数据变量和方法
C 类是对所有具有一定共性的对象的抽象
D Java 语言的类只支持单继承
4．能作为类及其成员的修饰符是：（）
A interface
B class
C protected
D public
5．设x、y 均为已定义的类名，下列声明对象x1 的语句不可能正确的是：（）
A public x xl=new y();
B public y xl=new x();
C x xl=new x();
D x xl=x();
6．面向对象程序设计技术的特点是：（）
A 可重用性
B 可维护性
C 表示方法的一致性
D 可重用性、可维护性、表示方法的一致性
7．下列方法定义中，方法头不正确的是：（）
A public static x(double a){…}
B public static int x(double y){…}
C void x(double d)
D public int x(){…}
8．设已声明了一个类A 的两个对象al、a2，为了初始化a1 和a2，下面语句正确的是：（）
A al=new(); a2=new();
B al=A new(); a2=A new();
C al,a2=new A();
D al=new A(); a2=new A();
9．构造方法何时被调用?（）
A 类定义时
B 使用对象的变量时
C 调用对象方法时
D 创建对象时
10．下列哪个类声明是正确的?（）
A public abstract class Car{…}
B abstract private move(){…}
C protected private number;
D abstra ct final class Hl{…}
11．下列不属于面向对象程序设计的基本特征的是：（）
B 封装
C 继承
D 静态
12．请看下面的程序段
class Person {
String name,department;
int age;
public Person(String n) { name = n; }
public Person(String n,int a) { name = n; age = a; }
public Person(String n,String d,int a) {
//doing the same as two arguments version of constructer
//including assignment name=n,age=a
}
}
下面那一选项可以添加到“//doing the same……”处：（）
A Person(n,a)
B this(Person(n,a))
C this(n,a)
D this(name.age)
13．（）是一个特殊的方法，用于对类的实例变量进行初始化。
A 终止函数
B 构造函数
C 重载函数
D 初始化函数
14．关于变量和它们范围的说法，正确的是：（）
A 实例变量是类的成员变量
B 实例变量要用关键字static 来声明
C 在一个方法执行时，定义在该方法的局部变量才被创建
D 局部变量必须在它们使用前初始化
15．请看下面的程序段
class Test{
private int m;
public static void fun(){
//some code…
}
}
方法fun()如何来访问变量m：（）
A 将private int m 改成protected int m
B 将private int m 改成public int m
C 将private int m 改成static int m
D 将private int m 改成int m
16．在Java 中，方法main()将返回一个（）值。
A String
C char
D void
17．有一个类A，对于其构造函数的声明正确的是（）
A void A(int x){…}
B pub lic A(int x){…}
C A A(int x){…}
D int A(int x){…}
18．请看下面的程序段
public class Test {
long a[ ] = new long[10];
public static void main(String arg[ ]) {
System .out .println(a[6]);
}
}
那一个选项是正确的：（）
A 不输出任何内容
B 输出0
C 当编译时有错误出现
D 当运行时有错误出现
19．关键字（）表明一个对象或变量在初始化后不能修改。
A extends
B final
C this
D finalizer
20．声明为static 的方法不能访问（）类成员。
A 超类
B 子类
C 非static
D 用户自定义类
类的封装练习
一、判断题
1.在子类中可以用完全相同的signature 重新定义一个超类方法，这称为方法的覆盖（override）。（）
2.final 修饰的方法是不能被子类覆盖的，只能被重载。（）
3.声明为final的类不能是超类。（）
4.当一个超类成员不适合该子类时，子类会以恰当的方式重新定义它。（）
5.对子类实例化对象需要调用超类的构造函数进行初始化工作，完成对子类中的超类实例变量的初始化，则子类可以继承超类的构造函数。（）
6.在类的定义中如果不明确给出超类，那么默认超类就是Object 类。（）
7.protected 类型的实例变量或方法只能由声明该变量或方法的类本身及其子类访问。（）
8.Java 的每个子类的构造函数都要显式的调用它的直接超类的构造函数。（）
9.超类对象的集合通常比它的任何一个子类对象集合大。（）
10.子类可以从多个超类中派生出来。（）
二、选择题
1．为了区分重载多态中同名的不同方法，要求：（）
A 参数名不同
B 返回值类型不同
C 采用不同的形式参数列表
D 选项A B C 都对
2．在某个类中定义一个方法：void GetSort(int x)，以下关于能否作为这个方法的重载错误的是：（）
A void GetSort(float x){x*=x;}
B int GetSort(double y){ return(int)(2*y); }
C double GetSort(int x,int y){return x+y; }
D 都不能
3．下列对继承的说法，哪个是正确的：（）
A 子类只能继承父类public 方法和状态
B 子类能继承父类的非私有方法和状态
C 子类能继承父类的所有方法和状态
D 子类只能继承父类的方法，而不继承状态
4．定义类A 如下：
class A
{ int a,b,c;
public void B(int x,int y,int z){a=x; b=y; c=z; }
}
下面对方法B()的重载哪些是正确的：（）
A public void A(int xl,int yl,int z1){ a=x; b=y; c=z; }
B public void B(int x1,int yl,int z1){ a=x; b=y; c=z;}
C public void B(int x,int y){ a=x; b=y; c=0;}
D public B(int x,int y,int z){a=x; b=y; c=z; }
5．下列程序的结果输出为：（）
class Strange{
int j;
Strange(){
this(4);
}
Strange(int j){
this.j=j;
}
}
class MainStrange{
public static void main(string[] args){
Strange funny=new Strange();
System.out.println(“j=“+funny.j);
}
}
A j=2
B j=4
C j=6
D j=7
6．下列说法正确的是：（）
A Java 中允许一个子类有多个父类
B 某个类是一个类的子类，它仍有可能成为另一个类的父类
C 一个父类只能有一个子类
D 继承关系最多不能超过4 层
7．下列说法正确的是：（）
A 子类只能覆盖父类的方法，而不能重载
B 子类只能重载父类的方法，而不能覆盖
C 子类不能定义和父类同名同形参的方法，否则，系统将不知道使用哪个方法。
D 重载就是一个类中有多个同名但不同形参和方法体的方法
8．关于构造函数的说法正确的是：（）
A 一个类只能有一个构造函数
B 一个类可以有多个不同名的构造函数
C 构造函数与类同名
D 构造函数必须自己定义，不能使用父类的所有构造函数
9．下面是有关子类调用父类构造函数的描述正确的是：（）
A 子类定义了自己的构造函数，就不会调用父类的构造函数
B 子类必须通过super 关键字调用父类有参数的构造函数
C 如果子类的构造没有通过super 调用父类构造函数，那么子类会先调用子类自己的构造函数，再调用父类不含参数的构造函数。
D 创建子类的对象时，先调用子类自己的构造函数，然后调用父类的构造函数
10．构造方法何时被调用? （）
A 类定义时
B 使用对象的变量时
C 调用对象方法时
D 创建对象时
11．如果超类不允许其通过继承的方式产生的子类访问它的某些成员，那么它必须以什么方式声明该成员。（）
A public
B private
C rotected
D static
12．声明为final 的变量不能在子类中覆盖，声明为（）和（）的方法是隐式的final。（）
A public private
B private protected
C protected static
D static private
13．继承性使▁▁成为可能，它不仅节省开发时间，而且也鼓励人们使用已经验证无误和调试过的高质量软件。（）
A 节省时间
B 软件复用
C 软件管理
D 延长软件生命周期
14．编译运行下面的程序，结果是（）。
Public class A
{
public static void main(String[] args)
{
B b=new B();
b.test();
}
void test()
{
System.out.print(“A”);
}
}
class B extends A
{
27 void test()
{
super.test();
System.out.println(“B”);
}
}
A 产生编译错误
B 代码可以编译运行，并输出结果：AB
C 代码可以编译运行，但没有输出
D 编译没有错误，但会产生运行时异常
15．已知类关系如下：
class Employee;
class Manager extends Employeer;
class Director extends Employee;
则以下语句正确的是：（）
A Employee e=new Manager();
B Director d=new Manager();
C Director d=new Employee();
D Manager m=new Director();
16．一个▁▁类的对象可以当作相应的▁▁类对象看待。（）
A 子系统
B 用户系统
C 子超
D 超用户
17．哪个方法是对如下方法的重载？（）
public void example(){...}
A public void example( int m){...}
B public int example(){...}
C public void example2(){...}
D public int example ( int m, float f){...}
18、被声明为private，protected 及public 的类成员，在类外部：（）
A 只能访问到声明为public 的成员
B 只可能访问到声明为protected 和public 的成员
C 都可以访问
D 都不能访问
19、现有两个类A、B，以下描述中表示B 继承自A 的是（）
A class A extends B
B class B implements A
28 C class A implements
D class B extends A
20、设类B 是类C 的父类，下列声明对象x1 的语句中不正确的是（）
A C x1=new B()；
B B x1=new C()；
C C x1=new C()；
D B xl=new B()；
三、简述题
1．方法的重载和覆盖有什么区别？
2．简述超类和子类的关系。
3．在方法体中可以使用this 和super 关键字，其意义是什么，在什么情况下使用？4．试分清“是一个”关系和“有一个”关系。
5．调用构造方法遵循什么规则？
6．要使一个类的多个对象具有不同的初始状态，应如何实现？
接口和基本类库练习题
一、判断题
1．Java 中的类和接口都只支持单重继承。（）
2．由于Java 中类只支持单重继承，所以一个类只能继承一个抽象类和实现一个接口。（）3．内部类始终可以访问外部类。（）
4．对于一个抽象类，改变它的属性和方法一定会改变它所有子类的属性和方法。（）5．一个类可以实现抽象类的所有方法，也可以只实现部分方法，但实现部分方法的类仍然是一个抽象类。（）
6．在实现接口的时候，要实现所有方法。（）
7．接口其实是一个特殊的abstract class。（）
8．一个接口不可以继承其他接口。（）
二、选择题
1．下面有关接口的说法，哪个是正确的?（）
A 接口与抽象类是相同的概念
B 一个类不可实现多个接口
C 接口之间不能有继承关系
D 实现一个接口必须实现接口的所有方法
2、在使用interface 声明一个接口时，可以使用（）修饰符修饰该接口。
A private
B protected
C private or protected
D public
3．下列哪个不是属于接口用途的？（）
A 通过接口可以实现不相关类的相同行为
B 通过接口可以指明多个类需要实现的方法
C 通过接口可以了解对象的交互界面
D 通过接口可以了解对象所对应的类
5．虽然接口和抽象类不能创建对象，但它们的对象引用仍可指向该类型的对象。这种说法（）
A 正确
B 不正确
C 不能确定
D 接口和抽象类不能说明其对象引用
6．下面哪个类包括drawImage( )方法、drawString( )方法和setColor( )方法。（）
A java .awt .Applet
B java .awt .Image
C java .awt .Graphics
D java .util .Date
7．接口中说明了一组公共的抽象方法，其中是否包含公共的静态方法？答案是（）
A 可以
B 不可以
C 不能肯定
D 因静态方法不能被改写，故不能出现在接口中
8．接口是Java 面向对象的实现机制之一，以下说法正确的是：（）
A Java 支持多重继承，一个类可以实现多个接口
B Java 只支持单重继承，一个类可以实现多个接口
C Java 只支持单重继承，一个类只可以实现一个接口
D Java 支持多重继承，但一个类只可以实现一个接口
9．关于接口的定义和实现，以下描述正确的是：（）
A 接口定义中的方法都只有定义没有实现
B 接口定义中的变量都必须写明final 和static
C 如果一个接口由多个类来实现，则这些类在实现该接口中的方法时应采用统一的代码
D 如果一个类实现一个接口，则必须实现该接口中的所有方法，但方法未必声明为public 11．声明接口的保留字是（）
A interface
B protect
C final
D static
13．下面的接口（类）定义正确的是：（）
A
public class A
{
private int x;
public getx()
{ return x; }
}
B
public abstract class A
32 {
private int x;
public abstract int getx();
public int amethod()
{ return 0; }
}
C
public class A
{
private int x;
public abstract int getx();
}
D
public interface Interfacea
{
private int x;
public int getx()
{ return x; }
}
14．接口具有下面的特性。（）
A 多重继承
B 不可继承
C 抽象性
D 嵌套
15．定义一个包的关键字是（）。
A import
B package
C interface
D protected
16．下列选项中，用于在程序开头引入包的关键字是（）。
A import
B implements
C integer
D protected
17．以下语句输出的结果是（）。
System.out.println(Math.floor(-0.8));
A 0
B -1
33 C -0.8
D 0.8
18．下面的程序段执行后，变量a、b、c 的值分别是（）。
int a,b,c;
a=(int)Math.round(-4.51);
b=(int)Math.ceil(-4.51);
c=(int)Math.floor(-4.1);
A -5, -4, -5
B -4,-4,-5
C -5,-5,-5
D -4,-4,-4
19．下面（）说法不正确。
A 如果某公共的接口被声明在一个源文件中，则接口必须与源文件具有相同的名字
B 如果源文件包含import 语句，则该语句必须是除空行和注释行外的第一个语句行
C 如果某源文件包含package 语句，则该语句必须是第一个非空、非注释行
D 接口中的方法不一定是抽象方法，所以可以不用关键字abstract 修饰
JAVA类与对象及数组习题及复习资料
JA V A类和对象及数组习题 一、选择题 （1）下列构造方法的调用方式中，正确的是（ D ）--原因：在通过new实例化一个类对象时系统会自动调用该类相应的构造方法。 A．按照一般方法调用B．由用户直接调用 C．只能通过new自动调用D．被系统调用 （2）在Java中，能实现多重继承效果的方式是（ C ）--原因：一个类可以同时实现多个接口。Java接口反映了对象较高层次的抽象，还弥补了Java只支持单继承的不足，可用它来完成多继承的一些功能。 A．内部类B．适配器C．接口D．同步 （3）int型public成员变量MAX_LENGTH，该值保持为常数100，则定义这个变量的语句是( D )—原因：java中定义常量用关键字final来定义。 A．public int MAX_LENGTH=100 B．final int MAX_LENGTH=100 C．public const int MAX_LENGTH=100 D．public final int MAX_LENGTH=100 （4）下列叙述中，正确的是( A )—原因：Java严格区分大小写，所以变量number 与Number不相同；Java 中的注释方式除了“//”行注释之外还有段注释“/*-------*/”和文档注释/**-------*/。Java源文件中的public类只能有一个。 A. 声明变量时必须指定一个类型 B. Java认为变量number与Number相同 C. Java中唯一的注释方式是"//" D. 源文件中public类可以有0或多个 （5）下列叙述中，错误的是( D )—原因：子类继承父类，并且可以有自己的成员变量和成员方法。所以可以认为子类是父类的扩展。
实验2：Java面向对象程序设计
实验2：Java面向对象程序设计（一） 实验目的 ●掌握类的定义；掌握构造方法的使用；掌握对象的创建。 ●掌握静态变量与静态方法的使用；了解静态变量和成员变量的区别。 ●熟悉访问修饰符的作用；掌握访问修饰符的使用方法。 ●掌握方法的重载；掌握访问器get/set方法。 实验步骤 一、类和对象的创建 1.创建一个圆类，成员变量有半径radius和圆周率pi，提供计算圆面积的方法，并在main方法中创建圆类的对象，调用其计算面积的方法进行测试。 2.编写上述代码，编译运行代码，查看程序执行结果。 ●试述程序中两个类的各自作用。 ●类Circle都封装了什么？求圆面积的初始数据是通过哪个方法实现的？请修改程序采用构造函数的方法初始化数据。 ●类Circle是如何声明的？在类中都声明了什么？在主函数中是如何创建Circle类对象的？ 二、静态变量和静态方法的设计 （一）.静态变量和实例变量练习 1.创建一个类，类名为StaticVariableTest，包含static变量和实例变量，类型为int型，在main方法中分别调用这2个变量并且输出结果。 2.部分源代码如下： 3.将上述代码中的main方法补充完整后，编译运行代码，查看程序执行结果。 ●根据完善后的源码，分析调用静态变量和实例变量有什么不同？ （二）.静态方法和实例方法练习 1.创建一个类，类名为StaticMethodTest，包含一个静态方法和一个实例方法，在main方法中分别调用这个两个方法进行测试。 2.部分源代码如下：
3.将上述代码中的main函数补充完整，编译运行代码，查看程序执行结果。 ●根据完善后的源码，分析如何调用静态方法和实例方法？ 三、访问修饰符与方法的重载 （一）.访问修饰符练习 1.创建一个Person类，在该类中用不同的访问修饰符设立不同的person属性，再创建一个PersonTest类，包括main方法，在此类中分别访问Person类中各个属性。 2.源代码如下： 3.先填写下面的表格，在预测结果中，如果能打印输出，填写程序输出结果，否则填“N”。 ●记录程序运行结果。 表4-3-1预测和验证结果 4.编写上述代码，编译运行代码。在上表中填写程序验证结果。 ●访问private变量时，编译会出现什么问题，为什么？ ●通过什么方式能访问private变量？编程实现访问Person类中的private变量。
JAVA基础-第3章类与对象-练习题-200910
第3章类与对象 一．选择题 1.下列不属于面向对象编程的特性是（D）。 A．封装性 B. 继承性 C. 多态性 D. 编译执行 2.下列类的声明中不合法的是（C）。 A. class People{…} B. class 植物{…} C. Class A{…} D. public class 共有类{… 3.下列方法的声明中不合法的是（C）。 A. float area(){…} B. void area(){…} C. double area(d){…} D. int area(int r){…} 4. 下列构造方法（构造器）的调用中正确的是（C）。 A. 按照一般的方法调用 B. 由用户直接调用 C. 只能通过new自动调用 D. 被系统调用 5.下列程序运行的结果是（A）。 class Book{ int width; int length; } public class A{ static void f(Book p){ p.width=20; p.length=40; } public static void main(String args[]){ Book b=new Book(); b.width=10; b.length=20; f(b); System.out.print(" "+b.width); System.out.print(" "+b.length); } } A. 20 40 B. 10 40 C. 10 20 D. 以上都不对 6.下列程序运行的结果是（D）。 public class A{ static void f(int y){ y=y+10; } public static void main(String args[]){ double x=10; f(x); System.out.println(x); } }
完成Java面向对象程序设计实验课的心得体会范文
Java面向对象程序设计实验课的心得体会经过这几周对Java面向对象程序设计的学习，让我更加了解到Java学习的重要性。 在实验课上，我们完成多个实验，在这个阶段的学习中，我从认识到熟悉，而后到能够自主运用。通过对Java的了解，我发现它确实有很多方便之处，它集抽象性、封装性、继承性和多态性于一体，实现了代码重用和代码扩充，提高了软件开发的效率。对于我们这个专业来说学好Java语言是很重要的，所以在实验的过程中我都尽力理解java编程思想、掌握基本技巧，尽量学到最多的知识。 学习程序设计的基本目的就是培养描述实际问题的程序化解决方案的关键技能，Java面向对象程序设计是一门实践性比较强的课程，在实际中，我们必须把理论和实践结合起来。在实验中，我们理解理论课上的知识，然后运用到实际的操作中，我们必须在现有的理论的基础上，进行实践。多次实验后，也让我看到了现在学习的一个很大弱点：只听不练，永远不会熟练运用；空记技巧，忽略思想，会在多变的习题中十分无奈。 Java思想：Java是一门面向对向语言，他定义一切都是对象面向对象，就是面对现实； 现实中的一切都是对象，他们有分类，就产生了“类”； 他们有不同，类和类之间的不同，使用类来区分； 同一个类中不同的对象的区别，使用成员区分。
所以，面向对象的内部逻辑是分类。 面向对象编程思想就象数学上的一些概念，如：空间、群、环、域等 原始的编程思想就象古典数学，人们只在一个集合上探讨问题，没有系统的方法（即运算）定义，于是仁者见仁、智者见智，这样在一定程度上造成了理论的一种混乱局面，不利于科学的发展。于是近代数学向公理化发展，这是什么意思呢？就是说，人们除了在限定论域（即上面的集合，面向对象也有此概念）外，还在此论域上加进了一套通用的、公认的运算（方法）；集合加上集合上定义的运算就构成了数学上的空间、群等，在计算机领域里，就变成为“类”。这种集合上定义了操作的东西利用起来就方便多了，这使得人们讨论问题时都在给定集合的运算能力上下工夫，即有通用性可事半功倍。 面向对象的编程思想就要想近世代数的分析思想，首先要确定“论域”，即工程所涉及到的所有的“对象”，然后要分类处理，把隶属同一类别的对象集合在一起（做成一个集合），定义他们之间的运算性质及可以进行的操作，这样就构建了一个类，当然以后用到这个类的对象时都要通过已经定义了的操作来完成各项功能，这就是常要求的类的“类的成员变量要通过共有函数来操作”。 我想真正的面向对象编程思想不应该是编程思想，应该是面向对象的分析方法才对！ 我的理解： 1、将分析过程为抽象的过程：简言之：分成多个小问题（组成部分），
Java基础语法考试题
学士后Java阶段测试-U1单元-笔试试卷1 考试时间 60分钟 选择题(共50题，每题2分，满分100分) 1) 在Java类中，使用以下（）声明语句来定义公有的int型常量MAX。 A. public int MAX = 100; B. final int MAX = 100; C. public static int MAX = 100; D. public static final int MAX = 100; 2) 在Java中，下列关于方法重载的说法中错误的是（）（多选）。 A. 方法重载要求方法名称必须相同 B. 重载方法的参数列表必须不一致 C. 重载方法的返回类型必须一致 D. 一个方法在所属的类中只能被重载一次 3) 给定Java代码如下所示，在横线处新增下列（）方法，是对cal方法的重 载。（多选） public class Test{ public void cal(int x, int y, int z) {} ________________ } A. public int cal(int x, int y, float z){ return 0; } B. public int cal(int x, int y, int z){ return 0; } C. public void cal(int x, int z){ } D. public void cal(int z, int y, int x){ } 4) 在Java中，下面对于构造函数的描述正确的是（）。 A. 类必须显式定义构造函数 B. 构造函数的返回类型是void C. 构造函数和类有相同的名称，并且不能带任何参数 D. 一个类可以定义多个构造函数 5) 下面Java代码的运行结果是（）。 class Penguin { private String name=null; // 名字 private int health=0; // 健康值 private String sex=null; // 性别 public void Penguin() { health = 10; sex = "雄"; System.out.println("执行构造方法。");
JAVA类与对象及数组习题及答案
JAV A类和对象及数组习题 一、选择题 （1）下列构造方法的调用方式中，正确的是（D ）--原因：在通过new实例化一个类对象时系统会自动调用该类相应的构造方法。 A．按照一般方法调用B．由用户直接调用 C．只能通过new自动调用D．被系统调用 （2）在Java中，能实现多重继承效果的方式是（C ）--原因：一个类可以同时实现多个接口。Java接口反映了对象较高层次的抽象，还弥补了Java只支持单继承的不足，可用它来完成多继承的一些功能。 A．内部类B．适配器C．接口D．同步 （3）int型public成员变量MAX_LENGTH，该值保持为常数100，则定义这个变量的语句是( D )—原因：java中定义常量用关键字final来定义。 A．public int MAX_LENGTH=100 B．final int MAX_LENGTH=100 C．public const int MAX_LENGTH=100 D．public final int MAX_LENGTH=100 （4）下列叙述中，正确的是( A )—原因：Java严格区分大小写，所以变量number 与Number不相同；Java 中的注释方式除了“//”行注释之外还有段注释“/*-------*/”和文档注释/**-------*/。Java源文件中的public类只能有一个。 A. 声明变量时必须指定一个类型 B. Java认为变量number与Number相同 C. Java中唯一的注释方式是"//" D. 源文件中public类可以有0或多个 （5）下列叙述中，错误的是( D )—原因：子类继承父类，并且可以有自己的成员变量和成员方法。所以可以认为子类是父类的扩展。
Java面向对象习题
选择题 1、下列关于变量的叙述哪个是错的？（） A. 实例变量是类的成员变量。 B. 在方法中定义的局部变量在该方法被执行时创建。 C. 实例变量用关键字static声明。 D. 局部变量在使用前必须被初始化。 2、在Java语言中，下列哪个包是编译器自动导入的？（） A. java.applet B. https://www.360docs.net/doc/d215418716.html,ng C. java.io D. java.awt 3、当类的成员未用访问权限修饰符时，Java认为此成员的访问权限为（）。 A. private B. protected C.friendly D.public 4、下面哪个关键字不是用来控制对类成员的访问的？（） Ａ. public B. protected C. default D. private 5、下面哪一个特性不是面向对象编程主要体现的（）。 A. 封装性 B. 继承 C. 多态 D. 类 6、不允许作为类及类成员的访问控制符的是（）。 A. public B. private C. static D. protected 7、为AB类的一个无形式参数无返回值的方法method书写方法头，使得使用类名AB 作为前缀就可以调用它，该方法头的形式为（）。 A、static void method( ) B、public void method( ) C、final void method( ) D、abstract void method( ) 8、可以在下面代码段point x处写入的是？（） //point x public class Interesting{ //do something } A. String str; B. static int PI=3.14; C. public class MyClass{//do other thing…} D. import java.awt.*; 9、下列关于变量的叙述哪个是错的？（） A、实例变量是类的成员变量。 B、在方法中定义的局部变量在该方法被执行时创建。 C、实例变量用关键字static声明。 D、局部变量在使用前必须被初始化。 10、下列哪个类声明是正确的？（） A、abstract final class HI{} B、abstract private move(){} C、protected private number; D、public abstract class Car{}
Java实验 类和对象
一、实验目的 掌握类和对象的定义，以及它们之间的关系 学习类中属性和方法的设计 会用UML图来对类进行描述 熟悉修饰符的作用，会用set/get方法对数据进行封装 二、实验要求 设计一个名为Rectangle的类表示矩形。这个类包括： ?两个名为width和height的私有double型数据域。用来表示宽、高。默认值为1.0。 ?创建默认矩形的无参构造方法。 ?一个创建width和height为指定值的矩形的构造方法。 ?一个名为GetArea()的公有方法返回矩形面积double ?一个静态的Compare方法，比较两个矩形的面积大小是否相等并返回一个布尔型结果，相等返回true，不等返回false； 画出UML 类图，实现Rectangle类，编写测试程序创建两个Rectangle类的对象。第一个对象的width为1，height为1；第一个对象的width为5，height为6。调用compare方法判断两个矩形是否相等并显示结果。 三、实验内容 1.使用Jude工具绘制UML图
2.编写代码实现类Rectangle package edu.neu.li.test; publicclass Rectangle { privatedouble width; privatedouble height; public Rectangle() { this.width = 1.0; this.height = 1.0; public Rectangle(double width, double height) { this.width = width; this.height = width; } publicdouble GetArea() { returnthis.width * this.height ; } publicstaticboolean Compare(Rectangle rec1, Rectangle rec2) { if(rec1.GetArea()==rec2.GetArea()) { returntrue; } returnfalse; } }
java面向对象编程实验报告
java面向对象编程实验报告 篇一：java面向对象编程实验报告 信息工程学院 Java程序设计实验/实习报告 学院:信息工程学院班级:信息112 姓名:吴连梅学号:XX013305 成绩:A 实验二面向对象编程 1．实验目的 （1）掌握类与对象基本知识； （2）Java中的继承机制及包（package）、接口（interface）等的设计方法； （3）掌握static、this、super等关键字的使用； （4）掌握Java中两种比较器的用法。 2．实验内容 实验题 1 定义一个类Book，包含两个属性：一个是private的String类型的属性title、一个是private的float类型的属性listPrice，封装这两个属性的四个方法setTitle（）和getTitle（）、setListPrice( )和geListPrice （）。 基本要求： （1）设计类Book及类BookManagement，在类BookManagement中输出Book类的对象的两个private属性；
（2）重写父类的toString（）方法，实现Book类实例的两个属性的输出。 实验过程： 新建工程后，在工程下面建立一个包Book，在包下再建立一个Book类，类中包含两个属性，一个是private的String类型的属性title、一个是private的float类型的属性listPrice，之后是封装这两个属性的四个方法，用快捷键Alt+Shift+S选择gennerate Getters and Setters,再实验报告的内容与格式按任课教师的要求书写。 然后就是重写父类的toString（）方法，用快捷键Alt+Shift+S选择gennerate toString，快捷重写。 这段程序写完是这样的： 接下来便是BookManagement类，在包book下新建一个类BookManagement， 写完的程序是这样的： BookManagement类中创建了书的对象，在主方法中调用output函数，赋值，输出。程序写完后，将其存盘，再进行运行，得出的结果如下： 实验题2 有两个类：MobileManagement和Mobile，分别描述如图 3.4所示两部手机名称及价格，类MobileManagemen(本文来自：小草范文网:java面向对象编程实验报告)t在包，而Mobile在包
java基础语法练习
编程题 1、编写一个程序在屏幕上输出“Hello Java!”。 2、编写一个程序，打印从1到100的值。 3、输出1到100之间的偶数。 4、根据考试成绩的等级打印出百分制分数段: GradeLevel.java 0-59：输出不及格；60-89：良好；90-100：优秀； 5、使用for循环计算1+2+3+ (100) 6、使用while循环计算1+2+3+ (100) 7、使用do循环计算1+2+3+ (100) 8、1~100之间7的倍数的个数。并打印。
Java语言基础 选择题 1．下面（A ）不是java的关键字 A．integer B. double C. float D. char 2．以下语句没有编译错误或警告提示信息的是（C ） A．byte =256； B. double d=89； C. char c=“a”； D. short s=8.6f； 3．以下语句输出结果是（） String str=”123”; int x=4,y=5; str=str+x+y; System.out.println(str); A．1239 B.12345 C. 会产生编译错误 D. 123+4+5 4．以下选项中变量均已定义，合法的赋值语句是（B ） A．a= =1； B. ++i； C. a=a+1=5； D. y=int（i）； 5．设x为int型变量，执行以下语句段后，x的值为（） x=10； x+=x-=x-x； A．10 B.20 C. 30 D. 40 6．对下面的语句正确的说法是（） int c=’A’/3; c+=’1’%5;b System.out.println(c); A．产生编译错误 B. 输出结果25 C. 输出结果21 D. 输出结果2 7．执行下面语句后，b，x，y的值正确的是（） int x=6,y=8; boolean b; b=x 试验四 类和对象的创建 一.类的定义 类是组成Java程序的基本要素。类封装了一类对象的状态和方法。类用来定义对象的模板。 类的实现包括两部分：类声明和类体。基本格式为： 修饰符class类名[extends父类名]{ /*类体的内容*/ } 1.类声明 以下是一个类声明的例子。 class People成为类声明，People是类名。习惯上，类名的第一个字母大写，但这不是必须的。类的名字不能是Java中的关键字，要符合标识符规定，即类的名字可以由字母、下划线、数字或美元符号组成，并且第一个字母不能是数字。但给类命名时，最好遵守下列规则： (1)如果类名使用拉丁字母，那么名字的首写字母使用大写字母，如Hello、Time、People等。 (2)类名最好容易识别，当类名由几个“单词”复合而成时，每个单词的首写字母使用大写，如BeijingTi me、AmericanGame、HelloChina等。 2.类体 编写类的目的是为了描述一类事物共有的属性和功能，描述过程由类体来实现。类声明之后的一对大括号“{”、“}”以及它们之间的内容称为类体，大括号之间的内容称为类体的内容。 类体的内容由两部分构成：一部分是变量的定义，用来刻画属性；另一部分是方法的定义，用来刻画功能。 下面是一个类名为“Trapezia”的类，类体内容的变量定义部分定义了4个float类型变量：top、bottom、h igh和laderArea，方法定义部分定义了两个方法：“getArea”和“setHigh”。 二.对象 1.对象的创建 创建一个对象包括对象的声明和为对象分配内存两个步骤。 (1)对象的声明。 一般格式为： 类的名字对象名字; 如： 这里People是类的名字，zhubajie是我们声明的对象的名字。 (2)为声明的对象分配内存。 使用new运算符和类的构造方法为声明的对象分配内存，如果类中没有构造方法，系统会调用默认的构造方法（你一定还记得构造方法的名字必须和类名相同这一规定），如： 例1： 「注」如果类里定义了一个或多个构造方法，那么Java不提供默认的构造方法。 2.对象的使用 对象不仅可以改变自己变量的状态，而且还拥有了使用创建它的那个类中的方法的能力，对象通过使用这些方法可以产生一定的行为。 通过使用运算符“.”，对象可以实现对自己的变量访问和方法的调用。 例2： 【练习题】类的成员变量： 猜数字游戏：一个类A有一个成员变量v，有一个初值100。定义一个类，对A 类的成员变量v进行猜。如果大了则提示大了，小了则提示小了。等于则提示猜测成功。 【练习题】类的成员变量： 请定义一个交通工具(Vehicle)的类，其中有: 属性：速度(speed)，体积(size)等等 方法：移动(move())，设置速度(setSpeed(int speed))，加速speedUp(),减速speedDown()等等. 最后在测试类Vehicle中的main()中实例化一个交通工具对象，并通过方法给它初始化speed,size的值，并且通过打印出来。另外，调用加速，减速的方法对速度进行改变。 【练习题】类的成员变量与方法、构造方法 在程序中，经常要对时间进行操作，但是并没有时间类型的数据。那么，我们可以自己实现一个时间类，来满足程序中的需要。 定义名为MyTime的类，其中应有三个整型成员：时（hour），分（minute），秒（second），为了保证数据的安全性，这三个成员变量应声明为私有。 为MyTime类定义构造方法，以方便创建对象时初始化成员变量。 再定义diaplay方法，用于将时间信息打印出来。 为MyTime类添加以下方法： addSecond(int sec) addMinute(int min) addHour(int hou) subSecond(int sec) subMinute(int min) subHour(int hou) 分别对时、分、秒进行加减运算。 【练习题】构造方法 编写Java程序，模拟简单的计算器。 定义名为Number的类，其中有两个整型数据成员n1和n2，应声明为私有。编写构造方法，赋予n1和n2初始值，再为该类定义加（addition）、减（subtration）、乘（multiplication）、除（division）等公有成员方法，分别对两个成员变量执行加、减、乘、除的运算。 在main方法中创建Number类的对象，调用各个方法，并显示计算结果。 【练习题】构造方法： 编写Java程序，用于显示人的姓名和年龄。 定义一个人类（Person），该类中应该有两个私有属性，姓名（name）和年龄（age）。定义构造方法，用来初始化数据成员。再定义显示（display）方法，将姓名和年龄打印出来。 Java编程面向对象——类与对象的关系 面向对象是一种组件化的设计思想，OOA、OOD、OOP 类与对象是整个面向对象之中最为基础的组成单元，如果需要给划出定义：类就是共性的集合，而对象是某一个性的产物；所有类实际上是用来描述一个对象的结构。 类是通过对象来使用的，而对象是通过类来创建的。 类与对象的基本定义： 在程序中，定义类，可以使用“class 类名称{}”的语法结构完成。 而类之中的组成主要有两点： * Field （属性、成员、变量），就是一推变量的集合 * Method （方法、行为），此时的方法是由对象调用的。 这个类中定义了两个属性和一个方法（可以定义更多属性和方法） *类虽然存在，但是类的使用，必须有对象； 对象的定义格式： 声明并实例化对象： 类名称对象名称 = new 类名称(); 分步完成： 声明对象：类名称对象名称 = null； 实例化对象：对象名称 = new 类名称(); 引用数据类型： 引用数据类型最大的不同在于需要内存的开辟及使用，所以关键字new 的主要功能就是开辟内存空间； 即：只要引用数据类型想使用，就必须使用关键字new 来开辟空间。 当一个对象实例化之后就可以使用以下方式利用对象来操作类的结构： 对象.属性：表示要操作类中属性内容 对象.方法()：表示要调用类中的方法内容 内存概念： 堆内存：保存每一个对象的属性内容，堆内存需要用关键字 new 才可以开辟； 栈内存：保存的是一块堆内存的地址。简单的理解，栈内存保存的是对象的名字； 编程中的栈内存和堆内存的操作过程： 引用数据的初步分析： 引用是整个 Java 开发中的核心精髓所在，即：只有掌握了“引用”这一概念之后，才能加入下一步学习，类似C/C++ 中的指针概念。 在所有的引用分析里面，最关键的还是在于关键字 “new ”，每一次使用关键字new ，都会开辟新的堆内存空间，如果你的代码里面声明两个对象，并且使用了关键字new 为两个对象分别实例化操作，那么一定是各自占有各自(独立)的堆内存空间 Java 面向对象 一、单选： （1）在JDK1.5.0 安装目录下的bin 文件夹中，下面哪个程序是Java 执行器 (B) A ）Javac.exe B ）java.exe C）jdb.exe D ）javah.exe E）javadoc.exe (E) （2）在JDK1.5.0 安装目录下的bin 文件夹中，下面哪个程序能生成Java 参考文档 A ）Java.exe B ）javac.exe C）appletviewer.exe D）javah.exe E）javadoc.exe （3）下列数据类型不属于整型的是 (E) A ）byte 类型 B ）short 类型 C）int 类型 D ）long 类型 E）float 类型 （4 ）精确保存一个值为“53.21458961”需要用什么数据类型 ( D) A ）int 类型 B ）long 类型 C）String 类型 D ）double 类型 E）以上都可以 （5）循环语句for(int i=0。i<4。i++){}循环的次数为 (D) A ）无限次 B ）不确定 C）1 次 D ）3 次 E）4 次 （6）若i、j 为已定义的整型，下面程序段中循环体执行的次数为 (B) for(i=0。i<5。i++){ for(j=0。j<=i。j++){ } } A ）不确定 B ）5 次 C）15 次 D ）25 次 E）无限次 （7）执行下列程序段后，j 的值变为 (E) int i=1。 int j=10。 do{ j-=i。 i++。 }while(j--<0)。 A ）9 B）10 C）-1 D）-2 E）8 （8）执行下列程序段后，y 的值变为 (E) int x,y。 for(y=1,x=1。y<=50。y++){ if(x>=10){ Java基础语法练习题 一、选择题 1、编译Java Application 源程序文件将产生相应的字节码文件，这些字节码文件的扩展名为 A. java B. .class C. html D. .exe 2、下面哪个是Java语言中正确的标识符 A、3com B、import C、that D、public 3、设 x = 1 , y = 2 , z = 3，则表达式 y＋＝z－－/＋＋x 的值是 A. 3 B. 3. 5 C. 4 D. 5 4、下面的代码段中，执行之后i 和j 的值是什么 int i = 1; int j; j = i++*2+3*--i; A、1, 2 B、1, 5 C、 2, 1 D、 2, 2 5、如下哪个是Java中有效的关键字 A、name B、hello C、false D、good 6、下列语句序列执行后，k 的值是 int m=3, n=6, k=0; while( (m++) < ( -- n) ) ++k; A、0 B、1 C、2 D、3 7、下面的代码段执行之后count的值是什么( ) int count = 1; for (int i = 1; i <= 5; i++) { count += i; } System.out.println(count); A、5 B、1 C、15 D、16 8、设有定义 int i = 6 ，则执行以下语句后，i 的值为 i += i - 1; A、10 B、121 C、11 D、100 9、下列语句序列执行后，ch1 的值是 char ch1='A',ch2='W'; if(ch1 + 2 < ch2 ) ++ch1; A、'A' B、'B' C、'C' D、B 10、下列语句序列执行后，i 的值是 int i=8, j=16; if( i-1 > j ) i--; else j--; A、15 B、16 C、7 D、8 11、下列语句序列执行后，k 的值是 int i=10, j=18, k=30; switch( j - i ) { case 8 : k++; case 9 : k+=2; case 10: k+=3; default : k/=j; } A、31 B、32 C、2 D、33 12、下面语句执行后，i 的值是 1.实现简易计算器，分别实现两个整数、三个浮点数的加法运算.（用JAVA中的类和对象） 源码如下： package days;//包名自己修改 import java.util.Scanner;//注意别忘记导入这个包名了public class NumSum { public int add(int num1,int num2){ return num1+num2; } public double add(double num1,double num2,double num3){ return num1+num2+num3; } public static void main(String[] args) { // TODO Auto-generated method stub NumSum nc=new NumSum(); NumSum nc1=new NumSum(); //调用2个整数相加的方法 //Scanner是用键盘手动输入数字。 System.out.println("请用键盘手动输入两个整数："); System.out.println(nc.add(new Scanner(System.in) .nextInt(),new Scanner(System.in).nextInt())); //调用3个浮点数相加的方法 System.out.println("请用键盘手动输入三个浮点数："); System.out.println(nc1.add(new Scanner(System .in).nextDouble(), new Scanner(System.in).nextDouble( ), new Scanner(System.in).nextDouble())); } } Java 练习题答案 一、填空 1、对象的状态和行为是对象的主要属性；前者对应类的变 量，行为又称为对象的操作，对应着类的方法。类的定义包括变量声明和方法声明。 2、要嵌入在HTML文件中运行的程序是Java Applet （Java Application 、Java Applet ）。 3、安装JDK后，Java 开发工具在Bin 目录。 4、声明接口的保留字是interface 。 5、类的声明“ public class Test extends Applet implements Runable{} ” 中，定义的类名是Test ，其父类是Applet ；实现了Runable 接口。这个类的源程序必须保存为Test.java （写出包括扩展名的文件名）。 6、一个完整的Java 应用程序由一个或多个类组成；其中Java Application 至少有一个主类，这个类中包含一个名为main 的方法 7、JDK下解释执行Java 的程序是java.exe 。 8、语句如下： int[] c1=int[10]; int[] c2={1,2,3,4,5,6,7,8,9,0}; 数组c1 中的元素有10 个;c2 中的元素有10 个; 已初始化赋 值的是c2 （c1 c2 ）。 9、执行完下列程序后i 的值为5 int i=0; while(i<5) { i++; 10、运行下列程序段后，结果 c 的取值为120 int a = 100, b = 20,c; char oper ='+'; switch(oper) { case '+': c = a+b; break; case '-': c = a - b; break; default: c = a * b; break; } 11、为了能使用Java 中已提供的类，我们需要用import 语句来引入所需要的类。语句import java.io.* ；中引入了java.io 包的所有类。 二、选择题 1、属于访问控制的关键字是（ D ）。 A、static B 、final C、abstract D 、private 2、对成员的访问控制保护最强的是（C ） A、public 、 B、缺省、 C private D protected 3、可用做Java 标识符的是（ B ）。 A、try B_isYour C 2time D my name 实验报告 一、实验项目：类与对象 二、实验目的： 1. 学会使用类来封装对象的属性和功能 2. 掌握类变量与实例变量，以及类方法与实例方法的区别 3. 掌握使用package和import语 三、实验器材：计算机、Java编程软件JCreator 四、实验原理（或仪器装置图）： 1. 类与对象 类是组成Java程序的基本要素。类封装了一类对象的状态和方法。类是用来定义对象的模板。 类声明 class 类名{ 类体 } 对象的声明 一般格式为： 类的名字对象名字; 定义对象引用后，用new运算符完成对象的创建工作，分配存储空间，并对其初始化。 变量名=new 类名([构造方法实参表]); 对象的使用 访问成员的基本语法形式如下： 对象名.变量成员名 对象名.方法成员名([实际参数表]) 2.成员变量和局部变量 成员变量格式：[修饰符] 变量类型变量名[=初值]; 成员方法： 格式:[修饰符] 返回值的数据类型方法名（参数1，参数2，…） { 语句序列； return[表达式]; } 类中定义的变量是成员变量，而方法中定义的变量是局部变量。 3. 构造方法 构造方法是一种特殊的方法，创建对象时被自动调用。与一般的方法不同，它没有返回值类型的说明，方法体中也不可以用return语句带回返回值。构造方法的方法名与类名相同在构造方法中可以通过this关键字调用该类中其他的构造方法。 4.包 包是Java语言中有效地管理类的一个机制。 ①通过关键字package声明包语句。package 语句作为Java源文件的第一条语句，指 明该源文件定义的类所在的包。package语句的一般格式为：package 包名; ②import 语句：使用import 语句可以引入包中的类。 五、实验步骤及数据记录： 1．定义一个圆柱体类Cylinder，并创建相应的对象，然后计算圆柱体的底面积与体积。 1、以下为一个名为的文件，要使其编译和运行，在屏幕上显示“你好” 。哪句有错误？ { ① ([] ){ ② ("你好"); ③ } } A.①有错 B.②有错 C.③有错 D.没有错 2、源文件和编译后的文件扩展名分别为 A、和 B、和 C、和 D、和 3. 下列正确编写入口点语句的是 A. ([] ) B. ([] ) C. ([] ) D. ([] ) 4、下列声明变量方式正确的是 A． 1 12345; B. 12 154; C. ’’; D. 0; 5、下列程序能正确执行的是 A. { ([] ) { (“!”); } } B. { ([] ) { (“!”) } } C. { ([] ) { (“!”); } } D. { ([] ); { (“!”); } } 6、新建一个文件存放在E盘文件夹，下列语法在命令模式中正 确是 A．切换源文件所在目录: \d B．用命令编译源文件： C．在命令模式下命令执行时生成文件 D．运行程序： 7、以下变量名合法的是 A. B. 2 C． D. 8、下列对数组进行初始化错误的是： A．[] {1,2,3,4,5}; B．[] []{1,2,3,4,5}; C．[] [5]; D．[] [5]{1,2,3,4,5}; 9、下列程序存在语法错误的是 A． 0; (<10;){ ; (i); } B． ( 0<10); (i); (;;){ (i); } C． ( 0<10) (i)； D． 0; 10、下列代码执行的结果是： ( 0<10){ (20){ ; (i); } ("a"); JAVA类与对象习题 一、写出一个类People，并由该类做基类派生出子类Employee和Teacher。其中People 类具有name、age两个保护成员变量，分别为String类型、整型，且具有公有的getAge 成员函数，用于返回age变量的值。Employee类具有保护成员变量empno,Teacher类有teano和zc成员变量。 二、（1）创建Rectangle类，添加属性width、height； （2）在Rectangle类中添加两种方法计算矩形的周长和面积； （3）编程利用Rectangle输出一个矩形的周长和面积 三、（1）设计一个User类，其中包括用户名、口令等属性以及构造方法（至少重载2 个）。获取和设置口令的方法，显示和修改用户名的方法等。编写应用程序测试User 类。 （2）定义一个student类,其中包括用户名、姓名、性别、出生年月等属行以及init()——初始化各属性、display()——显示各属性、modify()——修改姓名等方法。实现并测试这个类。 （3）从上题的student类中派生出Granduate(研究生)类，添加属性：专业subject、导师adviser。重载相应的成员方法。并测试这个类。 四、项目名称:Bank Account Management System 银行账户管理系统简称BAM 练习1:(面向对象基础语法) 写一个账户类(Account), 属性: id:账户号码长整数 password:账户密码 name:真实姓名 personId:身份证号码字符串类型 email:客户的电子邮箱 balance:账户余额 方法: deposit: 存款方法,参数是double型的金额 withdraw:取款方法,参数是double型的金额JAVA类与对象的创建
JAVA面向对象编程上机 练习题汇总
Java实例对象概念图解
JAVA面向对象编程测试题
java基础语法练习题2
java类和对象的例子
Java练习题及答案
Java类与对象实验报告
Java基础语法测试题(1)---答案
JAVA类与对象习题