摘自：https://zhidao.baidu.com/question/489562987146637292.html

下面程序的运行结果是什么？

public class Dervied extends Base {

private String name = "dervied";

    public Dervied() {
        tellName();
        printName();
    }

    public void tellName() {
        System.out.println("Dervied tell name: " + name);
    }

    public void printName() {
        System.out.println("Dervied print name: " + name);
    }

    public static void main(String[] args){
        new Dervied(); 
    }
}

class Base {

    private String name = "base";

    public Base() {
        tellName();
        printName();
    }

    public void tellName() {
        System.out.println("Base tell name: " + name);
    }

    public void printName() {
        System.out.println("Base print name: " + name);
    }
}

输出：



Dervied tell name: null
Dervied print name: null
Dervied tell name: dervied
Dervied print name: dervied

关键点：问题出在构造函数的地方，对于java中的extends，每个子类构造方法的第一条语句都是隐含的调用super，而且如果父类没有这种形式的构造函数就会报错。

详细解释： 

1，首先先说一下父类与子类方法覆写（overrider）相关的概念，覆写在java中主要是通过方法表来完成，java中每个类型（Class）中都存在一个方法表，其中存放java类型的实例方法（public/protected），static方法属于静态方法，和类型相关，不属于javad实例方法。private和default属于私有方法，private/default修饰的方法不进入类型的方法表。

2，接下来说一下和方法，其中称为类初始化方法，称为对象实例化方法，该问题就与方法息息相关。 

方法: 

Java在进行对象创建时首先进行类型加载，如果Class类型存在父类型，则需要先加载父类完成以后再加载子类型。并且对static变量进行初始化操作，对static变量或者static代码块初始化的逻辑就封装在方法中。 

Java类型初始化过程中对static变量的初始化操作依赖与对static变量的赋值语句的前后关系，static语句块与static变量声明存在位置关系，java编译器与static变量的赋值位置有关。 

方法: 

Java对象在进行实例化时，首先会进行父类的实例化操作，然后再进行子类的实例化操作。该部分操作封装在方法中，并且子类的方法中会首先对父类方法的调用。 

Java对象实例化过程中对实例域的初始化赋值操作全部在方法中进行，方法显式的调用父类的方法，实例域的声明语句以及实例初始化语句块存在位置关系，方法以构造方法作为结束。

接下来回到这道题上来，启动java虚拟机： 

第一步：加载应用用到的类，加载顺序为Base–>Dervied，这里涉及到方法的调用，但是当前类型中没有static域或者是static{}，所以方法不再讨论。

第二步：对象实例化操作，首先我们new Dervied();，这样就触发对Dervied.的调用，但是根据以上知识（“并且子类的方法中会首先对父类方法的调用”）我们可以知道，Dervied.首先会调用到Base.方法，所以现在我们调用的方法是Base.，Base.方法中，首先是对name域（父类Base）进行初始化，然后调用tellName()方法，因为子类以及覆写了tellName()方法，所以tellName方法实际调用为Dervied.tellName()方法，tellName方法要打印name域（子类Dervied）的值，但是当前Dervied对象中的name域还没有被初始化，所以打印出来的值为null。printName()方法执行与tellName()方法一致。

第三步：Base.方法返回到Dervied.方法中，紧接着对name域（子类Dervied）进行初始化操作，然后调用子类Dervied的tellName方法和printName方法，name域（子类Dervied）已经初始化完成，所以能正确打印出来。

 
编写一个控制台应用程序，完成下列功能，并写出运行程序后输出的结果。
1) 创建一个类A，在A中编写一个可以被重写的带int类型参数的方法MyMethod，并在该方法中输出传递的整型值加10后的结果。
2) 再创建一个类B，使其继承自类A，然后重写A中的MyMethod方法，将A中接收的整型值加50，并输出结果。
3) 在Main方法中分别创建类A和类B的对象，并分别调用MyMethod方法。
 
【解答】
 
 
using System;
public class A
{
    public virtual void MyMethod(int num)
    {
        num += 10;
        Console.WriteLine(num);
    }
}
public class B : A
{
    public override void MyMethod(int num)
    {
        num += 50;
        Console.WriteLine(num);
    }
}
class MainClass
{
    public static void Main()
    {
        A newa = new A();
        newa.MyMethod(2);
        B newb = new B();
        newb.MyMethod(2);
        Console.ReadLine();
    }
} 
 

输出结果：
12
52

class A {
	static {
		System.out.print("父类静态成员  ");
	}
	//初始化块，也即是非static语句块
	{
		System.out.print("父类非静态成员  ");
	}

	public A() {
		System.out.print("父类构造方法  ");
	}
}

class B extends A {
	static {
		System.out.print("子类静态成员  ");
	}
	{
		System.out.print("子类非静态成员  ");
	}

	public B() {
		System.out.print("子类构造方法  ");
	}
}

public class Test {

	public static void main(String[] args) {
		A ab = new B();
		System.out.println("\n---------------------------------");
		ab = new B();
	}
}

运行结果

结果说明
创建对象时调用顺序如下：
①先初始化父类和子类的静态成员。
②父类非静态成员。
③父类构造方法。
④子类非静态成员。
⑤子类构造方法。
另外需要注意的是，加static的语句块在加载类时就加载初始化了；不加static的语句块即初始化块，是在创建类的对象的时候才加载，在调用构造方法之前要先调用初始化块。

先说说背景。

这几天项目中遇到一个签名的算法，没有相应的python库，自己去实现又比较费时间。

中间的过程是这样的。

经过查找发现这个开源项目本身支持一个JavaScript的SDK，里面已经实现了必须的功能。大概试了一下写了几个简单的js脚本，就实现了所需要的基本功能。既然js脚本很容易就实现了需要的功能，为了方便（其实是因为我懒，懒得去自己用python再实现内容转换和签名的算法了）就决定使用python调用已经写好的js脚本，获取脚本的输出来做为结果，在解析整理下就可以了。

思路有了，下面就是如何用python的实现程序的调用和获取结果了。

看了下有些人使用os模块提供的函数，类似os.system, os.spawn族的函数（其实就是Linux下相应的C的API）。但是觉得太底层了，而且有些还只能在特定的平台上使用。就没有使用这种方法。转而找到了subprocess库（终于进入正题了）。

去官方的文档看了下描述，发现就是用来代替os.system，os.spawn族之类的


This module intends to replace several older modules and functions:

os.system

os.spawn*


我的需求很容易就满足了，使用subproces的run方法获取输出和返回值。

然后，又好奇了两个问题：

第一，如何实时的获取程序的输出。当程序会运行相当长一段时间，或者有很大量的输出的时候

第二，如何改变程序的运行环境

首先说第一个问题。我现在官方文档上找了下。发现似乎可以使用Popen类来实现。文档里面说到的跟输出相关的有两个，一个是Popen.communicate方法，一个是Popen的stdout属性。两者的描述很容易再官文上找到就不贴了。大概说一下就是官方推荐使用communicate方法来跟运行的子进程进行交互。

我就试了一下communicate方法，包括timeout参数。

发现下面的几点：

1.communicate在不设置timeout的时候，会一直block，直到子进程运行完。

2.communicate再设置了timeout参数，并且捕获了TimeoutExpired事件之后，获取的out是空的，并且子程序还在继续运行没有收到影响

总结一下就是，使用communicate你必须等到程序运行完之后才能够一次性获取全部的输出。运行过程中，程序的输出是暂存在内存里面的。所以在communicate的描述后面特别说明了，如果输出较大的时候，不要使用这个函数。

之后，就看了stdout，stdin之类的属性，也发现一个警告说可能引起死锁之类的。然后Google了一下。发现还是很多人在用stdout这个属性的。当然用法就是把它当作一个打开的文件对象。使用readline方法不断获取程序的输出，但是在每个readline的调用中，依然是block的。

总结一下，关于第一个问题。如果子进程的运行时间有限，输出的内容也比较少的情况下，使用communicate方法比较合适。还有一种情况就是要限制子进程的运行时间，这个时候可以用communicate的timeout参数，并在timeout时间的处理中kill掉子进程。如果程序运行时间长，需要实时的获取输出，或者输出比较多的情况下，就使用stdout这样的属性，不断调用readline获取输出就好。

然后关于第二个问题。其实使用Popen类就可以完美解决，Popen类的cwd参数用来设定子进程的工作目录，还有env参数用来设定子进程运行的环境变量。基本上就可以满足我们的使用中的大部分场景了。

今天就先好奇这些吧，后面有时间遇到再继续挖。