31. 反射的作用与原理

简单的来说,反射机制其实就是指程序在运行的时候能够获取自身的信息。如果知道一个类的名称或者它的一个实例对象, 就能把这个类的所有方法和变量的信息(方法名,变量名,方法,修饰符,类型,方法参数等等所有信息)找出来。如果明确知道这个类里的某个方法名+参数个数 类型,还能通过传递参数来运行那个类里的那个方法,这就是反射。
在Java中,Class类与java.lang.reflect类库一起对反射的概念提供了支持,该类库包含了Field、Method以及Constructor类(每个类都实现了Member接口)。我们知道对RTTI(运行时类型识别)来说,编译器在编译时打开和检查.class文件。而对于反射机制来说,.class文件在编译时是不可获取的,所以是在运行时打开和检查.class文件的。
说了这么多,反射究竟有什么用呢?我们来看一下以下的例子:
  1. import java.lang.reflect.Field;
  2. import java.lang.reflect.Method;
  3. class A {
  4. private int varA;
  5. public void myPublicA() {
  6. System.out.println("I am public in A !");
  7. };
  8. private void myPrivateA() {
  9. System.out.println("I am private in A !");
  10. };
  11. }
  12. class B extends A {
  13. public int varB;
  14. public void myPublicB(){};
  15. }
  16. public class Main {
  17. public static void main(String[] args) throws Exception {
  18. B b = new B();
  19. // 子类方法
  20. Method methods[] = b.getClass().getMethods();
  21. for (Method method : methods)
  22. System.out.println(method);
  23. System.out.println("");
  24. // 子类变量
  25. Field fields[] = b.getClass().getFields();
  26. for (Field field : fields)
  27. System.out.println(field);
  28. // 基类
  29. System.out.println("\n" + b.getClass().getSuperclass() + "\n");
  30. // 基类private方法也不能避免
  31. Class superClass = b.getClass().getSuperclass();
  32. methods = superClass.getDeclaredMethods();
  33. for (Method method : methods) {
  34. System.out.println(method);
  35. method.setAccessible(true);
  36. // 实例化A来调用private方法!
  37. method.invoke(superClass.newInstance(), null);
  38. }
  39. }
  40. }

在上面的例子中,我们用一个子类B,通过反射找到了他的数据域、与方法,还找到了他的基类A。更甚者,我们实例化了基类A,还调用了A里面的所有方法,甚至是private方法。从以上的例子相信大家都感受到了反射的威力了,运用使用class对象和反射提供的方法我们可以轻易的获取一个类的所有信息,包括被封装隐藏起来的信息,不仅如此我们还可以调用获取的信息来构造实例和调用方法。以上的展示只是反射的冰山一角,反射在动态代理和调用隐藏API等黑科技方面还发挥着重要的作用,博主在此不做深入探讨。

 

32. 泛型常用特点,List<String>能否转为List<Object>

泛型是Java SE5引入的一种新特性,泛型实现了参数化类型的概念,使得我们的代码可以应用于更多类型,更多场景。在以往的J2SE中,没有泛型的情况下,通常是使用Object类型来进行多种类型数据的操作。这个时候操作最多的就是针对该Object进行数据的强制转换,而这种转换是基于开发者对该数据类型明确的情况下进行的(例如将Object型转换为String型)。如果类型不一致,编译器在编译过程中不会报错,但在运行时会出错。相比之下,使用泛型的好处在于,它在编译的时候进行类型安全检查,并且在运行时所有的转换都是强制的,隐式的,大大提高了代码的重用率。
先来回答List<String>能否转为List<Object>的问题,答案是不行的,因为String的list不是Object的list,String的list持有String类和其子类型,Object的list持有任何类型的Object,String的list在类型上不等价于Object的list。但List<String>可以转为List<? extends Object>,Java代码如下:
  1. List<String> listString = new ArrayList<>();
  2. // error : Type mismatch: cannot convert from List<String> to List<Object>
  3. List<Object> listObject = listString;
  4. // it's ok !
  5. List<? extends Object> listExtendsObject = listString;
  6. // error : The method add(capture#1-of ? extends Object) in the type List<capture#1-of ? extends Object> is not applicable for the
  7. // arguments (String)
  8. listExtendsObject.add("string");
  9. // it's ok !
  10. listExtendsObject.add(null);
  11. // it's ok !
  12. Object object = listExtendsObject.get(0);

接下来讲讲泛型常用的特点,利用泛型我们可以实现以下内容:

1.带参数类型的类,泛型类

类的参数类型写在类名的后面,多个参数类型用逗号分隔,定义完类型参数后,我们可以在定义位置之后的类的几乎任意地方(静态块,静态属性,静态方法除外)使用类型参数:
  1. class A<T,S> {
  2. }
 

2.带参数类型的方法,泛型方法

除了可以定义泛型类,我们还可以把泛型应用于方法之上,要定义泛型方法只需把泛型参数列表置于返回值之前:
 
  1. public <T> void f(T x) {
  2. }

使用泛型方法时通常不必指明参数类型,编译器会为我们找出具体类型,这称为类型参数推断。

3.关键字

 
泛型还有两个重要的关键字extends和super,这两个关键字用于限制泛型的范围。extends把类型参数限制为某个类的子类:
  1. class A {}
  2. class B extends A {}
  3. class C {};
  4. //代表了T为A或A的子类
  5. class D <T extends A> {};
  6. public class Main {
  7. public static void main(String[] args) {
  8. D<A> a;
  9. D<B> b;
  10. // no work!
  11. D<C> c;
  12. }
  13. }

super与extends相反,把类型参数限制为某个类的父类。(此处博主研究不够深入,故对super关键字不够了解,在此不深入讨论)

4.擦除

Java的泛型不是完美的泛型,Java的泛型为了考虑兼容性的问题,使用了擦除来实现。看一下下面的例子:
  1. import java.util.Arrays;
  2. class A {}
  3. class B extends A {}
  4. class C extends B {};
  5. class D <T> {
  6. T t;
  7. D(T t) {
  8. this.t = t;
  9. }
  10. public void f() {
  11. System.out.println(Arrays.toString(this.getClass().getTypeParameters()));
  12. }
  13. };
  14. public class Main {
  15. public static void main(String[] args) {
  16. D<A> a = new D<A>(new A());
  17. D<B> b = new D<B>(new B());
  18. D<C> c = new D<C>(new C());
  19. a.f();
  20. b.f();
  21. c.f();
  22. }
  23. }

D中的f方法通过获取D的Class类来获取其类型信息,其打印的结果如下:



并不是我们传入的参数A、B、C,真是太失望了。这就是Java泛型擦除的特点,残酷的现实告诉我们在泛型代码的内部,我们无法获得任何有关泛型的参数类型信息,擦除会把类的类型信息给擦除到它的边界(如果有多个边界会擦除到第一个)。也就是说,对于上面例子中的T,我们只能把其当做Object类来处理(Object类为所有类的父类)。擦除使得所有与类型信息相关的操作都无法在泛型代码中进行,extends会稍微改善一点这种情况:

  1. class A {
  2. public void fa() {};
  3. }
  4. class C <T> { // 擦除到Object
  5. T t;
  6. public void f(Object a) {
  7. if (a instanceof T) {} // error,不知道具体的类型信息
  8. T var = new T(); // error,不知道该类型是否有默认构造函数
  9. T[] array = new T[1]; // error
  10. t.fa(); // error
  11. }
  12. };
  13. class D <T extends A> { // 擦除到A
  14. T t;
  15. public void f(Object a) {
  16. t.fa(); // this works
  17. }
  18. };

33. 解析XML的几种方式的原理与特点:DOM、SAX、PULL

1.DOM

DOM解析方法首先把xml文件读取到内存中,保存为节点树的形式,然后我们使用其API来读取树上的节点的信息。由于DOM解析xml文件时需要将其载入到内存,故xml文件较大时或内存较小的设备不适用该方法。
使用DOM解析xml主要步骤如下:
  1. 使用DocumentBuilderFactory.newInstance方法获取DOM工厂实例
  2. 使用工厂的newDocumentBuilder方法获取builder
  3. 使用builder的parse方法解析xml获取生成的Document对象
  4. 使用Document的getDocumentElement方法获取根节点
  5. 调用根节点的getChildNodes方法遍历子节点

2.SAX

与DOM不同,SAX全称为Simple API for XML ,是基于事件驱动的解析手段。对于SAX而言分析xml能够立即开始,而不用等待所有的数据被处理。而且,由于SAX只是在读取数据时检查数据,因此不需要将数据存储在内存中。一般来说SAX解析比DOM解析快许多,但由于SAX解析xml文件是一次性处理,因此相对DOM而言没有那么灵活方便。
使用SAX解析主要步骤如下:
  1. 调用SAXParserFactory.newInstance获取SAX工厂实例
  2. 调用工厂的newSAXParser方法获取解析器
  3. 调用解析器的getXMLReader获取事件源reader
  4. 调用setContentHandler方法为事件源reader设置处理器
  5. 调用parse方法开始解析数据

3.PULL

与SAX类似,Pull也是一种基于事件驱动的xml解析器。与SAX不同在于Pull让我们手动控制解析进度,通过返回eventType来让我们自行处理xml的节点,而不是调用回调函数,eventType有如下几种:
  • 读取到xml的声明返回      START_DOCUMENT
  • 读取到xml的结束返回       END_DOCUMENT
  • 读取到xml的开始标签返回 START_TAG
  • 读取到xml的结束标签返回 END_TAG
  • 读取到xml的文本返回       TEXT
使用Pull解析的主要步骤如下:
  1. 使用XmlPullParserFactory.newInstance方法获取Pull工厂
  2. 调用工厂newPullParser方法返回解析器
  3. 使用解析器setInput方法设置解析文件
  4. 调用next方法解析下一行,调用getEventType方法获取当前的解析情况
3中解析方法的代码如下:
DOM与SAX:
  1. public static void main(String[] args) throws Exception {
  2. // 桌面的xml文件,文件内容如下
  3. // <all name="testData">
  4. // <item first="1" second="A" third="一"/>
  5. // <item first="2" second="B" third="二"/>
  6. // <item first="3" second="C" third="三"/>
  7. // <item first="4" second="D" third="四"/>
  8. // <item first="5" second="E" third="五"/>
  9. // </all>
  10. File file = new File("C:/Users/Administrator/Desktop/test.xml");
  11. // 文件流
  12. FileInputStream fis = new FileInputStream(file);
  13. {
  14. // DOM解析xml
  15. System.out.println("DOM:");
  16. // 获取DOM工厂实例
  17. DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
  18. // 生成builder
  19. DocumentBuilder builder = factory.newDocumentBuilder();
  20. // 解析文件
  21. Document document = builder.parse(file);
  22. // 获取根节点
  23. Element element = document.getDocumentElement();
  24. System.out.println(element.getTagName() + " " + element.getAttribute("name"));
  25. // 获取子节点列表
  26. NodeList nodeList = element.getChildNodes();
  27. for (int i = 0; i < nodeList.getLength(); i++) {
  28. Node node = nodeList.item(i);
  29. // 节点类型为元素节点
  30. if (node.getNodeType() == Node.ELEMENT_NODE) {
  31. Element child = (Element) node;
  32. // 输出标签名和元素内容
  33. System.out.println(child.getTagName() + " " + child.getAttribute("first") + " "
  34. + child.getAttribute("second") + " " + child.getAttribute("third"));
  35. }
  36. }
  37. }
  38. System.out.println(""); // empty line
  39. {
  40. // SAX解析xml
  41. System.out.println("SAX:");
  42. // 获取SAX工厂实例
  43. SAXParserFactory factory = SAXParserFactory.newInstance();
  44. // 获取SAX解析器
  45. SAXParser parser = factory.newSAXParser();
  46. // 获取reader
  47. XMLReader reader = parser.getXMLReader();
  48. // 设置解析源和处理器
  49. reader.setContentHandler(new MySAXHandler()); // 在parse之前设置
  50. reader.parse(new InputSource(fis));
  51. }
  52. }
  53. // 自定义SAX处理器
  54. static class MySAXHandler extends DefaultHandler {
  55. @Override
  56. public void startDocument() throws SAXException {
  57. // 解析文档开始时调用
  58. super.startDocument();
  59. }
  60. @Override
  61. public void startElement(String uri, String localName, String qName, Attributes attributes)
  62. throws SAXException {
  63. // 解析元素开始时调用
  64. // 打印元素名
  65. System.out.print(qName);
  66. // 打印元素属性
  67. for (int i = 0; i < attributes.getLength(); i++)
  68. System.out.print(" " + attributes.getValue(i));
  69. System.out.println("");
  70. super.startElement(uri, localName, qName, attributes);
  71. }
  72. @Override
  73. public void endElement(String uri, String localName, String qName) throws SAXException {
  74. // 解析元素结束时调用
  75. super.endElement(uri, localName, qName);
  76. }
  77. @Override
  78. public void endDocument() throws SAXException {
  79. // 解析文档结束时调用
  80. super.endDocument();
  81. }
  82. }
 

Pull(此为Android解析中国天气网省份信息xml文件的例子):

  1. XmlPullParserFactory factory = XmlPullParserFactory
  2. .newInstance();
  3. XmlPullParser xmlPullParser = factory.newPullParser();
  4. // use gb2312 encode
  5. ByteArrayInputStream is = new ByteArrayInputStream(
  6. response.getBytes("GB2312"));
  7. xmlPullParser.setInput(is, "GB2312");
  8. int eventType = xmlPullParser.getEventType();
  9. String provinceName = "";
  10. String provinceCode = "";
  11. while (eventType != XmlPullParser.END_DOCUMENT) {
  12. String nodeName = xmlPullParser.getName();
  13. switch (eventType) {
  14. // start parse node
  15. case XmlPullParser.START_TAG:
  16. if ("city".equals(nodeName)) {
  17. provinceName = xmlPullParser.getAttributeValue("",
  18. "quName");
  19. provinceCode = xmlPullParser.getAttributeValue("",
  20. "pyName");
  21. Province province = new Province();
  22. province.setProvinceName(provinceName);
  23. province.setProvinceCode(provinceCode);
  24. coolWeatherDB.saveProvince(province);
  25. }
  26. break;
  27. default:
  28. break;
  29. }
  30. eventType = xmlPullParser.next();

本人对三种解析方法的总结如下:

  • 需要解析小的xml文件,需要重复解析xml文件或需要对xml文件中的节点进行删除修改排序等操作:使用DOM
  • 需要解析较大的xml文件,只需要解析一次的xml文件:使用SAX或Pull
  • 只需要手动解析部分的xml文件:使用Pull
 

34. Java与C++对比

Java是由C++发展而来的,保留了C++的大部分内容,其编程方式类似于C++,但是摒弃了C++的诸多不合理之处,Java是纯面向对象的编程语言。Java和C++的区别主要如下:

1.都是类与对象

在Java中,一切的组件都是类与对象,没有单独的函数、方法与全局变量。C++中由于可以使用C代码,故C++中类对象与单独的函数方法共存。

2.多重继承

在C++中类可以多重继承,但这有可能会引起菱形问题。而在Java中类不允许多重继承,一个类只能继承一个基类,但可以实现多个接口,避免了菱形问题的产生。

3.操作符重载

C++允许重载操作符,而Java不允许。

4.数据类型大小

在C++中,不同的平台上,编译器对基本数据类型分别分配不同的字节数,导致了代码数据的不可移植性。在Java中,采用基于IEEE标准的数据类型,无论任何硬件平台上对数据类型的位数分配总是固定的。(然而boolean基本类型要看JVM的实现)

5.内存管理

C++需要程序员显式地声明和释放内存。Java中有垃圾回收器,会在程序内存不足或空闲之时在后台自行回收不再使用的内存,不需要程序员管理。

6.指针

指针是C++中最灵活也最容易出错的数据类型。Java中为了简单安全去掉了指针类型。

7.类型转换

C++中,会出现数据类型的隐含转换,涉及到自动强制类型转换。Java中系统要对对象的处理进行严格的相容性检查,防止不安全的转换。如果需要,必须由程序显式进行强制类型转换。(如int类型不能直接转换为boolean类型)

8.方法绑定

C++默认的方法绑定为静态绑定,如果要使用动态绑定实现多态需要用到关键字virtual。Java默认的方法绑定为动态绑定,只有final方法和static方法为静态绑定。

目前博主就想到这么多,还有的以后再补充。

35. Java1.5、1.7与1.8新特性

JDK1.5:

  1. 自动装箱与拆箱:基本类型与包装类型自动互换
  2. 枚举类型的引入
  3. 静态导入:import static,可直接使用静态变量与方法
  4. 可变参数类型
  5. 泛型
  6. for-each循环

JDK1.7:

  1. switch允许传入字符串
  2. 泛型实例化类型自动推断:List<String> tempList = new ArrayList<>()
  3. 对集合的支持,创建List / Set / Map 时写法更简单了,如:List< String> list = ["item"],String item = list[0],Set< String > set = {"item"}等
  4. 允许在数字中使用下划线
  5. 二进制符号加入,可用作二进制字符前加上 0b 来创建一个二进制类型:int binary = 0b1001_1001
  6. 一个catch里捕捉多个异常类型,‘|’分隔

JDK1.8:

  1. 允许为接口添加默认方法,又称为拓展方法,使用关键字default实现
  2. Lambda 表达式
  3. Date API
  4. 多重注解

36. JNI的使用

先简单介绍一下JNI,JNI即Java Native Interface的缩写,中文译为“Java本地调用”。通俗的说,JNI是一种实现Java层与Native层(C/C++)交互的技术。有时为了追求效率问题,或者是使用用native代码编写的函数库,我们就不得不使用JNI接口。
以下是一个JNI的小例子:
  1. public class Main {
  2. public static void main(String[] args) throws Exception {
  3. // 动态库名字,windows平台自动拓展成makeStr_jni.dll
  4. System.loadLibrary("makeStr_jni");
  5. // 打印字符串
  6. printString("Java World!");
  7. }
  8. // native关键字表示为本地方法
  9. public static native void printString(String str);
  10. }

我们在Java中使用JNI接口只需要两步:

  1. 使用native关键字声明某方法为本地方法
  2. 使用System.loadLibrary加载由C/C++编写成的动态链接库(我们只需要写出库名字即可,Java会根据平台补充库的全名windows:dll,linux:so)
接下啦我们来看看如何编写Native层的cpp文件(以下注册Native函数方法为静态注册,动态注册本文不提及):
为了让Java层中的函数与Native层中的函数一一对应,JNI规定了一套复杂的命名体系。在此本文就不深入介绍该命名方法了,我们使用JDK提供的javah工具生成对应的.h头文件:
首先我们把写好的Java代码编译成.class文件:
 
 
然后我们使用javah工具生成对应的.h头文件(-o后面第一个参数为.h的文件名,第二个参数为.class的文件名):
 
 
然后我们就能看到生成的.h文件了:
 
 
以下是.h文件中的代码:
  1. /* DO NOT EDIT THIS FILE - it is machine generated */
  2. #include "jni.h"
  3. /* Header for class Main */
  4. #ifndef _Included_Main
  5. #define _Included_Main
  6. #ifdef __cplusplus
  7. extern "C" {
  8. #endif
  9. /*
  10. * Class:     Main 方法所在的类
  11. * Method:    printString 方法名
  12. * Signature: (Ljava/lang/String;)V 签名
  13. */
  14. JNIEXPORT void JNICALL Java_Main_printString
  15. (JNIEnv *, jclass, jstring);
  16. #ifdef __cplusplus
  17. }
  18. #endif
  19. #endif

可以看到我们在Java层定义的printString方法对应成了Native层的Java_Main_printString方法,方法上面有javah给我们生成的注释,它提供了以下信息:

  • Class:方法所属于的类
  • Method:方法的名称
  • Signature:方法的签名。签名是由于Java中的方法允许重载,仅仅通过类与名称并不能确定该Native方法所对应的Java方法,因此JNI技术中就将参数类型和返回值的组合作为了一个函数的签名信息,有了签名和函数名我们才能顺利找到Javac层中对应的函数
接下来我们只要写一个.cpp文件实现该方法即可:
  1. #include<iostream>
  2. #include"_Main.h"
  3. using namespace std;
  4. /*
  5. *  JNIEnv  :   env JNI环境,一个提供JNI系统函数的结构体
  6. *  jclass  :   clazz   代表Java层的Class对象,由于printString方法是一个静态方法,故传入Class对象
  7. *  jstring  :  s   代表Java层的String对象,表示传入的参数
  8. */
  9. JNIEXPORT void JNICALL Java_Main_printString
  10. (JNIEnv * env, jclass clazz, jstring s) {
  11. jboolean iscopy;
  12. // 通过jstring对象生成本地字符串
  13. const char *charData = env->GetStringUTFChars(s, &iscopy);
  14. // 打印字符串
  15. cout << "A message from Native World: " << charData << endl;
  16. // 释放资源
  17. env->ReleaseStringUTFChars(s, charData);
  18. }

以上代码相信注释已解释的非常清楚,故此处不再赘述。值得一提的是在Native层中有多种与Java层中相对应的数据结构,如:jclass代表Class对象,jstring代表String对象,jboolean代表boolean基本类型等。有兴趣的童鞋可以自行去了解下。

写完该.cpp文件后,我们编译工程生成dll文件(Windows平台),并把文件加入我们Java工程的引用库中:
然后运行我们的Java代码,我们就可以看到使用JNI技术后来自Native层的问候:

关于一些基础的Java问题的解答(七)的更多相关文章

  1. 关于一些基础的Java问题的解答(一)

    学习一门语言基础是非常重要的,因此本文总结了一些常见的Java基础问题的解答,希望可以帮到大家. 1. 九种基本数据类型的大小,以及他们的封装类. 9种基本数据类型 基本类型 包装类型 大小 bool ...

  2. 关于一些基础的Java问题的解答(六)

    26. ThreadPool用法与优势 ThreadPool即线程池,它是JDK1.5引入的Concurrent包中用于处理并发编程的工具.使用线程池有如下好处: 降低资源消耗:通过重复利用已创建的线 ...

  3. 关于一些基础的Java问题的解答(四)

    16. Java面向对象的三个特征与含义 java中的面向对象的三大基本特征分别是:封装.继承.多态: 封装:把过程和数据包围起来,对数据的访问只能通过已定义的界面,主要是方便类的修改 继承:对象的一 ...

  4. 关于一些基础的Java问题的解答(五)

    21. 实现多线程的两种方法:Thread与Runable 在Java中实现多线程编程有以下几个方法: 1.继承Thread类,重写run方法 public class Test { public s ...

  5. 关于一些基础的Java问题的解答(三)

    11. HashMap和ConcurrentHashMap的区别   从JDK1.2起,就有了HashMap,正如上一个问题所提到的,HashMap与HashTable不同,不是线程安全的,因此多线程 ...

  6. 关于一些基础的Java问题的解答(二)

    6. Hashcode的作用 官方对于hashCode的解释如下: Whenever it is invoked on the same object more than once during an ...

  7. 黑马程序员:Java基础总结----java注解

    黑马程序员:Java基础总结 java注解   ASP.Net+Android+IO开发 . .Net培训 .期待与您交流! java注解 lang包中的基本注解 @SuppressWarnings ...

  8. java面试题—精选30道Java笔试题解答(二)

    摘要: java面试题-精选30道Java笔试题解答(二) 19. 下面程序能正常运行吗() public class NULL { public static void haha(){ System ...

  9. Java基础:Java的四种引用

    在Java基础:java虚拟机(JVM)中,我们提到了Java的四种引用.包括:强引用,软引用,弱引用,虚引用.这篇博客将详细的讲解一下这四种引用. 1. 强引用 2. 软引用 3. 弱引用 4. 虚 ...

随机推荐

  1. Mego开发文档 - 事务

    事务 事务允许以原子方式处理多个数据库操作.如果事务已提交,则所有操作都已成功应用于数据库.如果事务回滚,则没有任何操作应用于数据库. 默认行为 默认情况下,如果数据库提供程序支持事务,则单次的提交操 ...

  2. sts 和 lombok

    1.安装lombok.jar到sts.exe所在目录 如果是eclipse,需要放到eclipse.exe所在目录,同理myeclipse. 2.修改sts.ini配置使用lombok 如果是ecli ...

  3. python 爬取百度翻译进行中英互译

    感谢RoyFans 他的博客地址http://www.cnblogs.com/royfans/p/7417914.html import requests def py(): url = 'http: ...

  4. linux centos6.8 下安装mysql 步骤

    安装环境:vmware12.centos6.8.centos中配置阿里云数据元 1.下载mysql 运行: sudo yum -y install mysql-server 如果下载失败,可以卸载重新 ...

  5. MongoDB GridFS 存储大文件

    我们经常会遇到这样的场景:上传/下载文件. 有两种思路可以解决这个问题: (1)将文件存储在服务器的文件系统中: (2)将文件存储在数据库中. 如果我们选择(2),那么我们可以使用MongoDB Gr ...

  6. Python系列-python函数

    函数是组织好的,可重复使用的,用来实现单一,或相关联功能的代码段. 函数能提高应用的模块性,和代码的重复利用率.你已经知道Python提供了许多内建函数,比如print().但你也可以自己创建函数,这 ...

  7. Stanford依存句法关系解释

    ROOT:要处理文本的语句 IP:简单从句 NP:名词短语 VP:动词短语 PU:断句符,通常是句号.问号.感叹号等标点符号 LCP:方位词短语 PP:介词短语 CP:由'的'构成的表示修饰性关系的短 ...

  8. python3全栈开发-面向对象、面向过程

    一. 什么是面向对象的程序设计及为什么要有它 1.面向过程 面向过程的程序设计:核心是过程二字,过程指的是解决问题的步骤,即先干什么再干什么......面向过程的设计就好比精心设计好一条流水线,是一种 ...

  9. zoj 3981 Balloon Robot

    https://vjudge.net/problem/ZOJ-3981 题意: 有m个座位,其中n个队伍坐在这些位置上,一个队伍一个座位.当一个队A了题之后,他们们会得到气球,假设他们在a时刻A题,但 ...

  10. $rootscope说明

    scope是AngularJS中的作用域(其实就是存储数据的地方),很类似JavaScript的原型链 .搜索的时候,优先找自己的scope,如果没有找到就沿着作用域链向上搜索,直至到达根作用域roo ...