第一篇：Java 面向对象16种设计原则总结版（模版）
Java 面向对象16种设计原则
一 类的设计原则 依赖倒置原则－Dependency Inversion Principle(DIP)2 里氏替换原则－Liskov Substitution Principle(LSP)3 接口分隔原则－Interface Segregation Principle(ISP)4 单一职责原则－Single Responsibility Principle(SRP)5 开闭原则－The Open-Closed Principle(OCP)
二 包的设计原则 重用发布等价原则－Release Reuse Equivalency Principle(REP)7 无环依赖原则－The Acyclic Dependencies Principle(ADP)8 稳定依赖原则－The Stable Dependencies Principle(SDP)9 稳定抽象等价原则－The Stable Abstractions Principle(SAP)10 共同封闭原则－The Common Closure Principle(CCP)11 全部重用原则－The Common Reuse Principle(CRP)
三 扩展原则
迪米特法则 －Least Knowledge Principle(LKP)13 黑盒原则－ BBP(Black Box Principle)14 缺省抽象原则 －DAP(Default Abstraction Principle)15 接口设计原则 －IDP(Interface Design Principle)16 不要构造具体的超类原则 －DCSP(Don't Concrete Supperclass Principle)
1.Dependency Inversion Principle(DIP)里氏替换原则
所有引用基类的地方必须能透明地使用其子类的对象。也就是说，只有满足以下2个条件的OO设计才可被认为是满足了LSP原则：
A 不应该在代码中出现if/else之类对子类类型进行判断的条件。以下代码就违反LSP定义。if(obj typeof Class1){ do something } else if(obj typeof Class2){ do something else } B 子类应当可以替换父类并出现在父类能够出现的任何地方，或者说如果我们把代码中使用基类的地方用它的子类所代替，代码还能正常工作。
里氏替换原则LSP是使代码符合开闭原则的一个重要保证。同时LSP体现了：
1）类的继承原则：如果一个继承类的对象可能会在基类出现地方出现运行错误，则该子类不应该从该基类继承，或者说，应该重新设计它们之间的关系。
2）动作正确性保证：从另一个侧面上保证了符合LSP设计原则的类的扩展不会给已有的系统引入新的错误。
类的继承原则：
Robert C.Martin举了Rectangle和Square的例子。这里沿用这个例子，但用Java语言对其加以重写，并忽略了某些细节只列出下面的精要部分来说明 里氏替换原则 对类的继承上的约束。
1.class Rectangle { 2.double width;3.double height;4.5.public double getHeight(){ 6.return height;7.} 8.public void setHeight(double height){ 9.this.height = height;10.} 11.public double getWidth(){ 12.return width;13.} 14.public void setWidth(double width){ 15.this.width = width;16.} 17.} 18.19.class Square extends Rectangle { 20.public void setHeight(double height){ 21.super.setHeight(height);22.super.setWidth(height);23.} 24.25.public void setWidth(double width){ 26.super.setHeight(width);27.super.setWidth(width);28.} 29.}
这里Rectangle是基类，Square从Rectangle继承。这种继承关系有什么问题吗？
假如已有的系统中存在以下既有的业务逻辑代码： void g(Rectangle r){ r.setWidth(5);r.setHeight(4);if(r.getWidth()* r.getHeight()!= 20){ throw new RuntimeException();} }
则对应于扩展类Square，在调用既有业务逻辑时： Rectangle square = new Square();g(square);时会抛出一个RuntimeException异常。这显然违反了LSP原则。
动作正确性保证：
因为LSP对子类的约束，所以为已存在的类做扩展构造一个新的子类时，根据LSP的定义，不会给已有的系统引入新的错误。Design by Contract 根据Bertrand Meyer提出的Design by Contract（DBC：基于合同的设计）概念的描述，对于类的一个方法，都有一个前提条件以及一个后续条件，前提条件说明方法接受什么样的参数数据等，只有前提条件得到满足时，这个方法才能被调用；同时后续条件用来说明这个方法完成时的状态，如果一个方法的执行会导致这个方法的后续条件不成立，那么此方法也不应该正常返回。
现在把前提条件以及后续条件应用到继承子类中，子类方法应该满足： １）前提条件不强于基类． ２）后续条件不弱于基类．
换句话说，通过基类的接口调用一个对象时，用户只知道基类前提条件以及后续条件。因此继承类不得要求用户提供比基类方法要求的更强的前提条件，亦即，继承类方法必须接受任何基类方法能接受的任何条件（参数）。同样，继承类必须顺从基类的所有后续条件，亦即，继承类方法的行为和输出不得违反由基类建立起来的任何约束，不能让用户对继承类方法的输出感到困惑。这样，我们就有了基于合同的LSP，基于合同的LSP是LSP的一种强化。
在很多情况下，在设计初期我们类之间的关系不是很明确，LSP则给了我们一个判断和设计类之间关系的基准：需不需要继承，以及怎样设计继承关系。
3.Interface Segregation Principle(ISP)单一职责原则
永远不要让一个类存在多个改变的理由。换句话说，如果一个类需要改变，改变它的理由永远只有一个。如果存在多个改变它的理由，就需要重新设计该类。
SRP（Single Responsibility Principle）原则的核心含意是：只能让一个类有且仅有一个职责。这也是单一职责原则的命名含义。
为什么一个类不能有多于一个以上的职责呢？
如果一个类具有一个以上的职责，那么就会有多个不同的原因引起该类变化，而这种变化将影响到该类不同职责的使用者（不同用户）：
1，一方面，如果一个职责使用了外部类库，则使用另外一个职责的用户却也不得不包含这个未被使用的外部类库。
2，另一方面，某个用户由于某原因需要修改其中一个职责，另外一个职责的用户也将受到影响，他将不得不重新编译和配置。这违反了设计的开闭原则，也不是我们所期望的。
职责的划分
既然一个类不能有多个职责，那么怎么划分职责呢？
Robert.C Martin给出了一个著名的定义：所谓一个类的一个职责是指引起该类变化的一个原因。如果你能想到一个类存在多个使其改变的原因，那么这个类就存在多个职责。
Single Responsibility Principle(SRP)的原文里举了一个Modem的例子来说明怎么样进行职责的划分，这里我们也沿用这个例子来说明一下：
SRP违反例： Modem.java interface Modem { public void dial(String pno);//拨号 public void hangup();//挂断
public void send(char c);//发送数据 public char recv();//接收数据 } 咋一看，这是一个没有任何问题的接口设计。但事实上，这个接口包含了2个职责：第一个是连接管理（dial, hangup）；另一个是数据通信（send, recv）。很多情况下，这2个职责没有任何共通的部分，它们因为不同的理由而改变，被不同部分的程序调用。所以它违反了SRP原则。
下面的类图将它的2个不同职责分成2个不同的接口，这样至少可以让客户端应用程序使用具有单一职责的接口：
让ModemImplementation实现这两个接口。我们注意到，ModemImplementation又组合了2个职责，这不是我们希望的，但有时这又是必须的。通常由于某些原因，迫使我们不得不绑定多个职责到一个类中，但我们至少可以通过接口的分割来分离应用程序关心的概念。事实上，这个例子一个更好的设计应该是这样的，如图：
小结
Single Responsibility Principle(SRP)从职责（改变理由）的侧面上为我们对类（接口）的抽象的颗粒度建立了判断基准：在为系统设计类（接口）的时候应该保证它们的单一职责性。
5.The Open-Closed Principle(OCP)对扩展开放（open）重用发布等价原则
包的内部关系方面（聚合性）的原则，重用粒度等价于发布粒度。重用主要是从用户的观点来看的。对用户来说，使用某个发布单位（组件，类，类群等），如果作者因为某种原因对其作了修改而发布了一个新的版本，用户会期望在升级为新版本之后，不会影响到原系统的正常运作。也就是说，对于一个可重用（能供其它用户或系统使用）的元素（组件，类，类群等），作者应该承诺新版本能够兼容旧版本。否则，用户将拒绝使用该元素。
Robert C.Martin给出的对重用的定义：
代码可以看作为可重用的代码，当且仅当：用户只需联结静态库或包含动态库
-当库发生改变（错误纠正，功能增强）时，用户只需要得到一个新的版本便能集成到原有的系统
怎么做到重用呢？
一个组件要做到能够重用，它必须有一个得到良好设计的结构，它所包含所有元素必须也是可以重用的。
因为如果一个为重用而设计的发布单位里，包含了不可重用的元素，当不可重用的元素发生改变时，用户也不得不改变原有系统以适应新的版本。这显然违反了重用的定义规则。
也就是说，一个为重用目的而设计的发布单位里，不能包含不可重用的元素；如果包含了不可重用的元素，它将变得不可重用。
发布单位
当用户使用的重用组件被作者修改后，用户希望得到通知，然后决定是否升级或升级的时机。为了能使升级后的系统也能正常运作，用户也希望作者有一个规范的发布，包括版本号，类库的说明等等。
一旦用户决定升级新版本，不管这些修改是否影响到用户，用户也不得不包含新版本所包含的所有类库。
REP规定重用粒度不能小于发布粒度，所有重用元素也必须被一起发布。
发布粒度可以为包（组件）或类等实体，但一个应用往往包含了很多类，所以，具有更大的尺度的包（组件）更加适合作为发布粒度。
重用发布等价原则为我们指明了包的设计方针：一个包中的元素（类）要么都可重用，要么都不可重用。
小结
重用发布等价原则（REP）从用户观点的角度上为我们规范了包设计的原则：在设计包时，包中应该包含的元素要么都可以重用，要么都不可以重用。
7.The Acyclic Dependencies Principle(ADP)稳定依赖原则
一个设计中的包之间的依赖应该朝着稳定的方向进行。一个包只应该依赖那些比自己更稳定的包。换成另一个说法是： 朝着稳定的方向进行依赖。包之间的关系方面（耦合性）的原则。
包的依赖
如果一个包A 中的类引用了包B中的类，我们称包A依赖包B。
“依赖”在具体的程序语言中表现为，如果A依赖B，C/C++语言则在A包的文件/类中通过#include语句包含B包中的文件/类；Java语言则A包的类中通过import语句引入B包中的类。
图1（包A依赖包B）
虚线表示一种依赖关系，箭头表示依赖的方向，箭头所在的一侧就是被依赖的包。
包的稳定依赖原则
包应该依赖比自己更稳定的包。因为如果依赖一个不稳定的包，那么当这个不稳定的包发生变化时，本身稳定的包也不得不发生变化，变得不稳定了。
所谓稳定，在现实生活中是指一个物体具有稳固不变的属性使它很难发生变化。应用到软件概念上，我们认为一个软件是稳定的，是因为这个软件很难发生改变，或更确切地说，是不需要发生改变。一个设计良好，能应对各种变化不需要修改的软件当然是稳定的了，但事实上，往往一个软件常常需要对应某个事先没有预测到的用户需求而不得不发生改变，当这种改变发生时，能把修改控制在最小的范围之内，并能稳定的工作（包括软件本身以及依赖它的其它软件实体等），我们也会认为该软件是相对稳定的。
怎么样让一个软件足够稳定呢？一个确切的方法是，让大量其它软件的包依赖它。一个包被很多其他包依赖是非常稳定的，这是因为被依赖的包为了协调其他包必须做很多的工作来对应各种变化（责任的负担者）。
图1：稳定的包X 我们认为X是稳定的，因为：
X没有依赖别的包，它是独立的。
相反，下面列出了一个非常不稳定的包Y，如图：
图2：不稳定的包Y 我们认为Y是不稳定的，因为：
-Y没有被其他的包所依赖。不是责任的担当着。稳定抽象等价原则
最稳定的包应该是最抽象的包。不稳定的包应该是具体的包。包的抽象程度跟它的稳定性成正比。稳定的包应该是抽象的包。
包的稳定抽象等价原则
我们在The Stable Dependencies Principle(SDP)它们是具体的包实现
稳定的（不容易改变的）包处于下层共同封闭原则
一个包中所有的类应该对同一种类型的变化关闭。一个变化影响一个包，便影响了包中所有的类。一个更简短的说法是：一起修改的类，应该组合在一起（同一个包里）。包的内部关系方面（聚合性）的原则
如果必须修改应用程序里的代码，我们希望所有的修改都发生在一个包里（修改关闭），而不是遍布在很多包里。
CCP原则就是把因为某个同样的原因而需要修改的所有类组合进一个包里。如果2个类从物理上或者从概念上联系得非常紧密，它们通常一起发生改变，那么它们应该属于同一个包。
CCP跟开闭原则（OCP: Open Closed Principle）有着很深的渊源关系，CCP的“关闭”（closure）就是OCP所提倡的：classes should be closed for modification but open for extension.类应该对修改关闭，对扩展开放。但我们知道，100%的“关闭”是不现实的，我们在设计系统时，只能尽量地保持对大多数可预见的修改关闭。
CCP延伸了OCP的“关闭”概念，当因为某个原因需要修改时，把需要修改的范围限制在一个最小范围内的包里。CCP原则帮助我们决定哪些类应该被放到同一个包里。
小结
共同封闭原则（CCP）从软件功能的角度上为我们规范了包设计的一个原则：在设计包时，相互之间紧密关联的类应该放在同一包里。
11.The Common Reuse Principle(CRP)Single Responsibility Principle(SRP)就一个类而言，应该仅有一个引起它变化的原因。(职责即为“变化的原因”。)2.开放-封闭原则Liskov Substitution Principle(LSP)子类型(subclass)必须能够替换掉它们的基类型(superclass)。
4.依赖倒置原则(IoCP)或 依赖注入原则-Dependence Inversion Principle(DIP)抽象不应该依赖于细节。细节应该依赖于抽象。(Hollywood原则: “Don't call us, we'll call you”.程序中所有的依赖关系都应该终止于抽象类和接口。针对接口而非实现编程。
任何变量都不应该持有一个指向具体类的指针或引用。任何类都不应该从具体类派生。
任何方法都不应该覆写他的任何基类中的已经实现了的方法。)5.接口隔离原则(ISP)不应该强迫客户依赖于它们不用的方法。接口属于客户，不属于它所在的类层次结构。(多个面向特定用户的接口胜于一个通用接口。)
----包内聚原则----
6.重用发布等价原则(REP)重用的粒度就是发布的粒度。7.共同封闭原则(CCP)包中的所有类对于同一类性质的变化应该是共同封闭的。一个变化若对一个包产生影响，则将对该包中的所有类产生影响，而对于其他的包不造成任何影响。8.共同重用原则(CRP)一个包中的所有类应该是共同重用的。如果重用了包中的一个类，那么就要重用包中的所有类。
(相互之间没有紧密联系的类不应该在同一个包中。)----包耦合原则
9.无环依赖原则(ADP)在包的依赖关系图中不允许存在环。10.稳定依赖原则(SDP)朝着稳定的方向进行依赖。
应该把封装系统高层设计的软件（比如抽象类）放进稳定的包中，不稳定的包中应该只包含那些很可能会改变的软件（比如具体类）。11.稳定抽象原则(SAP)包的抽象程度应该和其稳定程度一致。
(一个稳定的包应该也是抽象的，一个不稳定的包应该是抽象的.)
----其它扩展原则----
12.BBP(Black Box Principle)黑盒原则 多用类的聚合，少用类的继承。
13.DAP(Default Abstraction Principle)缺省抽象原则
在接口和实现接口的类之间引入一个抽象类,这个类实现了接口的大部分操作.14.IDP(Interface Design Principle)接口设计原则 规划一个接口而不是实现一个接口。
15.DCSP(Don't Concrete Supperclass Principle)不要构造具体的超类原则 避免维护具体的超类。16.迪米特法则
一个类只依赖其触手可得的类。
第二篇：Java面向对象编程习题总结
第一章
面向对象开发方法概述
1.面向对象的软件开发有哪些优点？
1）
把软件系统看成是各种对象的集合，这更接近人类的自然思维方式。
2）
软件需求的变动性往往是功能的变动，而功能的执行者——对象，一般不会有多大的变化，比结构化更稳定。
3）
对象包括属性和行为，对象把数据及方法的具体实现方式一起封装起来，使得方法与之相关的数据不再分析，提高了每个子系统的相对对立性，从而提高软件的可维护性。
4）
支持封装，抽象，继承和多态。提高了软件的可重用性，可维护性和可扩展性。
2.在软件系统中，为什么说一个孤立的不对外提供任何服务的对象是没有意义的？
1）
每个对象都具有特定的功能，相对于其他对象而言，它的功能就是为其他对象提供的服务。
2）
从使用者角度出发，整个软件系统就是一个服务的提供者。
3）
在系统内部，每个子系统也都是服务的提供者，它们其他子系统提供服务。
4）
因此说一个孤立的部队为提供任何服务的系统是美欧任何意义的。
3.列举一些现实生活中的例子，来说明什么是依赖关系、什么是聚集关系，以及什么是关联关系。
1）
关联关系：关联是指类之间的特定对应关系，可以分为单向关联和双向关联，也可以分为一对一关联、一对多关联以及多对多关联。A关联B，是指Class A与Class B之间存在特定的对应关系。举例如学生和老师，订单和客户。
2）
依赖关系：类之间的调用关系。A依赖B，Class A访问Class B提供的服务。如Panel与Shape的关系。
3）
聚集关系：是整体与部分之间的关系
4.列举一些显示生活中的例子，来说明什么是封装，什么是接口。
1)
接口：对象中所有向使用者公开的方法的声明构成了对象的接口。
2)
封装：隐藏对象的属性和实现细节，仅仅对外公开接口。
3)
接口的优点：a.提高系统之间松散耦合b.提高了系统的可扩展性。
4)
封装的有点：
a.便于使用者正确、方便地理解和使用系统，防止使用者错误修改系统的属性。
b.有助于建立各个系统之间的松耦合关系，提高系统的独立性。
c.提高软件的可重用性，没个系统都是一个相对独立的整体，可以在多种环境中得到重用。
d.降低构建大型系统的风险，即使整个系统不成功，个别的独立子系统有可能依然有价值。
5.抽象的最主要特征是什么？
抽象是指从特定角度出发，从已经存在的一些事物中抽取我们所关注的特性，形成一个新的事物的思维过程。
6.在建立对象模型时，要经历哪些抽象思维过程？
1)
从问题领域的事物到软件模型中对象的抽象。
2)
从对象到类的抽象。
3)
从子类到父类的抽象
7.类就是程序员自定义的类型。这种说法是否正确？
不正确，类是一组具有相同属性和行为的对象的抽象。类及类的关系构成了对象模型的主要内容。开发人员需要根据先识别对象，然后再进行分类(创建任意的数据模型)的思路来建立对象模型。
8.小王本来体重70kg，经过减肥，体重降到45kg，试从这个问题领域中识别对象、类、属性、状态和状态的变化。
1）
类：人。
2）
对象：小王。
3）
属性：体重。
4）
状态：70kg。
5）
状态的变化：小王的减肥行为导致体重下降。
9.在UML图中哪些框图描述了系统的动态结构，哪些框图描述了系统的静态结构？
1)
用例图、类框图、组件图、部署图构成了系统的静态模型。
2)
状态转换图、时序图、协作图则构成了系统的动态模型。
第二章
第一个Java应用
1.把一个类放在包里有什么用？
答：把类分包的作用：
(1)
能够区分名字相同的类
(2)
有助于实施访问权限控制
(3)
有助于划分和组织Java应用中的各个类
2.JavaDoc文档是不是为软件的终端用户提供的使用指南？
答：不是的，JavaDoc文档是供Java开发人员阅读的，他们通过JavaDoc文档来了解其他开发人员开发的类的用法。Java开发人员应该养成经常阅读JavaDoc文档的良好习惯。
3.对于com.abc.dollapp.AppMain类，使用以下命令进行编译，编译出来的.class文件位于什么目录下？
java –d C:classes –sourcepath C:src C:srccomabcdollappAppMain.java
答：将会存放在C:classescomabcdollapp下。
4.对于以上编译出来的AppMain类，以下哪个java命令能正确运行它？
(a)
java C:classescomabcdollappAppMain.class
(b)
java –classpath C:classes AppMain
(c)
java –classpath C:classescomabcdollapp AppMain
(d)
java –classpath C:classes com.abc.dollapp.AppMain
答：(b)
5.以下哪些main()方法的声明能够作为程序的入口方法？
(a)
public static void main()
(b)
public static void main(String[] string)
(c)
public static void main(String args)
(d)
static public int main(String[] args)
(e)
static void main(String[] args)
答：(b)，主函数必须以public static void形式存在，参数必须为String数组形式。
6.假定以下程序代码都分别放在MyClass.java文件中，哪些程序代码能够编译通过？
(a)
import java.awt.*;package Mypackage;
class MyClass{};
(b)
package MyPackage;
import java.awt.*;
class MyClass{};
(c)
/*This is comment*/
package MyPackage;
import java.awt.*;
public class MyClass{};
答：(c)，程序顺序必须按照import, package, class走，源文件必须以public类型的类命名。
7.对于以下Myprog类，运行命令”java Myprog good morning”，将会得到打印结果？
public class Myprog {
public static void main(String argv[])
{
System.out.println(argv[2]);
} }
答：打印结果为空。argv[0] = “good”, argv[1] = “morning”。
8.下面哪些是Java的关键字？
(a)
default
(b)
NULL
(c)
String
(d)
throws
(e)
long
(f)
true
答：(a),(d),(e),(f),java中所有的关键字都是小写。
9.当AppMain类的main()方法创建了5个Doll对象时，运行时数据区的数据如何分布的？参考2.4节的图2-13，画出此时运行时数据区的状态图。
运行时数据区(内存)
Java栈区
执行main()方法的主线程的方法调用栈
局部变量beibei
局部变量jingjing
局部变量huanhuan
局部变量yingying
局部变量nini
堆区
Doll实例
name:贝贝
Doll实例
name:晶晶
Doll实例
name:欢欢
Doll实例
name:迎迎
Doll实例
name:妮妮
方法区
Doll类型信息
AppMain类型信息
（包含main()方法信息）
10.下面哪些是合法的Java标识符？
(a)
#_pound
(b)
_underscore
(c)
5Interstate
(d)
Interstate5
(e)
_5_
(f)
class
答：(b),(d),(e)标识符命名规则如下：
(1)
标识符首字母必须为字母、下划线“_”、美元“$”、人民币“￥”(2)
标识符由数字、大写字母、小写字母、下划线以及美元等组成
(3)
不能把关键字和保留字作为标识符
(4)
标识符没有长度的限制
(5)
标识符是大小写敏感的第三章
数据类型和变量
1.对于以下程序，运行“java Abs”，将得到什么打印结果？
public class Abs
{
static int a = 0x11;
//十六进制
static int b = 0011;
//八进制
static int c = 'u0011';
//十六进制数据的Unicode字符编码
static int d = 011;
//八进制
/**
* @param args
*/
public static void main(String[] args)
{
System.out.println(“a=”+a);
System.out.println(“b=”+b);
System.out.println(“c=”+c);
System.out.println(“d=”+d);
} }
答：输出如下
a=17 b=9 c=17 d=9
2.以下哪段代码能正确编译通过？
(a)
char a = „a‟;
char b = 1;
char c = 08;
(b)
int a = „a‟;
(c)
long a =‟u00FF‟;
(d)
char a = „u0FF‟;
(e)
char d = “d”;
答：(b)、(c)能通过编译。(a)中“char c=08”将int赋值给char需要部分强制转换，“char c=8”就正确；(d)中unicode编码错误，java采用的是UCS-2编码，共16位；(e)字符赋值是使用单引号，字符串String赋值时才使用双引号。
3.下面哪些代码能编译通过？
(a)
short myshort=99S;
(b)
String name = „Excellent tutorial Mr Green‟;(c)
char c = 17c;
(d)
int z = 015;
答：(d)可以编译通过。(a)中char赋值给short需要强制转换；(b)中String类型赋值用双引号；(c)中int赋值给char需要部分强制转换。
4.字符“A”的Unicode字符编码为65.下面哪些代码正确定义了一个代表字符“A”的变量？
(a)
Char ch=65;
(b)
Char ch=‟65‟;
(c)
Char ch =‟u0041‟;
(d)
Char ch=‟A‟;
(e)
Char ch =”A”
答：(c)、(d)可以得到”A”。(b)的输出为5，其他无法编译通过。
5.以下代码共创建了几个对象？
String s1=new String(“hello”);
String s2=new String(“hello”);
String s3=s1;
String s4=s2;
答：共创建了2个对象。栈区4个局部变量分别引用了堆区的2个实例，而2个实例又引用了工作区的同一个类。
6.以下代码能否编译通过？假如能编译通过，运行时将得到什么打印结果？
class Test {
static int myArg = 1;
public static void main(String[] args)
{
Int myArg;
System.out.println(myArg);
} }
答：无法编译通过，因为局部变量myArg声明之后Java虚拟机就不会自动给它初始化为默认值，若在使用前未被初始化，编译会报错。
7.对于以下程序，运行“java Mystery Mighty Mouse”，将得到什么打印结果？
public class Mystery
{
public static void main(String[] args)
{
Changer c = new Changer();
c.method(args);
System.out.println(args[0]+“ ”+args[1]);
}
static class Changer
{
void method(String[] s)
{
String temp = s[0];
s[0] = s[1];
s[1] = temp;
}
} }
答：打印结果为“Mighty Mystery”
8.对于以下程序，运行“java Pass”，将得到什么打印结果？
public class Pass
{
static int j = 20;
public static void main(String[] args)
{
int i=10;
Pass p = new Pass();
p.amethod(i);
System.out.println(“i=”+i);
System.out.println(“j=”+j);
}
public void amethod(int x)
{
x*=2;
j*=2;
} }
答：打印结果是
i=10 j=40
其中“int x”是传参，作用域仅在amethod之中。
第四章 操作符
1.以下哪些程序代码能够编译通过？
(a)
int i=0;if(i){
System.out.println(“hello”);}
(b)
boolean b1=true;
boolean b2=true;
if(b1==b2){
System.out.println(“So true”);}
(c)
int i=1;
int j=2;
if(i==1||j==i){
System.out.println(“ok”);}
(d)
int i=1;
int j=2;
if(i==1&|j==i){
System.out.println(“ok”);}
答：(b)、(c)能编译通过。(a)中int不能作为boolean出现，(d)中不能出现&|该操作符。
2.运行以下程序，将得到什么打印结果？
System.out.println(-1>>>1);
System.out.println(-1>>1);
System.out.println(2>>1);
System.out.println(1<<<1);
答：>>>是逻辑右移位操作符，也称不带符号右移位操作符，在移位的过程中二进制数开头填0；>>是右移位操作符，也称带符号右移位操作符，舍弃末尾，在开头填符号位；<<<操作符不存在；
11111111 11111111 11111111 11111111
-1>>>1
01111111 11111111 11111111 11111111
11111111 11111111 11111111 11111111
-1>>1
11111111 11111111 11111111 11111111
00000000 00000000 00000000 00000010
2>>1
00000000 00000000 00000000 00000001
2147483647-1 1
3.以下temp变量最终取值是什么？
long temp =(int)3.9;
temp %= 2;
答：取值为1。
4.以下代码能否编译通过？假如能编译通过，运行时将得到什么打印结果？
if(5 & 7 > 0 && 5 | 2)System.out.println(“true”);
答：int型不能作为boolean型出现。
5.以下代码能否编译通过？假如编译通过，运行时将得到什么打印结果？
int output=10;
boolean b1 = false;
if((b1==true)&&((output+=10)==20)){
System.out.println(“We are equal”+output);} else {
System.out.println(“Not equal!”+output);}
答：Not equal!10
6.以下代码能否编译通过？假如能编译通过，运行时将得到什么打印结果？
int output=10;
boolean b1 = false;
if((b1==true)&((output+=10)==20)){
System.out.println(“We are equal”+output);} else {
System.out.println(“Not equal!”+output);}
答：Not equal!20
7.对于以下声明：
String s1=new String(“Hello”);
String s2=new String(“there”);
String s3=new String();
下面哪些是合法的操作？
(a)
s3=s1+s2;
(b)
s3=s1-s2;
(c)
s3=s1&s2;
(d)
s3=s1&&s2;
答：(a)是合法操作。除了“+”能用于字符串的连接以外，其他操作符（如“-”、“&”、“&&”等）都不支持String类型的操作元。
第五章
流程控制
1.运行以下代码，将得到什么打印结果？
int i = 3;
int j = 0;
double k = 3.2;
if(i < k)
if(i == j)
System.out.println(i);
else
System.out.println(j);
else
System.out.println(k);
答：0
2.以下代码能否编译通过？假如能编译通过，运行时将得到什么打印结果？
int i = 4;
switch(i){
default:
System.out.println(“default”);
case 0:
System.out.println(“zero”);
break;
case 1:
System.out.println(“one”);
case 2:
System.out.println(“two”);｝
答：可以编译通过，打印结果是：
default
zero
分析：default可以放在任何位置上，一旦符合一个case即从头执行到尾，不再判断case。
3.以下哪些是合法的
(a)
int i;for(i=5, int j=10;i<10;j--){}
(b)
int i,j;for(i=0, j=10;i<10, j>0;i++, j--){}
(c)
int i,k;for(i=0, k=9;(i<10 && k>0);i++, k--){}
(d)
int i,j;for(i=0;j=10;i<10;i++,j--){} 答：(a)for语句中int定义要放在开头。编译不通过。
(b)循环判断语句不可以用逗号连接。编译不通过。
(c)合法。
(d)分号只能有2个。
4.运行以下代码，将得到什么打印结果？
int i = 1;
switch(i){
default:
System.out.println(“default”);
case 0:
System.out.println(“zero”);
break;
case 1:
System.out.println(“one”);
case 2:
System.out.println(“two”);｝
答：分析同1，运行结果如下：
one
two
5.以下哪些代码合法？
(a)
float x=1;
switch(x){
case 1;
System.out.println(“Got a 1”);
}
(b)
long x=1;
switch(x){
case 1;
System.out.println(“Got a 1”);
}
(c)
byte x=1;
switch(x){
case 1/1;
System.out.println(“Got a 1”);
}
(d)
int x=1;
int c=1;
switch(c){
case x;
System.out.println(“Got a 1”);}
(e)
short x=1;
switch(x){
case 3.2/2;
System.out.println(“Got a 1”);
}
(f)
short x=1;
switch(x){
case 1,2,3;
System.out.println(“Got a 1”);
}
答：只有(c)是合法的。
6.以下代码能否编译通过？假如能编译通过，运行时将得到什么打印结果？
for(int a=0, b=0;a<2;b=++a, System.out.println(“b=”+b)){
System.out.println(“a=”+a);}
答：可以通过编译，打印结果：
a=0 b=1 a=1 b=2
7.以下代码能否编译通过？假如能编译通过，运行时将得到什么打印结果？
int x=0;one:
while(x<10)
{
two:
System.out.println(++x);
if(x>3)
break two;
}
答：不能通过编译。
第三篇：java面向对象的学习心得
Java面向对象的学习心得
大三的时候学校组织我们去苏州NIIT参加四个月的java实训，我开始系统的学习期java，之前大学的时候学的比较宽泛，没有专门的正对java的学习。
首先我是从学习Java编程开始接触OOP(面向对象编程)，刚开始使用Java编写程序的时候感觉很别扭，因为我早以习惯用C来编写程序，很欣赏C的简洁性和高效性，喜欢C简练而表达能力丰富的风格，特别忍受不了Java运行起来慢吞吞的速度，相对冗长的代码，而且一个很简单的事情，要写好多类，一个类调用一个类，心里的抵触情绪很强。
我对Java的面向对象的特性琢磨良久，自认为有所领悟，也开始有意识的运用OOP风格来写程序，然而还是经常会觉得不知道应该怎样提炼类，面对一个具体的问题的时候，会觉得脑子里千头万绪的，不知道怎么下手，一不小心，又会回到原来的思路上去。
举个例子，要发广告邮件，广告邮件列表存在数据库里面。倘若用C来写的话，一般会这样思考，先把邮件内容读入，然后连接数据库，循环取邮件地址，调用本机的qmail的sendmail命令发送。
然后考虑用Java来实现，既然是OOP，就不能什么代码都塞到main过程里面，于是就设计了三个类：
一个类是负责读取数据库，取邮件地址，调用qmail的sendmail命令发送； 一个类是读邮件内容，MIME编码成HTML格式的，再加上邮件头；
一个主类负责从命令读参数，处理命令行参数，调用发email的类。
把一件工作按照功能划分为3个模块分别处理，每个类完成一件模块任务。
仔细的分析一下，就会发现这样的设计完全是从程序员实现程序功能的角度来设计的，或者说，设计类的时候，是自低向上的，从机器的角度到现实世界的角度来分析问题的。因此在设计的时候，就已经把程序编程实现的细节都考虑进去了，企图从底层实现程序这样的出发点来达到满足现实世界的软件需求的目标。
这样的分析方法其实是不适用于Java这样面向对象的编程语言，因为，如果改用C语言，封装两个C函数，都会比Java实现起来轻松的多，逻辑上也清楚的多。
我觉得面向对象的精髓在于考虑问题的思路是从现实世界的人类思维习惯出发的，只要领会了这一点，就领会了面向对象的思维方法。
举一个非常简单的例子：假使现在需要写一个网页计数器，客户访问一次页面，网页计数器加1，计数器是这样来访问的后台有一个数据库表，保存每个id（一个id对应一个被统计访问次数的页面）的计数器当前值，请求页面一次，对应id的计数器的字段加1(这里我们忽略并发更新数据库
表，出现的表锁定的问题)。
如果按照一般从程序实现的角度来分析，我们会这样考虑：首先是从HTTP GET请求取到id，然后按照id查数据库表，获得某id对应的访问计数值，然后加1，更新数据库，最后向页面显示访问计数。
现在假设一个没有程序设计经验的人，他会怎样来思考这个问题的呢？他会提出什么样的需求呢？他很可能会这样想：
我需要有一个计数器，这个计数器应该有这样的功能，刷新一次页面，访问量就会加1，另外最好还有一个计数器清0的功能，当然计数器如果有一个可以设为任意值的功能的话，我就可以作弊了。
做为一个没有程序设计经验的人来说，他完全不会想到对数据库应该如何操作，对于HTTP变量该如何传递，他考虑问题的角度就是我有什么需求，我的业务逻辑是什么，软件应该有什么功能。
按照这样的思路(请注意，他的思路其实就是我们平时在生活中习惯的思维方式)，我们知道需要有一个计数器类 Counter，有一个必须的和两个可选的方法：
getCount()// 取计数器值方法
resetCounter()// 计数器清0方法
setCount()// 设计数器为相应的值方法
把Counter类完整的定义如下：
public class Counter {
public int getCount(int id){}
public void resetCounter(int id){}
public void setCount(int id, int currentCount){}
}
解决问题的框架已经有了，来看一下如何使用Counter。在count.cgi里面调用Counter来计数，程序片断如下：
// 这里从HTTP环境里面取id值
...Counter myCounter = new Counter();// 获得计数器
int currentCount = myCounter.getCount(id);// 从计数器中取计数
// 这里向客户浏览器输出
...程序的框架全都写好了，剩下的就是实现Counter类方法里面具体的代码了，此时才去考虑具体的程序语言实现的细节，比如，在getCount()方法里面访问数据库，更新计数
值。
从上面的例子中看到，面向对象的思维方法其实就是我们在现实生活中习惯的思维方式，是从人类考虑问题的角度出发，把人类解决问题的思维方式逐步翻译成程序能够理解的思维方式的过程，在这个翻译的过程中，软件也就逐步被设计好了。
在运用面向对象的思维方法进行软件设计的过程中，最容易犯的错误就是开始分析的时候，就想到了程序代码实现的细节，因此封装的类完全是基于程序实现逻辑，而不是基于解决问题的业务逻辑。
学习JDBC编程的经典错误问法是：“我怎样封装对数据库的select操作？”
面向对象的设计是基于解决业务问题的设计，而不是基于具体编程技术的设计。我不会去封装select语句的，我只封装解决问题的业务逻辑，对数据库的读取是在业务逻辑的编码实现阶段才去考虑的问题。
回过头看上面那个发广告邮件的例子，应该如何应用面向对象的思维方法呢？
对于一个邮件来说，有邮件头，邮件体，和邮件地址这三个属性，发送邮件，需要一个发送的方法，另外还需要一个能把所有邮件地址列出来的方法。所以应该如下设计：
类JunkMail
属性：
head
body
address
方法：
sendMail()// 发送邮件
listAllMail()// 列邮件地址
用Java来表示：
public class JunkMail {
private String head;
private String body;
private String address;
public JunkMain(){ // 默认的类构造器
// 从外部配置文件读邮件头和邮件体
this.head=...;
this.body=...;
}
public static boolean sendMail(String address){
// 调用qmail，发送email
}
public static Collection listAllMail(){
// 访问数据库，返回一个邮件地址集合}
}
当把JunkMail设计好了以后，再调用JunkMail类完成邮件的发送，将是非常轻松的事情。
如果说传统的面向过程的编程是符合机器运行指令的流程的话，那么面向对象的思维方法就是符合现实生活中人类解决问题的思维过程。
在面向对象的软件分析和设计的时候，要提醒自己，不要一上来就去想程序代码的实现，应该抛开具体编程语言的束缚，集中精力分析我们要实现的软件的业务逻辑，分析软件的业务流程，思考应该如何去描述和实现软件的业务。毕竟软件只是一个载体，业务才是我们真正要实现的目标。
但是在设计过程中，心里却往往在担心，如果我完全不去考虑程序代码的实现的话，那么我怎么知道我的设计一定合理呢？我怎么知道我设计的类、接口一定可以实现呢？所以经常可以看到的现象就是：
在设计过程中，虽然知道不能过早考虑代码实现，但是每设计一个类，一个接口，心里都要不知不觉的用自己熟悉的编程语言大概的评估一下，看看能否编出来，因此，一不小心，就会又回到按照程序功能实现的思路进行设计的老路上去了。
举个例子来说明，在做Web程序设计的时候，经常要遇到分页显示数据的情况。比如说需要把系统中所有的用户都列出来这样的功能。假设使用User类来表示用户，增加用户addUser()，删除用户deleteUser()，查询所有用户listUsers()方法。而数据库中有一个user表，一条记录是一个用户的信息。下面考虑一下User类的方法的实现：
addUser()和deleteUser()方法都好实现，就是对数据库增加记录和删除记录。对于listUsers()方法，其实就是对user表的select，取出一个记录集。但是该怎么从listUsers()方法中得到所有用户的列表呢？
一个方法调用的返回值只有一个，没有多个，所以很多情况下采用的办法就是返回值定义为集合类型，比如Vector。这样就可以在listUsers()方法的具体代码实现的时候，从数据库依次取出一个个记录，插入到Vector里面来。在主程序里面，调用listUsers()方法可以返回一个Vector，然后再对Vector遍历操作，就可以得到用户列表了。
public class User {
public static void addUser(...){
// 数据库insert一条记录
}
public static void deleteUser(...){
// 数据库delete一条记录
}
public Vector listUsers(...){
// 数据库select结果放到一个集合里面
}
}
这样的设计基本合理，但是仍然有点小问题。因为在设计的时候，就考虑到了用Java的集合类Vector来实现对不定长数据集的存放，因而违反了面向对象设计的一个原则：在设计的时候不应过早的考虑具体程序语言的实现。所以必须用抽象的方法，和具体实现无关的方法来表达业务逻辑。
我们知道，通常对具有集合特征的数据结构进行遍历通常可以使用next和hasNext方法，next实现取下一个用户，hasNext判断是否还有元素。因此我们定义一个接口Iterator，这个接口中定义两个方法next和hasNext：
public interface Iterator {
public boolean hasNext(){}
public Object next(){}
}
而User类的listUses方法返回值改为Iterator接口的实现类:
public class User {
...public Iterator listUsers(){
}
...}
这样就把User类的设计和具体的实现方法分离开了，因为此时任何实现了next()和hasNext()方法的类都可以做为listUsers的返回值，都可以被用来表达“用户列表”，而不仅仅可以使用Vector而已。比如，我可以用ArrayList来表达用户列表，因为ArrayList也实现了Iterator，当然我也可以自己专门写一个类来存放用户列表，只要实现next()和hasNext()方法就行了。
这样在具体的编写代码的时候，程序员具有了最大的灵活性，可以根据具体的情况，采用不同的编程方法来存放用户列表。特别是降低了程序的耦合度，提高了程序的可移植性。对于上面那个JunkMail的listAllMail()方法也同样应该改为接口类型。
然后，在主程序里面就这样来使用User类的listUsers方法：
User myUser = new User();
Iterator iterator = myUser.listUsers();
while(iterator.hasNext()){
iterator.next();
}
这样就可以完全不用考虑程序代码实现了，从高层次上把功能抽象出来，定义成为接口，同时又可以把系统设计的很合理，完全根据业务的需求来进行设计。
结语
通过上面的几个例子的设计说明，使用面向对象的思维方法，其实是一个把业务逻辑从具体的编程技术当中抽象出来的过程，而这个抽象的过程是自上而下的，非常符合人类的思维习惯，也就是先不考虑问题解决的细节，把问题的最主要的方面抽象成为一个简单的框架，集中精力思考如何解决主要矛盾，然后在解决问题的过程中，再把问题的细节分割成一个一个小问题，再专门去解决细节问题。
因而一旦牢牢的抓住了这一点，你就会发现在软件设计和开发过程中，你自己总是会不知不觉的运用面向对象的思维方法来设计和编写程序，并且程序的设计和开发也变得不再那么枯燥，而一个合理运用面向对象技术进行设计和架构的软件，更是具备了思维的艺术美感。
最后，愿面向对象的思维方法也能给您的程序设计之路带来创作的乐趣。
第四篇：java面向对象程序设计教案
武汉大学珞珈学院 系/教研室 Java 面 向 对 象 程 序 设 计 课 教 案
主讲教师：熊春秀 编写时间：2011-4-30
第一章：概述
第 1、2 节：面向对象的基本概念、面向对象程序设计概述 授课时间：2011-2-
22、23
计划学时数：1 教学任务与目的：让学生理解面向对象的基本概念 教学重点：掌握面向对象的基本概念 教学难点：理解面向对象程序设计的方法 教学方法：多媒体+板书 参考书目：《面向对象程序设计导论》，[美]C.Thomas wu著，电子工业出版社 专业词汇：Java虚拟机、Applet程序 备注
第二章：Java特点及运行环境
第 1、2、3 节：Java语言特点、Java应用程序及运行环境、Java Applet程序及运行环境 授课时间：2011-2-
22、23
计划学时数：3 教学任务与目的：让学生学会JDK的下载、安装与环境配置。教学重点：掌握编译和执行Java程序的基本步骤
教学难点：理解Java程序的入口并能够通过命令行传递参数 教学方法：多媒体+板书 参考书目：《面向对象程序设计导论》，[美]C.Thomas wu著，电子工业出版社 专业词汇：JDK、lib、bin 备注 第三章：Java语言基础
第 1、2 节：Java程序的构成、数据类型、表达式以及流程控制语句 授课时间：2011-3-
1、2
计划学时数：3 教学任务与目的：让学生学会Java基本的数据类型和表示方法、数值类型的运算、逻辑运算和比较、条件执行语句（包括三种条件语句和switch语句）、循环控制语句（包括for、while、do while循环及相应的辅助语句）、字符串类String和BufferString以及数组的声明及使用。
教学重点：掌握Java基本的数据类型和表示方法
教学难点：理解Java程序的循环控制语句（包括for、while、do while循环及相应的辅助语句）
教学方法：多媒体+板书 参考书目：《Java语言与面向对象程序设计》，印旻编著，清华大学出版社 专业词汇：变量、数据类型、循环控制语句 备注 第三章：Java语言基础 第 3 节：Java与C比较
授课时间：2011-3-
8、9
计划学时数：3 教学任务与目的：让学生在C语言的基本上进一步学习Java语言。教学重点：掌握Java语言与C语言的区别与联系。教学难点：理解Java语言在C语言上的改进。教学方法：多媒体+板书 参考书目：《Java2参考大全（第四版）》，[美]Herbert Schildt著，张玉清、吴浦峰、尚勇等译，清华大学出版社。专业词汇：Java、C 备注 第四章：抽象、封装与类
第 1 节：抽象、封装与Java类的概念
授课时间：2011-3-
15、16
计划学时数：3 教学任务与目的：让学生学会面向对象的基本特征、掌握如何定义一个类以及如何生成对象、深入掌握方法的定义及技巧、深入掌握类的访问权限与封装机制、深入掌握包的定义与包的使用方法。
教学重点：掌握类的定义与对象的生成。教学难点：理解类的抽象与封装机制。教学方法：多媒体+板书 参考书目：《Java2 实用教程》，耿祥义、张跃平编著，清华大学出版社。专业词汇：抽象、封装、类 备注 第四章：抽象、封装与类 第 2 节：系统定义的类
授课时间：2011-3-
22、23
计划学时数：3 教学任务与目的：让学生学会使用系统定义的类，并掌握与用户自定义类的区别。教学重点：掌握如何定义所需要的类。
教学难点：熟悉Java平台定义了哪些经常要用到、而且满足我们需要的类。教学方法：多媒体+板书 参考书目：《Java2 实用教程》，耿祥义、张跃平编著，清华大学出版社。专业词汇：系统定义的类、用户自定义类 备注 第四章：抽象、封装与类
第 3 节：类、域和方法的修饰符
授课时间：2011-3-
29、30
计划学时数：3 教学任务与目的：让学生学会类的声明。
教学重点：掌握如何定义类的修饰和方法的修饰符。教学难点：熟悉类的变量的定义与使用方法。教学方法：多媒体+板书 参考书目：《Java2 实用教程》，耿祥义、张跃平编著，清华大学出版社。专业词汇：成员变量、类变量、成员方法、类方法 备注 第五章：继承与多态
第 1、2 节：Java的继承与派生、域的继承与隐藏 授课时间：2011-4-
5、6
计划学时数：3 教学任务与目的：让学生全面掌握面向对象的基本特征、掌握如何使用继承性来到达软件的重用、深入掌握继承过程中域的隐藏和方法的覆盖技巧。教学重点：掌握如何使用继承性来到达软件的重用。教学难点：熟悉继承过程中域的隐藏和方法的覆盖技巧。教学方法：多媒体+板书 参考书目：《Java2 实用教程》，耿祥义、张跃平编著，清华大学出版社。专业词汇：继承派生、域、隐藏 备注 第五章：继承与多态
第 3、4 节：方法的继承、重载与覆盖、this与super、构造函数的继承与重载 授课时间：2011-4-
12、13
计划学时数：3 教学任务与目的：让学生通过继承可以更有效地组织程序结构，明确类之间的关系，并充分利用已有的类来创建新类，通过继承可以实现代码的重用，以完成更复杂的设计、开发。教学重点：掌握类的重载与覆盖的区别与联系。教学难点：熟悉类的重载与覆盖使用方法。教学方法：多媒体+板书 参考书目：《Java语言与面向对象程序设计》，印旻编著，清华大学出版社。专业词汇：继承、重载、覆盖、this、super 备注 第五章：继承与多态
第 5、6 节：多态性的实现、接口声明与实现 授课时间：2011-4-
19、20
计划学时数：3 教学任务与目的：让学生深入掌握抽象类和抽象方法的定义，掌握多态通过统一多个相关类的对外接口，在运行时根据不同的情况执行不同的操作，提高类的抽象度和灵活性，深入掌握接口的定义和使用技巧。
教学重点：熟悉多态性实现的两种方式以及接口的实现。教学难点：熟悉多态性与接口的实现方法。教学方法：多媒体+板书 参考书目：《Java语言与面向对象程序设计》，印旻编著，清华大学出版社。专业词汇：多态性、接口 备注 第六章：工具类与算法
第 1、2 节：语言基础类库、Applet类与小程序的基本原理 授课时间：2011-4-
26、27
计划学时数：3 教学任务与目的：深入了解Applet生命周期的主要方法和特点、熟练掌握Applet程序的编写方法、深入了解Applet的安全机制及其合理运用。教学重点：熟练掌握Applet程序的编写方法。
教学难点：深入了解Applet的安全机制及其合理运用。教学方法：多媒体+板书 参考书目：《Java语言与面向对象程序设计》，印旻编著，清华大学出版社。专业词汇：Applet、生命周期 备注 第六章：工具类与算法
第 3、4 节：数组、字符串、常用算法
授课时间：2011-5-
3、4
计划学时数：3 教学任务与目的：让学生学会字符串类String和BufferString、数组的声明及使用。教学重点：熟练掌握字符串与数组的使用方法。教学难点：深入了解数组的使用方法。教学方法：多媒体+板书 参考书目：《Java语言与面向对象程序设计》，印旻编著，清华大学出版社。专业词汇：数组、字符串 备注 第七章：用户图形界面的设计
第 1、2 节：用户自定义成分、事件驱动设计 授课时间：2011-5-
10、11
计划学时数：3 教学任务与目的：让学生学会使用面向对象的程序设计方法构建图形用户界面、深入了解抽象窗口工具包（AWT）、掌握事件处理基本原理和方法。教学重点：熟练掌握图形用户界面的开发方法。教学难点：深入了解图形界面的各种事件。教学方法：多媒体+板书 参考书目：《Java语言与面向对象程序设计》，印旻编著，清华大学出版社。专业词汇：AWT、GUI 备注 第七章：用户图形界面的设计
第 3、4 节：GUI对象，包括：按钮、文本框、鼠标、键盘等事件的处理、布局设计 授课时间：2011-5-
17、18
计划学时数：3 教学任务与目的：让学生深入了解GUI构件及掌握布局控制方法、熟练掌握菜单和对话框、掌握简单绘图方法。
教学重点：熟练使用Java语言提供的布局管理器来管理组件在容器中的布局。教学难点：深入了解组件在程序中安排中位置和大小使用方法。教学方法：多媒体+板书 参考书目：《Java语言与面向对象程序设计》，印旻编著，清华大学出版社。专业词汇：布局管理器、容器 备注 第八章：Java高级编程
第 1、2、3节：异常处理、多线程机制、Java程序对网上资源的访问 授课时间：2011-5-
24、25
计划学时数：3 教学任务与目的：让学生深入理解多线程的基本概念、熟练掌握创建线程的两种基本方法、熟练处理线程的同步问题和死锁问题、深入理解异常的基本概念、熟悉和掌握Java平台定义异常类、熟练掌握创建自定义异常类的方法。教学重点：熟练掌握创建线程的两种基本方法。教学难点：深入了解线程的同步问题和死锁问题。教学方法：多媒体+板书 参考书目：《Java语言与面向对象程序设计》，印旻编著，清华大学出版社。专业词汇：同步、死锁、多线程、异常
第五篇：Java面向对象程序设计教学大纲
Java面向对象程序设计课程教学大纲
Object-Oriented Programming with Java Syllabus
课程名称 课程类别 建设单位/教研室 前后课程 适用专业、层次 Java面向对象程序设课程英文名Object-Oriented Programming with Java 计 称 专业必修课 学分/学时 4.0/42+42 计算机系/软件工程教研室 考核方式 考试 C语言程序设计
软件工程、计算机科学与技术、网络工程
Upon completion of this course, students should master the basic knowledge of Java language, understand and grasp the basic object-oriented programming design ideas and skillfully use Java language to write, compile and debug programs.These would lay a good foundation for students on independently finish the work of program development with Java in the future.教学目的
The emphasis: 1.The origin of Java, Why should we learn Java language, Java cross-platform principle analysis(JVM)and Java Environment variable configuration.2.Data and Expressions: including Character Strings, Variables and Assignment, Primitive Data Types, Expressions, Data Conversion, Interactive Programs.3.Oriented object programming ideas: including Class, Object, Variables, Methods, Encapsulation, Inheritance, Polymorphism, Interface and so on.4.Java statements: including conditionals and loops statements.5.Arrays: Declaring and using one-dimensional arrays and two-dimensional arrays.6.Exceptions: including exception handling, uncaught exceptions, and try-catch statement and so on.7.GUI: including event handling and graphics user interface.The difficulty：
Object-oriented concept and idea, establishing application model and algorithm of description, the algorithm optimization of program and so on.教材和主要参考资料： Text and references Text ：
John Lewis “Java程序设计教程(第六版)英文版” 电子工业出版社 ISBN-978-7-121-08808-7 References：
1.《Java编程思想(英文版 第3版)》，（美）Bruce Eckel编，机械工业出版社出版社； 2.Java程序设计基础》，（美）Gary J.Bronson编, 赵德奎 林仕平译，北京大学出版社。
3.Cay S.Horstmann, Gary Cornell.Java 2核心技术 卷I:基础知识.机械工业出版社, 2001.4.Cay S.Horstmann, Gary Cornell.Java 2核心技术 卷II:高级特性.机械工业出版社, 2001.教学内容 学时 基本要求
按章、节具体列出
教学内容 Topic 具体列出教学的基本要求，如了解、理解、掌握及应用等。
By the end of chapter ,students should understand Chapter 1 Introduction
Chapter 2 Data and ExpressionsChapter 3 Using Classes and Objects Chapter 4 Writing Classes 3+3 To be able to have a fundamental understanding of software role in a computer system. To know components of a computer To understand how those components interact To grasp how computers store and manipulate information To know how computers are connected into networks to share information. To profile programming and programming languages To profile an introduction to Java To grasp object-oriented concepts 3+6 Explore some of the basic types of data used in a Java program and the use of expressions to perform calculations. To understand character strings, concatenation, and escape sequences. To grasp the declaration and use of variables. To be familiar with Java primitive data types. To understand expressions and operator precedence. To grasp the syntax and processing of expressions. To understand the types of data conversions and the mechanisms for
accomplishing them. To know how to create interactive programs. To understand the basic graphic concepts and the techniques for drawing
shapes. To know the concept of a Java applet.4+4 Use the predefined classes in the Java class library that are provided to us to make the process of writing programs easier. To grasp the creation of objects and the use of object reference variables. To be familiar with the services provided by the String class. To know how the java standard class library is organized into packages. To be familiar with the services provided by the Random and Math class. To grasp ways to format output using the NumberFormat and DecimalFormat
classes. To be familiar with enumerated types. To understand wrapper classes and the concept of autoboxing. To understand components and containers used in graphics user interfaces. To know a label component and the use of images.6+6 We've been using predefined classes.Now we will learn to write our own classes to define objects. To grasp the structure and content of a class definition. To understand the concept of object state using instance data. To know the effect of visibility modifiers on methods and data. To grasp the structure of a method definition, including parameters and return
values. To grasp the structure and purpose of a constructor. To grasp the creation of graphical objects. To understand the concepts needed to create an interactive graphical user
interface.Chapter 5 Conditionals and Loops
Chapter 6 OBJECT-ORIENTED DESIGN
Chapter 7 Arrays
Chapter 8 Inheritance To know some basic GUI components and events.4+4 Now we will examine programming statements that allow us to make decisions and repeat processing steps in a loop. To know the flow of control through a method. To understand Boolean expressions that can be used to make decisions. To grasp to perform basic decision making using if and switch statements. To understand issues pertaining to the comparison of certain types of data. To grasp familiarly to execute statements repetitively using while, do, and for
loops. To understand the concept of an iterator object and use one to read a text file. To know how to draw with the aid of conditionals and loops. To know more GUI components and events.4+4 Now we can extend our discussion of the design of classes and objects To know key issues related to the design of object-oriented software. To techniques for identifying the classes and objects needed in a program. To understand the relationships among classes. To understand the effect on the static modifier on methods and data. To grasp the creation of a formal object interface. Further grasp the definition of enumerated type classes. To grasp issues related to the design of methods, including method
overloading. To know issues related to the design of graphics user interface, including
layout managers.6+3 Arrays are objects that help us organize large amounts of information Define and use arrays for basic data organization. To know bounds checking and techniques for managing capacity. To learn to compare the issues related to arrays as objects and arrays of
objects. To grasp the use of command-line arguments. To grasp the syntax and use of variable-length parameter lists. To be familiar with the creation and use of multidimensional arrays. To be familiar with the ArrayList class and its generic parameter. To know more mouse and keyboard events.6+6 Inheritance is a fundamental object-oriented design technique used to create and organize reusable classes. To know the derivation of new classes from existing ones. To understand the concept and purpose of method overriding. To grasp the design of class hierarchies. To grasp the issue of visibility as it relates to inheritance. To have the ability to derive on interface from another. To grasp object-oriented design in the context of inheritance. To know the inheritance structure for GUI components. To explore the creation of listeners by extending adaptor classes.Chapter 9 Polymorphism 3+3 Chapter 10 Exceptions 3+3 有关说明：
拟稿（签名）：谢彦麒 Polymorphism is an object-oriented concept that allows us to create versatile software designs To understand polymorphism and explore its benefits. To understand the concept of dynamic binding. To grasp to use inheritance relationships to create polymorphic references. To grasp to use interfaces to create polymorphic references. To grasp sorting and searching using polymorphic implementations. To be familiar with object-oriented design in the context of polymorphism. To know the processing of events as an example of polymorphism. To know more GUI components.Exception handling is an important aspect of object-oriented design To know the purpose of exceptions. To know exception messages and the call stack trace.
To be familiar with the usage of the try-catch statement for handling exception. To understand the concept of exception propagation.
To be familiar with the exception class hierarchy in the Java standard class library. To be familiar with I/O exception and the ability to write text files. To know how to create GUI using mnemonics and tool tips.
To know additional GUI components and containers.核稿（签名）： 审批（签名）： 年 月 日
点击咨询 