黑马程序员技术交流社区

标题: 杭州大数据就业班1期关于面向对象编程的核心思想概述 [打印本页]
作者: shylock    时间: 2018-5-1 11:53
标题: 杭州大数据就业班1期关于面向对象编程的核心思想概述

面向对象编程思想
1.面向对象的基本概念：
    面向对象编程（Object Oriented Programming，OOP，面向对象程序设计）是一种计算机编程架构。OOP 的一条基本原则是计算机程序是由单个能够起到子程序作用的单元或对象组合而成。
    OOP是一种计算机编程模式, 它将对象作为问题空间的基本元素, 利用对象和对象之间的相互作用来设计程序。OOP的设计思想是以数据为中心, 自底向上, 逐步合并。OOP的最核心属性就是其可重用性, 相比其他范式却并不具有明显优势, 但它更接近人类的认知模式。
    OOP的核心思想可以归纳为: 以数据为中心组织逻辑, 将系统视为互相作用的对象的集合, 并利用继承与多态来增强可维护性, 可扩展性和可重用性。

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

3.类
   具有相同或相似性质的对象的抽象就是类.。因此, 对象的抽象是类, 类的具体化就是对象, 也可以说类的实例是对象.。iphoneX是一个类。

4.关系
l   继承
一般和特殊的关系, 它指定了子类如何特化父类的特征和行为，继承只能单一继承不能多继承。例如, 小米手机定制版是小米手机的一种。
²  继承的好处
1)      提高了代码的复用性
2)      多个类相同的成员可以放到同一个类中
3)      提高了代码的维护性
4)      如果功能的代码需要修改，修改一处即可
5)      让类与类之间产生了关系，是多态的前提
²  继承的弊端
1)      好处的第三点同时也是继承的弊端
2)      类与类之间产生了关系，让类的耦合性增强了
3)      设计原则：高内聚低耦合
l   实现
是一种类与接口的关系,表示类是接口的特征和行为的实现。发短信这个功能大伙都知道, 小米手机就实现了发短信这个功能, 而且苹果手机也实现了发短信这个功能。
1.接口的成员特点
²  成员变量
只能是常量：默认修饰符public static final
²  构造方法
没有，因为接口主要是扩展功能的，而没有具体存在
²  成员方法
默认修饰符public abstract
2. 类与类_类与接口_接口与接口的关系
²  类与类
继承关系，只能单继承，但是可以多层继承。
²  类与接口
实现关系，可以单实现，也可以多实现。还可以在继承一个类的同时实现多个接口。
²  接口与接口
继承关系，可以单继承，也可以多继承。
3. 抽象类与接口的区别
²  成员区别
1)      抽象类 变量,常量;有抽象方法;抽象方法,非抽象方法
2)      接口 常量;抽象方法
²  关系区别
1)      类与类 继承，单继承
2)      类与接口 实现，单实现，多实现
3)      接口与接口 继承，单继承，多继承
²  设计理念区别
1)      抽象类 被继承体现的是：”is a”的关系。共性功能
2)      接口 被实现体现的是：”like a”的关系。扩展功能  
l   组合
    是整体与部分的关系, 但部分不能离开整体而单独存在。 如一台小米手机拥有按键, 可是离开了手机, 按键也就失去了意义.。
l   聚合
     是整体与部分的关系, 且部分可以离开整体而单独存在。 一个豪华小米电视套餐还包含一套音箱, 这个音箱也可以是单独卖的。
l   关联
是一种拥有的关系, 一个类知道另外一个类的属性和方法。小米手机可以控制小米电视机。
l   依赖
是一种使用的关系, 一个类的实现需要另一个类的协助。小米手机控制小米电视机的时候需要有个路由器。

5.基本特征
l   封装
将对象或其中的方法属性加一层包装。电脑有硬盘, 可是我们只能够通过操作系统去访问他。
l   继承
对象的一个新类可以从现有的类中派生。
l   多态
不同类的对象对同一消息做出不同反应。我用不同牌子的手机, 收到电话的时候铃声是不同的。

6.设计原则
l   间接– 柔胜于刚,取胜于直
编程中有一句名言: 任何计算机问题均可通过增加一个间接层来解决。变量间接指代某个值或表达式, 函数也间接指代了某段代码。一个适当的中间层, 在形式上表现为间接层, 在实质上体现为抽象层。
l   抽象的意义
A.       掩盖了具体的细节, 提高代码的简洁度
B.       赋予了明确的语意, 提高代码的清晰度
l   间接的意义
a)       建立了名与实的映射, 提高了代码的一致性和可维护性
b)       实现了名与实的分离, 提高了代码的灵活性和可扩展性
l   依赖– 有求皆苦, 无欲则刚
抽象与规范是根本, 间接与分离是手段, 依赖与控制是关键, 接口与服务是核心。接口一方面作为一种抽象类型, 描述了一类对象所应遵守的行为规范; 另一方面作为间接层, 把两个耦合的具体类进行了分离。
1)      依赖反转原则Dependency Inversion Principle
高层模块不应该依赖底层模块, 它们都应该依赖抽象; 抽象不应该依赖细节, 细节应依赖抽象。
2)      依赖注入Dependency Injection
依赖的对象是从外部注入的，DI强调依赖的来源,完全有外部提供。DIP强调依赖的抽象性。
3）        控制反转IoC
控制反转是一种管理组建依赖的机制, 它打破了常规的流程控制模式, 把控制权从用户的应用代码转给了底层的某个组建, 以保证组建总能在合适的时候获得合适的依赖。 依赖注射是控制反转的一种实现方式。

7.内聚（ 不是一家人, 不进一家门）
Ø  耦合反映模块之间的关联程度, 内聚反映模块内部的关联成强度。
Ø  面向对象编程设计思想原则：高内聚，低耦合，就近原则 。
1)      单一职责原则
一个类应当只有一个变更的理由。
2)      局部化原则
让代码的物理紧密程度与逻辑紧密程度保持一致。
3)      接口隔离原则
不应强迫客户依赖那些他们不用的方法, 多个专用的接口比单纯一个总接口更好。
8.现在讲一个经典的面向对象编程的案例代码
²  ********数据库的增删改查操作******

1.    首先创建一个Account类
package com.itheima.dbutils.domain;
public class Account {
       private Integer id;
       private String name;
       private Double money;
       public Integer getId() {
              return id;
       }
       public void setId(Integer id) {
              this.id = id;
       }
       public String getName() {
              return name;
       }
       public void setName(String name) {
              this.name = name;
       }
       public Double getMoney() {
              return money;
       }
       public void setMoney(Double money) {
              this.money = money;
       }
       @Override
       public String toString() {
              return "Account [id=" + id + ", name=" + name + ", money=" + money + "]";
       }
      
}
2.其次创建JDBCUtils工具类
package com.itheima.jdbc.utils;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import javax.sql.DataSource;
import com.mchange.v2.c3p0.ComboPooledDataSource;
/**
* JDBC的工具类
* @author jt
*
*/
public class JDBCUtils2 {
       //创建一个连接池：但是这个连接池只需要创建一次即可。
       private static final ComboPooledDataSource dataSource = new ComboPooledDataSource();
      
       /**
        * 获得连接的方法
        * @throws SQLException
        */
       public static Connection getConnection() throws SQLException{
              return dataSource.getConnection();
       }
      
       /**
        * 获得连接池:
        */
       public static DataSource getDataSource(){
              return dataSource;
       }
      
       /**
        * 释放资源的方法
        */
       public static void release(Statement stmt,Connection conn){
              if(stmt != null){
                     try {
                            stmt.close();
                     } catch (SQLException e) {
                            e.printStackTrace();
                     }
                     
                     stmt = null;
              }
              if(conn != null){
                     try {
                            conn.close();
                     } catch (SQLException e) {
                            e.printStackTrace();
                     }
                     conn = null;
              }
       }
      
       public static void release(ResultSet rs,Statement stmt,Connection conn){
              //资源释放：
              if(rs != null){
                     try {
                            rs.close();
                     } catch (SQLException e) {
                            e.printStackTrace();
                     }
                     
                     rs = null;
              }
              if(stmt != null){
                     try {
                            stmt.close();
                     } catch (SQLException e) {
                            e.printStackTrace();
                     }
                     
                     stmt = null;
              }
              if(conn != null){
                     try {
                            conn.close();
                     } catch (SQLException e) {
                            e.printStackTrace();
                     }
                     conn = null;
              }
       }
}

3.然后利用DBUtils工具类库实现面向对象编程代码：
package com.itheima.dbutils.demo3;
import java.sql.SQLException;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.ArrayHandler;
import org.apache.commons.dbutils.handlers.ArrayListHandler;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.apache.commons.dbutils.handlers.ColumnListHandler;
import org.apache.commons.dbutils.handlers.KeyedHandler;
import org.apache.commons.dbutils.handlers.MapHandler;
import org.apache.commons.dbutils.handlers.MapListHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;
import org.junit.Test;
import com.itheima.dbutils.domain.Account;
import com.itheima.jdbc.utils.JDBCUtils2;
/**
* ResultSetHandler的实现类
*
* @author jt
*
*/
public class DBUtilsDemo3 {
       @Test
       /**
        * ArrayHandler:将一条记录封装到一个Object数组中
        */
       public void demo1() throws SQLException {
              QueryRunner queryRunner = new QueryRunner(JDBCUtils2.getDataSource());
              Object[] objs = queryRunner.query("select * from account where id = ?", new ArrayHandler(), 1);
              System.out.println(Arrays.toString(objs));
       }
       @Test
       /**
        * ArrayListHandler:将多条记录封装到一个装有Object数组的List集合中*
        * 一条记录封装到Objecct[]数组中，多条记录就是多个Object[]，那么多个Object数组就将其装入List集合中即可。
        */
       public void demo2() throws SQLException {
              QueryRunner queryRunner = new QueryRunner(JDBCUtils2.getDataSource());
              List<Object[]> list = queryRunner.query("select * from account", new ArrayListHandler());
              for (Object[] objects : list) {
                     System.out.println(Arrays.toString(objects));
              }
       }
       @Test
       /**
        * BeanHandler：将一条记录封装到一个JavaBean中
        */
       public void demo3() throws SQLException {
              QueryRunner queryRunner = new QueryRunner(JDBCUtils2.getDataSource());
              Account account = queryRunner.query("select * from account where id = ?",
                            new BeanHandler<Account>(Account.class), 2);
              System.out.println(account);
       }
       @Test
       /**
        * BeanListHandler:将多条记录封装到一个装有JavaBean的List集合中。
        * *一条记录就是一个Java的对象（JavaBean），如果多条记录（多个Java的对象），将多个Java对象装到一个List集合中。
        */
       public void demo4() throws SQLException {
              QueryRunner queryRunner = new QueryRunner(JDBCUtils2.getDataSource());
              List<Account> list = queryRunner.query("select * from account ", new BeanListHandler<Account>(Account.class));
              for (Account account : list) {
                     System.out.println(account);
              }
       }
      
       @Test
       /**
        * MapHandler：将一条记录封装到一个Map集合中，Map的key是列名，Map的value就是表中列的记录值。
        */
       public void demo5() throws SQLException{
              QueryRunner queryRunner = new QueryRunner(JDBCUtils2.getDataSource());
              Map<String,Object> map = queryRunner.query("select * from account where id = ?", new MapHandler(), 4);
              System.out.println(map);
       }
      
       @Test
       /**
        * MapListHandler：将多条记录封装到一个装有Map的List集合中。
        */
       public void demo6() throws SQLException{
              QueryRunner queryRunner = new QueryRunner(JDBCUtils2.getDataSource());
              List<Map<String,Object>> list = queryRunner.query("select * from account", new MapListHandler());
              for (Map<String, Object> map : list) {
                     System.out.println(map);
              }
       }
      
       @Test
       /**
        * ColumnListHandler：将某列的值封装到List集合中
        */
       public void demo7() throws SQLException{
              QueryRunner queryRunner = new QueryRunner(JDBCUtils2.getDataSource());
              List<Object> list = queryRunner.query("select name,money from account", new ColumnListHandler("name"));
              for (Object object : list) {
                     System.out.println(object);
              }
       }
      
       @Test
       /**
        * ScalarHandler:单值封装
        */
       public void demo8() throws SQLException{
              QueryRunner queryRunner = new QueryRunner(JDBCUtils2.getDataSource());
              Object obj = queryRunner.query("select count(*) from account", new ScalarHandler());
              System.out.println(obj);
       }
      
       @Test
       /**
        * KeyedHandler：将一条记录封装到一个Map集合中。将多条记录封装到一个装有Map集合的Map集合中。而且外面的Map的key是可以指定的。
        */
       public void demo9() throws SQLException{
              QueryRunner queryRunner = new QueryRunner(JDBCUtils2.getDataSource());
              Map<Object,Map<String,Object>> map = queryRunner.query("select * from account", new KeyedHandler("id"));
              for (Object key : map.keySet()) {
                     System.out.println(key+" "+map.get(key));
              }
       }
@Test
       /**
        * 增加一条记录信息
        */
       public void demo10() throws SQLException {
              QueryRunner queryRunner = new QueryRunner(JDBCUtils2.getDataSource());
              int num = queryRunner.update("insert into account values(null,?,?)", "李四", 10000);
              if (num > 0) {
                     System.out.println("添加信息成功!!!");
              }
       }
       @Test
       /**
        * 删除一条记录信息
        */
       public void demo11() throws SQLException {
              QueryRunner queryRunner = new QueryRunner(JDBCUtils2.getDataSource());
              int num = queryRunner.update("delete from account where id =?", 3);
              if (num > 0) {
                     System.out.println("删除信息成功!!!");
              }
       }
       @Test
       /**
        * 修改一条记录信息
        */
       public void demo12() throws SQLException {
              QueryRunner queryRunner = new QueryRunner(JDBCUtils2.getDataSource());
              int num = queryRunner.update("update account set name =?,money=? where id = ?", "张三", 10000, 3);
              if (num > 0) {
                     System.out.println("修改信息成功!!!");
              }
       }
}

面向对象编程思想 .txt

94.04 KB, 下载次数: 44



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2