技术与架构中语言章(2)之高级计算机语言详解

前言

为什么把高级计算机语言特别写一章节了。因为它有很多特性很多分类，有很多细节，有很多高级计算机语言。他很复杂。看鸟菜如何把这些分类，特性，细节，复杂的因素简单的一一道来

脚本语言

想知道这个语言是不是脚本语言，很简单。只要能再命令行编码，并运行就好

muqi@lenovo:~$ python
Python 2.7.12 (default, Dec  4 2017, 14:50:18) 
[GCC 5.4.0 20160609] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> 1+1
2

可以直接运行编码的文件

if __name__ == '__main__':
       print(1+1)

[email protected]://Test$ python test.py 
2

反例

java的编码文件是.java结尾。必须通过javac编译这个文件。生成.class文件。

静态类型与动态类型,弱类型与强类型

类型是指变量的类型，或者方法返回的类型

声明

是只类，方法，字段定义的地方，有那些特征。

public static final transient  Integer niaocai = 1;

属性niaocai类型是Integer，并且初始化为1，声明为静态（static），不可变（final），不可序列化（transient）

赋值

public static  transient  Integer niaocai = 1;

public void nc(){
	this.niaocai = 2;
}

属性 niaocai 初始化为1，如果nc方法被调用，会重新赋值为2

动态类型

变量和方法的返回不需要声明具体的类型，只要声明是变量或方法，
语言变量可以不需要声明
变量的类型是由变量值的类型决定的，方法的类型由具体返回的类型决定
变量的值可以改成不同的类型

num = "niaocaim"
class Niaocai:
        num = "niaocai" # 没有self，通过等号直接识别成变量，并没有声明成变量
        def __init__(self):
                print("num" , self.num ,  type(self.num))
                self.num = 1          # self.num 直接定义变量，不用声明
                print("num" , self.num ,  type(self.num)) # 变量的类型是由变量值的类型决定的
                self.num = "num"      # 变量的值可以改成不同的类型
                print("num" , self.num ,  type(self.num)) # 变量的类型是由变量值的类型决定的
                print("num" , num ,  type(num))

if __name__ == '__main__':
        Niaocai()

num niaocai <class 'str'>
num 1 <class 'int'>
num num <class 'str'>
num niaocaim <class 'str'>

静态类型

变量必须声明具体的类型
变量声明之后，不能改变变量的类型。
变量除了声明类型之外，还可以加上其他声明

@Test
public void ttt (){
	Integer num = 2; //Integer是具体类型 变量必须声明具体的类型
	System.out.println(num.getClass().getName());

	num = "str" ;// 此处异常 变量声明之后，不能改变变量的类型
}

java.lang.Integer

java.lang.Error: 无法解析的编译问题：
	类型不匹配：不能从 String 转换为 Integer
	at com.niaocaia.blog.spring.core.ordere.OrdereTest.ttt(OrdereTest.java:58)

强类型

不同类型之间，不能做运算

>>> "1"+2
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: cannot concatenate 'str' and 'int' objects

弱类型

不同类型之间，可以做运算。注意不同语言之间，语言的版本之间，整数与字符进行运算是有区别

JavaScript

1.1+"12"；var d = 1.1+"12";typeof(d);
1.112
"string"

把字符转int

>>> 1.1+"12"
13.1

把字符转成byte

>>> 1+'1'
50

参考资料语言类型

总结

如果纯粹的静态类型与动态类型,弱类型与强类型中选择语言。鸟菜啊会优先选择静态类型，强类型的组合，其次选择静态类型，弱类型的组合。弱类型代码不小心，可能出错。不同类型之间可以运算感觉怪怪的。

解释与编译语言

编译语言：

高级语言写的代码，在平台（操作系统，虚拟机）编译之后，可以直接被平台执行的语言。就是编译语言
虚拟机可以把执行的代码编译成操作系统直接运行的机械码，也可以称之为编译语言。jvm的JIT模块就是负责把class代码编译成二进制机械码

解释语言：

动态语言是基于其他语言实现，代码是由实现语言解析执行。

鸟菜啊基于jvm给大家模拟什么是编译语言，写一个非常简单的解释语言，暂且命名为niaocai，只实现加减乘除

    @Test
    public void explain() throws Exception {
	String s = "12+24*12/12";

	List<String> list = splitStr(s);
	System.out.println(list.toString());
	List<String> newList = new ArrayList<>();
	String str = list.get(0), newStr = null;
	boolean d = true;
	for(int i = 1 ; i<list.size() ; i++){
	    newStr = list.get(i);
	    if(newStr.length() != 1){
		if(i == 1){
		    newList.add(str);
		}
		newList.add(newStr);
		str = list.get(++i);
		d = true;
		continue;
	    }
	    if(newStr.equals("*")){
		str = (Long.valueOf(str)*Long.valueOf(list.get(++i)))+"";
		d = false;
	    }else if(newStr.equals("/")){
		str = (Long.valueOf(str)/Long.valueOf(list.get(++i)))+"";
		d = false;
	    }else{
		if(i == 1){
		    newList.add(str);
		}
		newList.add(newStr);
		str = list.get(++i);
		d = true;
	    }
	}
	if(!d){
	    newList.add(str);
	}
	Long re = Long.valueOf(newList.get(0)),two;
	String one  ;
	for(int i = 1 ; ;){
	    one = newList.get(i);
	    two = Long.valueOf(newList.get(++i));
	    if(one.equals("+")){
		re = re+two;
	    }else if(one.equals("-")){
		re = re-two;
	    }
	    if(i == newList.size()-1){
		break;
	    }
	    i++;
	}
	System.out.println(  re );
    }

总结

大家通过观察会发现，解释性语言的性能绝对比编译行语言的性能要差。不知道为什么有人可以得除一下结论 PayPal为什么从Java迁移到Node.js，性能提高一倍，文件代码减少44% 是什么让Node.js比Java更快？为什么NodeJS这么快？

node.js 与java都是c与c++实现的。node.js是解释语言，java是基于虚拟机的编译语言，java的性能绝对要比node.js快，这点是无需置疑的。为什么上面的测试会出现异常结果

jvm默认启动模式是client，那么模式就是解释模式。
解释性语言在简单测试的时候的性能比基于虚拟机的解释性面向对象，静态类型，强类型的语言性能要好

重要的事情说三遍

基于虚拟机的解释性面向对象，静态类型，强类型的语言的性能要差于直接解释性解释语言性能要差于基于虚拟机的编译语言虚拟机的编译语言的性能要差于直接编译语言

上面的话是常识，在做语言性能测试的时候，先弄懂测试语言的类型是编译还是解释，是直接还是基于虚拟机。请不好混淆测试。解释类型的python性能没有基于虚拟机编译类型的java好，java性能绝对没有c++好，这是常识。同样解释类型的node的性能会比java要好吗？

测试之后，得到测试结果同时请提供

测试环境
测试配置
测试代码

如果无法提供上面内容，测试结果无效，纯粹耍流氓

记得关于姜承晓大师回答一位提问题者遇到性能方面的事情

地点：忘记

时间：忘记

人物：提问者，姜大师

提问题：@姜承晓姜博士，我这里有一条sql语句执行很慢，找到不原因.说了一大堆。怎么解决

姜大师：没有提供环境，没有提供参数，我怎么知道。在特性场景下，值需要修改一些配置，我可以让这条sql的性能上升3倍，也可以使之下降3倍。

请技术人员，认真，谨慎，负责任的对待技术，对待写出来的博客 写上面的模拟的解释代码，查资料一个多小时，写了一个多小时

面向对象与面向过程

面向对象是基于面向过程发展过来的，不想上面的类型，他们之间是对立的

面向对象比面向过程先进的要素是

必须有实例，对象，class的概念，并且明确区分。

对象

能够描述出来的一切

比如灵魂，外星人，去年诺贝尔物理学奖获得者，证实的引力波。

对象之间通过指标来区别。指标区分出来点就是特征

比如老人与小孩的区别就是年龄这指标，大于60就是老人，小于10岁就小孩

对象不具有任何可识别性

对象不具有具体的值

描述出来的，通过指标区别特征并且定义，识别方式通过特征来识别，即对象

实例

具有识别性的对象，就是实例

举例

大家都知道任何颜色是由三个基本颜色组成红，青，黄。颜色就是可以描述的红，青，黄是特征

    public class Colour{//
	
	private int red;
	
	private int yellow;
	
	private int young;

	private String calourName;
	
	public Colour(int red, int yellow, int young) {
	    this.red = red;
	    this.yellow = yellow;
	    this.young = young;
	    
	    this.calourName = "black";//这段计算过程
	}

	public String getCalourName(){
	    return this.calourName;
	}

	public int getRed() {
	    return red;
	}

	public int getYellow() {
	    return yellow;
	}

	public int getYoung() {
	    return young;
	}
	
    }

实例现在为红，黄，青设了具体的值，那么在这一个刻开始。就出来一个实例了。

Colour black = new Colour(1,1,1);

在此抱歉，因为时间与章副的关系，无法给大家详细描述面向对象三大要素。鸟菜真的想口述，如果要详细描述真的需要一，两天的工作日的时间。

总结

通俗一点说：在java世界中，使用class关键字定义的就是类，通过new关键字创建的对象，就是这个对象的实例。能够正确的理解并描述声明，赋值，对象，实例，有利于工作中的交流。

总结

面向对象语言必须需要虚拟机。只有虚拟机的编译特性才能完善，完整的解决继承，多态，封装等问题，并有一定的性能。

脚本语言必然是解释语言，动态语言，面向过程，半面向对象，弱类型居多

静态语言必然是面向对象(c除外)，静态语言，可以解释与编译选择的语言。如果选择解释，那性能实在太差了。所以静态语言大多都是编译语言，