面向对象程序设计期末考试模拟题.docx
《面向对象程序设计期末考试模拟题.docx》由会员分享，可在线阅读，更多相关《面向对象程序设计期末考试模拟题.docx（12页珍藏版）》请在冰豆网上搜索。
面向对象程序设计期末考试模拟题
面向对象程序设计期末考试模拟题
2007-11-2722:
09
说明:
期末考试重点考查对程序的理解能力和运用能力,期末考试的知识要点,题型,难度和题目示例如后面所示.
考试的知识点几乎于本模拟题完全相同,但是题目实际的程序将进行各种变化.
如果仅仅是记住答案而不能理解程序的执行过程,成绩很难得到30分以上.
变化方式通常为:
更改名称,更改数值,更改语句顺序,知识点重新组合等几种方式.
/*要点:
*整数的计算和输出
*浮点数的计算和输出
*字符的输出
*字符串的连接和输出
*/
packageT01;
publicclassJavaTestDemo01{
publicstaticvoidmain（String[]args）{
intnum=2+3;
System.out.println（num）;
doublepai=3.14;
System.out.println（pai）;
charaChar='A';
System.out.println（aChar）;
System.out.println（"Hello"）;
StringaString="Hello,";
aString+="World!
";
System.out.println（aString）;
}
}
答案:
5
3.14
A
Hello
Hello,World!
/*要点:
*类的定义,类与对象之间的关系:
* 类是用来定义（创造）对象的.
* 通常,根据一个类可以创建任意多个对象,各个对象的具有相同类型的数据成员,
* 但是各个对象的数据成员之间是相互独立的.
*用new产生一个新的对象时会调用构造函数（与类名相同）.
*构造函数应当对类的数据成员初始化（给一个初始值）.
*函数的重载,多个函数的名字可以相同,但是参数个数和参数的类型不应当相同.
* 这个示例中,构造函数是重载的.根据new类名（参数）中的参数调用对应的构造函数.
*用类对应的变量是对象名字.这个名字可以用于代表一个这个类型的对象.
*用new类名（这里可能有参数）是创建一个对象.
*/
packageT02;
classAccount{
privateintbalance;
publicAccount（）{
balance=0;
}
publicAccount（intbalance）{
this.balance=balance;
}
publicintgetBalance（）{
returnbalance;
}
publicvoiddeposit（intmoney）{
balance+=money;
}
publicvoidwithdraw（intmoney）{
balance-=money;
}
}
publicclassJavaTestDemo02{
publicstaticvoidmain（String[]args）{
AccountaAcount=newAccount（）;//类名对象名=new类名（）
AccountbAcount=newAccount（800）;
System.out.println（aAcount.getBalance（））;
System.out.println（bAcount.getBalance（））;
aAcount.deposit（100）;//deposit存款
System.out.println（aAcount.getBalance（））;
System.out.println（bAcount.getBalance（））;
aAcount=newAccount（）;
System.out.println（aAcount.getBalance（））;
}
}
答案:
0
800
100
800
0
/*要点:
*继承.可以在一个类（父类）的基础上,通过定义新的数据成员/函数,扩充出一个新的类（子类）
*用子类创建一个对象的过程是首先创建出一个父类对象（没有名字）,
*然后增加子类定义的新的数据成员/函数.
*因此,子类的构造函数中第一个语句是调用的父类的构造函数.
*用子类创建的对象是符合父类的定义的（只是增加了一些新的部分）,
*因此,这个对象是父类的一种特殊情况.
*用子类创建的对象和用父类创建的对象在数据成员上是彼此独立的.
*/
packageT03;
classAccount{
privateintbalance;
publicAccount（）{
balance=0;
}
publicAccount（intbalance）{
this.balance=balance;
}
publicintgetBalance（）{
returnbalance;
}
publicvoiddeposit（intmoney）{
balance+=money;
}
publicvoidwithdraw（intmoney）{
balance-=money;
}
}
classCCBAccountextendsAccount{
privateStringaccountID;
publicCCBAccount（）{
super（10）;
accountID="";
}
publicCCBAccount（StringID,intbalance）{
super（balance）;
this.accountID=ID;
}
publicStringgetAccountID（）{
returnaccountID;
}
}
publicclassJavaTestDemo03{
publicstaticvoidmain（String[]args）{
AccountaAccount=newAccount（）;
CCBAccountbAccount=newCCBAccount（）;
System.out.println（aAccount.getBalance（））;
System.out.println（bAccount.getBalance（））;
aAccount.deposit（100）;//给account付100块钱
System.out.println（aAccount.getBalance（））;
System.out.println（bAccount.getBalance（））;
aAccount=newCCBAccount（"007",50）;//是什么意思
System.out.println（aAccount.getBalance（））;
}
}
答案:
0
10
100
10
50
/*要点:
*对象之间有构成关系.一个对象是由其它几个对象组成的.
*类的数据成员可以是用其它类定义的.
*特别要注意,
* 在构造函数中应当为每个数据成员初始化（让对象名字的确代表一个对象）,
* 如果一个名字不代表任何对象,那么它应当=null
*构造函数的调用顺序通常应当为
* 父类的构造函数
* 组成部分的构造函数
*本程序的其它要点与前面的程序相同,只是复杂一些
*/
packageT04;
classMoney{
privateintamount;
publicMoney（）{
amount=0;
System.out.println（"MoneyCreated"）;
}
publicMoney（intamount）{
this.amount=amount;
System.out.println（"Money:
"+this.amount）;
}
publicintgetAmount（）{
returnamount;
}
publicvoidsetAmount（intamount）{
this.amount=amount;
}
publicvoidaddAmount（intamount）{
this.amount+=amount;
}
publicvoiddecAmount（intamount）{
this.amount-=amount;
}
}
classAccount{
privateStringID;
privateMoneybalance;
publicAccount（）{
ID="Anonymous";
balance=newMoney（10）;
}
publicAccount（StringID,intamount）{
this.ID=ID;
balance=newMoney（）;
balance.setAmount（amount）;
System.out.println（"ID:
"+this.ID）;
}
publicintgetBalance（）{
returnbalance.getAmount（）;
}
publicvoiddeposit（intamount）{
balance.addAmount（amount）;
}
publicvoidwithdraw（intamount）{
balance.decAmount（amount）;
}
publicStringgetAccountID（）{
returnID;
}
}
publicclassJavaTestDemo04{
publicstaticvoidmain（String[]args）{
Accounta=newAccount（）;
Accountb=newAccount（）;
System.out.println（a.getAccountID（））;
System.out.println（b.getAccountID（））;
a=newAccount（"007",50）;
a.deposit（20）;
b.deposit（30）;
System.out.println（a.getAccountID（））;
System.out.println（b.getAccountID（））;
a.withdraw（15）;
System.out.println（a.getBalance（））;最后两句是什么意思
System.out.println（b.getBalance（））;
}
}
答案:
Money:
10
Money:
10
Anonymous
Anonymous
MoneyCreated
ID:
007
007
Anonymous
55
40
/*要点:
*多态性.继承不仅仅是扩充,还可以用新的函数替换掉父类的函数（名称,参数和返回值的类型都要相同）.
*用父类创建的对象会调用父类自己的函数
*用子类创建的对象会调用自己定义的重新实现的函数
*用父类定义的对象名字代表一个用子类创建的对象是,仍然调用子类自己定义的重新实现的函数
*/
packageT05;
classAccount{
privateintbalance;
publicAccount（）{
balance=0;
}
publicAccount（intbalance）{
this.balance=balance;
}
publicintgetBalance（）{
returnbalance;
}
publicvoiddeposit（intmoney）{
balance+=money;
}
publicvoidwithdraw（intmoney）{
balance-=money;
}
}
classCCBAccountextendsAccount{
staticfinalintminBalance=10;
privateStringaccountID;
publicCCBAccount（）{
super（minBalance）;
accountID="";
}
publicCCBAccount（StringID,intbalance）{
super（balance）;
this.accountID=ID;
}
publicStringgetAccountID（）{
returnaccountID;
}
publicvoidwithdraw（intmoney）{
if（money<=this.getBalance（）-minBalance）
super.withdraw（money）;//执行上面的
else
System.out.println（"NotEnoughMoney"）;
}
}
publicclassJavaTestDemo05{
publicstaticvoidmain（String[]args）{
AccountaAccount=newAccount（）;
CCBAccountbAccount=newCCBAccount（）;
System.out.println（aAccount.getBalance（））;//0
System.out.println（bAccount.getBalance（））;//10
aAccount.deposit（100）;
bAccount.deposit（100）;
aAccount.withdraw（1000）;
bAccount.withdraw（1000）;
System.out.println（aAccount.getBalance（））;//-900
System.out.println（bAccount.getBalance（））;//110
aAccount=bAccount;
aAccount.withdraw（1000）;
bAccount.withdraw（1000）;
System.out.println（aAccount.getBalance（））;//110
System.out.println（bAccount.getBalance（））;//110
aAccount=newCCBAccount（）;
aAccount.deposit（1000）;
aAccount.withdraw（1000）;
System.out.println（aAccount.getBalance（））;//10
}
}
答案:
0
10
NotEnoughMoney
-900
110
NotEnoughMoney
NotEnoughMoney
110
110
10
/*要点:
*静态成员.静态成员是属于类的,是用这个类定义出的所有的对象共享的.
*本程序用一个类的静态数据成员作为创建对象数量的计数器.
*本程序用一个类的静态常量数据成员作为各个对象都要使用的相同数据.
*本程序演示了创建对象的工厂模式（一种设计模式）.
*把类的构造函数设置为private保证,在程序的其它位置不能够用new创建这个类型的对象.
*用一个静态函数applyCCBAccount创建该类型的对象,并进行计数.
*静态成员的访问方式,以下两种方式没有区别
* 静态成员可以通过类名.直接调用
* 静态成员可以通过该类型的对象名.调用
*注意:
静态成员不可使用本类内非静态成员（用new创建对象除外）.
*/
packageT21;
classAccount{
privateintbalance;
publicAccount（）{
balance=0;
}
publicAccount（intbalance）{
this.balance=balance;
}
publicintgetBalance（）{
returnbalance;
}
publicvoiddeposit（intmoney）{
balance+=money;
}
publicvoidwithdraw（intmoney）{
balance-=money;
}
}
classCCBAccountextendsAccount{
staticfinalintminBalance=10;
staticintcounter=0;
privateStringaccountID;
privateCCBAccount（）{
super（minBalance）;
accountID="";
}
privateCCBAccount（StringID,intbalance）{
super（balance）;
this.accountID=ID;
}
publicstaticCCBAccountapplyCCBAccount（）{
counter++;
returnnewCCBAccount（"CCB"+counter,minBalance）;
}
publicstaticintgetAccountAmount（）{
returncounter;
}
publicStringgetAccountID（）{
returnaccountID;
}
publicvoidwithdraw（intmoney）{
if（money<=this.getBalance（）-minBalance）
super.withdraw（money）;
else
System.out.println（"NotEnoughMoney"）;
}
}
publicclassJavaTestDemo11{
publicstaticvoidmain（String[]args）{
CCBAccounta=CCBAccount.applyCCBAccount（）;
System.out.println（a.getAccountAmount（））;
CCBAccountb=CCBAccount.applyCCBAccount（）;
System.out.println（a.getAccountID（））;
System.out.println（a.getBalance（））;
System.out.println（b.getAccountID（））;
System.out.println（b.getBalance（））;
a.deposit（100）;
a.withdraw（1000）;
System.out.println（a.getBalance（））;
b.deposit（1000）;
b.withdraw（100）;
System.out.println（a.getBalance（））;
System.out.println（b.get
升级会员 