一、面对对象思想

（1）大家肯定听过 Python 中”一切皆对象“的说法，但可能并不了解它的具体含义，只是在学习的时候听说 Python 是面向对象的编程语言，本节将向大家详细介绍 Python 面向对象的含义。

面向对象编程是在面向过程编程的基础上发展来的，它比面向过程编程具有更强的灵活性和扩展性。

面向对象编程（Object-oriented Programming，简称 OOP），是一种封装代码的方法。其实，在前面章节的学习中，我们已经接触了封装

代码封装，其实就是隐藏实现功能的具体代码，仅留给用户使用的接口，就好像使用计算机，用户只需要使用键盘、鼠标就可以实现一些功能，而根本不需要知道其内部是如何工作的。

面向对象编程，也是一种封装的思想，它可以更好地模拟真实世界里的事物（将其视为对象），并把描述特征的数据和代码块（函数）封装到一起。

（2）为什么说”一切皆对象“

a = 2

print(id(a))print(type(a))

b= 3

print(id(b))print(type(b))

b= 2

print(id(b)#输出结果如下

1441688672

1441688704

1441688672

如上述代码中，实际上整形数据2、3其实都是 integer class（整形类的一个实例对象），而 a、b只不过是这些对象的一个标签，可以简单理解为2、3是两个人，而a、b分别是他们的名字。就算把3的名字给了2这个人，那2这个人也是不会变的。这里的变指的是他们在内存中的地址，也就是上面例子中的 id() 。

二、类的理解

类：用来描述具有相同的属性和方法的对象的集合。可以理解是一个模板，通过它可以创建出无数个具体实例。

对象：类并不能直接使用，通过类创建出的实例（又称对象）才能使用。这有点像汽车图纸和汽车的关系，图纸本身（类）并不能为人们使用，通过图纸创建出的一辆辆车（对象）才能使用。

对象和类的关系：类和对象的关系就像模具和铸件的关系，类的实例化的结果就是对象，而对象的抽象体就是类。

属性：类中的所有变量称为属性。例如下面的 Student 类中的 self.name 和 self.score

方法：类中的所有函数通常称为方法。不过，和函数所有不同的是，类方法至少要包含一个 self 参数（后续会做详细介绍）。类方法无法单独使用，只能和类的对象一起使用。

类和实例

面向对象最重要的概念就是类（Class）和实例（Instance），必须牢记类是抽象的模板，比如 Student类，而实例是根据类创建出来的一个个具体的“对象”，每个对象都拥有相同的方法，但各自的数据可能不同。

仍以 Student 类为例，在 Python 中，定义类是通过 class 关键字：

classStudent(object):pass

class 后面紧接着是类名，即 Student，类名通常是大写开头的单词，紧接着是(object)，表示该类是从哪个类继承下来的，继承的概念我们后面再讲，通常，如果没有合适的继承类，就使用 object类，这是所有类最终都会继承的类。

1.类定义：

class定义类

class 后面加 类名称 加 () 加 :

2.类名称定义规范：

不要以纯数字命名

不要以python中保留字符（关键字）来命名

不要以文件名命名

不能出现特殊字符

要简短且见名知义

当类名称中有多个单词时，应采用驼峰式（每个单词首字母大写） --> XinFangShuo()

定义好了 Student 类，就可以根据 Student 类创建出 Student 的实例，创建实例是通过类名+()实现的：

bart = Student()

可以看到，变量 bart 指向的就是一个 Student 的实例，而 Student 本身则是一个类。

由于类可以起到模板的作用，因此，可以在创建实例的时候，把一些我们认为必须绑定的属性强制填写进去。通过定义一个特殊的__init__方法，在创建实例的时候，就把 name，score 等属性绑上去：

classStudent(object):def __init__(self, name, score):

self.name=name

self.score= score

注意：特殊方法“__init__”前后分别有两个下划线！！！

注意到__init__方法的第一个参数永远是 self，表示创建的实例本身，因此，在__init__方法内部，就可以把各种属性绑定到 self，因为 self 就指向创建的实例本身。

有了__init__方法，在创建实例的时候，就不能传入空的参数了，必须传入与__init__方法匹配的参数，但 self 不需要传，Python 解释器自己会把实例变量传进去：

bart = Student('Bart Simpson', 59)

和普通的函数相比，在类中定义的函数只有一点不同，就是第一个参数永远是实例变量 self，并且调用时，不用传递该参数。除此之外，类的方法和普通函数没有什么区别，所以，你仍然可以用默认

参数、可变参数、关键字参数和命名关键字参数。

class Four(): #类的定义

defsub(self,x,y):return x +y"""class Dog():

def __init__(self,name,age):

self.name = name

self.age = age

def sit(self):

print (self.name.title() + ' ' + "is now sitting")

def roll_over(self):

print (self.name.title() + ' ' + "is now roll over")

my_dog = Dog('willie',6) #参数实例化

# your_dog = Dog('lucy',3)

my_dog.sit()

my_dog.roll_over()"""

"""class Four_operations():

def __init__(self,a,b):

self.a = int(a)

self.b = int(b)

def add(self):

return self.a + self.b

def reduce(self):

return self.a - self.b

def ride(self):

return self.a * self.b

def Except(self):

return self.a / self.b

operation = Four_operations('12','4')

print (operation.add())

print (operation.reduce())

print (operation.ride())

print (operation.Except())"""

classReadWrite():"""txt文件读取类"""

def __init__(self,filepath):

self.filepath=filepathdef read(self,index=0):

with open(self.filepath) as book:returnbook.read().splitlines()[index]defwrite(self,body):

with open(self.filepath,"w") as book:

book.write(body)

ReadWrite("d:\\test1.txt").write("大家好，我是郑迎！")print (ReadWrite("d:\\test1.txt").read())

#coding=utf-8

mysql= {"zhangsan":"123456","lisi":"234567","wangwu":"345678"}classLoginRegister():"""登录注册函数封装实现如下：

1.登录mysql中的账号密码成功

2.密码错误则重新输入密码

3.账号错误调用注册方法进行注册，注册成功后调用登录方法登录已注册的账号"""

deflogin(self):

user= input("username:")if user inmysql.keys():for i in range(3):

pwd= input("password:")if pwd ==mysql.get(user):print ("Login ok")

break

else:print ("密码输错三次，将锁定账号！")

else:print ("Please register first!")LoginRegister().register()defregister(self):

user= input("Input you username:")whileTrue:

pwd= input("Input you password:")

repwd= input("Input you password again:")if repwd ==pwd:

mysql.setdefault(user,pwd)print ("Register ok,sign in now!")LoginRegister().login()break

else:print ("两次密码不一致，请重新输入！")LoginRegister().login()

三、类的封装/调用

调用类下的方法，必需通过类的的实例/类名（）进行调用

当类中初始化方法__init__中存在参数时，则在实例化时，需要往实例括号中传入参数

当类中无初始化方法或者__init__中不存在参数时，则在实例化时，不需要往实例括号中传入参数，而在调用方法时再进行传参

classFour():defsub(self,x,y):return x +yprint Four().sub(2,3)classFour_operations():def __init__(self,a,b):

self.a=int(a)

self.b=int(b)defadd(self):return self.a +self.bdefreduce(self):return self.a -self.bdefride(self):return self.a *self.bdefExcept(self):return self.a /self.b

operation= Four_operations('12','4') #实例化

print(operation.add())print(operation.reduce())print(operation.ride())print (operation.Except())

四、面向对象和面向过程

面向过程：吃(狗，屎)

优点：流程化，分步骤实现，效率高，代码短小精悍

缺点：思考难道大，代码复用率低，扩展差，难维护

defeat(dog,food):return "{} love to eat {}.".format(dog,food)print(eat("XiaoHei","shit"))#结果如下

XiaoHei love to eat shit.

面向对象：狗.吃(屎)

优点：结构化，模块化，易扩展，可继承，可覆盖，易维护

缺点：程序臃肿，性能低

classDog():defeat(self,food):return "Dogs love to eat {}.".format(food)print(Dog().eat("shit"))#结果如下

Dogs love to eat shit.

数据封装

面向对象编程的一个关键部分是封装，它涉及将相关变量和函数打包到一个简单易用的对象（类的一个实例）中。

一个相关的概念是隐藏数据，它隐藏了类的实现细节，并提供一个干净的标准接口。

在其它编程语言中，通常是通过私有方法和属性完成的，这些方法和属性阻止了对类中某些方法和属性的外部访问。

Python 的设计哲学略有不同。它认为 "我们都是成年人"，这意味着你不应该对类的访问设计任意的限制。因此，没有任何方法强制方法或属性是严格私有的。

但是，还是有一些方法可以阻止人们访问类的内部私有成员。

弱私有方法和属性在开头只有一个下划线。

这表明它们是私有的，不应该被外部代码使用。但是，它们基本上只有一个约定，并不阻止外部代码访问它们。

它唯一的实际效果是，从模块导入 from module_name import * 不会导入以单个下划线开头的变量。

运行结果：

上面的例子，属性 __Name 标记为私有，但是还是可以被外部代码访问。

弱私有方法和属性的名称开头有双下划线，这意味着它们不能从类之外被访问。

这样做的目的并不是确保它们是私有的，而是如果又具有相同名称的方法和属性的子类，则可以避免出现 bug。

使用这种方法直接访问是无法访问的，但可以通过不同的名称访问。Name 类的私有方法__privatemethod 可以通过 _Name__privatemethod 方法进行外部访问。

运行结果：

基本上，Python 通过内部更改名称以包含类名来保护这些成员。

更多Python视频、源码、资料加群683380553免费获取

类方法

目前为止，我们所看到调用对象的方法都是有类的一个实例调用的，然后传递给方法的 self参数。

类方法是不同的 -- 它们由一个类调用，该类被传递给方法的 cls 参数。

类方法的常见用途是工厂方法，它们使用与传递的类构造函数的参数不同的参数来实例化实例。

类方法被装饰符 @classmethod 标记为类方法。

运行结果：

lass_method_create 是类方法，它不在类的实例上调用。而是通过类的方法调用，它返回类 cls 的一个新对象。

从技术上将，self 和 cls 参数只是约定；它可以更改为其他任何东西。但是，这种约定被大多数人遵循。

静态方法

静态方法与类方法相似，只是没有任何附加参数比如 self 和 cls。它们与属于类函数的使用方法相同。它们被静态方法装饰器 @staticmethod 定义。

运行结果：

静态方法的行为类似于普通函数，除了不可以从类的实例中调用它们。

鸡汤

“为什么在这个世界上，有95%的人会无法成功，而只有那少数的5%会成功，因为大多数人的心里存在着这三个字：不可能。”

        在书写代码的时候，我们常常会碰到一些重复使用而且经常使用的代码，这些代码出现在我们逻辑代码中，显得代码很长，非常影响代码的简洁性，所以我们需要把他们封装起来，在进行使用的时候，直接调用即可

封装前VS封装后：

        封装前的测试类：

package Dao;

import com.qhit.entity.Student;
import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;

import java.io.IOException;
import java.io.InputStream;
import java.util.List;

import static org.junit.Assert.*;

/**
 * Description: mybatis01
 * Created by WuHuaSen .
 * Created Date:  2022/3/30 16:12
 * Version:  V1.0
 */
public class StudentDaoTest {
    @Test
    public void insertStudent() throws Exception {
        InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        //创建会话工厂
        SqlSessionFactory factory = builder.build(is);
        //会话连接
        SqlSession sqlSession = factory.openSession();
        //通过对象获取Dao对象、
        StudentDao studentDao = sqlSession.getMapper(StudentDao.class);
        //测试StudentDao方法
        int i = studentDao.InsertStudent(new Student(3, "1001", "张三", "男", 21));
        //手动提交
        sqlSession.commit();
        System.out.println(i);
    }

    @Test
    public void deleteStudent() throws Exception {
        InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
        SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        StudentDao studentDao = sqlSession.getMapper(StudentDao.class);
        int i = studentDao.DeleteStudent(2);
        sqlSession.commit();
        assertEquals(1, i);
    }

    @Test
    public void updateStudent() {
        try {
            InputStream is = Resources.getResourceAsStream("mybatis-config.xml");
            SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
            SqlSessionFactory sqlSessionFactory = sqlSessionFactoryBuilder.build(is);
            SqlSession sqlSession = sqlSessionFactory.openSession();
            StudentDao studentDao = sqlSession.getMapper(StudentDao.class);
            int i = studentDao.UpdateStudent(new Student(1, "15454", "麻溜", "男", 110));
            sqlSession.commit();
            assertEquals(1, i);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

        封装后：

import com.qhit.Dao.StudentDao;
import com.qhit.pojo.Student;
import com.qhit.untils.MyBatisUntil;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;
import org.junit.Test;
import org.apache.ibatis.io.Resources;


import java.io.IOException;
import java.io.InputStream;
import java.sql.ResultSet;
import java.util.List;

import static org.junit.Assert.*;

/**
 * Description: NewSsm
 * Created by WuHuaSen .
 * Created Date:  2022/3/29 20:56
 * Version:  V1.0
 */
public class StudentDaoTest {
    MyBatisUntil myBatisUntil = new MyBatisUntil();
    @Test
    public void insertStudent() throws Exception {
        SqlSession sqlSession=  myBatisUntil.getSqlSession(false);
        StudentDao studentDao = sqlSession.getMapper(StudentDao.class);
        //测试StudentDao方法
        int i = studentDao.InsertStudent(new Student(2, "1001", "张三", "男", 21));
        //手动提交，一般会有多个操作
        sqlSession.commit();
        //操作2
        //操作三

        System.out.println(i);
    }

    @Test
    public void deleteStudent() throws Exception {
        try {
            //自动提交
            StudentDao studentDao = myBatisUntil.getMapper(StudentDao.class);
            int i = studentDao.DeleteStudent(2);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Test
    public void updateStudent() {
        StudentDao studentDao = myBatisUntil.getMapper(StudentDao.class);
        int i = studentDao.updataStudent(new Student(0, "2222", "1wangwu", "女", 21));
        myBatisUntil.getSqlSession(true);
        assertEquals(1, i);
    }
}

可以明显的看出，我们的代码简洁了很多，下面将会具体讲讲mybatis的until工具类的创建 

MyBatisUntil工具类的创建：

        步骤：创建util包，新建MyBatisUntil类，定义会话工厂并对其进行私有化，创建线程锁在进行对象的跨层传递的时候，使用ThreadLocal可以避免多次传递，打破层次间的约束。

package com.qhit.untils;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;
import java.io.InputStream;

/**
 * Description: NewSsm
 * Created by WuHuaSen .
 * Created Date:  2022/4/1 16:23
 * Version:  V1.0
 */
public class MyBatisUntil {
    //封装会话工厂
    private static SqlSessionFactory Factory;
    /**在进行对象的跨层传递的时候，使用ThreadLocal可以避免多次传递，打破层次间的约束
     */
    private static ThreadLocal<SqlSession> local = new ThreadLocal<SqlSession>();

}

        设置静态代码块（随着类的加载而执行，并且只执行一次），所以将获取主配置文件以及建立会话工厂放进静态代码快，这样就减少了配置文件的加载，从而降低了内存的消耗

package com.qhit.untils;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;
import java.io.InputStream;

/**
 * Description: NewSsm
 * Created by WuHuaSen .
 * Created Date:  2022/4/1 16:23
 * Version:  V1.0
 */
public class MyBatisUntil {
    //封装会话工厂
    private static SqlSessionFactory Factory;
    /**在进行对象的跨层传递的时候，使用ThreadLocal可以避免多次传递，打破层次间的约束
     */
    private static ThreadLocal<SqlSession> local = new ThreadLocal<SqlSession>();

    static {
        try {
            InputStream is = Resources.getResourceAsStream("mysql-config.xml");
            SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
            Factory = sqlSessionFactoryBuilder.build(is);

        } catch (
                IOException e)

        {
            e.printStackTrace();
        }
    }
    
}

         由于在编写测试类的时候会用到会话SqlSession、以及会话工厂SqlSessionFactory，因此我们对二者分别进行封装处理，测试的时候只需要调用对应的方法即可~

package com.qhit.untils;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;
import java.io.InputStream;

/**
 * Description: NewSsm
 * Created by WuHuaSen .
 * Created Date:  2022/4/1 16:23
 * Version:  V1.0
 */
public class MyBatisUntil {
    //封装会话工厂
    private static SqlSessionFactory Factory;
    /**在进行对象的跨层传递的时候，使用ThreadLocal可以避免多次传递，打破层次间的约束
     */
    private static ThreadLocal<SqlSession> local = new ThreadLocal<SqlSession>();

    static {
        try {
            InputStream is = Resources.getResourceAsStream("mysql-config.xml");
            SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
            Factory = sqlSessionFactoryBuilder.build(is);

        } catch (
                IOException e)

        {
            e.printStackTrace();
        }
    }
    //封装factory方法
    public  static SqlSessionFactory getFactory(){
        return Factory;
    }

    //封装sqlSession会话
    public static SqlSession getSqlSession(boolean IsAutoComiit) {
        SqlSession sqlSession = local.get();
        if (sqlSession == null) {
            sqlSession = Factory.openSession(IsAutoComiit);
            local.set(sqlSession);
        }
        return sqlSession;
    }

}

        在测试的过程都会有一个通过getMapper方法获取Dao对象的方法（StudentDao studentDao = sqlSession.getMapper(StudentDao.class)过程，所以我们把这一部分也封装到工具类，但由于获取对象的类型是不确定的，所以这里我们要使用泛型~

package com.qhit.untils;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

import java.io.IOException;
import java.io.InputStream;

/**
 * Description: NewSsm
 * Created by WuHuaSen .
 * Created Date:  2022/4/1 16:23
 * Version:  V1.0
 */
public class MyBatisUntil {
    //封装会话工厂
    private static SqlSessionFactory Factory;
    /**在进行对象的跨层传递的时候，使用ThreadLocal可以避免多次传递，打破层次间的约束
     */
    private static ThreadLocal<SqlSession> local = new ThreadLocal<SqlSession>();

    static {
        try {
            InputStream is = Resources.getResourceAsStream("mysql-config.xml");
            SqlSessionFactoryBuilder sqlSessionFactoryBuilder = new SqlSessionFactoryBuilder();
            Factory = sqlSessionFactoryBuilder.build(is);

        } catch (
                IOException e)

        {
            e.printStackTrace();
        }
    }
    //封装factory方法
    public  static SqlSessionFactory getFactory(){
        return Factory;
    }

    //封装sqlSession会话
    public static SqlSession getSqlSession(boolean IsAutoComiit) {
        SqlSession sqlSession = local.get();
        if (sqlSession == null) {
            sqlSession = Factory.openSession(IsAutoComiit);
            local.set(sqlSession);
        }
        return sqlSession;
    }

    //使用泛型封装getMapper
    public static <T extends Object> T getMapper(Class<T> c) {
        SqlSession sqlSession = getSqlSession(true);
        return sqlSession.getMapper(c);
    }
}

        在使用泛型封装getMapper时候，我们给openSession（）赋值“true”，自动提交；而在getsqlSession（）方法中传递一个Boolean类型的值，来判断是否需要自动提交；True为自动提交，false为不自动提交,则需要手动提交sqlsession.commit();