精华内容
下载资源
问答
  • java枚举类封装

    千次阅读 2017-12-19 11:10:04
    java枚举类封装通常后端数据库需要int型的状态码,我们在编程记录不方便,所有我们可以使用java枚举进行封装

    java枚举类封装

    通常后端数据库中需要int型的状态码,我们在编程中记录不方便,所有我们可以使用java枚举类进行封装

    /**
     * @author LiHaiNan
     * @version V1.0
     * @Description: (用一句话描述该文件做什么)
     * @date 下午 1:30 2017/9/22 0022
     */
    public interface CodeEnum {
        Integer getCode();
    }
    import lombok.Getter;
    
    /**
     * @author LiHaiNan
     * @version V1.0
     * @Description: 商品状态
     * @date 下午 1:29 2017/9/22 0022
     */
    @Getter
    public enum ProductStatusEnum implements CodeEnum{
        UP(0, "在架"),
        DOWN(1, "下架")
        ;
    
        private Integer code;
    
        private String message;
    
        ProductStatusEnum(Integer code, String message) {
            this.code = code;
            this.message = message;
        }
    }
    import lombok.Getter;
    
    /**
     * @author LiHaiNan
     * @version V1.0
     * @Description: 枚举结果类
     * @date 下午 1:22 2017/9/22 0022
     */
    @Getter
    public enum ResultEnum {
    
        SUCCESS(0, "成功"),
    
        PARAM_ERROR(1, "参数不正确"),
    
        PRODUCT_NOT_EXIST(10, "商品不存在"),
    
        PRODUCT_STOCK_ERROR(11, "商品库存不正确"),
    
        ORDER_NOT_EXIST(12, "订单不存在"),
    
        ORDERDETAIL_NOT_EXIST(13, "订单详情不存在"),
    
        ORDER_STATUS_ERROR(14, "订单状态不正确"),
    
        ORDER_UPDATE_FAIL(15, "订单更新失败"),
    
        ORDER_DETAIL_EMPTY(16, "订单详情为空"),
    
        ORDER_PAY_STATUS_ERROR(17, "订单支付状态不正确"),
    
        CART_EMPTY(18, "购物车为空"),
    
        ORDER_OWNER_ERROR(19, "该订单不属于当前用户"),
    
        WECHAT_MP_ERROR(20, "微信公众账号方面错误"),
    
        WXPAY_NOTIFY_MONEY_VERIFY_ERROR(21, "微信支付异步通知金额校验不通过"),
    
        ORDER_CANCEL_SUCCESS(22, "订单取消成功"),
    
        ORDER_FINISH_SUCCESS(23, "订单完结成功"),
    
        PRODUCT_STATUS_ERROR(24, "商品状态不正确"),
    
        LOGIN_FAIL(25, "登录失败, 登录信息不正确"),
    
        LOGOUT_SUCCESS(26, "登出成功"),
    
        NO_BRANCH(27, "没有查询到该门店"),
    
        COMMON_ERROR(-1, "服务异常请稍后再试"),
    
        ;
    
        private Integer code;
    
        private String message;
    
        ResultEnum(Integer code, String message) {
            this.code = code;
            this.message = message;
        }
    }
    展开全文
  • MongoDB初探及JAVA工具类封装

    千次阅读 2018-05-05 00:12:43
    MongoDB 搭建及JAVA工具类封装 MongoDB 搭建及JAVA工具类封装 MongoDB 简介 基本语法 Mongo服务器搭建 安装包下载 环境变量配置 Mongo基本配置 Mongo起飞 JAVA工具类封装 MongoDB 简介  &...

    MongoDB 搭建及JAVA工具类封装

    MongoDB 简介


        MongoDB 旨在为WEB应用提供可扩展的高性能数据存储解决方案。MongoDB 将数据存储为一个文档,数据结构由键值(key=>value)对组成。MongoDB 文档类似于 JSON 对象。字段值可以包含其他文档,数组及文档数组。

    基本语法

        基本预发和使用作者不在论述,可参考 菜鸟mongo教程 ,文档上介绍的十分详细,如果不是为精通了解mongo,基本开发已经足够。

    Mongo服务器搭建

    安装包下载

        笔者使用的是老版本mac pro, 搭建工作踩坑无数,这里整理下供使用。好多博客说采用curl或者brew安装,但是笔者电脑因升级系统brew安装xcode失败,curl下载特别慢,只能采用离线安装。离线安装很简单,直接去网站mac版本下载地址下载对应安装的安装包,解压配置环境变量即可。
        我下载的版本是3.6.2,解压后配置环境变量即可。
    这里写图片描述

    环境变量配置

    • 编辑~/.bash_profile文件,添加环境变量
    export MONGO_PATH=/Users/mantan/Applications/mongodb-osx-x86_64-3.6.2
    export PATH=$PATH:$MONGO_PATH/bin
    • 使用source命令是环境变量生效
    source ~/.bash_profile

    完成上述配置后,环境变量配置成功,可以使用echo检查下哈。

    Mongo基本配置

    • 在mongo根目录下建如下文件 data、etc、log,分别用来存放data数据、配置文件和日志信息。
      这里写图片描述
    • 接下来,在data目录下建db文件夹,存放我们的mongo数据。
      然后在etc目录下建mongod.conf文件,内容如下:
    dbpath=/Users/mantan/Applications/mongodb-osx-x86_64-3.6.2/data/db
    logpath=/Users/mantan/Applications/mongodb-osx-x86_64-3.6.2//logs/mongodb/mongod.log
    logappend = true
    bind_ip = 127.0.0.1
    journal=true
    port = 27017
    # fork允许后端子进程启动,终端可以随便关
    fork = true
    # 安全权限,可以先以非授权模式启动Mongod,添加完用户db.addUser('root','pwd') ,再开启auth = true 后,db.auth('root','pwd'),带密码登陆
    auth = true
    • 接着,在log目录下建mongodb/mongod.log,用于记录日志

    到此,配置工作已经完成,马上起飞,是不是很激动 = - =。

    Mongo起飞

    • 使用命令启动Mongo服务
      mongod --config /Users/mantan/Applications/mongodb-osx-x86_64-3.6.2/etc/mongod.conf
      已经启动:
      这里写图片描述

    • 进入shell客户端操作
      执行mongo命令即可进入
      这里写图片描述
      笔者设置了auth用户登录权限
      这里写图片描述

    ### admin管理员用户
    db.createUser({ user: "root", pwd: "root", roles: [{ role: "userAdminAnyDatabase", db: "admin" }] }) 
    ### 普通数据库用户
    db.createUser({ user: "youruser2", pwd: "yourpassword2", roles: [{ role: "readWrite", db: "yourdatabase" }] })

    下面是我测试建立的collection,特别适合做数据字段动态转储
    这里写图片描述
    这里写图片描述

    JAVA工具类封装

    封装了Mongo操作的Java抽象类,基本满足日常开发需求,DAO层集成此基类即可使用能力。贡献出来,供大家参考,不当之处,评论处补充:

    package yonyou.esn.openapi.dao.mongo;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.mongodb.core.MongoTemplate;
    import org.springframework.data.mongodb.core.query.Criteria;
    import org.springframework.data.mongodb.core.query.Query;
    import org.springframework.data.mongodb.core.query.Update;
    import yonyou.esn.openapi.util.Page;
    
    import java.lang.reflect.ParameterizedType;
    import java.lang.reflect.Type;
    import java.util.List;
    
    public class MongoBaseDao<T> {
        private static final int DEFAULT_SKIP = 0;
        private static final int DEFAULT_LIMIT = 200;
    
        /**
         * spring mongodb 集成操作类 
         */
        @Autowired
        protected MongoTemplate mongoTemplate;
    
        protected String collection;
    
        /**
         * 通过条件查询实体(集合)
         *
         * @param query
         */
        public List<T> find(Query query) {
            return mongoTemplate.find(query, this.getEntityClass());
        }
    
        public List<T> find(Query query, String collectionName) {
            return mongoTemplate.find(query, this.getEntityClass(), collectionName);
        }
    
        /**
         * 通过一定的条件查询一个实体
         *
         * @param query
         * @return
         */
        public T findOne(Query query) {
            return mongoTemplate.findOne(query, this.getEntityClass());
        }
    
        public T findOne(Query query, String collectionName) {
            return mongoTemplate.findOne(query, this.getEntityClass(), collectionName);
        }
    
        /**
         * 通过条件查询更新数据
         *
         * @param query
         * @param update
         * @return
         */
        public void update(Query query, Update update) {
            mongoTemplate.findAndModify(query, update, this.getEntityClass());
        }
    
        public void update(Query query, Update update, String collectionName) {
            mongoTemplate.findAndModify(query, update, this.getEntityClass(), collectionName);
        }
    
        public void removeById(String id, String collectionName){
            Query query = new Query();
            query.addCriteria(Criteria.where("_id").is(id));
            mongoTemplate.remove(query, collectionName);
        }
    
        /**
         * 保存一个对象到mongodb
         *
         * @param entity
         * @return
         */
        public T save(T entity) {
            mongoTemplate.insert(entity);
            return entity;
        }
    
        public T save(T entity, String collectionName) {
            mongoTemplate.insert(entity, collectionName);
            return entity;
        }
    
        /**
         * 通过ID获取记录
         *
         * @param id
         * @return
         */
        public T findById(String id) {
            return mongoTemplate.findById(id, this.getEntityClass());
        }
    
        /**
         * 通过ID获取记录,并且指定了集合名(表的意思)
         *
         * @param id
         * @param collectionName
         *            集合名
         * @return
         */
        public T findById(String id, String collectionName) {
            return mongoTemplate.findById(id, this.getEntityClass(), collectionName);
        }
    
        /**
         * 分页查询
         * @param page
         * @param query
         * @return
         */
        public Page<T> findPage(Page<T> page, Query query){
            long count = this.count(query);
            page.setTotal(count);
            int pageNumber = page.getPageNumber();
            int pageSize = page.getPageSize();
            query.skip((pageNumber - 1) * pageSize).limit(pageSize);
            List<T> rows = this.find(query);
            page.setRows(rows);
            return page;
        }
    
        public Page<T> findPage(Page<T> page, Query query, String collectionName){
            long count = this.count(query, collectionName);
            page.setTotal(count);
            int pageNumber = page.getPageNumber();
            int pageSize = page.getPageSize();
            query.skip((pageNumber - 1) * pageSize).limit(pageSize);
            List<T> rows = this.find(query, collectionName);
            page.setRows(rows);
            return page;
        }
    
        /**
         * 求数据总和
         * @param query
         * @return
         */
        public long count(Query query){
            return mongoTemplate.count(query, this.getEntityClass());
        }
    
        public long count(Query query, String collectionName){
            return mongoTemplate.count(query, this.getEntityClass(), collectionName);
        }
    
    
        /**
         * 获取需要操作的实体类class
         *
         * @return
         */
        private Class<T> getEntityClass(){
            Type superclass = this.getClass().getGenericSuperclass();
            Type[] actualTypeArguments = ((ParameterizedType)superclass).getActualTypeArguments();
            return (Class) actualTypeArguments[0];
        }
    }
    展开全文
  • Java实体类中封装其他实体并引用

    千次阅读 2020-03-28 19:44:53
    在引用的时候有人会把二个表的数据全都封装在一个实体类中,然后在对这个实体进行操作,但如果是三个表呢?四个表呢?还都封装在一个实体吗?这样被封装的实体的数据是不是太多了呢?而且也会照成层次不分,...

    在Java开发过程中有很多情况是二个表及以上的联合操作,这是需要分清楚表的主次关系。在引用的时候有人会把二个表的数据全都封装在一个实体类中,然后在对这个实体类进行操作,但如果是三个表呢?四个表呢?还都封装在一个实体类吗?这样被封装的实体类的数据是不是太多了呢?而且也会照成层次不分,大大的抬高了代码的耦合性。和实体类泛滥的情况。下面开始介绍该如何正确的封装实体类

    第一个实体类

    public class UsersLogin {
        private Integer usersId;
        private String usersName;
        private String pass;
        private int flag;
        //省略Getter和Setter
        }
    

    第二个实体类

    public class Shoopping {
        private Integer shoopId;
        private String goodsName;
        private Double price;
        private String address;
        @DateTimeFormat(pattern = "yyyy-MM-dd")
        private Date produceDate;
        private String picture;
        private String categoryName;
        private int num;
        private int flag;
        //引用第一个表的实体对象
        private UsersLogin usersLogin;
        //省略Getter和Setter
        }
    

    使用mapper.xml

    <?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
            "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="com.springboot.mapper.ShiroUserMapper">
    <resultMap autoMapping="true" type="com.springboot.entity.UsersLogin " id="goodsMap">
        <id property="usersId" column="usersId"/>
        <association autoMapping="true" property="shiroUser" javaType="com.springboot.entity.Shoopping ">
            <id property="shoopId" column="shoopId"/>
        </association>
                <!--
            复杂的属性我们需要单独处理
               对象使用 : association
               集合使用 : collection
            -->
            <!--   collection中的ofType:使用ofType获取   -->
    <!--        <collection property="实体类属性名" ofType="接收获取的内容">-->
    <!--            <result column="employee_id" property="employeeId"></result>-->
    <!--        </collection>-->
    </resultMap>
        <select id="findUserList" resultMap="goodsMap">
             select * from UsersLogin u,Shoopping r where u.usersId=r.shoopId
        </select>
    </mapper>
    

    查询结果(我这展示的结果跟上面的实体类不对应,但大致结果是这种格式的)

    [
    UserList{id=1, user_name='admin@shiro.con', password='admin', role=Role{id=1, role_name='admin', user_name='admin@shiro.con'}},
    UserList{id=2, user_name='test@shiro.con', password='e10adc3949ba59abbe56e057f20f883e', role=Role{id=2, role_name='test', user_name='test@shiro.con'}}]
    

    第二种:创建第三个实体类,直接把这二个实体类封装里面

    第一个ShiroUser

    public class ShiroUser {
        private int id;
        private String user_name;
        private String password;
        //省略里面的方法
        }
    

    第二个Shiro_user_role

    public class Shiro_user_role {
        private int id;
        private String role_name;
        private String user_name;
        //省略方法
        }
    

    第三个UserList

    public class UserList {
        private ShiroUser shiroUser;
        private Shiro_user_role role;
        //省略方法
        }
    

    配置mapper.xml文件

    <?xml version="1.0" encoding="UTF-8" ?>
    <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
            "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
    <mapper namespace="com.springboot.mapper.ShiroUserMapper">
        <resultMap autoMapping="true" type="com.springboot.entity.UserList" id="goodsMap">
            <association autoMapping="true" property="role" javaType="com.springboot.entity.Shiro_user_role">
                <id property="user_name" column="user_name"/>
            </association>
            <association autoMapping="true" property="shiroUser" javaType="com.springboot.entity.ShiroUser">
                <id property="user_name" column="user_name"/>
            </association>
        </resultMap>
        <select id="findUserList" resultMap="goodsMap">
             select * from shiro_user u,shiro_user_role r where u.user_name=r.user_name
        </select>
    </mapper>
    

    结果:

    [
    UserList{shiroUser=ShiroUser{id=1, user_name='admin@shiro.con', password='admin'},
    role=Role{id=1, role_name='admin', user_name='admin@shiro.con'}
    },
    UserList{shiroUser=ShiroUser{id=2, user_name='test@shiro.con', password='e10adc3949ba59abbe56e057f20f883e'},
    role=Role{id=2, role_name='test', user_name='test@shiro.con'}
    }
    ]
    

    如果需要在html页面显示:

    <!DOCTYPE html>
    <html lang="en" xmlns:th="http://www.thymeleaf.org">
    <head>
        <meta charset="UTF-8">
        <title>权限管理</title>
    </head>
    <body>
      <table>
          <tr>
              <td>id</td><td>用户名</td><td>角色</td>
          </tr>
          <th:block th:each="u:${userLists}">
              <tr>
                  <td th:text="${u.getShiroUser().getId()}"></td>
                  <td th:text="${u.getShiroUser().getUser_name()}">
                  <td th:text="${u.getRole().getRole_name()}">
              </tr>
          </th:block>
      </table>
    </body>
    </html>
    
    展开全文
  • Java中封装

    万次阅读 多人点赞 2018-11-26 22:47:50
    1、封装的概念: 将的某些信息隐藏在的内部,不允许外部程序直接访问,而是通过该提供的方法来对隐藏的信息进行操作和访问。 2、好处: (1)只能通过规定的方法访问数据 (2)隐藏的实例细节,方便修改和...

    1、封装的概念:
    将类的某些信息隐藏在类的内部,不允许外部程序直接访问,而是通过该类提供的方法来对隐藏的信息进行操作和访问。
    2、好处:
    (1)只能通过规定的方法访问数据
    (2)隐藏类的实例细节,方便修改和实现。
    3、封装的实现步骤
    (1)修改属性的可见性设为(private)
    (2)创建getter/setter方法(用于属性的读写)(通过这两种方法对数据进行获取和设定,对象通过调用这两种发方法实现对数据的读写)
    (3)在getter/setter方法中加入属性控制语句(对属性值的合法性进行判断)
    4、Java中的包
    (1)作用:管理java文件,解决同名文件的冲突
    (2)定义包:package 包名
    必须放在java源程序的第一行,包名间可以使用“.”号隔开例如:com.imooc.Myclass
    5、包的使用。
    (1)可以通过import关键字,在某个文件中使用其他文件中的类。
    import.com.imooc.music.MyClass
    (2)java中,包的名字规范是全小写的字母拼写
    (3)使用时,不仅可以加载某个包下的所有文件 比如:com.imooc.*
    也可以加载某个具体子包下的所有文件 比如:com.imooc.music.*
    6、java中的访问修饰符
    private:只能在本类中使用(正因为private中的元素不能在外面直接访问,所以才利用调用getter/setter方法访问)
    默认:本来和同包中使用
    protected:本类,同包,子类中使用
    public:本类,同包,子类,其他中都可以使用
    7、java中的this关键字
    this关键字代表当前对象
    this.属性:操作当前对象的属性
    this.方法:调用当前对象的方法
    封装对象的属性的时候,经常会使用this关键字
    例如:

    private float screen;
    public void setScreen(float screen){
         this.screen=screen;     //因为参数和属性值一样了,所以用this.scree分清参数和属性
    }
    

    8、内部类
    (1)定义:内部类( Inner Class )就是定义在另外一个类里面的类。与之对应,包含内部类的类被称为外部类。
    (2)作用:内部类提供了更好的封装,可以把内部类隐藏在外部类之内,不允许同一个包中的其他类访问该类
    内部类的方法可以直接访问外部类的所有数据,包括私有的数据
    内部类所实现的功能使用外部类同样可以实现,只是有时使用内部类更方便
    (3)分类:
    成员内部类
    静态内部类
    方法内部类
    匿名内部类
    实例:

    public class HelloWorld {
        
        // 内部类Inner,类Inner在类HelloWorld的内部
        public class Inner ()
    		// 内部类的方法
    		public void show() {
    			System.out.println("welcome to imooc!");
    		}
    	}
    	public static void main(String[] args) {
            // 创建外部类对象
    		HelloWorld hello = new HelloWorld();
            // 创建内部类对象
    		Inner i = hello.new Inner();
            // 调用内部类对象的方法
    		i.show();
    	}
    }
    

    注意内部类对象的创建。
    9、内部类之成员内部类
    定义:定义在一个类中的类似于这个类的一个成员变量的内部类成为***成员内部类***
    成员内部类的使用方法:例如:
    在这里插入图片描述
    (1) Inner 类定义在 Outer 类的内部,相当于 Outer 类的一个成员变量的位置,Inner 类可以使用任意访问控制符,如 public 、 protected 、 private 等
    (2) Inner 类中定义的 test() 方法可以直接访问 Outer 类中的数据,而不受访问控制符的影响,如直接访问 Outer 类中的私有属性a
    (3) 定义了成员内部类后,必须使用外部类对象来创建内部类对象,而不能直接去 new 一个内部类对象,即:内部类 对象名 = 外部类对象.new 内部类( );
    (4) 编译上面的程序后,会发现产生了两个 .class 文件
    在这里插入图片描述
    其中,第二个是外部类的 .class 文件,第一个是内部类的 .class 文件,即成员内部类的 .class 文件总是这样:外部类名$内部类名.class
    (5)外部类是不能直接调用内部类的变量和方法的,可先创建内部类的对象,然后通过内部类的对象来访问其成员变量和方法。
    (6)如果外部类和内部类具有相同的成员变量或方法,内部类默认访问自己的成员变量或方法,如果要访问外部类的成员变量,可以使用 this 关键字。如:
    在这里插入图片描述
    10、静态内部类
    定义:被static修饰的内部类成为静态内部类
    使用方法:
    (1)静态内部类不能直接访问外部类的非静态成员,但可以通过 new 外部类().成员 的方式访问
    (2)如果外部类的静态成员与内部类的成员名称相同,可通过***“类名.静态成员”访问外部类的静态成员***(这里和成员内部类是不同的,成员内部类是通过类名.this.变量名来调用的);如果外部类的静态成员与内部类的成员名称不相同,则可通过“成员名”直接调用外部类的静态成员
    (3) 创建静态内部类的对象时,不需要外部类的对象,可以直接创建 内部类 对象名= new 内部类();
    11、方法内部类:
    定义:方法内部类就是内部类定义在外部类的方法中,方法内部类只在该方法的内部可见,即只在该方法内可以使用。例如:
    在这里插入图片描述
    注意:(1)因为是方法内部类不能被除了方法之外所使用,所以不能直接mo.print().应该是mo.show().因为这个内部类是定义在show这个方法中的。
    (2)由于方法内部类不能在外部类的方法以外的地方使用,因此方法内部类不能使用访问控制符和 static 修饰符。
    12、总结:(1)只有是成员内部类创建内部类对象时候才需要通过外部类对象来创建。其他都是可以直接创建的。
    (2)当外部类和内部类变量重名的话,想要调用外部变量。成员内部类需要(类名.this.变量名)。静态内部类需要是(类名.变量名)

    展开全文
  • JAVA中自己封装JDBC工具

    千次阅读 2019-03-07 09:04:04
    零、码仙励志 朋友和我说:人都是逼出来的。我经过深思熟虑,觉得很有道理。 一、前期准备 首先创建一个Dynamic Web Project 工程 jdbc ,...JAVA中的JDBD(MYSQL) 下面是我的工程截图,可以按照我的来 二、创...
  • Java数据封装类

    千次阅读 2017-07-27 17:21:45
    用户前端与后台的交互数据,这个封装类中包含分页、数据、错误码、状态码等信息!! 亲测好用哦!一个DataWrapperpublic class DataWrapper<T>{ private CallStatusEnum callStatus; private ErrorCodeEnum ...
  • java响应实体类封装

    千次阅读 2020-06-11 10:24:49
    前后端分离的开发模式,或者与第三方接口交互,需要规范接口响应,下面是我在开发封装的一组响应实体
  • java中封装和包

    千次阅读 2017-09-24 15:56:01
    封装就是JavaBean思想 你可以理解为 通过某个方法调用封装的隐藏属性,就像我把不同颜色的糖果封装在看不见的盒子里,你只有通过我特定的方法才能拿出来某个颜色的糖果,你看不见糖果 ,而且你不通过我你拿不到...
  • NDK学习笔记:java类封装c++

    千次阅读 2017-06-05 22:59:28
    本文介绍了jni开发的中java类如何直接对c++进行封装和调用,并附源码。另外修改了原文中的一些错误。
  • Java封装

    千次阅读 多人点赞 2019-05-12 21:11:33
    定义:将对象的属性和方法相结合,通过方法将对象的属性和实现细节保护起来,实现对象的属性隐藏。 做法:修改属性的可见性来限制对属性的访问,并为每个属性... 在赋值和取值方法,加入对属性的存取限制。 ...
  • Java 封装

    千次阅读 多人点赞 2018-12-24 13:25:29
    我们可以通过将的所有数据成员设为private,以在java中创建一个完全封装。现在我们可以使用setter和getter方法来设置和获取其中的数据。Java Bean是完全封装类的示例。 封装的应用 //save as Student.java ...
  • Java中如何封装自己的,建立并使用自己的类库?

    万次阅读 多人点赞 2012-02-21 22:49:53
    Java中如何使封装自己的,建立并使用自己的类库?  ——感谢您的阅读,转载请标明出处! 随着自己的编程经历的积累会发现往往自己在一些项目写的在别的项目也会有多次用到。你肯定会想:如何自己的写的一些...
  • Java中封装和复用

    千次阅读 2016-08-14 09:55:28
    Java是一种面向对象的编程语言,它更进一步,将变量和函数封装在一个类中,使用对象的形式模拟一个事物的多个方面,变量对应着对象的域,表示对象的多个属性,而函数则对应着对象的方法,模拟对象的功能。...
  • Java通用接口响应封装类

    万次阅读 2020-01-14 00:42:07
    Java接口响应封装类 Web开发,前后分离是个趋势,现在大部分公司研发部门已经在走前后分离的路子了,前后分离开发各司其职能够有效的提高工作效率和开发质量。 REST接口会返回各种各样的数据,如果对接口的格式不...
  • [Java]封装类

    千次阅读 2019-06-13 18:49:04
    python的int这样的数据类型已经是的情况下,老牌的Java当然也有对基本数据类型的类封装 但是Java并没有Python这样激进,Java中的基本数据类型的并不直接是 而是另外开辟炉灶,创建创建了一一对应的封装类...
  • java定义与调用封装

    千次阅读 2019-05-19 11:36:21
    实例:定义一个学生封装 定义完成后快速封装 鼠标右键单击选中cource >> 转到 >> generate getters and setters…
  • Java jdbc连接mysql 封装类

    千次阅读 2019-05-26 15:50:24
    Java jdbc连接mysql 封装类 开发工具与关键技术:java、 myelipse2017、jdk1.8 作者:Amewin 撰写时间:2019年5月26日 JDBC简介: JDBC全称为java database connectivity,是sun公司指定的java数据库连接技术的...
  • java封装类(wrapper

    万次阅读 2018-03-15 19:59:50
    封装类的构造器:1.对基本数据类型:Integer i=new Integer(10);2.对字符型:Integer i=new Integer("10");二.封装类的3种方法:1.valueOf();//静态方法,返回的是一个指定类型的封装类实例(目前jdk支持...
  • 新手小白学JAVA 面向对象 对象 封装

    万次阅读 多人点赞 2021-05-06 15:58:57
    面向对象其实是一种编程思想,通过它可以把生活复杂的事情变得简单化,从原来的执行者变成了指挥者。 面向对象是基于面向过程而言的。 面向过程强调的是过程,比如: 打开冰箱门 2. 把大象放进去 3. 关上冰箱门 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 973,266
精华内容 389,306
关键字:

java中类的封装

java 订阅