精华内容
下载资源
问答
  • 最常用也许是它N维数组对象,其他还包括一些成32313133353236313431303231363533e58685e5aeb931333436316238熟函数库,用于整合C/C++和Fortran代码工具包,线性代数、傅里叶变换和随机数生成函数等。...

    展开全部

    1、 NumPy

    NumPy几乎是一个无法回避的科学计算工具包,最常用的也许是它的N维数组对象,其他还包括一些成32313133353236313431303231363533e58685e5aeb931333436316238熟的函数库,用于整合C/C++和Fortran代码的工具包,线性代数、傅里叶变换和随机数生成函数等。NumPy提供了两种基本的对象:ndarray(N-dimensional array object)和 ufunc(universal function object)。ndarray是存储单一数据类型的多维数组,而ufunc则是能够对数组进行处理的函数。

    2、SciPy:Scientific Computing Tools for Python

    “SciPy是一个开源的Python算法库和数学工具包,SciPy包含的模块有最优化、线性代数、积分、插值、特殊函数、快速傅里叶变换、信号处理和图像处理、常微分方程求解和其他科学与工程中常用的计算。其功能与软件MATLAB、Scilab和GNU Octave类似。 Numpy和Scipy常常结合着使用,Python大多数机器学习库都依赖于这两个模块。”—-引用自“Python机器学习库”

    3、 Matplotlib

    matplotlib 是python最著名的绘图库,它提供了一整套和matlab相似的命令API,十分适合交互式地进行制图。而且也可以方便地将它作为绘图控件,嵌入GUI应用程序中。Matplotlib可以配合ipython shell使用,提供不亚于Matlab的绘图体验,总之用过了都说好。

    关于Python科学计算常用的工具包有哪些,环球青藤小编就和大家分享到这里了,学习是永无止境的,学习一项技能更是受益终身,所以,只要肯努力学,什么时候开始都不晚。如果您还想继续了解关于python编程的学习方法及素材等内容,可以点击本站其他文章学习。

    展开全文
  • 《几何画板》软件是由美国Key Curriculum Press公司制作并出版的优秀教育软件,正如其名“21世纪动态几何”,它能够动态地展现出几何对象的位置关系、运行变化规律,是数学与物理教师制作课件的“利剑”!...

    《几何画板》软件是由美国Key Curriculum Press公司制作并出版的优秀教育软件,正如其名“21世纪动态几何”,它能够动态地展现出几何对象的位置关系、运行变化规律,是数学与物理教师制作课件的“利剑”!

    几何画板菜单栏功能强大、操作灵活,可以创建、保存、打印文件以及修改、格式化、自定义画板中的对象。下面将详细介绍几何画板菜单栏

    菜单栏主要包括:文件菜单、编辑和显示菜单、构造和变换菜单、度量和数据菜单、绘图菜单、窗口菜单、帮助菜单。

    几何画板菜单栏 
    几何画板菜单栏示例

    详解几何画板菜单栏:

    1.文件菜单:可以创建、保存和打印整个文档。

    2.编辑菜单和显示菜单:包含更改外观、格式以及定义当前画板对象的命令。

    3.构造、变换、度量、数据和绘图菜单:支持在当前画板定义新的数学内容,创建与选择对象相关的新对象。

    4.窗口菜单:用于管理在桌面上打开的文档窗口。

    5.帮助菜单:提供一系列的帮助,如几何画板学习中心、参考中心、在线资源中心等。

    6.情境菜单:单击右键(Windows版本)或Ctrl+单击(Mac版本)画板即可出现与单击对象相关的选项,或者如果在空白区域单击会出现与画板文档相关的选项。

    温馨提示:Mac版的几何画板除了上述菜单外还有应用菜单,包含所有Mac应用程序的标准命令,这里不做阐述。

    以上便是几何画板菜单栏的所有内容,新用户在了解菜单栏之后就可以使用强大而灵活的菜单命令来构建、测量、格式化和修改画板对象。除此之外,几何画板工具箱也有很多学问,了解关于几何画板工具箱的相关教程,可参考几何画板工具箱的具体使用方法

    此文章为转载内容,原文为:http://www.jihehuaban.com.cn/xinwenzixun/caidan-lan.html

    转载于:https://www.cnblogs.com/jihehuaban/p/5391625.html

    展开全文
  • 这些知识包括哪些对象的哪些特征发生了变化、变化的程度有多大、变化的时效有多久、哪些信息元发生了质变、哪些信息元发生了量变。获取这些知识可以为解决矛盾问题提供依据,为决策者提出合理的策略提供参考。
  • 其中.FIG文件保存了关于静态窗口界面的所有对象的属性值,.M文件包括GUI设计、控制函数以及为子函数的用户控件回调函数,主要用于控制GUI展开时的各种特征。这个.M文件可以分为GUI初始化和回调函数两个部分,用户...
  • java基础面试题

    2017-11-16 22:09:00
    抽象:抽象是将一类对象的共同特征总结出来构造类的过程,包括数据抽象和行为抽象两方面。抽象只关注对象有哪些属性和行为,并不关注这些行为的细节是什么。 继承:继承是从已有类得到继承信息创建新类的过程。提供...

    1.面向对象的特征有哪些方面?

    • 抽象:抽象是将一类对象的共同特征总结出来构造类的过程,包括数据抽象和行为抽象两方面。抽象只关注对象有哪些属性和行为,并不关注这些行为的细节是什么。
    • 继承:继承是从已有类得到继承信息创建新类的过程。提供继承信息的类称为父类(超累,基类);得到继承信息的类被称为子类(派生类)。继承让变换中的软件系统有了一定的延续性。同时继承也是封装程序中可变因素的重要手段。
    • 封装:通常认为封装是把数据和操作数据的方法绑定起来,对数据的访问只能通过已定义的接口。面向对象的本质就是将现实世界描绘成一系列的完全自治、封闭的对象。我们在类中编写的方法就是对实现细节的一种封装;我们编写一个类就是对数据和数据操作的封装。可以说,封装就是隐藏一起可以隐藏的东西,只向外界提供最简单的编程接口。
    • 多态性:多态性是允许不同子类型对象对同一消息作出不同的响应。简单的说就是用同样的对象引用调用同样的方法但是做了不同的事情。多态性分为编译时多态性和运行时多态性。如果将对象的方法是为对象向外界提供的服务,那么运行时的多态性可以解释为:调用不同的子类对象替换父类对象。方法重载(overload)实现的是编译时多态性(也成为前绑定),而方法重写(override)实现的是运行时的多态性(也称为后绑定)。运行时的多态是面向对象最精髓的东西,要实现多态需要做两件事:1方法重写(子类继承父类并重写父类中已有的或抽象的方法)2对象造型(用父类引用子类对象)

    2.访问修饰符权限

    权限分为:当前类,同包,子类,其他包

    public均可;protected其他包不可;default同包下的可以;private只有自己可以。

    3.String是基本数据类型吗

    答:不是。java中8中基本类型:byte,short,int,long,float,double,char,boolean;除了基本类型(primitive type)和枚举类型(enumeration type),剩下的都是引用类型(reference type)。

     4.float f=3.4

    错误,默认是double的,需要强转,或者f=3.4f;

    5.int和integer

    为了将基本数据类型当做对象操作,Integer为包装类(wrapper class)。

    Integer缓存为-128到127.所以,这个范围内的Integer对象是同一个,==为true。其他为false。

    6.&和&&

    &链接的操作符都要计算。&&是短路运算,即当前面表达式有错误就停止计算。

    7.解释内存中的栈(stack)、堆(heap)、和静态区(static area)的 用法

    答:通常我们定义一个基本数据类型的变量,一个对象的引用,还有就是函数调用的现场保存都使用内存中的栈空间;而通过new关键字和构造器创建的对象放在堆空间;程序中的字面量(literal)如直接书写的100、“hello"和常量都是放在静态区中。栈空间操作起来最快但栈很小,通常大量的对象都是放在堆空间,理论上整个内存没有被其他进程使用的空间甚至磁盘上的虚拟内存都可以当做堆空间来使用。

    1
    String str = new String("hello");

      上面,str放栈,用new出来的字符串对象放堆上,而“hello”这个字面量放在静态区。

    java6开始使用“逃逸分析”的技术,可以将一些局部对象放在栈上提升对象操作性能。

    8.switch是否可以用在byte,long,String?

    答:java5前只可以:byte、short、char、int。5后增加enum,7后增加String.

    9.最有效率的方法计算2乘以8

    答:2<<3(左移3相当于乘以2的3次方,右移3相当于除以2的3次方)

    补充:我们为编写的类重写hashCode方法时,可能会看到如下所示的代码,其实我们不太理解为什么要使用这样的乘法运算来产生哈希码(散列码),而且为什么这个数是个素数,为什么通常选择31这个数?前两个问题的答案你可以自己百度一下,选择31是因为可以用移位和减法运算来代替乘法,从而得到更好的性能。说到这里你可能已经想到了:31 * num 等价于(num << 5) - num,左移5位相当于乘以2的5次方再减去自身就相当于乘以31,现在的VM都能自动完成这个优化。

    10.数组有没有length()方法,String有没有length()方法?

    答:数组没有length()方法,有length属性。String有length()方法。js中字符串是length属性。

     11.构造器constructor是否可以override?

    答:构造器不能被继承,因此不能被重写,但可以被重载。

    12.两个对象值相同(x.equals(y)==true),但却可以有不同的hash code,这句话对不对?

    答:不对。equals的hashcode必须相同。

    13.是否可以继承String类

    答:String类是final类,不可以被继承。继承String是个错误的行为,应该用关联关系(Has-A)和依赖关系(Use A)而不是继承关系(Is-A).

    14.当一个对象被当作参数传递到一个方法后,此方法可改变这个对象的属性,并可返回变化后的结果,那么这里到底是值传递还是引用传递? 
    答:是值传递。Java语言的方法调用只支持参数的值传递。当一个对象实例作为一个参数被传递到方法中时,参数的值就是对该对象的引用。对象的属性可以在被调用过程中被改变,但对对象引用的改变是不会影响到调用者的。

    15.String==

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    @Test
        public void str_c(){
            String a = "hehe";
            String b = "he"+"he";
            String c = new String("hehe");
            String d = new String("hehe");
     
        System.out.println(a==b);//true
        System.out.println(a==c);//false
        System.out.println(a==a.intern());//true
        System.out.println(c==d);//false
        }

    16.重载(Overload)和重写(Override)的区别。重载的方法能否根据返回类型进行区分? 
    答:方法的重载和重写都是实现多态的方式,区别在于前者实现的是编译时的多态性,而后者实现的是运行时的多态性。重载发生在一个类中,同名的方法如果有不同的参数列表(参数类型不同、参数个数不同或者二者都不同)则视为重载;重写发生在子类与父类之间,重写要求子类被重写方法与父类被重写方法有相同的返回类型,比父类被重写方法更好访问,不能比父类被重写方法声明更多的异常(里氏代换原则)。重载对返回类型没有特殊的要求。

    22、char 型变量中能不能存贮一个中文汉字,为什么? 
    答:char类型可以存储一个中文汉字,因为Java中使用的编码是Unicode(不选择任何特定的编码,直接使用字符在字符集中的编号,这是统一的唯一方法),一个char类型占2个字节(16比特),所以放一个中文是没问题的。

    23.抽象类(abstract class)和接口(interface)有什么异同?

    答:抽象类和接口都不能实例化,但可以定义抽象类和接口类型的引用。一个类如果继承了某个抽象类或者实现了某个接口都需要对其中的抽象方法全部进行实现,否则该类仍然需要声明为抽象类。接口比抽象类更加抽象,因为抽象类中可以定义构造器,可以有抽象方法和具体方法,而接口中不能定义构造器而且其中的方法全部都是抽象方法。抽象类中的成员可以是privae,默认,protected,public,而接口中的成员变量全部是public。抽象类中可以定义成员变量,而接口中定义的成员白嬢实际上都是常量。有抽象方法的类必须被声明为抽象类,抽象类未必有抽象方法。

    24、静态嵌套类(Static Nested Class)和内部类(Inner Class)的不同? 
    答:Static Nested Class是被声明为静态(static)的内部类,它可以不依赖于外部类实例被实例化。而通常的内部类需要在外部类实例化后才能实例化。

    25、Java 中会存在内存泄漏吗,请简单描述。 
    答:理论上Java因为有垃圾回收机制(GC)不会存在内存泄露问题(这也是Java被广泛使用于服务器端编程的一个重要原因);然而在实际开发中,可能会存在无用但可达的对象,这些对象不能被GC回收,因此也会导致内存泄露的发生。例如Hibernate的Session(一级缓存)中的对象属于持久态,垃圾回收器是不会回收这些对象的,然而这些对象中可能存在无用的垃圾对象,如果不及时关闭(close)或清空(flush)一级缓存就可能导致内存泄露。下面例子中的代码也会导致内存泄露。

     上面的代码实现了一个栈(先进后出(FILO))结构,乍看之下似乎没有什么明显的问题,它甚至可以通过你编写的各种单元测试。然而其中的pop方法却存在内存泄露的问题,当我们用pop方法弹出栈中的对象时,该对象不会被当作垃圾回收,即使使用栈的程序不再引用这些对象,因为栈内部维护着对这些对象的过期引用(obsolete reference)。在支持垃圾回收的语言中,内存泄露是很隐蔽的,这种内存泄露其实就是无意识的对象保持。如果一个对象引用被无意识的保留起来了,那么垃圾回收器不会处理这个对象,也不会处理该对象引用的其他对象,即使这样的对象只有少数几个,也可能会导致很多的对象被排除在垃圾回收之外,从而对性能造成重大影响,极端情况下会引发Disk Paging(物理内存与硬盘的虚拟内存交换数据),甚至造成OutOfMemoryError。

     26、抽象的(abstract)方法是否可同时是静态的(static),是否可同时是本地方法(native),是否可同时被synchronized修饰? 
    答:都不能。抽象方法需要子类重写,而静态的方法是无法被重写的,因此二者是矛盾的。本地方法是由本地代码(如C代码)实现的方法,而抽象方法是没有实现的,也是矛盾的。synchronized和方法的实现细节有关,抽象方法不涉及实现细节,因此也是相互矛盾的。

    27、阐述静态变量和实例变量的区别。 
    答:静态变量是被static修饰符修饰的变量,也称为类变量,它属于类,不属于类的任何一个对象,一个类不管创建多少个对象,静态变量在内存中有且仅有一个拷贝;实例变量必须依存于某一实例,需要先创建对象然后通过对象才能访问到它。静态变量可以实现让多个对象共享内存。

    补充:在Java开发中,上下文类和工具类中通常会有大量的静态成员。

    28.继承中变量的覆盖和输出

    子类覆盖了父类的方法,并且覆盖了父类的成员变量,并且在覆盖的方法中调用了这个覆盖的成员变量。这时候,调用这个覆盖的方法会调用覆盖的成员变量。如果子类只覆盖了成员变量,没有覆盖方法,调用这个方法会调用父类的成员变量,尽管这个成员变量被覆盖了。

    28、是否可以从一个静态(static)方法内部发出对非静态(non-static)方法的调用? 
    答:不可以,静态方法只能访问静态成员,因为非静态方法的调用要先创建对象,在调用静态方法时可能对象并没有被初始化。

    29、如何实现对象克隆? 
    答:有两种方式: 
    1). 实现Cloneable接口并重写Object类中的clone()方法; 
    2). 实现Serializable接口,通过对象的序列化和反序列化实现克隆,可以实现真正的深度克隆,代码如下。

     View Code

    注意:基于序列化和反序列化实现的克隆不仅仅是深度克隆,更重要的是通过泛型限定,可以检查出要克隆的对象是否支持序列化,这项检查是编译器完成的,不是在运行时抛出异常,这种是方案明显优于使用Object类的clone方法克隆对象。让问题在编译的时候暴露出来总是优于把问题留到运行时。

    30、GC是什么?为什么要有GC? 
    答:GC是垃圾收集的意思,内存处理是编程人员容易出现问题的地方,忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃,Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的,Java语言没有提供释放已分配内存的显示操作方法。Java程序员不用担心内存管理,因为垃圾收集器会自动进行管理。要请求垃圾收集,可以调用下面的方法之一:System.gc() 或Runtime.getRuntime().gc() ,但JVM可以屏蔽掉显示的垃圾回收调用。 
    垃圾回收可以有效的防止内存泄露,有效的使用可以使用的内存。垃圾回收器通常是作为一个单独的低优先级的线程运行,不可预知的情况下对内存堆中已经死亡的或者长时间没有使用的对象进行清除和回收,程序员不能实时的调用垃圾回收器对某个对象或所有对象进行垃圾回收。在Java诞生初期,垃圾回收是Java最大的亮点之一,因为服务器端的编程需要有效的防止内存泄露问题,然而时过境迁,如今Java的垃圾回收机制已经成为被诟病的东西。移动智能终端用户通常觉得iOS的系统比Android系统有更好的用户体验,其中一个深层次的原因就在于Android系统中垃圾回收的不可预知性。

    补充:垃圾回收机制有很多种,包括:分代复制垃圾回收、标记垃圾回收、增量垃圾回收等方式。标准的Java进程既有栈又有堆。栈保存了原始型局部变量,堆保存了要创建的对象。Java平台对堆内存回收和再利用的基本算法被称为标记和清除,但是Java对其进行了改进,采用“分代式垃圾收集”。这种方法会跟Java对象的生命周期将堆内存划分为不同的区域,在垃圾收集过程中,可能会将对象移动到不同区域: 
    - 伊甸园(Eden):这是对象最初诞生的区域,并且对大多数对象来说,这里是它们唯一存在过的区域。 
    - 幸存者乐园(Survivor):从伊甸园幸存下来的对象会被挪到这里。 
    - 终身颐养园(Tenured):这是足够老的幸存对象的归宿。年轻代收集(Minor-GC)过程是不会触及这个地方的。当年轻代收集不能把对象放进终身颐养园时,就会触发一次完全收集(Major-GC),这里可能还会牵扯到压缩,以便为大对象腾出足够的空间。

     

    与垃圾回收相关的JVM参数:

    • -Xms / -Xmx — 堆的初始大小 / 堆的最大大小
    • -Xmn — 堆中年轻代的大小
    • -XX:-DisableExplicitGC — 让System.gc()不产生任何作用
    • -XX:+PrintGCDetails — 打印GC的细节
    • -XX:+PrintGCDateStamps — 打印GC操作的时间戳
    • -XX:NewSize / XX:MaxNewSize — 设置新生代大小/新生代最大大小
    • -XX:NewRatio — 可以设置老生代和新生代的比例
    • -XX:PrintTenuringDistribution — 设置每次新生代GC后输出幸存者乐园中对象年龄的分布
    • -XX:InitialTenuringThreshold / -XX:MaxTenuringThreshold:设置老年代阀值的初始值和最大值
    • -XX:TargetSurvivorRatio:设置幸存区的目标使用率

    31、String s = new String("xyz");创建了几个字符串对象? 
    答:两个对象,一个是静态区的"xyz",一个是用new创建在堆上的对象。

    32、接口是否可继承(extends)接口?抽象类是否可实现(implements)接口?抽象类是否可继承具体类(concrete class)? 
    答:接口可以继承接口,而且支持多重继承。抽象类可以实现(implements)接口,抽象类可继承具体类也可以继承抽象类。

    35、内部类可以引用它的包含类(外部类)的成员吗?有没有什么限制? 
    答:一个内部类对象可以访问创建它的外部类对象的成员,包括私有成员。

    36、Java 中的final关键字有哪些用法? 
    答:(1)修饰类:表示该类不能被继承;(2)修饰方法:表示方法不能被重写;(3)修饰变量:表示变量只能一次赋值以后值不能被修改(常量)。

    46、try{}里有一个return语句,那么紧跟在这个try后的finally{}里的代码会不会被执行,什么时候被执行,在return前还是后? 
    答:会执行,在方法返回调用者前执行。

    注意:在finally中改变返回值的做法是不好的,因为如果存在finally代码块,try中的return语句不会立马返回调用者,而是记录下返回值待finally代码块执行完毕之后再向调用者返回其值,然后如果在finally中修改了返回值,就会返回修改后的值。显然,在finally中返回或者修改返回值会对程序造成很大的困扰

     49、列出一些你常见的运行时异常? 
    答: 
    - ArithmeticException(算术异常) 
    - ClassCastException (类转换异常) 
    - IllegalArgumentException (非法参数异常) 
    - IndexOutOfBoundsException (下标越界异常) 
    - NullPointerException (空指针异常) 
    - SecurityException (安全异常)

    50、阐述final、finally、finalize的区别。 
    答: 
    - final:修饰符(关键字)有三种用法:如果一个类被声明为final,意味着它不能再派生出新的子类,即不能被继承,因此它和abstract是反义词。将变量声明为final,可以保证它们在使用中不被改变,被声明为final的变量必须在声明时给定初值,而在以后的引用中只能读取不可修改。被声明为final的方法也同样只能使用,不能在子类中被重写。 
    - finally:通常放在try…catch…的后面构造总是执行代码块,这就意味着程序无论正常执行还是发生异常,这里的代码只要JVM不关闭都能执行,可以将释放外部资源的代码写在finally块中。 
    - finalize:Object类中定义的方法,Java中允许使用finalize()方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在销毁对象时调用的,通过重写finalize()方法可以整理系统资源或者执行其他清理工作。

    52、List、Set、Map是否继承自Collection接口? 
    答:List、Set 是,Map 不是。Map是键值对映射容器,与List和Set有明显的区别,而Set存储的零散的元素且不允许有重复元素(数学中的集合也是如此),List是线性结构的容器,适用于按数值索引访问元素的情形。

    53、阐述ArrayList、Vector、LinkedList的存储性能和特性。 
    答:ArrayList 和Vector都是使用数组方式存储数据,此数组元素数大于实际存储的数据以便增加和插入元素,它们都允许直接按序号索引元素,但是插入元素要涉及数组元素移动等内存操作,所以索引数据快而插入数据慢,Vector中的方法由于添加了synchronized修饰,因此Vector是线程安全的容器,但性能上较ArrayList差,因此已经是Java中的遗留容器。LinkedList使用双向链表实现存储(将内存中零散的内存单元通过附加的引用关联起来,形成一个可以按序号索引的线性结构,这种链式存储方式与数组的连续存储方式相比,内存的利用率更高),按序号索引数据需要进行前向或后向遍历,但是插入数据时只需要记录本项的前后项即可,所以插入速度较快。Vector属于遗留容器(Java早期的版本中提供的容器,除此之外,Hashtable、Dictionary、BitSet、Stack、Properties都是遗留容器),已经不推荐使用,但是由于ArrayList和LinkedListed都是非线程安全的,如果遇到多个线程操作同一个容器的场景,则可以通过工具类Collections中的synchronizedList方法将其转换成线程安全的容器后再使用(这是对装潢模式的应用,将已有对象传入另一个类的构造器中创建新的对象来增强实现)。

    补充:遗留容器中的Properties类和Stack类在设计上有严重的问题,Properties是一个键和值都是字符串的特殊的键值对映射,在设计上应该是关联一个Hashtable并将其两个泛型参数设置为String类型,但是Java API中的Properties直接继承了Hashtable,这很明显是对继承的滥用。这里复用代码的方式应该是Has-A关系而不是Is-A关系,另一方面容器都属于工具类,继承工具类本身就是一个错误的做法,使用工具类最好的方式是Has-A关系(关联)或Use-A关系(依赖)。同理,Stack类继承Vector也是不正确的。Sun公司的工程师们也会犯这种低级错误,让人唏嘘不已。

    54、Collection和Collections的区别? 
    答:Collection是一个接口,它是Set、List等容器的父接口;Collections是个一个工具类,提供了一系列的静态方法来辅助容器操作,这些方法包括对容器的搜索、排序、线程安全化等等。

    55、List、Map、Set三个接口存取元素时,各有什么特点? 
    答:List以特定索引来存取元素,可以有重复元素。Set不能存放重复元素(用对象的equals()方法来区分元素是否重复)。Map保存键值对(key-value pair)映射,映射关系可以是一对一或多对一。Set和Map容器都有基于哈希存储和排序树的两种实现版本,基于哈希存储的版本理论存取时间复杂度为O(1),而基于排序树版本的实现在插入或删除元素时会按照元素或元素的键(key)构成排序树从而达到排序和去重的效果。

    56、TreeMap和TreeSet在排序时如何比较元素?Collections工具类中的sort()方法如何比较元素? 
    答:TreeSet要求存放的对象所属的类必须实现Comparable接口,该接口提供了比较元素的compareTo()方法,当插入元素时会回调该方法比较元素的大小。TreeMap要求存放的键值对映射的键必须实现Comparable接口从而根据键对元素进行排序。Collections工具类的sort方法有两种重载的形式,第一种要求传入的待排序容器中存放的对象比较实现Comparable接口以实现元素的比较;第二种不强制性的要求容器中的元素必须可比较,但是要求传入第二个参数,参数是Comparator接口的子类型(需要重写compare方法实现元素的比较),相当于一个临时定义的排序规则,其实就是通过接口注入比较元素大小的算法,也是对回调模式的应用(Java中对函数式编程的支持)。 

    57、Thread类的sleep()方法和对象的wait()方法都可以让线程暂停执行,它们有什么区别? 
    答:sleep()方法(休眠)是线程类(Thread)的静态方法,调用此方法会让当前线程暂停执行指定的时间,将执行机会(CPU)让给其他线程,但是对象的锁依然保持,因此休眠时间结束后会自动恢复(线程回到就绪状态,请参考第66题中的线程状态转换图)。wait()是Object类的方法,调用对象的wait()方法导致当前线程放弃对象的锁(线程暂停执行),进入对象的等待池(wait pool),只有调用对象的notify()方法(或notifyAll()方法)时才能唤醒等待池中的线程进入等锁池(lock pool),如果线程重新获得对象的锁就可以进入就绪状态。

    58、线程的sleep()方法和yield()方法有什么区别? 
    答: 
    ① sleep()方法给其他线程运行机会时不考虑线程的优先级,因此会给低优先级的线程以运行的机会;yield()方法只会给相同优先级或更高优先级的线程以运行的机会; 
    ② 线程执行sleep()方法后转入阻塞(blocked)状态,而执行yield()方法后转入就绪(ready)状态; 
    ③ sleep()方法声明抛出InterruptedException,而yield()方法没有声明任何异常; 
    ④ sleep()方法比yield()方法(跟操作系统CPU调度相关)具有更好的可移植性。

    60、请说出与线程同步以及线程调度相关的方法。 
    答: 
    - wait():使一个线程处于等待(阻塞)状态,并且释放所持有的对象的锁; 
    - sleep():使一个正在运行的线程处于睡眠状态,是一个静态方法,调用此方法要处理InterruptedException异常; 
    - notify():唤醒一个处于等待状态的线程,当然在调用此方法的时候,并不能确切的唤醒某一个等待状态的线程,而是由JVM确定唤醒哪个线程,而且与优先级无关; 
    - notityAll():唤醒所有处于等待状态的线程,该方法并不是将对象的锁给所有线程,而是让它们竞争,只有获得锁的线程才能进入就绪状态;

    提示:关于Java多线程和并发编程的问题,建议大家看我的另一篇文章《关于Java并发编程的总结和思考》

    补充:Java 5通过Lock接口提供了显式的锁机制(explicit lock),增强了灵活性以及对线程的协调。Lock接口中定义了加锁(lock())和解锁(unlock())的方法,同时还提供了newCondition()方法来产生用于线程之间通信的Condition对象;此外,Java 5还提供了信号量机制(semaphore),信号量可以用来限制对某个共享资源进行访问的线程的数量。在对资源进行访问之前,线程必须得到信号量的许可(调用Semaphore对象的acquire()方法);在完成对资源的访问后,线程必须向信号量归还许可(调用Semaphore对象的release()方法)。

    61、编写多线程程序有几种实现方式? 
    答:Java 5以前实现多线程有两种实现方法:一种是继承Thread类;另一种是实现Runnable接口。两种方式都要通过重写run()方法来定义线程的行为,推荐使用后者,因为Java中的继承是单继承,一个类有一个父类,如果继承了Thread类就无法再继承其他类了,显然使用Runnable接口更为灵活。

    补充:Java 5以后创建线程还有第三种方式:实现Callable接口,该接口中的call方法可以在线程执行结束时产生一个返回值

    64、启动一个线程是调用run()还是start()方法? 
    答:启动一个线程是调用start()方法,使线程所代表的虚拟处理机处于可运行状态,这意味着它可以由JVM 调度并执行,这并不意味着线程就会立即运行。run()方法是线程启动后要进行回调(callback)的方法。

    65、什么是线程池(thread pool)? 
    答:在面向对象编程中,创建和销毁对象是很费时间的,因为创建一个对象要获取内存资源或者其它更多资源。在Java中更是如此,虚拟机将试图跟踪每一个对象,以便能够在对象销毁后进行垃圾回收。所以提高服务程序效率的一个手段就是尽可能减少创建和销毁对象的次数,特别是一些很耗资源的对象创建和销毁,这就是”池化资源”技术产生的原因。线程池顾名思义就是事先创建若干个可执行的线程放入一个池(容器)中,需要的时候从池中获取线程不用自行创建,使用完毕不需要销毁线程而是放回池中,从而减少创建和销毁线程对象的开销。 
    Java 5+中的Executor接口定义一个执行线程的工具。它的子类型即线程池接口是ExecutorService。要配置一个线程池是比较复杂的,尤其是对于线程池的原理不是很清楚的情况下,因此在工具类Executors面提供了一些静态工厂方法,生成一些常用的线程池,如下所示: 
    - newSingleThreadExecutor:创建一个单线程的线程池。这个线程池只有一个线程在工作,也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束,那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。 
    - newFixedThreadPool:创建固定大小的线程池。每次提交一个任务就创建一个线程,直到线程达到线程池的最大大小。线程池的大小一旦达到最大值就会保持不变,如果某个线程因为执行异常而结束,那么线程池会补充一个新线程。 
    - newCachedThreadPool:创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程,那么就会回收部分空闲(60秒不执行任务)的线程,当任务数增加时,此线程池又可以智能的添加新线程来处理任务。此线程池不会对线程池大小做限制,线程池大小完全依赖于操作系统(或者说JVM)能够创建的最大线程大小。 
    - newScheduledThreadPool:创建一个大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。 
    - newSingleThreadExecutor:创建一个单线程的线程池。此线程池支持定时以及周期性执行任务的需求。

    第60题的例子中演示了通过Executors工具类创建线程池并使用线程池执行线程的代码。如果希望在服务器上使用线程池,强烈建议使用newFixedThreadPool方法来创建线程池,这样能获得更好的性能。

    68、Java中如何实现序列化,有什么意义? 
    答:序列化就是一种用来处理对象流的机制,所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作,也可将流化后的对象传输于网络之间。序列化是为了解决对象流读写操作时可能引发的问题(如果不进行序列化可能会存在数据乱序的问题)。 
    要实现序列化,需要让一个类实现Serializable接口,该接口是一个标识性接口,标注该类对象是可被序列化的,然后使用一个输出流来构造一个对象输出流并通过writeObject(Object)方法就可以将实现对象写出(即保存其状态);如果需要反序列化则可以用一个输入流建立对象输入流,然后通过readObject方法从流中读取对象。序列化除了能够实现对象的持久化之外,还能够用于对象的深度克隆(可以参考第29题)。

    69、Java中有几种类型的流? 
    答:字节流和字符流。字节流继承于InputStream、OutputStream,字符流继承于Reader、Writer。在java.io 包中还有许多其他的流,主要是为了提高性能和使用方便。关于Java的I/O需要注意的有两点:一是两种对称性(输入和输出的对称性,字节和字符的对称性);二是两种设计模式(适配器模式和装潢模式)。另外Java中的流不同于C#的是它只有一个维度一个方向。

    面试题 - 编程实现文件拷贝。(这个题目在笔试的时候经常出现,下面的代码给出了两种实现方案)

     View Code

    注意:上面用到Java 7的TWR,使用TWR后可以不用在finally中释放外部资源 ,从而让代码更加优雅。

    70、写一个方法,输入一个文件名和一个字符串,统计这个字符串在这个文件中出现的次数。 

     View Code

    71、如何用Java代码列出一个目录下所有的文件? 

    复制代码
      /**
         * 列出当前文件夹下的文件
         */
        public void fileList(String source){
            File file = new File(source);
            for (File temp : file.listFiles()) {
                if (temp.isFile()){
                    System.out.println(temp.getName());
                }
            }
        }
    复制代码

    如果需要对文件夹继续展开,代码如下所示:

     View Code

    在java7中可以使用NIO.2的api来做:

     View Code

     72、用Java的套接字编程实现一个多线程的回显(echo)服务器。 
    答:

     View Code

    73、XML文档定义有几种形式?它们之间有何本质区别?解析XML文档有哪几种方式? 

    答:xml文档定义分为DTD和Schema两种形式,二者都是对xml语法的约束,其本质区别在于Schema本身也是一个xml文件,可以被xml解析器解析,而且可以为xml承载的数据定义类型,约束能力较之DTD更强大。对xml的解析主要有

    dom(文档对象模型,Document Object Model)、SAX(Simple API for xml)和StAx(java6中引入的新的解析xml的方式,Streaming API for xml),其中dom处理大型文件时其性能下降的非常厉害,这个问题是由DOM树结构占用的内存较多造成的,而且dom解析方式必须在解析文件之前把整个文件装入内存,适合对xml的随机访问(典型的空间换时间);sax是事件驱动的xml解析方法,它顺序读取xml文件,不需要一次全部装载整个文件。档遇到像文件开头,文档结束,或者标签开头与标签结束时,它会触发一个事件,用户通过事件回调代码来处理xml文件,适合对xml的顺序访问;顾名思义,StAx把重点放在流上,实际上StAX与其他解析方式的本质区别就在于应用程序能够把xml做为一个事件流来处理。将xml做为一组事件来处理的想法并不新颖(sax就是这样做的),但不同之处在于StAx允许应用程序代码把这些事件逐个拉出来,而不用提供在解析器方便时从解析器中接收事件的处理程序。

     本文转自Ryan.Miao博客园博客,原文链接:http://www.cnblogs.com/woshimrf/p/5282821.html,如需转载请自行联系原作者

    展开全文
  • 对象多个特征组成特征向量,可以自然地看作是高维数据空间中 一点。许多实际问题涉及到高维数据点。在高维空间中点超球范围查 找问题是:已知一个高维数据点集,输入一个点和半径数值,询问所确定 超球范围...
  • 面向对象的开发方法包括面向对象的分析、面向对象的设计和面向对象的程序设计。( √) 7. 软件危机的主要表现是软件的需求量迅速增加,软件价格上升。(×) 8. 软件工具的作用是为了延长软件产品的寿命。(×) 9. ...
  • NumPy是由Python实现科学计算开源扩展程序库,最重要一个特点是具有一个快速而灵活大数据集容器N维数组对象(即Ndarray),NumPy主要包括以下几点: 1.由实际数据和描述这些数据元数据组成一个强大N维...

    NumPy是由Python实现科学计算的开源扩展程序库,最重要的一个特点是具有一个快速而灵活的大数据集容器N维数组对象(即Ndarray),NumPy主要包括以下几点:
    1.由实际的数据和描述这些数据的元数据组成的一个强大的N维数组对象ndarray。
    2.比较成熟的函数库
    3.用于整合C/C++和Fortran代码的工具包
    4.实用的线性代数、傅里叶变换和随机数生成函数

    一 、常用的Ndarray创建方法有哪些?

    (1)由list创建

    In [1]: import numpy as np                                                      
    
    In [2]: m = np.array([[1,2,3],[4,5,6]])                                         
    
    In [3]: m, type(m)                                                              
    Out[3]: 
    (array([[1, 2, 3],
            [4, 5, 6]]),
     numpy.ndarray)
    
    In [4]: import numpy as np                                                      
    
    In [5]: m2 = np.array([1,3.14,'xxt'])                                           
    
    In [6]: m2, type(m2)                                                            
    Out[6]: (array(['1', '3.14', 'xxt'], dtype='<U32'), numpy.ndarray)
    
    

    (2)由np.ones()函数创建

    np.ones(shape, dtype=None, order=‘C’)是由1组成的ndarray,如

    n = np.ones(shape=(3, 5), dtype=np.int8)
    print(n)
    

    运行结果

    [[1 1 1 1 1]
     [1 1 1 1 1]
     [1 1 1 1 1]]
    

    (3)由np.zeros()函数创建

    np.zeros(shape, dtype=float, order=‘C’)是由0组成的ndarray,如

    p = np.zeros(shape=(2, 3), dtype=np.int8)
    print(p)
    

    输出

    [[0 0 0]
     [0 0 0]]
    

    (4)由np.full()函数创建

    np.full(shape, fill_value, dtype=None, order=‘C’)创建的ndarray的每个值都是一样的,如:

    q = np.full(shape=(5, 3), fill_value=5.21)
    print(q)
    

    输出

    [[5.21 5.21 5.21]
     [5.21 5.21 5.21]
     [5.21 5.21 5.21]
     [5.21 5.21 5.21]
     [5.21 5.21 5.21]]
    

    (5)由np.eye()函数创建

    np.eye(N, M=None, k=0, dtype=float)的ndarray对角线为1其他位置为0,如:

    l = np.eye(5)
    print(l)
    

    输出

    [[1. 0. 0. 0. 0.]
     [0. 1. 0. 0. 0.]
     [0. 0. 1. 0. 0.]
     [0. 0. 0. 1. 0.]
     [0. 0. 0. 0. 1.]]
    

    (6)由np.linspace()函数创建

    np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)得到等分的ndarray元组

    k = np.linspace(1, 17, num=8, endpoint=False, retstep=True)
    print(k)
    

    输出

    (array([ 1.,  3.,  5.,  7.,  9., 11., 13., 15.]), 2.0)
    

    再比如:

    k1 = np.linspace(1, 21, num=5, endpoint=False, retstep=True)
    print(k1)
    

    输出

    (array([ 1.,  5.,  9., 13., 17.]), 4.0)
    

    (7)由np.arange()函数创建

    np.arange([start, ]stop, [step, ]dtype=None),得到的是左闭右开的等差ndarray,如:

    h = np.arange(1, 15, step=2)
    print(h)
    

    输出

    [ 1  3  5  7  9 11 13]
    

    (8)由np.random相关函数创建

    np.random.randint(low, high=None, size=None, dtype=‘l’)得到的是随机整数ndarray,如:

    r = np.random.randint(-19, 100, size=(2, 3))
    print(r)
    

    输出

    [[-1 25 47]
     [62  7 87]]
    

    再如,np.random.randn(2,3)得到的是标准正态分布ndarray:

    r2 = np.random.randn(2, 3)
    print(r2)
    

    输出

    [[-1.75994655  0.06129896  1.24847171]
     [-1.12129842 -1.74107121  1.3208108 ]]
    

    二、Ndarry的属性有哪些?

    属性 说明
    dtype 返回数组元素的类型
    ndim 返回数组的维度
    shape 返回数组中每个维度的大小,用tuple表示
    size 返回数组中元素的个数,等于shape中所有整数的乘积
    itemsize 返回数组中每个元素的字节大小
    T 返回数组的转置
    flat 返回一个数组的迭代器,对flat赋值将导致整个数组的元素被覆盖
    real/imag 返回复数数组的实部/虚部
    nbytes 返回数组占用的存储空间

    例如:

    import numpy as np
    
    n = np.array([[[1, 2, 3], [4, 5, 6]], [[7, 8, 9], [10, 11, 12]]])
    print('数据类型: ', type(n))
    print('\nNumPy的形状: ', n.shape)
    print('\nNumPy的维度:', n.ndim)
    

    输出

    数据类型:  <class 'numpy.ndarray'>
    
    NumPy的形状:  (2, 2, 3)
    
    NumPy的维度: 3
    

    三、常用Ndarray方法

    方法 解释
    astype(dtype) 返回指定元素类型的数组副本
    argmax()/argmin() 返回最大值/最小值的索引
    copy() 返回数组的深复制
    cumprod 返回指定轴的累积
    compress() 返回满足条件的元素构成的数组
    flatten() 返回将原数组压缩成一维数组的复制
    fill(value) 返回将数组元素全部设定为标量值value的数组
    mean()/var()/std() 返回数组元素的均值/方差/标准差
    max()/min()/ptp() 返回数组的最大值/最小值/取值范围
    reshape() 返回重组数组形状(shape)后的数组,不改变原数组元素的个数
    resize() 返回给定数组形状(shape)的数组,原数组shape发生改变
    ravel() 返回将原数组压缩成一维数组的视图,原数组不改变
    sort() 返回按照指定轴或指定算法排序的数组
    sum() 返回数组中所有元素的和
    take() 返回一个从原数组中根据指定的索引获取对应元素的新数组
    tolist() 返回一个列表,注意与直接使用list(array)的区别
    view() 返回一个使用相同内存,但使用不同的表示方法的数组

    reshape示例:

    m = np.array([[1, 2, 3], [4, 5, 6]])
    
    print('reshape: ', m.reshape(3, 2))
    print('\nm: ', m)
    

    输出

    reshape:  [[1 2]
     [3 4]
     [5 6]]
    
    m:  [[1 2 3]
     [4 5 6]]
    

    resize()示例:

    m = np.array([[1, 2, 3], [4, 5, 6]])
    m.resize((5, 5), refcheck=False)
    print(m)
    

    输出

    [[1 2 3 4 5]
     [6 0 0 0 0]
     [0 0 0 0 0]
     [0 0 0 0 0]
     [0 0 0 0 0]]
    

    四、Ndarray的基本操作

    (1)索引和切片

    创建Ndarray

    import numpy as np
    
    n = np.arange(10)**3
    nd = np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10], [11, 12, 13, 14, 15], [16, 17, 18, 19, 100]])
    print('一维数组: ', n)
    print('\n多维数组: ', nd)
    
    输出
    一维数组:  [  0   1   8  27  64 125 216 343 512 729]
    
    多维数组:  [[  1   2   3   4   5]
     [  6   7   8   9  10]
     [ 11  12  13  14  15]
     [ 16  17  18  19 100]]
    

    (a)一维数组可以被索引、切片和迭代,就像列表和其他python序列一样

    n = np.arange(10)**3
    print('通过索引获取元素: ', n[2], n[[1, 6]])
    print('通过切片获得所需元素: ', n[0:6])
    print('通过切片获得苏所需元素: ', n[::-1])
    

    输出

    通过索引获取元素:  8 [  1 216]
    通过切片获得所需元素:  [  0   1   8  27  64 125]
    通过切片获得苏所需元素:  [729 512 343 216 125  64  27   8   1   0]
    

    (b)多维数组每个轴可以有一个索引,这些索引以逗号分隔的元组给出

    nd = np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10], [11, 12, 13, 14, 15], [16, 17, 18, 19, 100]])
    print('通过索引获得元素: ', nd[2], nd[1, 2])
    print('通过切片获得元素: ', nd[0:2, 1:3])
    

    输出

    通过索引获得元素:  [11 12 13 14 15] 8
    通过切片获得元素:  [[2 3]
     [7 8]]
    

    (2)Numpy Array的合并和重构

    (a)np.vatack()执行上下合并,np.hstack()执行左右合并

    import numpy as np
    
    A = np.array([1, 1, 1])
    B = np.array([2, 2, 2])
    print('上下合并:\n', np.vstack((A, B)))
    print('左右合并:', np.hstack((A, B)))
    

    输出

    上下合并:
     [[1 1 1]
     [2 2 2]]
    左右合并: [1 1 1 2 2 2]
    

    (b)Concatenate()合并函数,axis=0表示纵向合并,axis=1表示横向合并

    C = np.array([[1, 1, 1], [1, 1, 1]])
    D = np.array([[2, 2, 2], [2, 2, 2]])
    
    E = np.concatenate((C, D), axis=0)
    F = np.concatenate((C, D), axis=1)
    
    print('axis=0纵向合并:\n', E)
    print('axis=1横向合并:\n', F)
    

    输出

    axis=0纵向合并:
     [[1 1 1]
     [1 1 1]
     [2 2 2]
     [2 2 2]]
    axis=1横向合并:
     [[1 1 1 2 2 2]
     [1 1 1 2 2 2]]
    

    (c)使用reshape函数,可以改变Array的结构,即重构array,其中参数是一个tuple

    G = np.arange(12)
    H = np.arange(12).reshape(3, 4)
    print('G数组:\n', G)
    print('H数组:\n', H)
    

    输出

    G数组:
     [ 0  1  2  3  4  5  6  7  8  9 10 11]
    H数组:
     [[ 0  1  2  3]
     [ 4  5  6  7]
     [ 8  9 10 11]]
    

    (3)广播机制

    广播机制是对两个形状不同的阵列进行数学计算的处理机制,即把较小的阵列“广播”到较大阵列相同的形状尺寸上,使他们对等,从而可以进行数学计算。

    from numpy import array
    
    a = array([[[1, 2, 3], [5, 6, 7]], [[11, 12, 13], [15, 16, 17]]])
    b = array([1, 1, 1])
    c = array([[1, 1, 1], [2, 2, 2]])
    
    print('a的形状:%s, b的形状:%s, c的形状:%s\n' % (a.shape, b.shape, c.shape))
    print('b的轴长是1,可广播:\n', a+b)
    print('\na和c的后缘维度都是(2,3),可广播:\n', a+c)
    

    输出

    a的形状:(2, 2, 3), b的形状:(3,), c的形状:(2, 3)
    
    b的轴长是1,可广播:
     [[[ 2  3  4]
      [ 6  7  8]]
    
     [[12 13 14]
      [16 17 18]]]
      
    a和c的后缘维度都是(23,可广播:
     [[[ 2  3  4]
      [ 7  8  9]]
    
     [[12 13 14]
      [17 18 19]]]
    

    五、NumPy基本运算

    最简单的运算就是给数组加上一个标量,然后每个元素都加上这个标量,当然也可以进行减法、乘法和除法运算。

    (1)一维数组运算

    import numpy as np
    
    a = np.array([10, 20, 30, 40])
    b = np.array(4)
    c = b**2
    g = a/2
    d = np.sin(a)
    e = np.cos(a)
    f = np.tan(a)
    
    print('加法a+b:', a+b, '\n', '减法a-b:', a-b, '\n', '乘c:', c, '\n', '除g:', g)
    print('正弦d:', d, '\n', '余弦e:', e)
    print('比较b<3:', b<3)
    

    输出

    加法a+b: [14 24 34 44] 
     减法a-b: [ 6 16 26 36] 
     乘c: 16 
     除g: [ 5. 10. 15. 20.]
    正弦d: [-0.54402111  0.91294525 -0.98803162  0.74511316] 
     余弦e: [-0.83907153  0.40808206  0.15425145 -0.66693806]
    比较b<3: False
    

    (2)多维数组运算

    import numpy as np
    
    a = np.array([[1, 1, 1, 1], [2, 2, 2, 2]])
    b = np.arange(1, 9).reshape(2, 4)
    
    s1 = a + b
    s2 = a - b
    s3 = a * b
    s4 = b / a
    s5 = b.dot(a.T)
    s6 = a.dot(b.T)
    
    print('加法a+b:\n', s1, '\n', '减法a-b:\n', s2, '\n', '乘法a*b:\n', s3, '\n', '除法a/b:\n', s4)
    print('矩阵转置a.T:\n', a.T, '\n', '矩阵转置b.T:\n', b.T)
    print('矩阵点乘b.dot(a):\n', s5, '\n', '矩阵点乘a.dot(b):\n', s6)
    

    输出

    加法a+b:
     [[ 2  3  4  5]
     [ 7  8  9 10]] 
     减法a-b:
     [[ 0 -1 -2 -3]
     [-3 -4 -5 -6]] 
     乘法a*b:
     [[ 1  2  3  4]
     [10 12 14 16]] 
     除法a/b:
     [[1.  2.  3.  4. ]
     [2.5 3.  3.5 4. ]]
    矩阵转置a.T:
     [[1 2]
     [1 2]
     [1 2]
     [1 2]] 
     矩阵转置b.T:
     [[1 5]
     [2 6]
     [3 7]
     [4 8]]
    矩阵点乘b.dot(a):
     [[10 20]
     [26 52]] 
     矩阵点乘a.dot(b):
     [[10 26]
     [20 52]]
    
    展开全文
  • OpenGL ES 3.0 基础知识

    2017-01-03 06:26:00
    管线分别包括了顶点缓冲区/数组对象,定点着色器,纹理,片段着色器,变换反馈,图元装配,光栅化,逐片段操作,帧缓冲区。其中顶点着色器和片段着色器是管线可编程阶段。 顶点着色器 其实现了顶点操作通用可...
  • 总之,凡是用数字方式对信号进行滤波、变换、增强、压缩、估计和识别等都是数字信号处理研究对象。 数字信号处理课程是电子信息工程、通信工程等学科专业本科生必选技术基础课程。本课程介绍了数字信号处理...
  • 软件工程教程

    热门讨论 2012-07-06 23:10:29
    过去数十种面向对象的建模语言各自为战,而UML可以消除一些潜在差异,一统江湖 通过统一语义和符号表示,提高面向对象技术 使项目建立在一个成熟的标准建模语言基础之上 便于沟通和交流,统一的理解 UML主要内容 ...
  • 找出进程打开了哪些文件、注册表项和其他对象以及已加载哪些 DLL 等信息。这个功能异常强大实用工具甚至可以显示每个进程所有者。 Process Monitor 实时监视文件系统、注册表、进程、线程和 DLL 活动。 ...
  • 找出进程打开了哪些文件、注册表项和其他对象以及已加载哪些 DLL 等信息。这个功能异常强大实用工具甚至可以显示每个进程所有者。 Process Monitor 实时监视文件系统、注册表、进程、线程和 DLL 活动。 ...
  • 调试开发工具集

    2015-03-25 16:32:14
    找出进程打开了哪些文件、注册表项和其他对象以及已加载哪些 DLL 等信息。这个功能异常强大实用工具甚至可以显示每个进程所有者。 Process Monitor 实时监视文件系统、注册表、进程、线程和 DLL 活动。 ...
  • 找出进程打开了哪些文件、注册表项和其他对象以及已加载哪些 DLL 等信息。这个功能异常强大实用工具甚至可以显示每个进程所有者。Process Monitor 实时监视文件系统、注册表、进程、线程和 DLL 活动。...
  • 软件工程简答题

    2012-01-03 21:26:00
    喷泉模型 喷泉模型是一种以用户需求为动力,以对象作为驱动的模型,适合于面向对象的开发方法。6.基于知识的模型 基于知识的模型又称智能模型,它把瀑布模型和专家系统结合在一起。该模型在开发的各个阶段都利用相应...
  • SysinternalsSuite

    2012-07-26 21:31:11
     找出进程打开了哪些文件、注册表项和其他对象以及已加载哪些 DLL 等信息。这个功能异常强大实用工具甚至可以显示每个进程所有者。  Process Monitor  实时监视文件系统、注册表、进程、线程和 DLL 活动。  ...
  • 2018年软件学院C++课程设计 课程设计目的: 1、熟悉利用面向对象的方法以及C++的编程思想来完成系统的设计; 2、锻炼学生在设计的过程中,建立清晰的类层次,应用继承和多态等面向对象的编程思想; 3、通过本课程...
  • 找出进程打开了哪些文件、注册表项和其他对象以及已加载哪些 DLL 等信息。这个功能异常强大实用工具甚至可以显示每个进程所有者。 Process Monitor v2.8(2009 年 11 月 3 日) 实时监视文件系统、注册表、进程...
  • (46) 面向对象的设计方法与传统的的面向过程的方法有本质不同,它的基本原理是(C) A. 模拟现实世界中不同事物之间的联系 B. 强调模拟现实世界中的算法而不强调概念 C. 使用现实世界的概念抽象地思考问题从而自然地...
  • (13) 面向对象的程序设计方法中涉及的对象是系统中用来描述客观事物的一个______。 答:实体 (14) 软件的需求分析阶段的工作,可以概括为四个方面:______、需求分析、编写需求规格说明书和需求评审。 答:需求获取...
  • 在用法方面,ggplot2也开创了一种奇特而绝妙的语法,那就是加号:一幅图形从背后的设计来说,是若干图形语法的叠加,从外在的代码来看,也是若干R对象的相加。这一点精妙尽管只是ggplot2系统的很小一部分,但我个人...
  • iPhone开发秘籍(第2版)--源代码

    热门讨论 2012-12-11 13:51:22
    2.8 秘诀:使用Instruments监视缓存对象的内存分配 48 2.9 使用Clang静态分析器 50 2.10 针对iPhone进行构建 51 2.10.1 安装开发配置 51 2.10.2 编辑应用程序标识符 51 2.10.3 设置Code Signing Identity 52 ...
  • iPhone开发秘籍(第2版)--详细书签版

    热门讨论 2012-12-11 13:42:25
    2.8 秘诀:使用Instruments监视缓存对象的内存分配 48 2.9 使用Clang静态分析器 50 2.10 针对iPhone进行构建 51 2.10.1 安装开发配置 51 2.10.2 编辑应用程序标识符 51 2.10.3 设置Code Signing Identity 52 ...

空空如也

空空如也

1 2 3
收藏数 44
精华内容 17
关键字:

对象的变换包括哪些