精华内容
下载资源
问答
  • 连续函数的分量连续性质,让我得以将数学分析研究的一元函数的性质,推广到多元函数。因此,我们必要回顾一下一元函数的一些性质。...因此,研究函数的连续性,一躲不开的问题,是序列的极限...

    连续函数的分量连续性质,让我得以将数学分析研究的一元函数的性质,推广到多元函数。因此,我们有必要回顾一下一元函数的一些性质。一般地,我们有两种定义连续函数的性质。一种是利用ϵ\epsilon-δ\delta语言定义,一种是利用序列极限定义。在一元函数中,这两种定义是等价的。同时,利用分量连续的性质,不难证明这两种定义在多元函数中也是等价的。因此,研究函数的连续性,一个躲不开的问题,是序列的极限。关于实数序列极限,在数学分析中有许多重要的定理,包括确界原理,阿基米德性质,单调有界收敛定理,柯西收敛定理,闭区间套定理,有限覆盖定理,收敛子序列定理等等。这些结论中,将其中一个或者两个作为原理,可以推导出余下的定理。它们共同构成实数完备性的基石,当然也是整个分析学的基石。

    按照一般的设定,我们通常假设确界原理是一个公理,由此推导出其他的定理。本文介绍的是实数序列的单调有界收敛定理。

    定义 我们说实数序列{xm}\{x_m\}是单调非减的,如果xjxj+1x_j \leq x_{j+1}对所有的正整数jj成立。类似地,我们可以定义单调非增序列。

    定义 我们说实数序列{xm}\{x_m\}有界,如果存在实数CC满足xj<C|x_j| < C对所有的正整数jj成立。

    单调有界收敛定理 任何单调有界的序列都有极限。

    证明 我们假设序列{xm}\{x_m\}单调非增,对于非减的情况证明类似。设集合{xm}\{x_m\}的上确界为xx,我们将证明limmxm=x\lim_{m\rightarrow\infty} x_m=x

    事实上,对于任意的ϵ>0\epsilon > 0都存在正整数MM满足
    xϵ<xMxx-\epsilon < x_M \leq x。
    由序列的单调性知
    xϵ<xnxx-\epsilon < x_n \leq x
    也即
    xnx<ϵ| x_n - x | < \epsilon
    对所有的n>Mn>M成立。这就证明了limmxm=x\lim_{m\rightarrow\infty} x_m=x。证毕。

    单调有界收敛定义最大的应用在于,我们可以不显式地求解序列的极限,来判断序列是否收敛。因为,绝大部分序列的极限是没有显式表达式的。

    关于一个单调有界序列,一个最著名的例子是
    an=m=0n1m! a_n=\sum_{m=0}^n \frac{1}{m!}
    其单调性非常容易验证。为证明它有界我们有m!2m1m!\leq2^{m-1}对所有的m2m\geq2成立。故而
    an2+m=2n1m!2+m=2n12m1<3 a_n \leq 2 + \sum_{m=2}^n \frac{1}{m!} \leq 2 + \sum_{m=2}^n \frac{1}{2^{m-1}}<3。
    从上面我们可以推知{an}\{a_n\}的极限介于2与3之间。事实上,它的极限是自然对数ee

    关于自然对数,另一个重要的序列是
    bn=(1+1n)n b_n=(1+\frac{1}{n})^n。
    为了验证序列{bn}\{b_n\}的单调性,将bnb_n进行二项式展开,
    bn=m=0n(nm)1nm=m=0nc(n,m) b_n =\sum_{m=0}^n \binom{n}{m}\frac{1}{n^m}=\sum_{m=0}^n c(n, m),
    其中
    c(n,m)=(nm)1nm=n(n1)...(nm+1)m!nm=1m!(11n)(12n)...(1m1n) \begin{array}{lll} c(n,m)&=&\binom{n}{m}\frac{1}{n^{m}}\\ &=&\frac{n\cdot(n-1)\cdot...\cdot(n-m+1)}{m!n^m}\\ &=&\frac{1}{m!}(1-\frac{1}{n})(1-\frac{2}{n})...(1-\frac{m-1}{n})。 \end{array}
    显然,c(n,m)>0c(n,m)>0且关于nn单调递增。于是
    bn+1=m=0n+1c(n+1,m)>m=0nc(n+1,m)>m=0nc(n,m)=bn b_{n+1} =\sum_{m=0}^{n+1} c(n+1, m)>\sum_{m=0}^{n} c(n+1, m)>\sum_{m=0}^{n} c(n, m)=b_n,
    这说明序列bn+1b_{n+1}是单调递增的。同时bn<anb_n < a_n,故bnb_n有界,其中{an}\{a_n\}是上一个例子中定义的序列。于是序列{bn}\{b_n\}极限存在。

    接下来,我们证明
    liman=limbn \lim a_n = \lim b_n。
    很显然,limanlimbn\lim a_n \geq \lim b_n。为了证明limanlimbn\lim a_n \leq \lim b_n,对于任意给定的实数ϵ>0\epsilon > 0以及正整数nn,都存在正整数MnM_n满足
    (11Mn)(12Mn)...(1n1Mn)>1ϵ (1-\frac{1}{M_n})(1-\frac{2}{M_n})...(1-\frac{n-1}{M_n}) > 1 - \epsilon。
    于是
    bMn=m=0Mn1m!(11Mn)(12Mn)...(1m1Mn)m=0n1m!(11Mn)(12Mn)...(1m1Mn)(1ϵ)m=0n1m!=(1ϵ)an \begin{array}{lll} b_{M_n}&=&\sum_{m=0}^{M_n} \frac{1}{m!} (1-\frac{1}{M_n})(1-\frac{2}{M_n})...(1-\frac{m-1}{M_n})\\ &\geq&\sum_{m=0}^{n} \frac{1}{m!} (1-\frac{1}{M_n})(1-\frac{2}{M_n})...(1-\frac{m-1}{M_n})\\ &\geq&(1-\epsilon)\sum_{m=0}^{n} \frac{1}{m!} \\ &=& (1-\epsilon) a_n。 \end{array}
    这样,我们有
    limbn=limbMn(1ϵ)liman \lim b_n = \lim b_{M_n} \geq (1-\epsilon)\cdot\lim a_n。
    ϵ\epsilon的任意性可知limbnliman\lim b_n \geq \lim a_n成立。

    展开全文
  • 函数可谓是在程序猿无处不在,不管你学什么语言,都会接触到函数,我看的文章将函数定义为一等公民,这就可以看得出函数对于我们来说地位是多么的高,是多么的重要,废话不多说,我们进入正题。 老样子,我们先...

    前面我们说完了对象和数组的定义,接下来就是一个重头戏---函数。函数可谓是在程序猿界无处不在,不管你学什么语言,都会接触到函数,我看有的文章将函数定义为一等公民,这就可以看得出函数对于我们来说地位是多么的高,是多么的重要,废话不多说,我们进入正题。

    老样子,我们先说一下在JavaScript中,对于函数的定义和使用。什么是函数?函数就是被开发者用来执行某一项或多项功能任务的代码块。在JS中定义函数的方式通常有以下几种:

    // 方式1
    var sum = function (a, b) {
        return a + b
    }
    
    // 方式2
    function sum(a, b) {
        return a + b
    }
    
    // 方式3
    var sum = (a, b) => a + b
    
    // 方式4
    var sum = new Function("a", "b", "return a + b")

    其中,方式1和方式2比较常见,方式3是ES6中的箭头函数表达式,这种箭头函数表达式很好的解决了开发中的this指向问题,后续会出一篇博客单独讲解这个,在这里就不赘述了,方式4是以构造函数的方式,在实际开发中用的很少,了解即可。

    下面说一下在typescript中函数的定义方式,结合前面关于对象及数组的定义方式,我们可以采取结合数据类型定义的方式来定义函数(类似于上述JavaScript定义方式2),如下:

    // 声明函数中的输入和输出的数据类型
    function sum(x: number, y: number): number {
        return x + y;
    }

    在这里我们定义了函数sum的输入和输出的数据类型,均为number类型,所以在调用函数的时候必须按照定义的格式严格执行,以下调用的方式均为错误方式,如下:

    // 情形一:参数比定义的多
    function sum(x: number, y: number): number {
        return x + y;
    }
    sum(1, 2, 3);  // 编译报错:Expected 2 arguments, but got 3.
    
    // 情形二:参数比定义的少
    function sum(x: number, y: number): number {
        return x + y;
    }
    sum(1);  // 编译报错:Expected 2 arguments, but got 1.
    
    // 情形3:参数类型不是定义的数据类型及其子类型
    function sum(x: number, y: number): number {
        return x + y;
    }
    sum(1, '2');   // 编译报错:Argument of type '"2"' is not assignable to parameter of type 'number'.

    当然,我们可以写类似于上述JavaScript中方式一的定义方式来定义函数表达式,如下:

    let sum = function (x: number, y: number): number {
        return x + y;
    }

    上面这样的写法没有错,但是不够严谨,因为我们可以看到上面的写法仅对表达式右边的函数的类型进行了定义,而没有对等号左侧的进行定义,这样就类似于我们前面提到的数据类型推论,根据右侧的定义来推断左侧的类型,所以,我们可以在定义右侧类型的同时,也给左侧添加类型,如下:

    let sum: (x: number, y: number) => number = function (x: number, y: number): number {
        return x + y;
    }

    这种定义方式中,可以看到一个熟悉的符号 '=>',瞬间想起了箭头函数,有木有!!!!!!可惜,这里的 '=>'跟箭头函数的那个完全没关系,在 typescript 的类型定义中,'=>'用来表示函数的定义,左边是输入类型,需要用括号括起来,右边是输出类型。切记!!!!

    我们一直在重复一句话,万物皆对象,是的,函数也可以用类似于对象接口的定义方式,如下:

    // 创建一个Sum的接口,定义输入输出数据类型
    interface Sum{
        (x: number, y: number): number;
    }
    // 定义一个函数sum,它的类型是Sum
    let sum: Sum;
    // 创建函数sum,它的类型要符合接口Sum的定义
    sum = function(x: number, y: number) {
        return x + y;
    }

    typescript的定义就说到这,我们接下来看一下关于typescript中函数的一些特性:

    (1)定义函数时,参数可选,而且可选参数必须在后面,如下:

    function sum(x: number, y?: number) {   // 切记:可选参数必须放在后面,不然会报错
        if (y) {
            return x + y;
        } else {
            return x;
        }
    }
    let sum_1 = sum(1, 2);
    let sum_2 = sum(1);

    (2)定义函数时,设置默认参数,设置的顺序没有限制,如下:

    function sum(x: number, y: number = 3) {
        return x + y
    }
    let sum_1 = sum(1, 2);
    let sum_2 = sum(1);
    
    
    function sum(x: number = 3, y: number) {
        return x + y
    }
    let sum_1 = sum(1, 2);
    let sum_2 = sum(undefined, 1);  // 注意这里的参数传入方式,如果定义默认参数的位置不在后面,那么我们需要一个占位的数据变量来占据输入参数的位置,而且TS编译也会报错:Expected 2 arguments, but got 1.

    (3)定义函数时,可以利用...rest来表示剩余参数,这里的rest表示的就是参数,如下:

    function push(array, ...items) {
        items.forEach(function(item) {
            array.push(item);
        });
    }
    
    let a = [];
    push(a, 1, 2, 3);
    
    // 这样看上去比较懵哈,附上编译好的JS代码作对比
    
    function push(array) {
        var items = [];
        for (var _i = 1; _i < arguments.length; _i++) {
            items[_i - 1] = arguments[_i];
        }
        items.forEach(function (item) {
            array.push(item);
        });
    }
    var a = [];
    push(a, 1, 2, 3);

    (4)重载,就是允许一个函数接受不同数量或类型的参数时,作出不同的处理,也就是允许多类型的参数,我们要利用联合类型的方法来定义函数,如下:

    function getResult(x: number): number;
    function getResult(x: string): string;
    function getResult(x: number | string): number | string {   // 重载的特性:最后一个相同函数名的会覆盖之前函数
        if (typeof x === 'number') {
            return x + 2
        } else if (typeof x === 'string') {
            return x + 'kreme'
        }
    }

     

     

    到底啦!!!!!!

    展开全文
  • 三角函数

    2020-10-31 12:48:51
    1 有界函数,即在-1和1之间活动 周期性为T=2π,2π为一周期,N周期组成了连续性 奇偶性 奇函数 注:奇函数远点对称,偶函数y轴对称 三边关系 sinx = 对边:斜边 2.余弦函数(正弦函数右移或左移π/2即...

    三角函数分为六种类型
    1.正弦函数
    y=sinx

    在这里插入图片描述

    性质:
    	x∈R
    	-1<y<1 有界函数,即在-1和1之间活动
    	周期性为T=2π,2π为一个周期,N个周期组成了连续性
    	奇偶性 奇函数 
    		注:奇函数远点对称,偶函数y轴对称
    	三边关系  sinx = 对边:斜边
    

    2.余弦函数(正弦函数右移或左移π/2即余弦函数)
    y=cosx

    在这里插入图片描述

    性质:
    	x∈R
    	1>y>-1有界函数
    	周期性:T=2π
    	偶函数(对y轴对称)
    	三边关系  cosx=邻边:斜边
    

    3.正切函数
    y=tanx

    在这里插入图片描述

    性质:
    	x≠kπ  k∈Z(Z是整数集合)
    	y∈R无界函数
    	周期性 T=π
    	奇偶性  奇函数
    	单调性  增函数
    	三边关系: tanx= 对边:邻边
    

    4.余切函数
    y=cotx 此函数为正切函数先对称在评议π/2的图像

    在这里插入图片描述

    性质:
    	x≠kπ k∈Z
    	y∈R  无界函数
    	周期性  T=π
    	奇偶性 奇函数
    	单调性 减函数
    	三边关系:cotx=tanx倒过来
    	
    

    5.正割函数
    y= secx
    6.余割函数
    y=cscx

    ==========================================

    这6个三角函数之间的关系

    6卦图表示
    在这里插入图片描述

    倒三角平方和公式

    即倒三角的两个上面的角的平方和==下面角的²
    该图中共有三个倒三角:
    	分别是sinx cosx和1    tanx 1 和secx   1cotx 和cecx
    根据公式可得到:
    	sinx^2 + cos^2=1
    	tanx^2 + 1 = secx^2
    	1 + cotx^2 = cscx^2
    

    邻点积公式

    六挂图中,任意一个顶点是相邻的两个顶点的积
    共有六个顶点(每个三角函数都是一个顶点)

    sinx=cosx*tanx
    cosx=sinx*cotx
    cotx=cosx*cscx
    cscx=cotx*secx
    secx =cscx*tanx
    tanx=sinx+secx
    

    二倍角公式

    二倍角公式可以延伸出降幂公式
    先说一下二倍角公式:
    cos2α = 2cos²*α-1
    通过运算可以降幂
    cos²=cos2+1/2

    特殊角的三角函数

    角度:
    	0°
    	30°
    	45°
    	60°
    	90°
    弧度:180°==π
    	0°==0
    	30°==π/6
    	45°==π/4
    	60°==π/3
    	90°==π/2
    

    在这里插入图片描述

    三角函数的符号(±)

    正三角函数: 第一象限全为正 二正三切四余弦(正弦 正切 余弦)

    诱导公式

    目的:解决非特殊三角函数【把非特殊变成特殊角度来计算】

    公式:
    	sin角度 = sin(特殊角±k*π/n)  π==180°这里就是将一个角度转换成特殊角+可整除90°的整数
    	一句话:拆分成可以计算的特殊角
    	例如:210° == 30°+180°   
    	注意事项:
    		奇变偶不变,符号看象限 奇偶代表k的值
    		变和不变是三角函数的名称(sin cos)
    		符号看象限 就是三角函数的符号公式
    		符号 原三角函数的原角度的符号(第一象限全为正 二正三切四余弦(正弦 正切 余弦))
    
    例如:sin210°
    			首先拆分成  sin(30°+2*90°)
    			2为偶数,函数仍然是sin
    			看原角度,sin210°在第三象限,而第三象限是正切是是正的,其他全是-的,即这里的符号是-的
    			可得:-sin30°
    			==    -根号1/2
    
    展开全文
  • 二 两重要极限 一极限存在准则 第节 极限存在准则 两重要极限 第一章 准则1 函数极限存在的夹逼准则 且 ( 利用定理1及数列的夹逼准则可证 ) 3. 准则2 单调有界数列必有极限 单调有界
  • 目录 7.模式匹配和样例类 7.1 匹配字符串 7.2 匹配类型 7.3 匹配数组、元组、集合 7.4 样例类 7.5 Option类型 7.6 偏函数 8. Scala中的协变、逆变、非变 ...9.Scala中的上下 ...Scala十分强大的...

    目录

    7.模式匹配和样例类

    7.1 匹配字符串

    7.2 匹配类型

    7.3 匹配数组、元组、集合

    7.4 样例类

    7.5 Option类型

    7.6 偏函数

    8. Scala中的协变、逆变、非变

    8.1 协变、逆变、非变介绍

    8.2 协变、逆变、非变总结

    8.3 案例

    9.Scala中的上下界

    9.1 上界、下界介绍


     

    7.模式匹配和样例类

    Scala有一个十分强大的模式匹配机制,可以应用到很多场合:如switch语句、类型检查等。并且Scala还提供了样例类,对模式匹配进行了优化,可以快速进行匹配。

    7.1 匹配字符串

    import scala.util.Random
    object CaseDemo01 extends App{
      val arr = Array("hadoop", "zookeeper", "spark")
      val name = arr(Random.nextInt(arr.length))
      name match {
        case "hadoop" => println("大数据分布式存储和计算框架...")
        case "zookeeper" => println("大数据分布式协调服务框架...")
        case "spark" => println("大数据分布式内存计算框架...")
        case _ => println("我不认识你...")
      }
    }

    7.2 匹配类型

    import scala.util.Random
    object CaseDemo01 extends App{
      val arr = Array("hello", 1, 2.0, CaseDemo)
      val v = arr(Random.nextInt(4))
      println(v)
      v match {
        case x: Int => println("Int " + x)
        case y: Double if(y >= 0) => println("Double "+ y)
        case z: String => println("String " + z)
        case _ => throw new Exception("not match exception")
      }
    }

    注意case y: Double if(y >= 0) => ...

    模式匹配的时候还可以添加守卫条件。如不符合守卫条件,将掉入case _中。

    7.3 匹配数组、元组、集合

    object CaseDemo03 extends App{
    
      val arr = Array(1, 3, 5)
      arr match {
        case Array(1, x, y) => println(x + " " + y)
        case Array(0) => println("only 0")
        case Array(0, _*) => println("0 ...")
        case _ => println("something else")
        //输出结果:3 5  
        //这里的第一个和第二个都能改匹配,当匹配到第一个时,后面就不再进行匹配了
      }
    
      //匹配集合
      val list=List(0,3,6)
      list match {
        //只有一个元素为0
        case 0::Nil        => println("only 0")
        //第一个为0 后面还有其它多个元素
        case 0::tail       => println("0....")
        //list 集合有3个元素,类型不固定  
        case x::y::z::Nil  => println(s"x:$x y:$y z:$z") // println("x:"+x+" y:"+y+" z:"+z)
        case _             => println("something else")
        
        //输出结果:0....
        //第二个和第三个都满足,谁先匹配上,走对应的逻辑
      }
    
      val tup = (1, 3, 7)
      tup match {
        case (1, x, y) => println(s"1, $x , $y")
        //第一个数任意
        case (_, z, 5) => println(z)
        case  _ => println("else")
        //输出结果:1, 3 , 7
      }
    }

    注意:在Scala中列表要么为空(Nil表示空列表)要么是一个head元素加上一个tail列表。

    9 :: List(5, 2)  :: 操作符是将给定的头和尾创建一个新的列表

    注意:: 操作符是右结合的,如9 :: 5 :: 2 :: Nil相当于 9 :: (5 :: (2 :: Nil))

    7.4 样例类

    在Scala中样例类是一种特殊的类,可用于模式匹配。

    注意:样例类会自动实现apply方法,构建实例对象可以不用new,也可以new

    定义形式:

    case class 类型,是多例的,后面要跟构造参数。 case class Student(name:String)

    case object 类型,是单例的。        case object Person

    import scala.util.Random
    
    case class SubmitTask(id: String, name: String)
    
    case class HeartBeat(time: Long)
    
    case object CheckTimeOutTask
    
    object CaseDemo04 extends App{
      //样例类会自动实现apply方法,构建实例对象可以不用new
      val arr = Array(CheckTimeOutTask, HeartBeat(12333), SubmitTask("0001", "task-0001"))
    
      arr(Random.nextInt(arr.length)) match {
        case SubmitTask(id, name) => {
          println(s"$id, $name")
        }
        case HeartBeat(time) => {
          println(time)
        }
        case CheckTimeOutTask => {
          println("check")
        }
      }
    }

    7.5 Option类型

    在Scala中Option类型用样例类来表示可能存在或者可能不存在的值(Option的子类有Some和None)。Some包装了某个值,None表示没有值

    //Option类型  包含2个子类,一个是Some(表示有值) ,一个是None(表示没有值)
    object OptionDemo extends App{
      //定义一个map
      val map=Map("a"->1,"b"->2)
    
      //调用map中的get方法,传入一个key,返回一个Option类型
      private val v: Option[Int] = map.get("c")
      v match{
        case Some(i)    =>println("存在..."+i)
        case None       =>println("不存在...")
      }
      //输出结果:不存在...
    
      //更好方式
      val m=map.getOrElse("c",100)
      println(m)
    }

    7.6 偏函数

    被包在花括号内没有match的一组case语句是一个偏函数,它是PartialFunction[A, B]的一个实例,A代表输入参数类型,B代表返回结果类型,常用作输入模式匹配,偏函数最大的特点就是它只接受和处理其参数定义域的一个子集

    /**
      * 偏函数
      */
    object PartialFuncDemo {
    
      //它是PartialFunction[A, B]的一个实例,A代表参数类型,B代表返回类型,常用作输入模式匹配
      //偏函数最大的特点就是它只接受和处理其参数定义域的一个子集。
    
      def main(args: Array[String]) {
        println(func("two"))
        println(func2("two"))
        //输出结果: 2 2    
      }
    
      //这里类型一旦固定,后面的输入参数类型和返回值结果类型都固定,想提升类型可以设为Any,相当于java的Object  
      val func:PartialFunction[String,Int]={
        case "one" =>  1
        case "two" =>  2
        case _     => -1
      }
    
      //定义一个普通的方法,通过match 和case 实现偏函数逻辑
      def func2(x:String):Int={
        x match {
          case "one" =>  1
          case "two" =>  2
          case _     => -1
        }
      }
    }
    

    8. Scala中的协变、逆变、非变

    8.1 协变、逆变、非变介绍

    协变和逆变主要是用来解决参数化类型的泛化问题。Scala的协变与逆变是非常有特色的,完全解决了Java中泛型的一大缺憾;举例来说,Java中,如果有 A是 B的子类,但 Card[A] 却不是 Card[B] 的子类(例如:Array[String]   Array[Object]);而 Scala 中,只要灵活使用协变与逆变,就可以解决此类 Java 泛型问题;

    由于参数化类型的参数(参数类型)是可变的,当两个参数化类型的参数是继承关系(可泛化),那被参数化的类型是否也可以泛化呢?Java中这种情况下是不可泛化的,然而Scala提供了三个选择,即协变(+)、逆变(“-”)和非变。

    下面说一下三种情况的含义,首先假设有参数化特征Queue,那它可以有如下三种定义。

    (1) trait Queue[T] {}

    这是非变情况。这种情况下,当类型B是类型A的子类型,则Queue[B]与Queue[A]没有任何从属关系,这种情况是和Java一样的。

    (2) trait Queue[+T] {} 
    这是协变情况。这种情况下,当类型B是类型A的子类型,则Queue[B]也可以认为是Queue[A]的子类型,即Queue[B]可以泛化为Queue[A]。也就是被参数化类型的泛化方向与参数类型的方向是一致的,所以称为协变。

    (3) trait Queue[-T] {} 

    这是逆变情况。这种情况下,当类型B是类型A的子类型,则Queue[A]反过来可以认为是Queue[B]的子类型。也就是被参数化类型的泛化方向与参数类型的方向是相反的,所以称为逆变。

    8.2 协变、逆变、非变总结

    • C[+T]:如果A是B的子类,那么C[A]是C[B]的子类。 源码中,协变较多
    • C[-T]:如果A是B的子类,那么C[B]是C[A]的子类。
    • C[T]: 无论A和B是什么关系,C[A]和C[B]没有从属关系。

    8.3 案例

    class Super
    
    class Sub extends Super
    
    //协变
    class Temp1[+A](title: String)
    
    //逆变
    class Temp2[-A](title: String)
    
    //非变
    class Temp3[A](title: String)
    
    object Covariance_demo{
    
      def main(args: Array[String]) {
    
        //支持协变 Temp1[Sub]还是Temp1[Super]的子类
        val t1: Temp1[Super] = new Temp1[Sub]("hello scala!!!")
    
        //支持逆变 Temp1[Super]是Temp1[Sub]的子类
        val t2: Temp2[Sub] = new Temp2[Super]("hello scala!!!")
    
        //支持非变 Temp3[Super]与Temp3[Sub]没有从属关系,如下代码会报错
        //val t3: Temp3[Sub] = new Temp3[Super]("hello scala!!!")
        //val t4: Temp3[Super] = new Temp3[Sub]("hello scala!!!")
    
        println(t1.toString) //Temp1@6adca536
        println(t2.toString) //Temp2@5a01ccaa
      }
    }

    9.Scala中的上下界

    9.1 上界、下界介绍

    ?  extends  T

    ?  super  T

           在指定泛型类型时,有时需要界定泛型类型的范围,而不是接收任意类型。比如,要求某个泛型类型,必须是某个类的子类,这样在程序中就可以放心的调用父类的方法,程序才能正常的使用与运行。此时,就可以使用上下边界Bounds的特性;

    Scala的上下边界特性允许泛型类型是某个类的子类,或者是某个类的父类;

    (1) U >: T     ?  super  T

    这是类型下界的定义,也就是U必须是类型T的父类(或本身,自己也可以认为是自己的父类)。

    (2) S <: T    ?  extends T

    这是类型上界的定义,也就是S必须是类型T的子类(或本身,自己也可以认为是自己的子类)。

     

     

     

    展开全文
  • 目录《重构-改善既代码的设计》第一章第二章第三章 代码的坏味道第章 重新组织函数 《重构-改善既代码的设计》 这本书有些“年纪”了,按理说it的书都是读新不读旧。但它有点特别,其中的关于重构和面向对象...
  • C++面试问题总结 2

    2016-11-17 17:40:29
    共有六个缺省函数 1. 缺省构造函数 2. 缺省拷贝构造函数 3. 缺省析构函数 4. 赋值运算符 5. 取地址运算符 6. 取地址运算符(const) /* 为什么会缺省函数? */ 正如自然中人会生老病死,
  • stl容器,空间配置器,适配器,迭代器,仿函数以及算法这6组件,它们者关系大概如下:容器通过配置器取得数据存储空间,算法通过迭代器获取容器内容,仿函数可以协助算法完成不同的策略变化,配接器可以修饰或套...
  • 空间配置器

    2018-07-27 16:32:09
    stl容器,空间配置器,适配器,迭代器,仿函数以及算法这6组件,它们者关系大概如下:容器通过配置器取得数据存储空间,算法通过迭代器获取容器内容,仿函数可以协助算法完成不同的策略变化,配接器可以修饰或套...
  • stl容器,空间配置器,适配器,迭代器,仿函数以及算法这6组件,它们者关系大概如下:容器通过配置器取得数据存储空间,算法通过迭代器获取容器内容,仿函数可以协助算法完成不同的策略变化,配接器可以修饰或套...
  • STL空间配置器剖析

    2018-06-05 17:11:48
    stl容器,空间配置器,适配器,迭代器,仿函数以及算法这6组件它们者关系大概如下:容器通过配置器取得数据存储空间,算法通过迭代器获取容器内容,仿函数可以协助算法完成不同的策略变化,配接器可以修饰或套...
  • 张宇带你学高数

    2018-06-11 13:35:26
    有界闭区域上连续函数的性质 9.2.偏导数与全微分 9.2.1.偏导数 定义 运算法则 四则运算 链式法则 隐函数存在定理 高阶偏导数 9.2.2.全微分 定义 可微与连续、偏导数存在的关系 9.2.3.方向导数 计算公式 几何意义 ...
  • 具体而言,使用Akaike信息准则,将冯·贝塔兰菲的S型增长函数(代谢指数对a = 2/3,b = 1)与无界线性增长和有界指数增长进行了比较。 因此,假设质量的对数正态分布(即,较重的动物的方差较高),则比较最大似然...
  • perl 程序开发教程

    2009-09-29 10:29:59
    、关联数组函数 第二部分 Perl的CGI应用 第一章 cgilib例 第二章 动态创建图像 Copyright: 本教程为flamephoenix翻译整理,欢迎参观我的主页http://flamephoenix.126.com。 本教程欢迎下载、转载和链接...
  • 1·3 有界数列 2.等差数列 2·1 等差数列 2·2 等差中项、相加平均 2·3 调和数列·调和中项·调和平均 3.等比数列 3·1 等比数列 3·2 等比中项·几何平均 3·3 各种平均值之间的关系 3·4 累积金和分期付款 4.各种...
  • 1·3 有界数列 2.等差数列 2·1 等差数列 2·2 等差中项、相加平均 2·3 调和数列·调和中项·调和平均 3.等比数列 3·1 等比数列 3·2 等比中项·几何平均 3·3 各种平均值之间的关系 3·4 累积金和分期付款 4.各种...
  • 代码包含大量注释,每一变量,数据结构,函数文字说明,函数注释统一放在函数开头以/**/为,语句注释以//为始跟随在语句后,通过大量注释可以快速方便地理清程序结构,添加或修改程序内容。本项目使用C语言...
  •  题型 5 函数性质(奇偶性,周期性,单调性,有界性)的判断(二(1),1999;二(8),2004)  题型 6 无穷小的比较或确定无穷小的阶(二(7),2004)  题型 7 数列极限的判定或求解(二(2),2003;(1)...
  • 三、线性算子的有界性与连续性的关系 四、有界线性算子空间 五、有界线性算子范数的次乘性 3.5方阵范数与方阵的谱半径 一、方阵范数的概念 二、方阵的谱半径 三、方阵的三种算子范数 习题3 A B 第4章矩阵分析 4.1...
  • 5. 极限的有界性定理及应用 6. 复合函数求极限 3.两重要极限 1. 第一重要极限 2. 第一重要极限的应用 3. 第二重要极限 4. 第二重要极限的应用 4.函数的连续性和间断点 1. 增量 2. 函数连续的两...
  • 极限及简单例题

    2021-03-23 18:25:54
    文章目录一 极限1.1 极限定义1.2 极限的一般性质1.3 极限的运算性质1.4 两重要极限二 无穷小2.1 无穷小的定义2.1 无穷小的性质三 其他四 例题4.1 题型二 左右极限4.2 题型三 不定型计算4.2 题型四 n项和或积...有界
  • 函数的性质(有界性、单调性、奇偶性、周期性),反函数,基本初等函数的概念、性质及其图形,复合函数,初等函数,数列极限,函数极限,无穷小与无穷大,无穷小与...
  • C++提高编程PDF版.pdf

    2020-03-29 16:48:40
    序列式容器:强调值的排序,序列式容器中的每元素均固定的位置。 关联式容器:二叉树结构,各元素之间没有 严格的物理上的顺序关系 算法:问题之解法也 有限的步骤,解决逻辑或数学上的问题,这一门学科我们叫做...
  • 吴恩达深度学习——目标检测学习目标...在最初接触的计算机视觉中,我们对图片进行的是图片分类,但是我们对图片中物体的位置是无从探知的,于是我们就了一想法,就是将物体的位置用边界框展示出来,这就是目标检测
  • 有界函数情形时部分和的估值 ------------706.函数有к阶有界导数时余项的估值 ------------707.函数有有界变差的к阶导数的情形 ------------708.函数及其导数的不连续性对于傅里叶系数的无穷小阶的影响 --------...

空空如也

空空如也

1 2 3 4
收藏数 65
精华内容 26
关键字:

六个有界函数