表与表之间的关系
"""把所有数据都存放于一张表的弊端
1.组织结构不清晰
2.浪费硬盘空间
3.扩展性极差"""
#上述的弊端产生原因类似于把代码全部写在一个py文件中，你应该怎么做？>>>解耦合！将上述一张表拆成员工和部门两张表！#类似的表关系学生与班级，也是如此，一张学生表和一张班级表
”””
确立表与表之间的关系 一定要换位思考(必须两方都考虑周全之后才能得出结论)
以员工表和部门表为例
先站在员工表看能否有多个员工对应一个部门
翻译过来:
一个部门能否有多个员工
可以!!!(暂时只能确定员工单向多对一部门)
再站在部门表看能否有多个部门对应一个员工
翻译过来:
一个员工能否属于多个部门
不可以!!!
结论:员工表和部门表之间仅仅是单向的多对一
那么它们的表关系就是"一对多"表关系中没有多对一一说,只有一对多
(无论是多对一还是一对多都叫"一对多")
””’
外键
"""通过我们的分析我们可以得到把一张表拆成两张表之后它们概念上的联系，那么我们要如何让这两张表有在代码层面上的真正关联，那么就要用到外键。
什么是外键？
让表与表有硬性物理层面上的联系。
foreign key
外键约束
1.在创建表的时候，必须先创建被关联表
2.插入数据的时候，也必须先插入被关联表的数据"""
一对多
#上代码来创建表#先建被关联表
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);
#修改表的数据
update dep set id=200 where id = 1;
update emp set dep_id= 300 where id = 1;
deletefrom dep where id = 3;
结果如下：
外键虽然能够帮你强制建立表关系 但是也会给表之间增加数据相关的约束
级联更新级联删除
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);
建立级联更新和级联删除后，可以进行表修改操作并让两边同步。
多对多
"""图书与作者表
一定要换位思考
先站在图书
多本书能否有一个作者
一个作者能否写多本书    可以!!!
再站在作者
多个作者能否和写一本书
一本书能否有多个作者    可以!!!
如果双方都是可以,那么就是多对多
强调  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);
一对一
客户表和学生表(学校的客户与学生之间,报名之前都是客户，只有报了名的才能是学生)
#左表的一条记录唯一对应右表的一条记录，反之也一样
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，区别在于如何使用以及其他条件限制即可做出三种关系
总结
"""判断表关系的最简单的语法
图书与出版社
一本书可不可以有多个出版社  不可以!!!
一个出版社可不可以出版多本书  可以!!!
一对多的关系"""图书与作者表
一本书可不可以有多个作者    可以!!!
一个作者可不可以写多本书     可以!!!
多对多的关系"""作者与作者详情
一个作者可不可以有多个详情  不可以!!!
一个作者详情可不可以有多个作者  不可以!!!
要么两者是一对一
要么两者之间没任何关系"""
修改表
#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 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原型模式）有半毛钱的关系吗？我这不是借物喻人，寓情于景吗，请原谅我的语文天赋点的有点歪……^_^~


  
开局一声吼，代码全靠编


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

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

坚决不跑题了哈，编起来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;
    }
}

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

自我评价(案例一)
本人是计算机专业毕业生，熟悉JAVA开发，尤其是JAVA后台开发；具备电子技术、信息技术和计算机网络方面的知识素养；具有熟练的计算机操作技能；自学能力强，容易接受并理解新知识、新事物；性格活泼开朗，能很好的处理同事之间的关系并与之交流。
自我评价(案例二)
熟练掌握JAVA语言，熟练运用MVC设计模式等各大主流框架，有一年的JAVA开发经验，熟练掌握JAVA，Oracle，Mysql，Linux，Hadoop云平台及周边技术，对Spark，Scala，Python等编程有一定研究。
自我评价(案例三)
1.具有良好的责任心、沟通能力和团队精神，能够很快 的融入团队。
2.有良好的学习能力，喜欢学习新技术，敢于面对和克服困难。
3.有比较强的动手能力，具备良好的分析问题和解决问题的能力。
4.阳光开朗，积极上进，具有吃苦耐劳的精神。
自我评价(案例四)
1. 工作认真负责，有耐心，能承受一定的压力，有良好的团队合作精神和积极主动的沟通意识；
2.热爱技术，喜欢钻研，对最新技术有浓厚的兴趣和钻研精神;
3.有责任心，忠实诚信，讲原则，说到做到，决不推卸责任;
4.有自制力，做事情始终坚持有始有终，从不半途而废;
5.肯学习，有问题不逃避，愿意虚心向他人学习；
6.自学能力强，敢于面对挑战，有动手能力，用行动去证明一切。