精华内容
下载资源
问答
  • 怎样封装类
    千次阅读
    2016-05-09 17:02:39

    自学到这里,看完书有点乱,整理一下

    一、基本数据类型与其对应的封装类之间的相互转换

         1.基本数据类型转换为封装类

            有三种方法:

            a.直接赋值  (自动装箱)      

    Integer i=3;
            b.使用封装类的含参构造方法(实例化)

    Integer i=new Integer(3);
    
    

            c.使用封装类提供的valueOf()方法(静态方法)

    Integer i=Integer.valueOf(3);

        2.封装类转换为基本数据类型

           有两种方法:

           a.直接赋值(自动拆箱)

    Integer i=new Integer(2);
    int j=i;
            b.使用封装类提供的value()方法

    Integer i=new Integer(3);
    int j=i.intValue();
    float f=i.floatValue();
    二、基本数据类型与字符串之间的相互转换      

           1.基本数据类型转换为字符串

              有三种方法:

              a.使用String类的valueOf()方法(静态方法)

    String s=String.valueOf(123);
              b.使用封装类的toString()方法(静态方法)

    String s=Integer.toString(3);

              c.使用字符串连接符“+”

    String s=""+123;
           2.字符串转换为基本数据类型

              有一种方法:

              a.使用封装类的静态方法

    int i=Integer.parseInt("12");
    三、封装类与字符串之间的相互转换

           1.字符串转换为封装类         

              有两种方法:

              a.使用封装类的含参构造方法(实例化)

    Integer i=new Integer("123");

              b.使用封装类的valueOf()方法

    Integer i=Integer.valueOf("123");

           2.封装类转换为字符串

              有三种方法:

              a.使用字符串连接符“+”

    Integer i=new Integer(123);
    String s=""+i;
    

             b.使用封装类的toString()方法

    Integer i=new Integer(123);
    String s=i.toString();


              c.使用String类的valueOf()方法

    Integer i=Integer.valueOf(123);
    
    String s=String.valueOf(i);
    


     四、总结 
    

             以上所列都是基本数据类型、封装类和字符串两两之间的直接转换,因此,可以衍生出来一些其他的东西,类似数学中的等量代换吧

    举例说明:

    Integer i=new Integer(23);
    String s=Integer.toString(i);

    这两行代码中,封装类Integer的toString方法要求的参数是基本数据类型int,但是变量i是int的封装类,所以这里就有一个把Integer转换为int的过程,即自动装箱


    。。。


    类似的还有很多,大家自行分析测试,也希望大家可以在平时的编程过程中灵活运用。


    自学,知识有限,不足之处,万望谅解,有什么补充意见或者建议,请联系博主,一起讨论,共同进步。

    更多相关内容
  • 主要介绍了java语言中封装类,涉及相关代码示例及结果分析,以及封装的好处简单介绍,具有一定借鉴价值,需要的朋友可以参考下
  • 主要为大家详细介绍了php实现搜索类封装示例,感兴趣的小伙伴们可以参考一下
  • c# 数据库操作的封装类,压缩包里的文件包含了所有数据库操作的封装类,很全,用取来也很方便
  • 首先介绍一下IC类封装的概念。 IC类封装: IC封装,就是指把硅片上的电路管脚,用导线接引到外部接头处,以便与其它器件连接。封装形式是指安装半导体集成电路芯片用的外壳。 这是最后效果图,如果你觉得有用,在...
  • 主要介绍了深入解析C++编程中封装特性,是C++入门学习中的基础知识,需要的朋友可以参考下
  • python(面向对象-类封装调用)

    千次阅读 2020-11-21 01:40:52
    一、面对对象思想(1)大家肯定听过 Python 中”一切皆对象“的说法,但可能并不了解它的具体含义,只是在学习的时候听说 Python 是面向...面向对象编程(Object-oriented Programming,简称 OOP),是一种封装代码...

    一、面对对象思想

    (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.

    展开全文
  • 基于Java语言编写的Spring Boot时间工具方法封装,主要方法如下:根据日期获取该日期内24小时的整点时刻、获取当月的 天数、根据 年、月 获取对应的月份 的 天数、根据指定日期得获取对应月份的所有日期的每日结束...
  • 美国国家半导体公司(National Semiconductor)日前推出声称业界最小巧的音频子系统,内置单声道D扬声器驱动器,并具备智能电话和网络电话所有必要的模拟及数字音频功能。  该款音频芯片采用全新micro SMDxt封装...
  • 面向对象编程的一个关键部分是封装,它涉及将相关变量和函数打包到一个简单易用的对象(的一个实例)中。 一个相关的概念是隐藏数据,它隐藏了的实现细节,并提供一个干净的标准接口。 在其它编程语言中,通常...

    数据封装

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

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

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

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

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

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

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

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

    Python基础教程之数据封装、类方法和静态方法

     

    运行结果:

    Python基础教程之数据封装、类方法和静态方法

     

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

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

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

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

    Python基础教程之数据封装、类方法和静态方法

     

    运行结果:

    Python基础教程之数据封装、类方法和静态方法

     

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

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

     

    类方法

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

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

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

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

    Python基础教程之数据封装、类方法和静态方法

     

    运行结果:

    Python基础教程之数据封装、类方法和静态方法

     

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

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

    静态方法

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

    Python基础教程之数据封装、类方法和静态方法

     

    运行结果:

    Python基础教程之数据封装、类方法和静态方法

     

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

    鸡汤

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

    展开全文
  • 对分页进行了封装,PageUtil.java的分页工具,自己写了一个dome。
  • Java 封装基础知识

    2020-08-18 21:50:36
    主要介绍了Java 封装的相关资料,文中示例代码非常详细,帮助大家更好的理解和学习,感兴趣的朋友可以了解下
  • 主要介绍了Python实现封装打包自己写的代码,被python import,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • MyBatis-工具封装

    2022-04-02 10:07:15
    在书写代码的时候,我们常常会碰到一些重复使用而且经常使用... 封装前的测试: package Dao; import com.qhit.entity.Student; import org.apache.ibatis.io.Resources; import org.apache.ibatis.session.Sq...

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

    封装前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();

    展开全文
  • 封装分为两个层面封装其实分为两个层面,但无论哪种层面的封装,都要对...第一个层面的封装(什么都不用做):创建和对象会分别创建二者的名称空间,我们只能用类名.或者obj.的方式去访问里面的名字,这本身就是...
  • 主要介绍了Python 面向对象之封装、继承、多态操作,结合实例形式分析了Python面相对象程序设计中封装、继承、多态相关操作技巧与使用注意事项,需要的朋友可以参考下
  • 封装继承和多态

    千次阅读 2019-12-20 18:04:26
    封装、继承和多态 的特性:封装性、继承性、多态性 和 抽象性。 Java 单继承 + 接口 的设计方法:封装、继承、多态。抽象原则。 一、和对象 Java程序设计的基本单位就是。一个Java程序就是一个...
  • 工程师经常要更换物料,所以全局替换元件封装就很有必要
  • ssh封装 使用

    2012-12-16 22:17:43
    ssh功能在封装 增删改查 分页 常用功能使用 有例子
  • 封装分类问题

    千次阅读 2013-11-30 13:17:06
    贴片电阻、贴片电容规格、封装、尺寸  贴片电阻常见封装有9种,用两种尺寸代码来表示。一种尺寸代码是由4位数字表示的EIA(美国电子工业协会)代码,前两位与后两位分别表示电阻的长与宽,以英寸为单位。我们...
  • Ajax的封装

    2022-04-21 21:24:17
    前端封装Ajax
  • Java封装图书信息

    千次阅读 2021-03-18 08:15:58
    了解上节有关封装的知识后,本节通过完整的例子再次实现封装。要求编写表示图书的 Book ,实现以下需求:基本信息包括图书名称(bookName)、总页数(pagelbtalNum),其中页数不能少于 200 页,否则输出错误信息,并...
  • 主要介绍了使用java数组 封装自己的数组操作,结合实例形式分析了java数组索引、遍历等相关封装操作技巧与注意事项,需要的朋友可以参考下
  • (八)线程--借助 封装类 实现“线程调用带参数方法”
  • 贴片元器件封装尺寸

    2019-03-05 09:57:35
    注意: 0603有公制,英制的区分 公制0603的英制是英制0201, 英制0603的公制是公制1608 还要注意1005与01005的区分, 1005也有公制,英制的区分 英制1005的公制是公制2512 公制1005的英制是英制0402
  • 主要介绍了JavaScript多态与封装,结合实例形式分析了JavaScript多态与封装的概念、功能、优缺点以及相关问题与注意事项,需要的朋友可以参考下
  • java如何实现封装

    千次阅读 2021-03-22 17:53:09
    java封装类通过三个步骤实现: (1)修改属性的可见性,限制访问。 (2)设置属性的读取方法。 (3)在读取属性的方法中,添加对属性读取的限制。Java中什么叫封装呢? 继承和多态都明白些,就是封装理解不上去,老师没...
  • 1、Mavan引用 javax.mail javax.mail-api 1.6.2 com.sun.mail javax.mail 1.6.2 2、Email工具:mailUtil.java package utils; import javax.activation.DataHandler; import javax.activation.DataSource; import ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 141,800
精华内容 56,720
关键字:

怎样封装类