面向对象编程思想.docx

面向对象编程思想.docx

《面向对象编程思想.docx》由会员分享，可在线阅读，更多相关《面向对象编程思想.docx（17页珍藏版）》请在冰豆网上搜索。

面向对象编程思想

面向对象编程思想

1.面向对象的基本概念：

面向对象编程（ObjectOrientedProgramming，OOP，面向对象程序设计）是一种计算机编程架构。

OOP的一条基本原则是计算机程序是由单个能够起到子程序作用的单元或对象组合而成。

OOP是一种计算机编程模式,它将对象作为问题空间的基本元素,利用对象和对象之间的相互作用来设计程序。

OOP的设计思想是以数据为中心,自底向上,逐步合并。

OOP的最核心属性就是其可重用性,相比其他范式却并不具有明显优势,但它更接近人类的认知模式。

OOP的核心思想可以归纳为:

以数据为中心组织逻辑,将系统视为互相作用的对象的集合,并利用继承与多态来增强可维护性,可扩展性和可重用性。

2.对象

对象是人们要进行研究的任何事物,从最简单的整数到复杂的飞机等均可看作对象,它不仅能表示具体的事物,还能表示抽象的规则,计划或事件。

如我手上的这部手机是一个对象。

3.类

具有相同或相似性质的对象的抽象就是类.。

因此,对象的抽象是类,类的具体化就是对象,也可以说类的实例是对象.。

iphoneX是一个类。

4.关系

●继承

一般和特殊的关系,它指定了子类如何特化父类的特征和行为，继承只能单一继承不能多继承。

例如,小米手机定制版是小米手机的一种。

✧继承的好处

1）提高了代码的复用性

2）多个类相同的成员可以放到同一个类中

3）提高了代码的维护性

4）如果功能的代码需要修改，修改一处即可

5）让类与类之间产生了关系，是多态的前提

✧继承的弊端

1）好处的第三点同时也是继承的弊端

2）类与类之间产生了关系，让类的耦合性增强了

3）设计原则：

高内聚低耦合

●实现

是一种类与接口的关系,表示类是接口的特征和行为的实现。

发短信这个功能大伙都知道,小米手机就实现了发短信这个功能,而且苹果手机也实现了发短信这个功能。

1.接口的成员特点

✧成员变量

只能是常量：

默认修饰符publicstaticfinal

✧构造方法

没有，因为接口主要是扩展功能的，而没有具体存在

✧成员方法

默认修饰符publicabstract

2.类与类_类与接口_接口与接口的关系

✧类与类

继承关系，只能单继承，但是可以多层继承。

✧类与接口

实现关系，可以单实现，也可以多实现。

还可以在继承一个类的同时实现多个接口。

✧接口与接口

继承关系，可以单继承，也可以多继承。

3.抽象类与接口的区别

✧成员区别

1）抽象类变量,常量;有抽象方法;抽象方法,非抽象方法

2）接口常量;抽象方法

✧关系区别

1）类与类继承，单继承

2）类与接口实现，单实现，多实现

3）接口与接口继承，单继承，多继承

✧设计理念区别

1）抽象类被继承体现的是：

”isa”的关系。

共性功能

2）接口被实现体现的是：

”likea”的关系。

扩展功能

●组合

是整体与部分的关系,但部分不能离开整体而单独存在。

如一台小米手机拥有按键,可是离开了手机,按键也就失去了意义.。

●聚合

是整体与部分的关系,且部分可以离开整体而单独存在。

一个豪华小米电视套餐还包含一套音箱,这个音箱也可以是单独卖的。

●关联

是一种拥有的关系,一个类知道另外一个类的属性和方法。

小米手机可以控制小米电视机。

●依赖

是一种使用的关系,一个类的实现需要另一个类的协助。

小米手机控制小米电视机的时候需要有个路由器。

5.基本特征

●封装

将对象或其中的方法属性加一层包装。

电脑有硬盘,可是我们只能够通过操作系统去访问他。

●继承

对象的一个新类可以从现有的类中派生。

●多态

不同类的对象对同一消息做出不同反应。

我用不同牌子的手机,收到电话的时候铃声是不同的。

6.设计原则

●间接–柔胜于刚,取胜于直

编程中有一句名言:

任何计算机问题均可通过增加一个间接层来解决。

变量间接指代某个值或表达式,函数也间接指代了某段代码。

一个适当的中间层,在形式上表现为间接层,在实质上体现为抽象层。

●抽象的意义

A.掩盖了具体的细节,提高代码的简洁度

B.赋予了明确的语意,提高代码的清晰度

●间接的意义

a）建立了名与实的映射,提高了代码的一致性和可维护性

b）实现了名与实的分离,提高了代码的灵活性和可扩展性

●依赖–有求皆苦,无欲则刚

抽象与规范是根本,间接与分离是手段,依赖与控制是关键,接口与服务是核心。

接口一方面作为一种抽象类型,描述了一类对象所应遵守的行为规范;另一方面作为间接层,把两个耦合的具体类进行了分离。

1）依赖反转原则DependencyInversionPrinciple

高层模块不应该依赖底层模块,它们都应该依赖抽象;抽象不应该依赖细节,细节应依赖抽象。

2）依赖注入DependencyInjection

依赖的对象是从外部注入的，DI强调依赖的来源,完全有外部提供。

DIP强调依赖的抽象性。

3）控制反转IoC

控制反转是一种管理组建依赖的机制,它打破了常规的流程控制模式,把控制权从用户的应用代码转给了底层的某个组建,以保证组建总能在合适的时候获得合适的依赖。

依赖注射是控制反转的一种实现方式。

7.内聚（不是一家人,不进一家门）

Ø耦合反映模块之间的关联程度,内聚反映模块内部的关联成强度。

Ø面向对象编程设计思想原则：

高内聚，低耦合，就近原则。

1）单一职责原则

一个类应当只有一个变更的理由。

2）局部化原则

让代码的物理紧密程度与逻辑紧密程度保持一致。

3）接口隔离原则

不应强迫客户依赖那些他们不用的方法,多个专用的接口比单纯一个总接口更好。

8.现在讲一个经典的面向对象编程的案例代码

✧********数据库的增删改查操作******

1.首先创建一个Account类

packagecom.itheima.dbutils.domain;

publicclassAccount{

privateIntegerid;

privateStringname;

privateDoublemoney;

publicIntegergetId（）{

returnid;

}

publicvoidsetId（Integerid）{

this.id=id;

}

publicStringgetName（）{

returnname;

}

publicvoidsetName（Stringname）{

this.name=name;

}

publicDoublegetMoney（）{

returnmoney;

}

publicvoidsetMoney（Doublemoney）{

this.money=money;

}

@Override

publicStringtoString（）{

return"Account[id="+id+",name="+name+",money="+money+"]";

}

}

2.其次创建JDBCUtils工具类

packagecom.itheima.jdbc.utils;

importjava.sql.Connection;

importjava.sql.ResultSet;

importjava.sql.SQLException;

importjava.sql.Statement;

importjavax.sql.DataSource;

importcom.mchange.v2.c3p0.ComboPooledDataSource;

/**

*JDBC的工具类

*@authorjt

*

*/

publicclassJDBCUtils2{

//创建一个连接池：

但是这个连接池只需要创建一次即可。

privatestaticfinalComboPooledDataSourcedataSource=newComboPooledDataSource（）;

/**

*获得连接的方法

*@throwsSQLException

*/

publicstaticConnectiongetConnection（）throwsSQLException{

returndataSource.getConnection（）;

}

/**

*获得连接池:

*/

publicstaticDataSourcegetDataSource（）{

returndataSource;

}

/**

*释放资源的方法

*/

publicstaticvoidrelease（Statementstmt,Connectionconn）{

if（stmt!

=null）{

try{

stmt.close（）;

}catch（SQLExceptione）{

e.printStackTrace（）;

}

stmt=null;

}

if（conn!

=null）{

try{

conn.close（）;

}catch（SQLExceptione）{

e.printStackTrace（）;

}

conn=null;

}

}

publicstaticvoidrelease（ResultSetrs,Statementstmt,Connectionconn）{

//资源释放：

if（rs!

=null）{

try{

rs.close（）;

}catch（SQLExceptione）{

e.printStackTrace（）;

}

rs=null;

}

if（stmt!

=null）{

try{

stmt.close（）;

}catch（SQLExceptione）{

e.printStackTrace（）;

}

stmt=null;

}

if（conn!

=null）{

try{

conn.close（）;

}catch（SQLExceptione）{

e.printStackTrace（）;

}

conn=null;

}

}

}

3.然后利用DBUtils工具类库实现面向对象编程代码：

packagecom.itheima.dbutils.demo3;

importjava.sql.SQLException;

importjava.util.Arrays;

importjava.util.List;

importjava.util.Map;

importmons.dbutils.QueryRunner;

importmons.dbutils.handlers.ArrayHandler;

importmons.dbutils.handlers.ArrayListHandler;

importmons.dbutils.handlers.BeanHandler;

importmons.dbutils.handlers.BeanListHandler;

importmons.dbutils.handlers.ColumnListHandler;

importmons.dbutils.handlers.KeyedHandler;

importmons.dbutils.handlers.MapHandler;

importmons.dbutils.handlers.MapListHandler;

importmons.dbutils.handlers.ScalarHandler;

importorg.junit.Test;

importcom.itheima.dbutils.domain.Account;

importcom.itheima.jdbc.utils.JDBCUtils2;

/**

*ResultSetHandler的实现类

*

*@authorjt

*

*/

publicclassDBUtilsDemo3{

@Test

/**

*ArrayHandler:

将一条记录封装到一个Object数组中

*/

publicvoiddemo1（）throwsSQLException{

QueryRunnerqueryRunner=newQueryRunner（JDBCUtils2.getDataSource（））;

Object[]objs=queryRunner.query（"select*fromaccountwhereid=?

",newArrayHandler（）,1）;

System.out.println（Arrays.toString（objs））;

}

@Test

/**

*ArrayListHandler:

将多条记录封装到一个装有Object数组的List集合中*

*一条记录封装到Objecct[]数组中，多条记录就是多个Object[]，那么多个Object数组就将其装入List集合中即可。

*/

publicvoiddemo2（）throwsSQLException{

QueryRunnerqueryRunner=newQueryRunner（JDBCUtils2.getDataSource（））;

Listlist=queryRunner.query（"select*fromaccount",newArrayListHandler（））;

for（Object[]objects:

list）{

System.out.println（Arrays.toString（objects））;

}

}

@Test

/**

*BeanHandler：

将一条记录封装到一个JavaBean中

*/

publicvoiddemo3（）throwsSQLException{

QueryRunnerqueryRunner=newQueryRunner（JDBCUtils2.getDataSource（））;

Accountaccount=queryRunner.query（"select*fromaccountwhereid=?

",

newBeanHandler（Account.class）,2）;

System.out.println（account）;

}

@Test

/**

*BeanListHandler:

将多条记录封装到一个装有JavaBean的List集合中。

**一条记录就是一个Java的对象（JavaBean），如果多条记录（多个Java的对象），将多个Java对象装到一个List集合中。

*/

publicvoiddemo4（）throwsSQLException{

QueryRunnerqueryRunner=newQueryRunner（JDBCUtils2.getDataSource（））;

Listlist=queryRunner.query（"select*fromaccount",newBeanListHandler（Account.class））;

for（Accountaccount:

list）{

System.out.println（account）;

}

}

@Test

/**

*MapHandler：

将一条记录封装到一个Map集合中，Map的key是列名，Map的value就是表中列的记录值。

*/

publicvoiddemo5（）throwsSQLException{

QueryRunnerqueryRunner=newQueryRunner（JDBCUtils2.getDataSource（））;

Mapmap=queryRunner.query（"select*fromaccountwhereid=?

",newMapHandler（）,4）;

System.out.println（map）;

}

@Test

/**

*MapListHandler：

将多条记录封装到一个装有Map的List集合中。

*/

publicvoiddemo6（）throwsSQLException{

QueryRunnerqueryRunner=newQueryRunner（JDBCUtils2.getDataSource（））;

List>list=queryRunner.query（"select*fromaccount",newMapListHandler（））;

for（Mapmap:

list）{

System.out.println（map）;

}

}

@Test

/**

*ColumnListHandler：

将某列的值封装到List集合中

*/

publicvoiddemo7（）throwsSQLException{

QueryRunnerqueryRunner=newQueryRunner（JDBCUtils2.getDataSource（））;

List