精华内容
下载资源
问答
  • 扩展性极差"""#上述的弊端产生原因类似于把代码全部在一个py文件中,你应该怎么做?>>>解耦合!将上述一张表拆成员工和部门两张表!#类似的表关系学生与班级,也是如此,一张学生表和一张班级表”””...

    表与表之间的关系

    e534c632a0a6b65483d8a980e9270ba4.png

    """把所有数据都存放于一张表的弊端

    1.组织结构不清晰

    2.浪费硬盘空间

    3.扩展性极差"""

    #上述的弊端产生原因类似于把代码全部写在一个py文件中,你应该怎么做?>>>解耦合!将上述一张表拆成员工和部门两张表!#类似的表关系学生与班级,也是如此,一张学生表和一张班级表

    ”””

    确立表与表之间的关系 一定要换位思考(必须两方都考虑周全之后才能得出结论)

    以员工表和部门表为例

    先站在员工表看能否有多个员工对应一个部门

    翻译过来:

    一个部门能否有多个员工

    可以!!!(暂时只能确定员工单向多对一部门)

    再站在部门表看能否有多个部门对应一个员工

    翻译过来:

    一个员工能否属于多个部门

    不可以!!!

    结论:员工表和部门表之间仅仅是单向的多对一

    那么它们的表关系就是"一对多"表关系中没有多对一一说,只有一对多

    (无论是多对一还是一对多都叫"一对多")

    ””’

    外键

    """通过我们的分析我们可以得到把一张表拆成两张表之后它们概念上的联系,那么我们要如何让这两张表有在代码层面上的真正关联,那么就要用到外键。

    什么是外键?

    让表与表有硬性物理层面上的联系。

    foreign key

    外键约束

    1.在创建表的时候,必须先创建被关联表

    2.插入数据的时候,也必须先插入被关联表的数据"""

    一对多

    44bb2795e23a0ef70554e4bff1e01c8e.png

    #上代码来创建表#先建被关联表

    create table dep(

    id int primary key auto_increment,

    dep_name varchar(32),

    dep_desc varchar(128)

    );#再建关联表

    create table emp(

    id int primary key auto_increment,

    emp_name varchar(64),

    emp_gender enum('male','female','others') default 'male',

    dep_id int,

    foreign key(dep_id) references dep(id)

    );#插入数据#先插被关联表的数据

    insert into dep(dep_name,dep_desc) values('外交部','搞外交'),

    ('教学部','教书育人'),

    ('技术部','技术能力有限部门');#再插关联表的数据

    insert into emp(emp_name,dep_id) values('jason',1),

    ('egon',2),

    ('tank',2),

    ('kevin',3);

    b24fc9cac6a0295efeed4f6a81489373.png

    #修改表的数据

    update dep set id=200 where id = 1;

    update emp set dep_id= 300 where id = 1;

    deletefrom dep where id = 3;

    结果如下:

    617f004ada9096ce5b924c0d9a5bfffa.png

    外键虽然能够帮你强制建立表关系 但是也会给表之间增加数据相关的约束

    级联更新级联删除

    1.删除数据的时候 先删员工表的数据 再删部门表的数据

    deletefrom emp where id = 4;

    deletefrom dep where id = 3;#因为不影响关联的字段,所以会报错,但比较麻烦

    我们应该让这两关联的表在一张表进行修改时,另一张也跟着它修改,于是引入了级联删除级联更新的概念。

    #创建表#创建被关联表

    create table dep(

    id int primary key auto_increment,

    dep_name varchar(32),

    dep_desc varchar(128)

    );#创建关联表

    create table emp(

    id int primary key auto_increment,

    emp_name varchar(64),

    emp_gender enum('male','female','others') default 'male',

    dep_id int,

    foreign key(dep_id) references dep(id)

    on update cascade

    on delete cascade

    );#被关联表里插入

    insert into dep(dep_name,dep_desc) values('外交部','搞外交'),

    ('教学部','教书育人'),

    ('技术部','技术能力有限部门')

    ;#关联表里插入

    insert into emp(emp_name,dep_id) values('jason',1),

    ('egon',2),

    ('tank',2),

    ('kevin',3);

    fc287f33eea62692c2220c89a9eedb60.png

    建立级联更新和级联删除后,可以进行表修改操作并让两边同步。

    多对多

    """图书与作者表

    一定要换位思考

    先站在图书

    多本书能否有一个作者

    一个作者能否写多本书 可以!!!

    再站在作者

    多个作者能否和写一本书

    一本书能否有多个作者 可以!!!

    如果双方都是可以,那么就是多对多

    强调 foreign key只是用来帮你建表关系的 不是某个关系特有的方法"""

    根据我们上面一对多的推导,我们可以将两张表互相设为外键,那么这样写是不是对的呢?当然不是,最简单的一个判断就是,在一堆多里,被关联的表需要你先进行创建,如果你这样写了,那么你这两张表该先去创建谁呢?

    所以我们只能用另一个方法,就是创建第三张表来记录着两张表之间的关系

    #先建两种普通的表 不需要设置外键

    create table book(

    id int primary key auto_increment,

    title varchar(32),

    price int

    );

    create table author(

    id int primary key auto_increment,

    name varchar(32),

    age int

    );#在创建第三张表并让它关联前两张表

    create table book2author(

    id int primary key auto_increment,

    book_id int,

    foreign key(book_id) references book(id)

    on update cascade

    on delete cascade,

    author_id int,

    foreign key(author_id) references author(id)

    on update cascade

    on delete cascade

    );

    insert into book(title,price) values('python从入门到入土',199),('程序员的自我修养之脊椎康复指南',299),('MySQL之删别人的库让别人跑路',25);

    insert into author(name,age) values('jason',18),('tank',38);

    insert into book2_author(book_id,author_id) values(4,3); #报错

    insert into book_author(book_id,author_id) values(1,1),(1,2),(2,1),(3,1),(3,2);

    b2aeee93f767dd2ff773c66e8907c527.png

    一对一

    客户表和学生表(学校的客户与学生之间,报名之前都是客户,只有报了名的才能是学生)

    #左表的一条记录唯一对应右表的一条记录,反之也一样

    create table customer(

    id int primary key auto_increment,

    name char(20) notnull,

    qq char(10) notnull,

    phone char(16) notnull

    );

    create table student(

    id int primary key auto_increment,

    class_name char(20) notnull,

    customer_id int unique,#该字段一定要是唯一的

    foreign key(customer_id) references customer(id) #外键的字段一定要保证unique

    on delete cascade

    on update cascade

    );#三种外键关系都是用foreign key,区别在于如何使用以及其他条件限制即可做出三种关系

    5cb5497a9333d45d28f857fafea5d42c.png

    594608fb026dfda177b6583216c77fe6.png

    总结

    """判断表关系的最简单的语法

    图书与出版社

    一本书可不可以有多个出版社 不可以!!!

    一个出版社可不可以出版多本书 可以!!!

    一对多的关系"""图书与作者表

    一本书可不可以有多个作者 可以!!!

    一个作者可不可以写多本书 可以!!!

    多对多的关系"""作者与作者详情

    一个作者可不可以有多个详情 不可以!!!

    一个作者详情可不可以有多个作者 不可以!!!

    要么两者是一对一

    要么两者之间没任何关系"""

    修改表

    #mysql对大小写不敏感!!!

    语法:1. 修改表名

    ALTER TABLE 表名

    RENAME 新表名;2. 增加字段

    ALTER TABLE 表名

    ADD 字段名 数据类型 [完整性约束条件…],

    ADD 字段名 数据类型 [完整性约束条件…];

    ALTER TABLE 表名

    ADD 字段名 数据类型 [完整性约束条件…] FIRST;

    ALTER TABLE 表名

    ADD 字段名 数据类型 [完整性约束条件…] AFTER 字段名;3. 删除字段

    ALTER TABLE 表名

    DROP 字段名;4. 修改字段 #modify只能改字段数据类型完整约束,不能改字段名,但是change可以!

    ALTER TABLE 表名

    MODIFY 字段名 数据类型 [完整性约束条件…];

    ALTER TABLE 表名

    CHANGE 旧字段名 新字段名 旧数据类型 [完整性约束条件…];

    ALTER TABLE 表名

    CHANGE 旧字段名 新字段名 新数据类型 [完整性约束条件…];

    复制表

    #查询语句执行的结果也是一张表,可以看成虚拟表

    #复制表结构+记录 (key不会复制: 主键、外键和索引)

    create table new_service select * fromservice;#只复制表结构

    select * from service where 1=2; //条件为假,查不到任何记录

    create table new1_service select* from service where 1=2;

    create table t4 like employees;

    展开全文
  • 共回答了16个问题采纳率:93.8%用MySQL测试通过,尽量标准SQL,如果是其他数据库,应该可以通过或稍加修改即可通过.13.select t2.sname from sp t1left join s as t2 on t1.sno=t2.snoleft join p t3 on t1.pno=t3....

    共回答了16个问题采纳率:93.8%

    用MySQL测试通过,尽量写标准SQL,如果是其他数据库,应该可以通过或稍加修改即可通过.

    13.

    select t2.sname from sp t1

    left join s as t2 on t1.sno=t2.sno

    left join p t3 on t1.pno=t3.pno

    where t3.color='red'

    group by t2.sname

    14. select sno,sname,status from s where city='BJ'

    15.

    select sum(t1.qty) from sp t1

    left join p t2 on t1.pno=t2.pno

    where t2.pname='p2'

    16. update p set weight=100 where pname='p2'

    17. update p set color='yellow' where pname='p2'

    18.

    select t2.sn from spj t1

    left join s t2 on t1.sno=t2.sno

    left join p t3 on t1.pno=t3.pno

    left join j t4 on t1.jno=t4.jno

    where t3.color='red' and t4.jn='j1'

    group by t2.sno

    19.

    select t2.jn from spj t1

    left join j t2 on t1.jno=t2.jno

    left join s t3 on t1.sno=t3.sno

    left join p t4 on t1.pno=t4.pno

    where t3.sn='s1'

    group by t2.jno

    20.

    select t2.pn from spj t1

    left join p t2 on t1.pno=t2.pno

    left join s t3 on t1.sno=t3.sno

    left join j t4 on t1.jno=t4.jno

    where t3.city=t4.city

    group by t2.pno

    1年前

    8

    展开全文
  • 拷贝模式(prototype原型模式) 你拷贝或不拷贝,她一直在哪里,风力不走,雨里不去,你忍心留她一个人?哦可惜爱不是几滴眼泪几封情书哦— 这样的话或许有点残酷 等待着别人给幸福的人 往往过的都不怎么幸福!...

    我写拷贝模式(prototype原型模式)

    你拷贝或不拷贝,她一直在哪里,风力不走,雨里不去,你忍心留她一个人?哦可惜爱不是几滴眼泪几封情书哦— 这样的话或许有点残酷 等待着别人给幸福的人 往往过的都不怎么幸福!咔咔咔以上和拷贝(prototype原型模式)有半毛钱的关系吗?我这不是借物喻人,寓情于景吗,请原谅我的语文天赋点的有点歪……^_^~

    开局一声吼,代码全靠编

    哎客官不可以,洒家风华正茂,一时意气用事,当不得真,您容我重新组织一下语言。客官留步啊,您请~听~我~说~

    听说白雪公主在逃跑,小红帽在担心大灰狼,啊我这嗓子一如既往的阔以,肿么办,辣么强,还要啥自行车。

    坚决不跑题了哈,编起来go

    话说天下大事,不对不对咳咳,话说有个People类俗称javaBean,长这吊样

    public class People {
    
        private String name;
        private int age;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    }

    长这吊样的多了去了,有啥用?

    这不是要说到拷贝模式(prototype原始模型)吗,咱改一改给他来点料,实现一个标识接口Cloneable后变成这货了

    public class People implements Cloneable{
    
        private String name;
        private int age;
    
        public People(String name, int age) {
            this.name = name;
            this.age = age;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        @Override
        protected Object clone() throws CloneNotSupportedException {
            return super.clone();
        }
    }

    如果不实现Cloneable,上面的clone方法是会报错的呀,当然了能报错就能解决,换成下方代码一次就好,我陪你天涯海角,oh不~

    @Override
    protected Object clone() throws CloneNotSupportedException {
         People people = new People(name,age);
         return (People)people;
    }

    PS一定要实现Cloneable不要问问什么,因为我不会告诉你这就是原型模式的核心哼(づ。◕‿‿◕。)づ

    实现完了咱就测试一下代码的流畅度,测试代码如下:

    public static void main(String[] args) {
            People people = new People("kevin",25);
            System.out.println("people:"+people.toString());
            try {
                Object clone = people.clone();
                if (clone instanceof People){
                    People people1 = (People) clone;
                    System.out.println("people1:"+people1.toString());
                    System.out.println("people==people1: " + (people==people1));
                    System.out.println("name: "+people.getName().equals(people1.getName()));
                    System.out.println("age==age1: "+(people.getAge() == people1.getAge()));
                }
            } catch (CloneNotSupportedException e) {
                e.printStackTrace();
            }
        }

    运行结果

    people:name=kevin,age=25
    people1:name=kevin,age=25
    people==people1: false
    name: true
    age==age1: true

    拷贝完以后数据是一样的说明是对的,但是巧的是name居然相等,age也居然相等,那不就是说引用的对象的地址是同一块地址呀,通俗的说,只是给这个people换了身行头因为(people==people1: false)看出来滴,内饰丝毫不改动呀,可能这样看的不清楚,咱给他加点work瞧一瞧

    新People如下:

    public class People implements Cloneable {
    
        private String name;
        private int age;
        private Work work;
    
        public People(String name, int age) {
            this.name = name;
            this.age = age;
            this.work = new Work("it码农", 9527);
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        public Work getWork() {
            return work;
        }
    
        public void setWork(Work work) {
            this.work = work;
        }
    
        @Override
        public String toString() {
            return "name=" + name + ",age=" + age;
        }
    
        class Work {
            private String workName;
            private int workNo;
    
            public Work(String workName, int workNo) {
                this.workName = workName;
                this.workNo = workNo;
            }
    
            public String getWorkName() {
                return workName;
            }
    
            public void setWorkName(String workName) {
                this.workName = workName;
            }
    
            public int getWorkNo() {
                return workNo;
            }
    
            public void setWorkNo(int workNo) {
                this.workNo = workNo;
            }
        }
    
        @Override
        protected Object clone() throws CloneNotSupportedException {
            return super.clone();
        }
    }

    再来个测试代码看看

    public static void main(String[] args) {
            People people = new People("kevin",25);
            System.out.println("people:"+people.toString());
            try {
                Object clone = people.clone();
                if (clone instanceof People){
                    People people1 = (People) clone;
                    System.out.println("people1:"+people1.toString());
                    System.out.println("people==people1: " + (people==people1));
                    System.out.println("name: "+people.getName().equals(people1.getName()));
                    System.out.println("age==age1: "+(people.getAge() == people1.getAge()));
                    System.out.println("work: "+(people.getWork() == people1.getWork()));
                    People.Work work = people.getWork();
                    People.Work work1 = people1.getWork();
                    work.setWorkName("i am work...");
                    System.out.println(work.getWorkName());
                    System.out.println(work1.getWorkName());
                }
            } catch (CloneNotSupportedException e) {
                e.printStackTrace();
            }
        }

    测试结果如下:

    people:name=kevin,age=25
    people1:name=kevin,age=25
    people==people1: false
    name: true
    age==age1: true
    work: true
    i am work...
    i am work...

    注意(work: true)这次很直观的发现引入的work是相等的,也就是拷贝的people依旧持有被拷贝people的work,通过给work(people中的work)赋值(i am work…),work1(拷贝完后的对象people1中的work)也跟着改变了内容,也就是说我只是做了上层拷贝(浅拷贝)只是神似罢了,哇那我不就可以引出深入一点的问题(深拷贝)了吗,机智如我呀,不如去吃个鸡?咳咳跑题了哈,往下走走

    深拷贝的People长如下这吊样,关键点是需要实现Serializable接口 ,People、Work必须要实现。因为我们要通过串行化来做深拷贝(deepClone方法),clone()方法咱做了浅拷贝,注Cloneable不能丢呀

    public class People implements Cloneable,Serializable {
    
        private String name;
        private int age;
        private Work work;
    
        public People(String name, int age) {
            this.name = name;
            this.age = age;
            this.work = new Work("it码农", 9527);
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        public Work getWork() {
            return work;
        }
    
        public void setWork(Work work) {
            this.work = work;
        }
    
        @Override
        public String toString() {
            return "name=" + name + ",age=" + age;
        }
    
        class Work implements Serializable{
            private String workName;
            private int workNo;
    
            public Work(String workName, int workNo) {
                this.workName = workName;
                this.workNo = workNo;
            }
    
            public String getWorkName() {
                return workName;
            }
    
            public void setWorkName(String workName) {
                this.workName = workName;
            }
    
            public int getWorkNo() {
                return workNo;
            }
    
            public void setWorkNo(int workNo) {
                this.workNo = workNo;
            }
        }
    
        /**
         * 浅拷贝
         * @return
         * @throws CloneNotSupportedException
         */
        @Override
        protected Object clone() throws CloneNotSupportedException {
            return super.clone();
        }
    
        /**
         * 深拷贝
         * @return
         */
        public Object deepClone() {
            ByteArrayOutputStream baos = null;
            ObjectOutputStream oos = null;
            ByteArrayInputStream bais = null;
            ObjectInputStream ois = null;
            try {
                baos = new ByteArrayOutputStream();
                oos = new ObjectOutputStream(baos);
                oos.writeObject(this);
    
                bais = new ByteArrayInputStream(baos.toByteArray());
                ois = new ObjectInputStream(bais);
                return ois.readObject();
            } catch (IOException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } finally {
                close(baos);
                close(oos);
                close(bais);
                close(ois);
            }
            return null;
        }
    
        /**
         * 关闭流
         * @param closeable
         */
        private static void close(Closeable closeable) {
            if (closeable != null) {
                try {
                    closeable.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    测试代码走一走:

    public static void main(String[] args) {
             People people = new People("kevin", 25);
            System.out.println("people:" + people.toString());
            Object clone = people.deepClone();
            if (clone instanceof People) {
                People people1 = (People) clone;
                System.out.println("people1:" + people1.toString());
                System.out.println("people==people1: " + (people == people1));
                System.out.println("name: " + people.getName().equals(people1.getName()));
                System.out.println("age==age1: " + (people.getAge() == people1.getAge()));
                System.out.println("work: " + (people.getWork() == people1.getWork()));
                People.Work work = people.getWork();
                People.Work work1 = people1.getWork();
                work.setWorkName("i am work...");
                System.out.println(work.getWorkName());
                System.out.println(work1.getWorkName());
            }
        }

    输出结果:

    people:name=kevin,age=25
    people1:name=kevin,age=25
    people==people1: false
    name: true
    age==age1: true
    work: false
    i am work...
    it码农

    老铁们,(work: false)work不相等了,深拷贝成功了呀,修改work的workName不会再影响work1的workName啦,激动呀。

    咦~这里的串行化不就是序列化和反序列化吗,老铁还不是信手拈来一段序列化代码

    请看,序列化little toolKit:这可是我做redis缓存数据用的序列化呀,倾囊相授,不要迷恋我哦

    public class SerializeUtil {
    
        /**
         * 单一对象序列化
         * @param object
         * @return
         */
        public static byte[] serialize(Object object) {
            if (object == null) {
                throw new IllegalArgumentException("object is null");
            }
            ObjectOutputStream oos = null;
            ByteArrayOutputStream baos = null;
            byte[] bytes = null;
            try {
                baos = new ByteArrayOutputStream();
                oos = new ObjectOutputStream(baos);
                oos.writeObject(object);
                bytes = baos.toByteArray();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                close(oos);
                close(baos);
                try {
                    oos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return bytes;
        }
    
        private static void close(Closeable closeable) {
            if (closeable != null) {
                try {
                    closeable.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    
        /**
         * 单一对象反序列化
         * @param bytes
         * @return
         */
        public static Object unserialize(byte[] bytes) {
            if (bytes == null) {
                throw new IllegalArgumentException("bytes is null");
            }
            ByteArrayInputStream bais = null;
            ObjectInputStream ois = null;
            try {
                bais = new ByteArrayInputStream(bytes);
                ois = new ObjectInputStream(bais);
                return ois.readObject();
            } catch (IOException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            } finally {
                close(bais);
                close(ois);
            }
            return null;
        }
    
        /**
         * 列表数据的序列化
         * @param list
         * @return
         */
        public static byte[] serializeList(List<?> list) {
            if (list == null || list.size() == 0) {
                return null;
            }
            ObjectOutputStream oos = null;
            ByteArrayOutputStream baos = null;
            byte[] bytes = null;
            try {
                baos = new ByteArrayOutputStream();
                oos = new ObjectOutputStream(baos);
                for (Object o : list) {
                    oos.writeObject(o);
                }
                bytes = baos.toByteArray();
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                close(baos);
                close(oos);
            }
            return null;
        }
    
        /**
         * 列表数据的反序列化
         * @param bytes
         * @return
         */
        public static List<?> unserializeList(byte[] bytes) {
            ByteArrayInputStream bais = null;
            ObjectInputStream ois = null;
            List<Object> list = new ArrayList<>();
            try {
                bais = new ByteArrayInputStream(bytes);
                ois = new ObjectInputStream(bais);
                while (bais.available() > 0){
                    Object object = ois.readObject();
                    if (object == null){
                        break;
                    }
                    list.add(object);
                }
                return list;
            } catch (IOException e) {
                e.printStackTrace();
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }finally {
                close(bais);
                close(ois);
            }
            return null;
        }
    }

    一个明朗的天,心情随着音乐摇摆呀(◡ᴗ◡✿)

    展开全文
  • 2020创业计划书怎么写 想创业怎么少得一份创业书呢?那么创业计划书怎么写,下面给大家分享两个范文。 20xx创业计划书范文1 1.运营模式 基地培训(免费)――》运输(自费)――》住宿(自费)――》推荐工作(免费)――...
  • 关系模式r的码都为单属性,则r一定是 几范式,说明理由,没有部分函数依赖我懂, 答案的是第二范式,怎么确定一定没有传递依赖呢
  • 自我评价(案例一)本人是计算机专业毕业生,熟悉JAVA开发,尤其是JAVA后台开发;...自我评价(案例二)熟练掌握JAVA语言,熟练运用MVC设计模式等各大主流框架,有一年的JAVA开发经验,熟练掌握JAVA,Oracle,Mysql...

    自我评价(案例一)

    本人是计算机专业毕业生,熟悉JAVA开发,尤其是JAVA后台开发;具备电子技术、信息技术和计算机网络方面的知识素养;具有熟练的计算机操作技能;自学能力强,容易接受并理解新知识、新事物;性格活泼开朗,能很好的处理同事之间的关系并与之交流。

    自我评价(案例二)

    熟练掌握JAVA语言,熟练运用MVC设计模式等各大主流框架,有一年的JAVA开发经验,熟练掌握JAVA,Oracle,Mysql,Linux,Hadoop云平台及周边技术,对Spark,Scala,Python等编程有一定研究。

    自我评价(案例三)

    1.具有良好的责任心、沟通能力和团队精神,能够很快 的融入团队。

    2.有良好的学习能力,喜欢学习新技术,敢于面对和克服困难。

    3.有比较强的动手能力,具备良好的分析问题和解决问题的能力。

    4.阳光开朗,积极上进,具有吃苦耐劳的精神。

    自我评价(案例四)

    1. 工作认真负责,有耐心,能承受一定的压力,有良好的团队合作精神和积极主动的沟通意识;

    2.热爱技术,喜欢钻研,对最新技术有浓厚的兴趣和钻研精神;

    3.有责任心,忠实诚信,讲原则,说到做到,决不推卸责任;

    4.有自制力,做事情始终坚持有始有终,从不半途而废;

    5.肯学习,有问题不逃避,愿意虚心向他人学习;

    6.自学能力强,敢于面对挑战,有动手能力,用行动去证明一切。

    展开全文
  • 夜大学习自我评价怎么写 夜大学习自我评价怎么写 不经意之间发现夜大学习已经到尾声,虽然我是已经走上工作岗位的学生,不像全日制学生那样全天候的在校学习、生活,但是普通学习模式还是让我收获匪浅。以下就是我...
  • 物业财务工作总结与计划怎么写 财务不仅是国民经济各部门、各单位在物质资料再生产过程中客观存在的资金运动及资金运动过程中所体现的经济关系,更主要的是财产和债务,即资产和负债等。今天小编给大家为您整理了...
  • 中班计划怎么写1 幼儿园安全工作计划使我园的教育质量、服务质量、品牌质量有了新的跨越,促进了保教工作顺利开展,同时我们把幼儿园安全工作计划做好,在本学期,幼儿园安全工作计划认真贯彻《幼儿园规程》,以...
  • 物业财务工作总结与计划怎么写 财务不仅是国民经济各部门、各单位在物质资料再生产过程中客观存在的资金运动及资金运动过程中所体现的经济关系,更主要的是财产和债务,即资产和负债等。今天小编给大家为您整理了...
  • 销售第四季度工作计划怎么写 【篇一】 为促进公司市场销售运作,加快产品推向市场,在有间内抢占信阳地区销售市场及份额,迅速增加产品销售渠道。现根据公司销售策略方针拟制第四季度营销方案,对销售实行集中管控...
  • 怎么看函数是否是无损连接分解? 很多书都有步骤求解,在这我按例子来说,就不把书上的上来了1. 第一步,画表(R的属性作为列,ρ的属性作为行) ... 第五步,如果有一行是满的,即关系模式的分解具有无损连接性...
  • 想拥有qps高的服务器怎么做,想淘宝那样的大型企业级电商,在双十一每秒几百万请求下也都稳如泰山,当然淘宝用到了很多顶尖技术解决高并发让服务器高可用,你可能会想到使用好的技术架构,页面缓存,非关系型是...
  • 对象关系映射,把类当成数据库中的表,把类对象当做数据库中的数据,每一个对象就对应表中没有每一条数据,通过对象.属性的方式,获取每条数据的字段值 需要用的知识点 面向对象,单利模式,元类 sql.py 文件 ...
  • "这些话,真烦人,个程序作为我的Proxy吧,凡是接收到这些话都设置好了自动的回答,接收到其他的话时再通知我回答,怎么样,酷吧。代理模式:代理模式给某一个对象提供一个代理对象,并由代理对象控制对源对象的...
  • 个人工作计划怎么写_2020公司员工个人工作计划范文大全5篇 制定好自己的工作计划,不断改进,继续前进!今天小编在这给大家带来员工工作计划,我们一起来看看吧! 员工工作计划(一) 一、实际招商开发操作方面 1、...
  • 本文是设计模式的第二篇文章,第一篇文章是不知道怎么封装代码?看看这几种设计模式吧!,后面还会有提高扩展性,提高代码质量的设计模式,点个关注不迷路,哈哈~ 想必大家都听说过DRY原则,其实就是Don't repeat ...
  • 什么是保护模式???? 什么是GDT? 什么是段基址?什么是段界限?它们是什么关系? 什么是选择子? gdtr寄存器是什么? cli怎么关的中断? A20地址线是什么? cr0是干嘛的? 什么是逻辑地址?什么是线性...
  • 设计模式思考3

    2020-08-29 10:26:59
    1.这种模式怎么理解?(尽量简单易懂) 2.类图怎样画?(代码怎样) 3.举个栗子?(使用场景) 4.使用这种模式有什么优缺点?(遵循什么原则) 行为型模式 14.观察者模式(Observer) (1)理解 对象间的一种一对...
  • 上面这个数据库字符串以及数据库类型由DBHelperFactory类传入 上面这个是数据库类型和连接字符串在DBHelper里面由配置节获得。 这怎么没办法上传源码啊?有源码就方便大家看了
  • 属性有name,number,class,sex,age,school等属性,如果每一个属性都可以为空,也就是说我们可以只用一个name,也可以用一个school,name,或者一个class,number,或者其他任意的赋值来创建一个学生对象,这时该怎么构造...
  • 桥接模式

    2019-11-13 22:50:41
    他应该错了,是聚合关系,不是组合,那怎么可能脱离整体存在 桥接(Bridge)模式的定义如下:将抽象与实现分离,使它们可以独立变化。 桥接(Bridge)模式的优点是: 由于抽象与实现分离,所以扩展能力强; ...
  • 在不同的需求,不同的要求下,我们怎么来设计我们的类,怎么来安排类与类之间的关系,从设计模式中,我们能够得到很好的启发。可以说设计模式能够帮助我们将应用组织成容易理解,容易维护,具有弹...
  • JAVA 拾遗 --Future 模式与 Promise 模式

    千次阅读 2019-10-21 10:36:40
    JAVA 拾遗 --Future 模式与 Promise 模式 这篇文章的动机,是缘起于微信闲聊群的一场讨论,粗略整理下...Future 模式和 Promise 模式是包含的关系,还是交集的关系,还是没有关系? 带着上面这些疑问,来看看我到...
  • 设计模式之组合模式

    2013-12-24 16:20:34
    关于组合模式,大部分都是的“部分——整体“的关系,部分组成了整体,把部分和整体可以看成一体。 可以把复杂的对象看做简单的对象。不过,再怎么说,我也觉得,这个模式还是没有深入的理解它的含义,印象不深刻...
  • 我之前过一篇策略模式的实现 项目中的if else太多了,该怎么重构? 用了注解+ApplicationListener来将映射关系保存在map中,有没有更简洁的方式呢?当然有!但是需要借助spring 策略模式本质上就是一个接口+多...
  • 图解Java设计模式(一)

    万人学习 2019-02-27 21:06:35
    本课程针对上述问题,有针对性的进行了升级 (1) 授课方式采用 图解+框架源码分析的方式,让课程生动有趣好理解 (2) 系统全面的讲解了设计模式,包括 设计模式七大原则、UML类图-类的六大关系、23种设计模式及其分类,...
  • 今天的博客主题 设计模式——》设计模式之迭代器模式 命令模式 CP (Command ...现在出的代码都是请求者与实现者通常都是一种紧耦合的关系,这样更简单明了,但缺乏扩展性。不适合在某些场合使用(行为记...

空空如也

空空如也

1 2 3 4 5 ... 17
收藏数 322
精华内容 128
关键字:

关系模式怎么写