学习面向切面编程的总结

第一篇：学习面向切面编程的总结

北大青鸟中关村

AOP（面向切面编程）

可以说是OOP（Object-Oriented Programing，面向对象编程）的补充和完善。OOP引入封装、继承和多态性等概念来建立一种对象层次结构，用以模拟公共行为的一个集合。当我们需要为分散的对象引入公共行为的时候，OOP则显得无能为力。也就是说，OOP允许你定义从上到下的关系，但并不适合定义从左到右的关系。例如日志功能。日志代码往往水平地散布在所有对象层次中，而与它所散布到的对象的核心功能毫无关系。对于其他类型的代码，如安全性、异常处理和透明的持续性也是如此。这种散布在各处的无关的代码被称为横切（cross-cutting）代码，在OOP设计中，它导致了大量代码的重复，而不利于

各个模块的重用。

而AOP技术则恰恰相反，它利用一种称为“横切”的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其名为“Aspect”，即方面。所谓“方面”，简单地说，就是将那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可操作性和可维护性。AOP代表的是一个横向的关系，如果说“对象”是一个空心的圆柱体，其中封装的是对象的属性和行为；那么面向方面编程的方法，就仿佛一把利刃，将这些空心圆柱体剖开，以获得其内部的消息。而剖开的切面，也就是所谓的“方面”了。然后它又以巧夺天功的妙手将这些剖开的切面复原，不留痕迹。

使用“横切”技术，AOP把软件系统分为两个部分：核心关注点和横切关注点。业务处理的主要流程是核心关注点，与之关系不大的部分是横切关注点。横切关注点的一个特点是，他们经常发生在核心关注点的多处，而各处都基本相似。

北大青鸟中关村

比如权限认证、日志、事务处理。Aop的作用在于分离系统中的各种关注点，将核心关注点和横切关注点分离开来。正如Avanade公司的高级方案构架师Adam Magee所说，AOP的核心思想就是“将应用程序中的商业逻辑同对其提供支持的通用服务进行分离。”

实现AOP的技术，主要分为两大类：一是采用动态代理技术，利用截取消息的方式，对该消息进行装饰，以取代原有对象行为的执行；二是采用静态织入的方式，引入特定的语法创建“方面”，从而使得编译器可以在编译期间织入有关“方面”的代码。然而殊途同归，实现AOP的技术特性却是相同的，分别为：

1、join point（连接点）：是程序执行中的一个精确执行点，例如类中的一个方法。它是一个抽象的概念，在实现AOP时，并不需要去定义一个join point。

2、point cut（切入点）：本质上是一个捕获连接点的结构。在AOP中，可以定义一个point cut，来捕获相关方法的调用。

3、advice（通知）：是point cut的执行代码，是执行“方面”的具体逻辑。

4、aspect（方面）：point cut和advice结合起来就是aspect，它类似于OOP中定义的一个类，但它代表的更多是对象间横向的关系。

5、introduce（引入）：为对象引入附加的方法或属性，从而达到修改对象结构的目的。有的AOP工具又将其称为mixin。

上述的技术特性组成了基本的AOP技术，大多数AOP工具均实现了这些技术。它们也可以是研究AOP技术的基本术语。2.2.2 横切技术

北大青鸟中关村

“横切”是AOP的专有名词。它是一种蕴含强大力量的相对简单的设计和编程技术，尤其是用于建立松散耦合的、可扩展的企业系统时。横切技术可以使得AOP在一个给定的编程模型中穿越既定的职责部分（比如日志记录和性能优化）的操作。

如果不使用横切技术，软件开发是怎样的情形呢？在传统的程序中，由于横切行为的实现是分散的，开发人员很难对这些行为进行逻辑上的实现或更改。例如，用于日志记录的代码和主要用于其它职责的代码缠绕在一起。根据所解决的问题的复杂程度和作用域的不同，所引起的混乱可大可小。更改一个应用程序的日志记录策略可能涉及数百次编辑——即使可行，这也是个令人头疼的任务。

在AOP中，我们将这些具有公共逻辑的，与其他模块的核心逻辑纠缠在一起的行为称为“横切关注点（Crosscutting Concern）”，因为它跨越了给定编程模型中的典型职责界限。2.2.2.1 横切关注点

一个关注点（concern）就是一个特定的目的，一块我们感兴趣的区域，一段我们需要的逻辑行为。从技术的角度来说，一个典型的软件系统包含一些核心的关注点和系统级的关注点。举个例子来说，一个信用卡处理系统的核心关注点是借贷/存入处理，而系统级的关注点则是日志、事务完整性、授权、安全及性能问题等，许多关注点——即横切关注点（crosscutting concerns）——会在多个模块中出现。如果使用现有的编程方法，横切关注点会横越多个模块，结果是使系统难以设计、理解、实现和演进。AOP能够比上述方法更好地分离系统关注点，从而提供模块化的横切关注点。

北大青鸟中关村

例如一个复杂的系统，它由许多关注点组合实现，如业务逻辑、性能，数据存储、日志和调度信息、授权、安全、线程、错误检查等，还有开发过程中的关注点，如易懂、易维护、易追查、易扩展等，图2.1演示了由不同模块实现的一批关注点组成一个系统。

图2.1 把模块作为一批关注点来实现

通过对系统需求和实现的识别，我们可以将模块中的这些关注点分为：核心关注点和横切关注点。对于核心关注点而言，通常来说，实现这些关注点的模块是相互独立的，他们分别完成了系统需要的商业逻辑，这些逻辑与具体的业务需求有关。而对于日志、安全、持久化等关注点而言，他们却是商业逻辑模块所共同需要的，这些逻辑分布于核心关注点的各处。在AOP中，诸如这些模块，都称为横切关注点。应用AOP的横切技术，关键就是要实现对关注点的识别。

北大青鸟中关村

如果将整个模块比喻为一个圆柱体，那么关注点识别过程可以用三棱镜法则来形容，穿越三棱镜的光束（指需求），照射到圆柱体各处，获得不同颜色的光束，最后识别出不同的关注点。如图2.2所示：

图2.2 关注点识别：三棱镜法则

上图识别出来的关注点中，Business Logic属于核心关注点，它会调用到Security，Logging，Persistence等横切关注点。public class BusinessLogic { public void SomeOperation(){ //验证安全性；Securtity关注点；

//执行前记录日志；Logging关注点；

DoSomething();//保存逻辑运算后的数据；Persistence关注点；

//执行结束记录日志；Logging关注点；

} }

北大青鸟中关村

AOP的目的，就是要将诸如Logging之类的横切关注点从BusinessLogic类中分离出来。利用AOP技术，可以对相关的横切关注点封装，形成单独的“aspect”。这就保证了横切关注点的复用。由于BusinessLogic类中不再包含横切关注点的逻辑代码，为达到调用横切关注点的目的，可以利用横切技术，截取BusinessLogic类中相关方法的消息，例如SomeOperation()方法，然后将这些“aspect”织入到该方法中。例如图2.3：

图2.3 将横切关注点织入到核心关注点中

通过利用AOP技术，改变了整个系统的设计方式。在分析系统需求之初，利用AOP的思想，分离出核心关注点和横切关注点。在实现了诸如日志、事务管理、权限控制等横切关注点的通用逻辑后，开发人员就可以专注于核心关注点，将精力投入到解决企业的商业逻辑上来。同时，这些封装好了的横切关注点提供的功能，可以最大限度地复用于商业逻辑的各个部分，既不需要开发人员作特殊的编码，也不会因为修改横切关注点的功能而影响具体的业务功能。为了建立松散耦合的、可扩展的企业系统，AOP应用到的横切技术，通常分为两种类型：动态横切和静态横切。2.2.2.2 动态横切

北大青鸟中关村

动态横切是通过切入点和连接点在一个方面中创建行为的过程，连接点可以在执行时横向地应用于现有对象。动态横切通常用于帮助向对象层次中的各种方法添加日志记录或身份认证。在很多应用场景中，动态横切技术基本上代表了AOP。

动态横切技术的核心主要包括join point（连接点），point cut（切入点），advice（通知）和aspect（方面）。在前面，我已经概要地介绍了这些术语分别代表的含义。接下来，我将以一个具体的实例来进一步阐述它们在AOP动态横切中实现的意义。

考虑一个电子商务系统，需要对订单进行添加、删除等管理操作。毫无疑问，在实际的应用场景中，这些行为应与权限管理结合，只有获得授权的用户方能够实施这些行为。采用传统的设计方法，其伪代码如下： public class OrderManager { private ArrayListm_Orders;public OrderManager(){ m_Orders = new ArrayList();} public void AddOrder(Order order){ if(permissions.Verify(Permission.ADMIN)){

北大青鸟中关村

m_Orders.Add(order);} } public void RemoveOrder(Order order){ if(permissions.Verify(Permission.ADMIN)){ m_Orders.Remove(order);} } } 同样的，在该电子商务系统中，还需要对商品进行管理，它采用了同样的授权机制：

public class ProductManager { private ArrayListm_Products;public ProductManager(){ m_Products = new ArrayList();} public void AddProduct(Product product){ if(permissions.Verify(Permission.ADMIN))

北大青鸟中关村

{ m_Products.Add(product);} } public void RemoveProduct(Product product){ if(permissions.Verify(Permission.ADMIN)){ m_Products.Remove(product);} } } 如此以来，在整个电子商务系统中，核心业务包括订单管理和商品管理，它们都需要相同的权限管理，如图2.4所示：

图2.4 电子商务系统的权限验证实现

毫无疑问，利用AOP技术，我们可以分离出系统的核心关注点和横切关注点，从横向的角度，截取业务管理行为的内部消息，以达到织入权限管理逻辑的目

北大青鸟中关村 的。当执行AddOrder()等方法时，系统将验证用户的权限，调用横切关注点逻辑，因此该方法即为AOP的join point。对于电子商务系统而言，每个需要权限验证的方法都是一个单独的join point。由于权限验证将在每个方法执行前执行，所以对于这一系列join point，只需要定义一个point cut。当系统执行到join point处时，将根据定义去查找对应的point cut，然后执行这个横切关注点需要实现的逻辑，即advice。而point cut和advice，就组合成了一个权限管理aspect。

图2.5 AOP动态横切的技术实现

由于aspect是一个封装的对象，我们可以定义这样一个aspect： private static aspect AuthorizationAspect{……}

然后在这个aspect中定义point cut，在point cut中，定义了需要截取上下文消息的方法，例如：

private pointcutauthorizationExecution(): execution(public void OrderManager.AddOrder(Order))||

北大青鸟中关村

execution(public void OrderManager.DeleteOrder(Order))|| execution(public void ProductManager.AddProduct(Product))|| execution(public void ProductManager.DeleteProduct(Product));由于权限验证是在订单管理方法执行之前完成，因此在before advice中，定义权限检查：

before(): authorizationExecution(){ if!(permissions.Verify(Permission.ADMIN)){ throw new UnauthorizedException();} } 通过定义了这样一个完整的aspect，当系统调用OrderManager或ProductManager的相关方法时，就触发了point cut，然后调用相应的advice逻辑。如此以来，OrderManager和ProductManager模块就与权限管理模块完全解除了依赖关系，同时也消除了传统设计中不可避免的权限判断的重复代码。这对于建立一个松散耦合、可扩展的系统软件是非常有利的。2.2.2.3 静态横切

静态横切和动态横切的区别在于它不修改一个给定对象的执行行为。相反，它允许通过引入附加的方法字段和属性来修改对象的结构。此外，静态横切可以把扩展和实现附加到对象的基本结构中。在AOP实现中，通常将静态横切称为introduce或者mixin。

北大青鸟中关村

静态横切在AOP技术中，受到的关注相对较少。事实上，这一技术蕴含的潜力是巨大的。使用静态横切，架构师和设计者能用一种真正面向对象的方法有效地建立复杂系统的模型。静态横切允许您不用创建很深的层次结构，以一种本质上更优雅、更逼真于现实结构的方式，插入跨越整个系统的公共行为。尤其是当开发应用系统时，如果需要在不修改原有代码的前提下，引入第三方产品和API库，则静态横切技术将发挥巨大的作用。

举例来说，当前已经实现了一个邮件收发系统，其中类Mail完成了收发邮件的功能。但在产品交付后，发现该系统存在缺陷，在收发邮件时，未曾实现邮件地址的验证功能。现在，第三方产品已经提供了验证功能的接口IValidatable： public interface IValidatable { boolValidateAddress();} 我们可以利用设计模式中的Adapter模式，来完成对第三方产品API的调用。我们可以定义一个新的类MailAdapter，该类实现了IValidatable接口，同时继承了Mail类：

public class MailAdapter:Mail,IValidatable { public boolValidateAddress(){ if(this.getToAddress()!= null){ return true;

北大青鸟中关村

} else { return false;} } } 通过引入MailAdapter类，原来Mail对象完成的操作，将全部被MailAdapter对象取代。然而，此种实现方式虽然能解决引入新接口的问题，但类似下面的代码，却是无法编译通过的： Mail mail = new Mail();IValidatable validate =((IValidatable)mail).ValidateAddress();必须将第一行代码作如下修改： Mail mail = new MailAdapter();利用AOP的静态横切技术，可以将IValidatable接口织入到原有的Mail类中，这是一种非常形象的introduce功能，其实现仍然是在aspect中完成： importcom.acme.validate.Validatable;public aspect MailValidateAspect { declare parents: Mail implements IValidatable;

北大青鸟中关村

publicbooleanMail.validateAddress(){ if(this.getToAddress()!= null){ return true;} else { return false;} } } 静态横切的方法，并没有引入类似MailAdapter的新类，而是通过定义的MailValidateAspect方面，利用横切技术为Mail类introduce了新的方法ValidateAddress()，从而实现了Mail的扩展。因此如下的代码完全可行。Mail mail = new Mail();IValidatable validate =((IValidatable)mail).ValidateAddress();2.3 AOP技术的优势

AOP技术的优势是显而易见的。在面向对象的世界里，人们提出了各种方法和设计原则来保障系统的可复用性与可扩展性，以期建立一个松散耦合、便于扩展的软件系统。例如GOF提出的“设计模式”，为我们提供了设计的典范与准则。设计模式通过最大程度的利用面向对象的特性，诸如利用继承、多态，对责任

北大青鸟中关村

进行分离、对依赖进行倒置，面向抽象，面向接口，最终设计出灵活、可扩展、可重用的类库、组件，乃至于整个系统的架构。在设计的过程中，通过各种模式体现对象的行为、暴露的接口、对象间关系、以及对象分别在不同层次中表现出来的形态。然而鉴于对象封装的特殊性，“设计模式”的触角始终在接口与抽象中大做文章，而对于对象内部则无能为力。

通过“横切”技术，AOP技术就能深入到对象内部翻云覆雨，截取方法之间传递的消息为我所用。由于将核心关注点与横切关注点完全隔离，使得我们能够独立的对“方面”编程。它允许开发者动态地修改静态的OO模型，构造出一个能够不断增长以满足新增需求的系统，就象现实世界中的对象会在其生命周期中不断改变自身，应用程序也可以在发展中拥有新的功能。设计软件系统时应用AOP技术，其优势在于：

（一）在定义应用程序对某种服务（例如日志）的所有需求的时候。通过识别关注点，使得该服务能够被更好的定义，更好的被编写代码，并获得更多的功能。这种方式还能够处理在代码涉及到多个功能的时候所出现的问题，例如改变某一个功能可能会影响到其它的功能，在AOP中把这样的麻烦称之为“纠结（tangling）”。

（二）利用AOP技术对离散的方面进行的分析将有助于为开发团队指定一位精于该项工作的专家。负责这项工作的最佳人选将可以有效利用自己的相关技能和经验。

（三）持久性。标准的面向对象的项目开发中，不同的开发人员通常会为某项服务编写相同的代码，例如日志记录。随后他们会在自己的实施中分别对日志

北大青鸟中关村

进行处理以满足不同单个对象的需求。而通过创建一段单独的代码片段，AOP提供了解决这一问题的持久简单的方案，这一方案强调了未来功能的重用性和易维护性：不需要在整个应用程序中一遍遍重新编写日志代码，AOP使得仅仅编写日志方面（logging aspect）成为可能，并且可以在这之上为整个应用程序提供新的功能。

总而言之，AOP技术的优势使得需要编写的代码量大大缩减，节省了时间，控制了开发成本。同时也使得开发人员可以集中关注于系统的核心商业逻辑。此外，它更利于创建松散耦合、可复用与可扩展的大型软件系统。

第二篇：面向对象编程的总结

面向对象编程的总结（理解与看法）面向对象程序设计（Object Oriented Programming，OOP，面向对象程序设计）是一种计算机编程架构。OOP 的一条基本原则是计算机程序是由单个能够起到子程序作用的单元或对象组合而成。

OOP 达到了软件工程的三个主要目标：重用性、灵活性和扩展性。为了实现整体运算，每个对象都能够接收信息、处理数据和向其它对象发送信息。

面向对象有三大特性，分别是：封装、继承、多态。封装是隐藏对象的属性和实现细节，仅对外公开接口，控制在程序中属性的读和修改的访问级别；将抽象得到的数据和行为（或功能）相结合，形成一个有机的整体，也就是将数据与操作数据的源代码进行有机的结合，形成“类”，其中数据和函数都是类的成员。目的是增强安全性和简化编程，使用者不必了解具体的实现细节，而只是要通过外部接口，以特定的访问权限来使用类的成员。任何类都可以从另外一个类继承，即这个类拥有它所继承类的所有成员。被继承的类称为父类或基类。C# 只支持单继承，不支持多重继承，即在C# 中一次只允许继承一个类，不能同时继承多个类。在C# 中，接口允许多继承，可以通过继承多个接口来实现类似于C++中的多重继承。

多态是同一个类在不同场合下表现出不同的行为特征。

使用抽象方法与虚方法都可以实现多态性。抽象方法是一个未实现的方法，使用abstract关键字修饰，含有抽象方法的类必然是抽象类。抽象方法要在其子方法中通过override关键字重写。

简单工厂模式用于在调用者不知道对象属于哪个自雷的情况下，创建不同的对象。

第三篇：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;

}

答：不能通过编译。

第四篇：C语言面向对象编程学习笔记

C语言面向对象编程笔记

1、在底层驱动函数前加static标识符的作用：

a：加了static后表示该函数失去了全局可见性，只在该函数所在的文件作用域内可见 b：当函数声明为static以后,编译器在该目标编译单元内只含有该函数的入口地址,没有函数名,其它编译单元便不能通过该函数名来调用该函数，这也是对1的解析与说明

2、底层驱动的封装模板

通常将存储类，显示类，AD-DA类的外设驱动函数封装为以下几个函数： Void Open（void）；

此函数用于开启外设，通常函数体中包涵IO和外设的初始化 Void Close(void)此函数用于关闭外设，特别是一些在休眠下功耗很大的外设，可用mos管控制其Vcc的通断，以此达到降低系统功耗的目的

Void Read（unsigned int address，unsigned char *data[]，unsigned int count）

此函数用于读取数据，参数分别为：address，地址，*data[]，存放数据的数组，count，要读取的字节数

Void Write（unsigned int address，unsigned char *data[]，unsigned int count）此函数用于写数据，参数功能与读函数中相似。

Void control（unsigned char cmd，unsigned char data）此函数用于控制外设的工作状态，如休眠，低功耗等等

3、命名规则

A、宏定义全部用大写

如：#define OLED_CS PBout(12)B、驱动函数名称大小写，并且动词放置在末尾如

static long _OLED_Close(void)C、结构体的名称，结构体名大写，变量名小写，“驱动”的首字母大写

如：struct OLED_DEVICE oledDevice;

4、关于外设的数据手册

外设的数据手册应该去芯片的官网下载最新版本，特别注意芯片的是否有功耗控制方面的内容，

第五篇：使用java实现面向对象编程总结

第一章：抽象和封装

1，为什么使用面向对象

1.1：万事万物皆对象，面向对象就是采用“现实模拟”的方法设计和开发程序。

2，使用面向对象进行设计

2.1：面向对象设计三部曲

1，发现类。

2，发现类的属性。

3，发现类的方法。

经验：在需求中找出名词的方式确定类和属性，找出动词的方式确定方法。

3，创建类的对象

1，通过构造方法来创建对象

2，通过对象名.属性名的方式调用属性。

3，通过对象名.方法名的方式调用方法。

4，Static可以用来修饰属性，方法和代码块。Static修饰的变

量属于这个类所有。即由这个类创建的所有对象共有同一个static变量。类属性，类方法可以通过类名和对象名访问，势力属性，实例方法只能通过对象名访问。

5，在方法里不可以定义static变量，类变量不能是局部变量。6，构造函数的重载

1，构造方法的名字和类名相同，没有返回值类型。构造

方法的作用主要就是在创建对象是执行一些初始化操作，赋值。

2，在没有给类提供任何构造方法时，系统会提供一个无

参的方法体为空的默认构造方法。一旦提供了自定义构造方法，系统将不会提供这个默认构造方法，如果要使用她，必须手动添加。

3，如果同一个类中包含了两个或两个以上方法，它们的方法名相同，方法参数个数或参数类型不同，则称该方法被重载。成员方法和构造方法都可以重载。

4，构造方法没有返回值类型。如果有，就不是构造方法，而是构造方法同名的成员方法。

5，封装

1，封装是类的三大特性之一，就是将类的状态信息隐

藏在内部。

2，封装的具体步骤：为每个属性创建一对一赋值，在赋值方法中，加入对属性的存取控制语句。

3，隐藏类的实现细节，让使用者只能通过程序员规定的方法来访问数据，可以方便地加入存取控制语句，限制不合理操作。