精华内容
下载资源
问答
  • 文章目录关系数据库关系操作基本关系操作关系数据库语言的分类关系模型的完整性实体完整性(Entity Integrity)参照完整性(Referential Integrity)用户定义完整性(User-defined Integrity)E-R图向关系模型的转换...

    本人就职于国际知名终端厂商,负责modem芯片研发。
    在5G早期负责终端数据业务层、核心网相关的开发工作,目前牵头6G算力网络技术标准研究。

    关系数据库

    关系操作

    数据模型的三个方面:

    • 数据结构
    • 数据操作
    • 完整性约束

    基本关系操作

    • 常用的关系操作
      👊查询:选择、投影、连接、除、并、交、差
      👊数据更新:插入、删除、修改
      👊查询的表达能力是其中最主要的部分
      👊选择、投影、并、差、笛卡尔积是5种基本操作

    • 关系操作的特点
      集合操做方式:操作的对象和结果都是集合,一次一集合的方式

    关系数据库语言的分类

    • 关系代数语言
      用对关系的运算来表达查询要求
      代表:ISBL
    • 关系演算语言:用谓词来表达查询要求
      元组关系演算语言:
      🔸 谓词变元的基本对象是元组变量
      🔸 代表:APLHA,QUEL
      域关系演算语言:
      🔸 谓词变元的基本对象是域变量
      🔸 代表:QBE
    • 具有关系代数和关系演算双重特点的语言
      代表:SQL(Structured Query Language)
      🔹 SQL不仅具有丰富的查询功能,而且具有数据定义和数据控制功能,是集查询、DDL(data definition language)、DML(data manipulation language)和DCL(Data Control Language)于一体的关系数据语言。它充分体现了关系数据语言的特点和优点,是关系数据库的标准语言
      🔹 SQL特点:完备的表达能力、非过程化的集合操作、功能强、能嵌入高级语言使用
      在这里插入图片描述
      关系代数、元组关系演算和域关系演算三种语言在表达能力上是完全等价的

    关系模型的完整性

    为了维护数据库中数据与现实世界的一致性,对关系数据库的插入、删除和修改操作必须有一定的约束条件,这就是关系模型的三类完整性:

    • 实体完整性
    • 参照完整性
    • 用户定义的完整性

    实体完整性(Entity Integrity)

    • 实体完整性是指主键的值不能为空或者部分为空
    • 关系模型中的一个元组对应一个实体,一个关系则对应一个实体集
      例如,一条学生记录对应着一个学生,学生关系对应着学生的集合
    • 现实世界中的实体是可区分的,即它们具有某种唯一性标识。与此相对应,关系模型中以主关系键来唯一标识元组
      例如,学生关系中的属性“学号”可以唯一标识一个元组,也可以唯一标识学生实体
    • 如果主键中的值为空或部分为空,即主属性为空,则不符合键的定义条件,不能唯一标识元组及其相对应的实体。这就说明存在不可区分的实体,从而与现实世界中的实体是可以区分的事实相矛盾。因此主键的值不能为空或部分为空
      例如,学生关系中的主键“学号”不能为空;选课关系中的主键“学号+课程号”不能部分为空,即“学号”和“课程号”两个属性都不能为空

    参照完整性(Referential Integrity)

    现实世界中的实体之间往往存在某种联系,在关系模型中实体及实体间的联系都是用关系来描述的。这样就自然存在着关系与关系间的引用。

    例1: 学生(学号,姓名,性别,专业号,年龄)
    专业(专业号,专业名)

    例2: 学生(学号,姓名,性别,专业号,年龄)
    课程(课程号,课程名,学分)
    选课(学号,课程号,成绩)

    • 定义:设F是基本关系R的一个或一组属性,但不是关系R的码,如果F与基本关系S的主码Ks相对应,则称F是基本关系R的外码(Foreign Key),并称基本关系R为参照关系(Referencing Relation),基本关系S为被参照关系(Referenced Relation)或目标关系(Target Relation)

    • 关系R和S不一定是不同的关系

    • 参照完整性规则:若属性(或属性组)F是基本关系R的外码,它与基本关系S的主码Ks相对应(基本关系R和S不一定是不同的关系),则对于R中每个元组在F上的值必须为:
      ①或者取空值(F的每个属性值均为空值);
      ②或者等于S中某个元组的主码值。

    • 如下图,学生关系中某个学生(如s1或s2)“系别”的取值,必须在参照的系别关系中主关系键“系别”的值中能够找到,否则表示把该学生分配到一个不存在的部门中,显然不符合语义。
      如果某个学生(如s11)“系别”取空值,则表示该学生尚未分配到任何一个系。否则,它只能取专业关系中某个元组的专业号值
      在这里插入图片描述

    • 例如:
      学生(学号,姓名,性别,专业号,年龄)
      课程(课程号,课程名,学分)
      选课(学号,课程号,成绩)

      如果按照参照完整性规则,选课关系中的外部关系键“学号”和“课程号”可以取空值或者取被参照关系中已经存在的值。但由于“学号”和“课程号”是选课关系中主属性,根据实体完整性规则,两个属性都不能为空。所以选课关系中的外部关系键“学号”和“课程号”中只能取被参照关系中已经存在的值

    • 实体完整性和参照完整性是关系模型必须满足的完整性约束条件,被称作关系的两个不变性。任何关系数据库系统都应该支持这两类完整性

    • 除此之外,不同的关系数据库系统由于应用环境的不同,往往还需要一些特殊的约束条件,这就是用户定义完整性

    用户定义完整性(User-defined Integrity)

    • 用户定义完整性是针对某一具体关系数据库的约束条件
    • 它反映某一具体应用所涉及的数据必须满足的语义要求
      例如,属性值根据实际需要,要具备一些约束条件,如选课关系中成绩不能为负数;某些数据的输入格式要有一些限制等;工资不能低于“地区最低工资”
    • 关系模型应该提供定义和检验这类完整性的机制,以便使用统一的、系统的方法处理它们,而不要由应用程序承担这一功能

    E-R图向关系模型的转换

    • E-R图向关系模型的转换要解决的问题
      ①如何将实体型和实体间的联系转换为关系模式
      ②如何确定这些关系模式的属性和码

    • 转换内容
      将E-R图转换为关系模型:将实体、实体属性和实体之间的联系转换为关系模式。

      实体型间的联系有以下不同情况:
      (1)一个1:1联系可以转换为一个独立的关系模式,也可以与任意一端对应的关系模式合并
      (2)一个1:n联系可以转换为一个独立的关系模型,也可以与n端对应的关系模式合并
      (3)一个m:n联系转换为一个关系模型。例如:“选修”联系是一个m:n联系,可以将它转换为如下关系模式,其中学号与课程号为关系的组合码 👉选修(学号课程号,成绩)
      (4)三个或三个以上实体间的一个多元联系转换为一个关系模式。例如:“讲授”联系是一个三元联系,,可以将它转换为如下关系模式,其中课程号、教工号和书号为关系的组合码👉讲授(课程号教工号书号

    综合练习 E-R图

    用E-R图表示某个工厂物资管理的概念模型

    • 实体
      仓库:仓库号、面积、电话号码
      零件:零件号、名称、规格、单价、描述
      供应商:供应商号、姓名、地址、电话号码、账号
      项目:项目号、预算、开工日期
      职工:职工号、姓名、年龄、职称
    • 实体之间的联系如下:
      (1)一个仓库可以存放多种零件,一种零件可以存放在多个仓库中。仓库和零件具有多对多的联系。用库存量来表示某种零件在某个仓库中的数量;
      (2)一个仓库有多个职工当仓库保管员,一个职工只能在一个仓库工作,仓库和职工之间是一对多的联系。职工实体型中具有一对多的联系;
      (3)职工之间具有领导与被领导关系。及仓库主任领导若干保管员;
      (4)供应商、项目和零件三者之间具有多对多的联系
      在这里插入图片描述
      将E-R图转换为关系模式,并说明外键和主键的对应关系
      供应(供应商号,项目号,零件号,…)
      🔹 (供应商号,项目号,零件号)为主键
      🔹 供应商号是外键与供应商的供应商号对应
      🔹 项目号是外键与项目的主键项目号对应
      🔹 零件号是外键与零件的主键零件号对应
      库存(仓库号,零件号,…)
      🔹 (仓库号,零件号)为主键
      🔹 仓库号是外键与仓库的主键仓库号对应
      🔹 零件号是外键与零件的主键零件号对应
      工作(仓库号,职工号,领导职工号,…)
      🔹 (仓库号,职工号,领导职工号)为主键
      🔹 仓库号是外键与仓库的主键仓库号对应
      🔹 职工号是外键与职工的主键职工号对应
      🔹 领导职工号是外键与职工的主键职工号对应

    关系数据库——关系数据结构及形式化定义
    关系数据库——关系代数


    在这里插入图片描述

    展开全文
  • 双亲委派模式优点

    万次阅读 多人点赞 2019-06-06 16:39:17
    能自己写个类叫java.lang.System? 答案:通常可以,但可以采取另类方法达到这个需求。 解释:为了让我们写System类,类加载采用委托机制,这样可以保证爸爸们优先,爸爸们能找到的类,儿子就没有机会加载...

    一道面试题
    能不能自己写个类叫java.lang.System?

    答案:通常不可以,但可以采取另类方法达到这个需求。
    解释:为了不让我们写System类,类加载采用委托机制,这样可以保证爸爸们优先,爸爸们能找到的类,儿子就没有机会加载。而System类是Bootstrap加载器加载的,就算自己重写,也总是使用Java系统提供的System,自己写的System类根本没有机会得到加载。

    但是,我们可以自己定义一个类加载器来达到这个目的,为了避免双亲委托机制,这个类加载器也必须是特殊的。由于系统自带的三个类加载器都加载特定目录下的类,如果我们自己的类加载器放在一个特殊的目录,那么系统的加载器就无法加载,也就是最终还是由我们自己的加载器加载。

    双亲委派模式优势

    避免重复加载 + 避免核心类篡改
    采用双亲委派模式的是好处是Java类随着它的类加载器一起具备了一种带有优先级的层次关系,通过这种层级关可以避免类的重复加载,当父亲已经加载了该类时,就没有必要子ClassLoader再加载一次。其次是考虑到安全因素,java核心api中定义类型不会被随意替换,假设通过网络传递一个名为java.lang.Integer的类,通过双亲委托模式传递到启动类加载器,而启动类加载器在核心Java
    API发现这个名字的类,发现该类已被加载,并不会重新加载网络传递的过来的java.lang.Integer,而直接返回已加载过的Integer.class,这样便可以防止核心API库被随意篡改。

    JVM预定义的三种类型类加载器:

    • 启动(Bootstrap)类加载器:是用本地代码实现的类装入器,它负责将
      <Java_Runtime_Home>/lib下面的类库加载到内存中(比如rt.jar)。由于引导类加载器涉及到虚拟机本地实现细节,开发者无法直接获取到启动类加载器的引用,所以不允许直接通过引用进行操作。

    • 标准扩展(Extension)类加载器:是由 Sun 的
      ExtClassLoader(sun.misc.Launcher$ExtClassLoader)实现的。它负责将<
      Java_Runtime_Home >/lib/ext或者由系统变量
      java.ext.dir指定位置中的类库加载到内存中。开发者可以直接使用标准扩展类加载器。

    • 系统(System)类加载器:是由 Sun 的
      AppClassLoader(sun.misc.Launcher$AppClassLoader)实现的。它负责将系统类路径(CLASSPATH)中指定的类库加载到内存中。开发者可以直接使用系统类加载器。

    双亲委派模型工作工程:

    1.当Application ClassLoader 收到一个类加载请求时,他首先不会自己去尝试加载这个类,而是将这个请求委派给父类加载器Extension ClassLoader去完成。

    2.当Extension ClassLoader收到一个类加载请求时,他首先也不会自己去尝试加载这个类,而是将请求委派给父类加载器Bootstrap
    ClassLoader去完成。

    3.如果Bootstrap ClassLoader加载失败(在<JAVA_HOME>\lib中未找到所需类),就会让Extension ClassLoader尝试加载。

    4.如果Extension ClassLoader也加载失败,就会使用Application ClassLoader加载。

    5.如果Application ClassLoader也加载失败,就会使用自定义加载器去尝试加载。
    在这里插入图片描述
    在这里插入图片描述

    这就涉及到了类的具体加载过程, 如下图, 类的加载过程被从左到右划分为 3 大阶段

    1.装载 (Loading)
    该阶段负责找到待加载类的二进制 class 文件, 并把它以 bytecode 的形式装载到虚拟机。 在这个过程中, JVM 会给这个类分配一个基本的内存结构, 但是方法, 变量域, 和它引用到的其他类在这个阶段都还没有处理, 也就是说, 这个类在目前阶段还不可用
    2.链接 (Linking)
    这个步骤又可细分为3个阶段

    • 字节码验证
      验证字节码是否是一个正确,符合规范的类字节码
    • 类准备
      为这个类定义好必须的数据结构以表示成员变量域, 方法, 以及实现的接口等等
    • 解析
      把这个类锁引用的其他类全部加载进来 , 引用的方式有如下几种:
      • 继承
      • 实现接口
      • 域变量
      • 方法定义
      • 方法中定义的本地变量

    3.初始化(Initializing)
    执行类中定义的静态代码块, 初始化静态变量为默认值

    隐式加载 vs 显示加载
    从上文类加载的详细过程可以看出, 类有两种方式被加载进来

    1. 显式加载
      程序主动调用下列类型的方法去主动加载一个类
    • classloader.loadClass( className)
    • Class.forName( className)
    1. 隐式加载
      被显式加载的类对其他类可能存在如下引用:
    • 继承
    • 实现接口
    • 域变量
    • 方法定义
    • 方法中定义的本地变量
    • 被引用的类会被动地一并加载至虚拟机, 这种加载方式属于隐式加载

    原文:https://blog.csdn.net/lengxiao1993/article/details/86689331

    展开全文
  • JAVA当中有23种设计模式,解决某一问题最有效的方法单例设计模式 解决一个类在内存中只存在一个对象 想要保证对象唯一该怎么做》1.为了避免其他程序过多建立该类对象,先禁止其他程序建立该类对象 2.还为了让其他...

    JAVA之旅(六)——单例设计模式,继承extends,聚集关系,子父类变量关系,super,覆盖


    java也越来越深入了,大家加油吧!咱们一步步来

    一.单例设计模式

    • 什么是设计模式?

      JAVA当中有23种设计模式,解决某一问题最有效的方法

    • 单例设计模式

      解决一个类在内存中只存在一个对象

    想要保证对象唯一该怎么做》

    • 1.为了避免其他程序过多建立该类对象,先禁止其他程序建立该类对象
    • 2.还为了让其他程序访问到该类对象,只好在本类中自定义一个对象
    • 3.为了方便其他程序对自定义对象的访问,可以对外提供一些访问方式

    这三步怎么怎么实现呢?

    • 1.将构造函数私有化
    • 2.在类中创建一个本类对象
    • 3.提供一个方法可以获取到该对象

    然后我们的代码就出来了

    /**
     * 单例模式
     * 
     * @author LGL
     *
     */
    public class Single {
    
        // 将构造函数私有化
        private Single() {
    
        }
    
        // 在类中创建一个本类对象
        private static Single s = new Single();
    
        // 提供一个方法可以获取到该对象
        public static Single getInstance() {
    
            return s;
        }
    }
    

    当然,我们还有一种写法——懒汉式

    /**
     * 单例模式
     * 懒汉式
     * @author LGL
     *
     */
    public class Single {
    
        private static Single s = null;
    
        public Single() {
            // TODO Auto-generated constructor stub
        }
    
        public static Single getInstance() {
            if (s == null)
                s = new Single();
    
            return s;
    
        }
    }
    

    也有这么一种写法

    /**
     * 单例模式 
     * 饿汉式
     * 
     * @author LGL
     *
     */
    public class Single {
    
        private static Single s = new Single();
    
        public Single() {
            // TODO Auto-generated constructor stub
        }
    
        public static Single getInstance() {
            return s;
    
        }
    }
    

    单例模式的写法多种多样,只要掌握这个思想就可以了

    饿汉式的特点:single类一进内存就已经创建好了对象
    懒汉式的特点:对象是方法被调用时才初始化,也叫作对象的延迟加载

    Single类进内存还没有存在,只有调用了getInstance()方法时才建立对象,这就叫做延迟加载

    我们一般用饿汉式,因为他安全,简单

    二.继承

    面向对象的思想中的一个思想,继承,我们可以这样去理解,我们可以定义一个学生类,他有名字和年龄,还有一个学习的方法

    /**
     * 学生
     * @author LGL
     *
     */
    class Student {
    
        String name;
    
        int age;
    
        void study() {
            System.out.println("学习");
        }
    }

    然后我们可以再定义一个工人类

    
    /**
     * 工人
     * @author LGL
     *
     */
    class Worker {
    
        String name;
    
        int age;
    
        void work() {
            System.out.println("工作");
        }
    }

    他同样有名字和年龄还有一个工作的方法

    这个时候我们可以发现,他们都存在相同的关系,他们都是人,人都具备年龄和姓名,所以我们可以将学生和工人的共性提取出来描述,只要让学生和工人与单独描述的类有关系就行,也就是继承

    /**
     * 人
     * 
     * @author LGL
     *
     */
    class Person {
        String name;
    
        int age;
    }

    这个Person就叫做父类,超类,基类

    然后我们的工人和学生就可以这样去写

    
    /**
     * 学生
     * 
     * @author LGL
     *
     */
    class Student extends Person {
    
        void study() {
            System.out.println("学习");
        }
    }
    
    /**
     * 工人
     * 
     * @author LGL
     *
     */
    class Worker extends Person {
    
        void work() {
            System.out.println("工作");
        }
    }

    他们是Person的子类,继承是源于生活,所以工人不能继承学生,没有伦理性,千万不要为了获取其他类的功能,简化代码而继承,必须是类与类之间有所属关系才可以继承,is a 的关系
    继承的优点

    • 1.提高代码的复用性
    • 2.让类与类之间产生关系,有了这层关系才有了多态的特性

    JAVA语言中,java只支持单继承,不支持多继承

    • 为什么不能多继承?

      因为多继承容易带来安全隐患,当多个父类中定义了相同的功能,当功能内容不同时,子类对象不确定运行哪一个,但是JAVA保留了这种机制,并用另一种体现形式来表示,多实现。


    JAVA支持多层继承,也就是一个继承体系

    如何使用一个继承体系的功能?

    • 想要使用体系,先查阅体系中父类的描述,因为父类中定义的是该体系中的共性内容,通过了解共性功能就可以知道该体系的基本功能,那么,这么体系已经可以基本使用了。

    • 那么集体调用时,要创建最子类的对象,为什么?一是因为有可能父类不能创建对象,二是创建子类对象可能使用更多的功能,包括基本的也包括特有的

    简单的说一句:查阅父类功能,创建子类对象使用功能

    三.聚集关系

    这个概念可能很多人不是很熟悉,确实我们实际开发当中很少提到,我们对象和对象之间,不光有继承关系,还有组合关系,

    • 聚合

      球员是球队中的一个,球队中有球员,这就是聚合关系

    • 组合

      手是人身体的一部分,腿是身体的一部分,这就是组合关系,你说这和聚合没什么不同,那你就错了,要知道,球队少了个球员没事,人少胳膊少腿就有事哦,所以组合关系更加紧密一点

    都是吧对象撮合在一起,像我们继承是秉承一个is a的关系,而聚集是has a的关系,谁里面有谁

    这个关系我们就不多做赘述了

    我们关系讲完了,现在应该可以用代码去表示表示了,这里我就用当继承关系时,子类和父类之间的变量关系来举例

    四.子父类变量关系

    我们来探索一下子父类出现后,类成员的特点

      1. 变量
    • 2.函数
    • 3.构造函数

    我们一步步来分析

    1.变量

    我们撸一串代码

    //公共的   类   类名
    public class HelloJJAVA {
        // 公共的 静态 无返回值 main方法 数组
        public static void main(String[] str) {
            /**
             * 子父类出现后,类成员的特点
             */
    
            Zi z = new Zi();
            System.out.println("num1 = " + z.num1 + "\n" + "num2 = " + z.num2);
        }
    }
    
    /**
     * 父类
     * 
     * @author LGL
     *
     */
    class Fu {
    
        int num1 = 4;
    }
    
    /**
     * 子类
     * 
     * @author LGL
     *
     */
    class Zi extends Fu {
    
        int num2 = 5;
    
    }

    这样,是不是很容易知道输出的结果

    这里写图片描述

    但是我们那会这么简单,我们还有特殊情况

    //公共的   类   类名
    public class HelloJJAVA {
        // 公共的 静态 无返回值 main方法 数组
        public static void main(String[] str) {
            /**
             * 子父类出现后,类成员的特点
             */
    
            Zi z = new Zi();
            System.out.println("num1 = " + z.num + "\n" + "num2 = " + z.num);
        }
    }
    
    /**
     * 父类
     * 
     * @author LGL
     *
     */
    class Fu {
    
        int num = 4;
    }
    
    /**
     * 子类
     * 
     * @author LGL
     *
     */
    class Zi extends Fu {
    
        int num = 5;
    
    }

    当子类和父类都有相同的变量的时候,现在该打印什么呢?

    这里写图片描述

    没错,打印了子类的值,为什么?因为输出的num前面其实默认带了一个this,如果我们要打印父类的值,需要加super,这是一个新的关键字了

    void show(){
            System.out.println(super.num);
        }

    结果显而易见了

    这里写图片描述

    所以变量的特点:如果子类中出现非私有的同名成员变量时,子类要访问本类中的成员变量,用this,子类访问父类中的同名变量,用super,this和super的使用几乎一致,this代表的是本类对象的引用,super代表父类对象的引用

    不过我们也不会这么蛋疼在父类创建又在子类创建,我们来看第二个

    2.函数

    也就是方法,我们正常的应该是这样写的

    //公共的   类   类名
    public class HelloJJAVA {
        // 公共的 静态 无返回值 main方法 数组
        public static void main(String[] str) {
            /**
             * 子父类出现后,类成员的特点
             */
    
            Zi z = new Zi();
            z.show1();
            z.show2();
        }
    }
    
    /**
     * 父类
     * 
     * @author LGL
     *
     */
    class Fu {
        void show1() {
            System.out.println("fu");
        }
    
    }
    
    /**
     * 子类
     * 
     * @author LGL
     *
     */
    class Zi extends Fu {
    
        void show2() {
            System.out.println("zi");
        }
    }

    这是很正常的实现

    这里写图片描述

    我们当然要说一种特殊情况,子父类方法同名我们该怎么办?我们运行一下

    这里写图片描述

    这是子运行了,这种情况叫做覆盖(重写),这个特性的特点

    • 当子类出现和父类一模一样的函数时,当子类对象被调用了该函数,会运行子类函数的内容,如同父类的函数被覆盖一样,这种情况就是覆盖了

    当子类继承了父类,沿袭了父类的功能到子类中,到子类中,但是子类虽具备该功能,但是功能的内容却和父类不一致,这时没有必要定义新功能,而是使用覆盖特性,保留父类的功能定义并重写功能内容

    • 覆盖

      1.子类覆盖父类,必须保证子类权限大于等于父类权限才可以覆盖,否则编译失败
      2.静态只能覆盖静态(一般没人用)

    • 记住

      重载:只看同名函数的参数列表
      重写:字符类方法要一模一样 ,包括返回值类型

    3.构造函数

    最后一个特点了

    //公共的   类   类名
    public class HelloJJAVA {
        // 公共的 静态 无返回值 main方法 数组
        public static void main(String[] str) {
            /**
             * 子父类出现后,类成员的特点
             */
            Zi z = new Zi();
    
        }
    }
    
    /**
     * 父类
     * 
     * @author LGL
     *
     */
    class Fu {
        public Fu() {
            System.out.println("fu");
        }
    }
    
    /**
     * 子类
     * 
     * @author LGL
     *
     */
    class Zi extends Fu {
        public Zi() {
            System.out.println("zi");
        }
    }

    我们现在运行一下

    这里写图片描述

    你会疑问,我明明实例化的是子类,怎么父类也实例化了,因为子类构造函数的第一行默认有一个方法

    super()

    在对子类对象进行初始化时,父类的构造函数也会执行,那就是因为子类的构造函数默认第一行有一条隐式的语句super();他会访问父类中空参数的构造函数,而且子类中所有的构造函数默认第一行都是super()

    • 为什么子类一定要访问父类中的构造函数?

      因为父类中的数据子类可以直接获取,所有子类建立对象的时候,需要先查看父类如何对这些数据进行初始化的,所有子类对这些对象初始化时,要先访问父类中的构造函数,如果要访问父类中指定的构造函数,可以手动定义super(xx,xx)的方式。

    • 注意

      super语句一定定义在子类构造函数的第一行

    • 结论:

      子类的所有的构造函数,默认都会访问父类中空参数的构造函数,因为子类每一个构造函数内的第一行都有一句隐式的super,当父类中没有空参数的构造函数时,子类必须手动通过super或者this语句的形式指定要访问父类中的构造函数

    当然,子类的构造函数也可以指定this来访问本类中的构造函数,子类中至少会有一个构造函数会访问父类中的构造函数,这个结论就是子类的实例化过程,逐级向上查找

    父类也向上查找,他找的是JAVA中所有类的老爹——Object

    行,我们本篇幅就闲到这里吧,概念多了,反而难以消化,我们要一点点的来

    如果有兴趣可以加群:555974449,这可能是迄今为止最和谐的IT群了

    展开全文
  • 关系数据库,是建立在关系模型基础上的数据库,借助于集合代数等数学概念和方法来处理数据库中的数据。简单说,关系型数据库是由多张能互相联接的二维行列表格组成的数据库。 关系模型就是指二维表格模型,因而一个...

    常见的数据库模型分为两种,分别是关系型数据库关系型数据库

    关系型数据库

    关系数据库,是建立在关系模型基础上的数据库,借助于集合代数等数学概念和方法来处理数据库中的数据。简单说,关系型数据库是由多张能互相联接的二维行列表格组成的数据库。

    关系模型就是指二维表格模型,因而一个关系型数据库就是由二维表及其之间的联系组成的一个数据组织。

    关系型数据库优点:

    1. 容易理解:二维表结构是非常贴近逻辑世界一个概念,关系模型相对网状、层次等其他模型来说更容易理解。
    2. 使用方便:通用的SQL语言使得操作关系型数据库非常方便。
    3. 易于维护:丰富的完整性(实体完整性、参照完整性和用户定义的完整性)大大减低了数据冗余和数据不一致的概率。
    4. 支持SQL,可用于复杂的查询。

    关系型数据库缺点:

    1. 为了维护一致性所付出的巨大代价就是其读写性能比较差。
    2. 固定的表结构。
    3. 高并发读写需求。
    4. 海量数据的高效率读写。

    数据库事务必须具备ACID特性,ACID是Atomic原子性,Consistency一致性,Isolation隔离性,Durability持久性。

    关系型数据库有:

    MySQL、Oracle、DB2、PostgreSQL、Microsoft SQL Server、Microsoft Access、Sybase、Informix、 FoxPro数据库、Teradata 、浪潮K-DB、SQLite、MariaDB(MySQL的一个分支)、sap等

    非关系型数据库:

    非关系型数据库,又被称为NoSQL(Not Only SQL ),意为不仅仅是SQL。强调key-value存储和文档数据库优点。

    1)面向检索的列式存储(Column-Oriented)

    面向检索的列式存储,其存储结构为列式结构,同于关系型数据库的行式结构,这种结构会让很多统计聚合操作更简单方便。使系统具有较高的可扩展性。这类数据还可以试应海量数据的增加以及数据结构的变化。

    典型数据库:HBase、Cassandra、Microsoft Azure Cosmos DB、Datastax Enterprise、Accumulo

    2)面向高性能并发读/写的缓存数据(Key-Value)

    面向高性能并发读/写的缓存数据,其结构类似于数据结构中的Hash表,每个Key分别对应一个Value,能够提供非常快的查询速度、大数据存放量和高并发操作,非常适合通过主键对数据进行查询和修改等操作。Key-Value数据库的主要特点是具有极高的高并发读/写性能,非常适合作为缓存系统使用。

    典型数据库:redis、memcached、memcacheDB,BerkeleyDB、Flare、Hazelcast、Microsoft Azure Cosmos DB、Amazon DynameoDB

    3)面向海量数据访问的文档存储(Document-Oriented)

    面向海量数据访问的文档存储,这类存储的结构与Key-Value非常相似,也是每个Key分别对应一个Value,但是这个Value主要以JSON(JavaScriptObjectNotations)或者XML等格式的文档来进行存储。这种存储方式可以很方便地被面向对象的语言所使用。这类数据库可在海量的数据中快速查询数据。

    典型数据库:MongoDB、CouchDB、Amazon DynameoDB、Couchbase、Microsoft Azure Cosmos DB

    非关系型数据库优点:

    1. 海量数据的增删改查是可以的。
    2. 海量数据的维护和处理非常轻松。
    3. NoSql具有扩展简单、高并发、高稳定性、成本低廉的优势。
    4. 可以实现数据的分布式处理。

    非关系型数据库缺点:

    1. NoSql暂时不提供sql支持,会造成开发人员额外学习的成本。
    2. 数据和数据没有关系,他们之间就是单独存在的。
    3. 非关系数据库没有关系,没有强大的事务关系,没有保证数据的完整性和安全性适合处理海量数据,保证效率,不一定安全。
    4. 持久化的性能低。
    5. 出道时间短,功能没有关系型数据库完善。
    6. NoSql的架构特性决定了其很难保证数据得完整性,适合一些特殊的应用常见使用。

    非关系型数据库有:

    Neo4j、MongoDB、CouchDB、Amazon DynameoDB、Couchbase、Microsoft Azure Cosmos DB、redis、memcached、memcacheDB,BerkeleyDB、Flare、Hazelcast、HBase、Cassandra、Datastax Enterprise、Accumulo

    注:参考百度百科

    展开全文
  • 关系模型中的常用概念 优点 不足 非关系型数据库 非关系型数据库: 非关系型数据库结构 优点 不足 分类 CAP 理论 关系型与非关系型数据库的比较 最近的数据库排名 关系型数据库 关系型数据库: 指采用...
  • 关系型数据库:指采用了关系模型来组织数据的数据库。 关系模型指的就是二维表格模型,而一个关系型数据库就是由二维表及其之间的联系所组成的一个数据组织。 关系模型中常用的概念: 关系:一张二维表,每个关系...
  • 我们发现这个设计可以使软件工程中的关注点分离,我们注意到通过MVC模式,我们实现了视图和模型的分离,通过控制器这个胶水层让两者间接联系起来,所以MVC的优点是让各个模块更好的协作。那么,它的缺点是什么呢?...
  • 关系数据库与非关系数据库的区别

    万次阅读 2018-11-01 20:50:59
    当前主流的关系型数据库有Oracle、DB2、Microsoft ...1)成本:nosql数据库简单易部署,基本都是开源软件,需要像使用oracle那样花费大量成本购买使用,相比关系型数据库价格便宜。 2)查询速度:nosql数据库将数...
  •  关系模型是在1970年由IBM的研究员E.F.Codd博士首先提出的,在之后的几十年中,关系模型的概念得到了充分的发展并逐渐成为主流数据库结构的主流模型。  简单来说,关系模型指的就是二维表格模型,而一个关系型...
  • 关系型和非关系型数据库的区别

    千次阅读 2018-11-19 16:57:56
    当前主流的关系型数据库有Oracle、DB2、Microsoft SQL Server、Microsoft Access、MySQL等。 非关系型数据库有 NoSql、Cloudant。 nosql和关系型数据库比较?...优点: 1)成本:nosql数据库简单易部...
  • 关系型和非关系型数据库的区别?

    千次阅读 2018-05-07 16:04:03
    当前主流的关系型数据库有...优点:1)成本:nosql数据库简单易部署,基本都是开源软件,需要像使用oracle那样花费大量成本购买使用,相比关系型数据库价格便宜。2)查询速度:nosql数据库将数据存储于缓存之...
  • 关系型数据库到非关系型数据库

    千次阅读 2013-05-16 11:06:08
    自1970年,埃德加·科德提出关系模型之后,关系数据库便开始出现,经过了40多年的演化,如今的关系型数据库具备了强大的存储、维护、查询数据的能力。但在关系数据库日益强大的时候,人们发现,在这个信息爆炸的...
  • 1、关系型数据库,是指采用了关系模型来组织 数据的数据库; 2、关系型数据库的最大特点就是事务的一致性; 3、简单来说,关系模型指的就是二维表格模型, 而一个关系型数据库就是由二维表及其之间的联系所组成...
  • 数据库类型 特性 优点 缺点 关系型数据库 SQLite、Oracle、mysql 1、关系型数据库,是指采用了关系模型来组织数据的数据库;...1、容易理解:二维表结构是非常贴近逻辑世界的一个概念,关系模型相对网状、层
  • 反欺诈技术揭秘-设备指纹VS关系网络模型   (2017-05-12 10:23:52) 转载▼ 标签:  设备指纹   关系网络   反欺诈   神经网络模型 分类: 风控 文章来源:...
  • 内存数据库、关系型数据库和非关系型数据库 一、内存数据库、关系型数据库和非关系型数据库 1.个人观点: 二、内存数据库(Redis,MongoDb,SQLite,Oracle等): 三、Raft分布式协议: 四、Redis出现宕机,...
  • Unity3D使用经验总结 优点

    千次阅读 2014-05-27 23:21:00
    Unity3D使用经验总结 优点篇 09年还在和其它小伙伴开发引擎的时候,Unity3D就初露头角。 当时就对这种基于组件式的设计结构很理解。 觉得拆分过于细致,同时影响效率。 而时至今日,UNITY3D已经...
  • 当前主流的关系型数据库有Oracle、DB2、Microsoft SQL Server、Microsoft Access、MySQL等。 非关系型数据库有 NoSql、Cloudant。   ==========================优缺点分析如下=========================...优点...
  • 关系型数据与非关系型数据库NoSql

    千次阅读 2016-05-20 14:52:29
    最近经常听到NoSql,知道什么意思,百度之,发现NoSql就是泛指的非关系型数据库。所以学习了一下,发现非关系型数据库最近非常的火,特别适用于某些应用如SNS网站,所以学习了NoSql与我们常用的关系型数据库之间的...
  • 1. 简介 在文档型NoSQL数据库出现之前,许多开发者一直绞尽脑汁思考,希望能想出更好的处理关系型数据库技术的方法,如今他们可能要跳出那种思维而另辟蹊径...随着大数据的发展,我们越来越有必要开始对数据模型做出
  • 关系模型是在1970年由IBM的研究员E.F.Codd博士首先提出的,在之后的几十年中,关系模型的概念得到了充分的发展并逐渐成为主流数据库结构的主流模型。 简单来说,关系模型指的就是二维表格模型,而一个关系型...
  • 用户—角色—权限多对多的关系。 权限修改只需对角色的关联权限进行修改。 若多身份,只需多用户进行多角色赋予即可。 权限通过角色来赋予至用户,使得用户即使发生变更、离职也不会影响权限本身的稳定性。 ...
  • hbase优点与数据检索流程

    千次阅读 2015-10-27 14:33:44
    hbase与关系型数据库相比较优点如下: 1. hbase数据存储于hdfs上,可扩展性强。数据条目数可以存储上一条。 2. 通过rowkey检索数据,速度可以准实时,达到秒级别。 3. 写数据非常快,只要写在Region的mem

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 62,851
精华内容 25,140
关键字:

关系模型不具备的优点