微信搜索【Python猫】，设为星标，第一时间接收优质文章
 
 
 
 
0、前言
 
 
我在上一篇文章中分析了 为什么 Python 没有 void 类型 的话题，在文章发布后，有读者跟我讨论起了另一个关于类型的问题，但是，我们很快就出现了重大分歧。
 
 
我们主要的分歧就在于：Python 到底是不是强类型语言？我认为是，而他认为不是。
 
 
他写了一篇很长的文章《谁告诉的你们Python是强类型语言！站出来，保证不打你！》，专门重申了他的观点，但可惜错漏百出。
 
 
我曾有想法要写写关于 Python 类型的问题，现在借着这个机会，就来系统地梳理一下吧。
 
 
（PS：在我写作进行到差不多一半的时候，微信读者群里恰好也讨论到“强弱类型”的话题！在与大家讨论时，我的一些想法得到了验证，同时我也学到了很多新知识，所以本文的部分内容有群友们的功劳，特此鸣谢！）
 
 
1、动静类型与强弱类型
 
 
很多读者应该都熟悉动态类型与静态类型，但是很多人也会把它们跟强弱类型混为一谈，所以我们有必要先作一下概念上的澄清。
 
 
这两组类型都是针对于编程语言而言的，但关注的核心问题不同。
 
 
对于“动静类型”概念，它的核心问题是“什么时候知道一个变量是哪种类型”？
 
 
一般而言，在编译期就确定变量类型的是静态类型语言，在运行期才确定变量类型的则是动态类型语言。
 
 
例如，某些语言中定义函数“int func(int a){…}”，在编译时就能确定知道它的参数和返回值是 int 类型，所以是静态类型；而典型如 Python，定义函数时写“def func(a):…”，并不知道参数和返回值的类型，只有到运行时调用函数，才最终确定参数和返回值的类型，所以是动态类型
 
 
对于“强弱类型”概念，它的核心问题是“不同类型的变量是否允许隐式转化”？
 
 
一般而言，编译器有很少（合理）隐式类型转化的是强类型语言，有较多（过分）隐式类型转化的是弱类型语言。  
 
 
例如，Javascript 中的 "1000"+1会得到字符串“10001”，而 "1000"-1则会得到数字 999，也就是说，编译器根据使用场合，对两种不同类型的对象分别做了隐式的类型转化，但是相似的写法，在强类型语言中则会报类型出错。（数字与字符串的转化属于过分的转化，下文会再提到一些合理的转化。）
 
 
按照以上的定义，有人将常见的编程语言画了一张分类图：
 
 
 
按强弱类型维度划分，可以归纳出：
 
 
 
强类型：Java、C#、Python、Ruby、Erlang（再加GO、Rust）……
 
 
弱类型：C、C++、Javascript、Perl、PHP、VB……
 
 
2、过去的强弱类型概念
 
 
动静类型的概念基本上被大家所认可，然而，强弱类型的概念在问答社区、技术论坛和学术讨论上却有很多的争议。此处就不作罗列了。
 
 
为什么会有那么多争议呢？
 
 
最主要的原因之一是有人把它与动静类型混用了。
 
 
最明显的一个例子就是 Guido van Rossum 在 2003 年参加的一个访谈，它的话题恰好是关于强弱类型的（Strong versus Weak Typing）：
 
 
 
但是，他们谈论的明显只是动静类型的区别。
 
 
访谈中还引述了 Java 之父 James Gosling 的话，从他的表述中也能看出，他说的“强弱类型”其实也是动静类型的区分。
 
 
另外还有一个经典的例子，C 语言之父 Dennis Ritchie 曾经说 C 语言是一种“强类型但是弱检查”的语言。如果对照成前文的定义，那他其实指的是“静态类型弱类型”。
 
 
为什么这些大佬们会有混淆呢？
 
 
其实原因也很简单，那就是在当时还没有明确的动静类型与强弱类型的概念之分！或者说，那时候的强弱类型指的就是动静类型。
 
 
维基百科上给出了 1970 年代对强类型的定义，基本可以还原成前文提到的静态类型：
 
 
 
  
In 1974, Liskov and Zilles defined a strongly-typed language as one in which "whenever an object is passed from a calling function to a called function, its type must be compatible with the type declared in the called function."[3] In 1977, Jackson wrote, "In a strongly typed language each data area will have a distinct type and each process will state its communication requirements in terms of these types."[4]
 
 
 
 
前面几位编程语言之父应该就是持有类似的观念。
 
 
不过，大佬们也意识到了当时的“强弱类型”概念并不充分准确，所以 Dennis Ritchie 才会说成“强类型但是弱检查”，而且在访谈中，Guido 也特别强调了 Python 不应该被称为弱类型，而应该说是运行时类型（runtime typing） 。
 
 
但是在那个早期年代，基本上强弱类型就等同于动静类型，而这样的想法至今仍在影响着很多人。
 
 
3、现在的强弱类型概念
 
 
早期对于编程语言的分类其实是混杂了动静与强弱两个维度，但是，它们并不是一一对应重合的关系，并不足以表达编程语言间的区别，因此就需要有更为明确/丰富的定义。
 
 
有人提出了“type safety”、“memory safety”等区分维度，也出现了静态检查类型和动态检查类型，与强弱类型存在一定的交集。
 
 
直到出现 2004 年的一篇集大成的学术论文《Type Systems》（出自微软研究院，作者 Luca Cardelli），专门研究编程语言的不同类型系统：
 
 
 
论文中对于强弱检查（也即强弱类型）有一个简短的归纳如下：
 
 
 
Strongly checked language: A language where no forbidden errors can occur at run time (depending on the definition of forbidden error).
 
 
Weakly checked language: A language that is statically checked but provides no clear guarantee of absence of execution errors.
 
 
其关键则是程序对于 untrapped errors 的检查强度，在某些实际已出错的地方，弱类型程序并不作捕获处理，例如 C 语言的一些指针计算和转换，而《C 程序员十诫》的前几个都是弱类型导致的问题。
 
 
 
论文对于这些概念的定义还是比较抽象的，由于未捕获的错误（untrapped errors）大多是由于隐式类型转换所致，所以又演化出了第一节中的定义，以隐式类型转换作为判断标准。
 
 
如今将“对隐式类型转换的容忍度”作为强弱类型的分类标准，已经是很多人的共识（虽然不够全面，而且有一些不同的声音）。
 
 
例如，维基百科就把隐式类型转换作为弱类型的主要特点之一：
 
 
 
  
A weakly typed language has looser typing rules and may produce unpredictable results or may perform implicit type conversion at runtime.
 
 
 
 
例如，以 Python 为例，社区的主流看法认为它是强类型语言，而判断的标准也是看隐式类型转换。
 
 
例子有很多，比如 Python 官方的 wiki，它专门回答了Why is Python a dynamic language and also a strongly typed language ，给出了 4 个答案，为 Python 的“动态强类型”定性：
 
 
 
再比如，在《流畅的Python》第11章的杂谈中，也专门提到了强弱类型的分类。（它的用语是“很少隐式类型转换”，算是比较严谨的，但是也错误地把 C++ 归为了强类型。）
 
 
4、Python 是不是强类型语言？
 
 
关于“Python 是否属于强类型”话题，在主流观点之外，还存在着不少误解的看法。
 
 
一方面的原因有些人混用了强弱类型与动静类型，这有历史的原因，前面已经分析了。
 
 
另外还有一个同样重要的原因，即有人把弱类型等同于“完全没有隐式类型转换”了，这种想法并不对。
 
 
事实上，强弱类型的概念中包含着部分相对主义的含义，强类型语言中也可能有隐式类型转换。
 
 
比如，Rust 语言为了实现“内存安全”的设计哲学，设计了很强大的类型系统，但是它里面也有隐式类型转换（自动解引用）。
 
 
问题在于：怎么样的隐式类型转换是在合理范围内的？以及，某些表面的隐式类型转换，是否真的是隐式类型转换？
 
 
回到 Python 的例子，我们可以分析几种典型的用法。
 
 
比如，"test"*3这种字符串“乘法”运算，虽然是两种类型的操作，但是并不涉及隐式类型转换转化。
 
 
比如，x=10; x="test"先后给一个变量不同类型的赋值，表面上看 x 的类型变化了，用 type(x) 可以判断出不同，但是，Python 中的类型是跟值绑定的（右值绑定），并不是跟变量绑定的。
 
 
变量 x 准确地说只是变量名，是绑定到实际变量上的一个标签，它没有类型。type(x) 判断出的并不是 x 本身的类型，而是 x 指向的对象的类型，就像内置函数 id(x) 算出的也不是 x 本身的地址，而是实际的对象的地址。
 
 
比如，1 + True这种数字与布尔类型的加法运算，也没有发生隐式类型转换。因为 Python 中的布尔类型其实是整型的子类，是同一种类型！（如果有疑问，可查阅 PEP-285）
 
 
再比如，整数/布尔值与浮点数相加，在 Python 中也不需要作显式类型转换。但是，它的实现过程其实是用了数字的__add__()方法，Python 中一切皆对象，数字对象也有自己的方法。（其它语言可不一定）
 
 
也就是说，数字间的算术运算操作，其实是一个函数调用的过程，跟其它语言中的算术运算有着本质的区别。
 
 
另外，不同的数字类型虽然在计算机存储层面有很大差异，但在人类眼中，它们是同一种类型（宽泛地分），所以就算发生了隐式类型转换，在逻辑上也是可以接受的。
 
 
最后，还有一个例子，即 Python 在 if/while 之后的真值判断，我之前分析过它的实现原理，它会把其它类型的对象转化成布尔类型的值。
 
 
但是，它实际上也只是函数调用的结果（__bool__() 和 __len__()），是通过计算而得出的合理结果，并不属于隐式的强制类型转换，不在 untrapped errors 的范畴里。
 
 
所以，严格来说，前面 5 个例子中都没有发生类型转换。 浮点数和真值判断的例子，直观上看是发生了类型转换，但它们其实是 Python 的特性，是可控的、符合预期的、并没有对原有类型造成破坏。
 
 
退一步讲，若放宽“隐式类型转换”的含义，认为后两个例子发生了隐式类型转换，但是，它们是通过严谨的函数调用过程实现的，也不会出现 forbidden errors，所以还是属于强检查类型。
 
 
5、其它相关的问题
 
 
前文对概念的含义以及 Python 中的表现，作了细致的分析。接下来，为了逻辑与话题的完整性，我们还需要回答几个小问题：
 
 
（1）能否以“隐式类型转换”作为强弱类型的分类依据？
 
 
明确的分类定义应该以《Type Systems》为准，它有一套针对不同 error 的分类，强弱类型其实是对于 forbidden errors 的处理分类。隐式类型转换是其明显的特征，但并不是全部，也不是唯一的判断依据。
 
 
本文为了方便理解，使用这个主要特征来划分强弱类型，但是要强调，强类型不是没有隐式类型转换，而是可能有很少且合理的隐式类型转换。
 
 
（2）假如有其它解释器令 Python 支持广泛的隐式类型转换，那 Python 还是强类型语言么？
 
 
语言的标准规范就像是法律，而解释器是执法者。如果有错误的执法解释，那法律还是那个法律，应该改掉错误的执法行为；如果是法律本身有问题（造成了解释歧义和矛盾，或者该废弃），那就应该修改法律，保证它的确定性（要么是强类型，要么是弱类型）。
 
 
（3）为什么说 Javascript 是弱类型？
 
 
因为它的隐式类型转换非常多、非常复杂、非常过分！比如，Javascript 中123 + null结果为 123，123 + {}结果为字符串“123[object Object]”。
 
 
另外，它的双等号“==”除了有基本的比较操作，还可能发生多重的隐式类型转换，例如true==['2']判断出的结果为 false，而true==['1']的结果是 true，还有[]==![]和[undefined]==false的结果都为 true……
 
 
（4）C++ 是不是弱类型语言？
 
 
前文提到《流畅的Python》中将 C++ 归为强类型，但实际上它应该被归为弱类型。C++ 的类型转换是个非常复杂的话题，@樱雨楼 小姐姐曾写过一个系列文章做了系统论述，文章地址：如何攻克 C++ 中复杂的类型转换？、详解 C++ 的隐式类型转换与函数重载！、谁说 C++ 的强制类型转换很难懂？
 
 
6、小结
 
 
强弱类型概念在网上有比较多的争议，不仅在 Python 是如此，在 C/C++ 之类的语言更甚。
 
 
其实在学术上，这个概念早已有明确的定义，而且事实上也被很多人所接纳。
 
 
那些反对的声音大多是因为概念混用，因为他们忽略了另一种对语言进行分类的维度；同时，还有一部分值得注意的原因，即不能认为强类型等于“完全无隐式类型转换”或“只要没有xxx隐式类型转换”。
 
 
本文介绍了社区中对 Python 的主流分类，同时对几类疑似隐式类型转换的用法进行了分析，论证出它是一种强类型语言。
 
 
文章体现了作者一贯的刨根问底精神，这是“Python为什么”系列文章的风格，如果你喜欢本文，欢迎订阅关注！
 
 
相关链接
 
 
[1] 谁告诉的你们Python是强类型语言！站出来，保证不打你！: https://blog.csdn.net/nokiaguy/article/details/108218260
 
 
[2] Strong versus Weak Typing: https://www.artima.com/intv/strongweak.html
 
 
[3] https://en.wikipedia.org/wiki/Strong_and_weak_typing#cite_note-2
 
 
[4] https://en.wikipedia.org/wiki/Strong_and_weak_typing#cite_note-3
 
 
[5] Type Systems: http://lucacardelli.name/Papers/TypeSystems.pdf
 
 
[6] C 程序员十诫: http://doc.cat-v.org/henry_spencer/ten-commandments
 
 
[7] Why is Python a dynamic language and also a strongly typed language: https://wiki.python.org/moin/Why%20is%20Python%20a%20dynamic%20language%20and%20also%20a%20strongly%20typed%20language
 
 
[8] PEP-285: https://github.com/chinesehuazhou/peps-cn/blob/master/StandardsTrack/285--%E6%B7%BB%E5%8A%A0%E5%B8%83%E5%B0%94%E7%B1%BB%E5%9E%8B.md
 
 
[9] Type Systems: http://lucacardelli.name/Papers/TypeSystems.pdf
 
 
[10] Python为什么: https://github.com/chinesehuazhou/python-whydo
 
 
 
 
优质文章，推荐阅读：
 
 
Python 编程语言的核心是什么？
 
 
漫画：如何分析运行中的 Python 程序？
 
 
2019 年 10 大顶级 Python 支持库
 
 
Python——gRPC详解及实战避坑方案(下)
 
 
 

 
 

   
1高级语言和低级语言
2编译型和解释型
3动态语言和静态语言
4强类型定义语言和弱类型定义语言
 
 
 
 
　　在软考期间，学习了程序语言的翻译方式有多种：解释、和编译。那到底什么是解释和编译呢。另外编程语言除了编译型和解释型，还有静态语言、动态语言、强类型语言、弱类型语言。那么每种语言类型是什么样子的呢，下面让我们来看看吧。 
 　　但是在此之前，我们需要先了解一下计算机原因的发展史，从低级语言到高级语言的转变。
 
1、高级语言和低级语言：
 
　　最初的计算机程序都是用0和1的序列表示的，程序员直接使用的是机器指令，无需翻译，从纸带打孔输入即可执行得到结果。后来为了方便记忆，就将用0、1序列表示的机器指令都用符号助记，这些与机器指令一一对应的助记符就成了汇编指令，从而诞生了汇编语言。无论是机器指令还是汇编指令都是面向机器的，统称为低级语言。因为是针对特定机器的机器指令的助记符，所以汇编语言是无法独立于机器(特定的CPU体系结构)的。但汇编语言也是要经过翻译成机器指令才能执行的，所以也有将运行在一种机器上的汇编语言翻译成运行在另一种机器上的机器指令的方法，那就是交叉汇编技术。
 
　　高级语言是从人类的逻辑思维角度出发的计算机语言，抽象程度大大提高，需要经过编译成特定机器上的目标代码才能执行，一条高级语言的语句往往需要若干条机器指令来完成。高级语言独立于机器的特性是靠编译器为不同机器生成不同的目标代码(或机器指令)来实现的。那具体的说，要将高级语言编译到什么程度呢，这又跟编译的技术有关了，既可以编译成直接可执行的目标代码，也可以编译成一种中间表示，然后拿到不同的机器和系统上去执行，这种情况通常又需要支撑环境，比如解释器或虚拟机的支持，Java程序编译成bytecode，再由不同平台上的虚拟机执行就是很好的例子。所以，说高级语言不依赖于机器，是指在不同的机器或平台上高级语言的程序本身不变，而通过编译器编译得到的目标代码去适应不同的机器。从这个意义上来说，通过交叉汇编，一些汇编程序也可以获得不同机器之间的可移植性，但这种途径获得的移植性远远不如高级语言来的方便和实用性大。
 
　　大致了解了以上的内容，下面我们正式解释各种语言类型就简单多了。
 
2）编译型和解释型
 
　　我们先看看编译型，其实它和汇编语言是一样的：也是有一个负责翻译的程序来对我们的源代码进行转换，生成相对应的可执行代码。这个过程说得专业一点，就称为编译（Compile），而负责编译的程序自然就称为编译器（Compiler）。如果我们写的程序代码都包含在一个源文件中，那么通常编译之后就会直接生成一个可执行文件，我们就可以直接运行了。但对于一个比较复杂的项目，为了方便管理，我们通常把代码分散在各个源文件中，作为不同的模块来组织。这时编译各个文件时就会生成目标文件（Object file）而不是前面说的可执行文件。一般一个源文件的编译都会对应一个目标文件。这些目标文件里的内容基本上已经是可执行代码了，但由于只是整个项目的一部分，所以我们还不能直接运行。待所有的源文件的编译都大功告成，我们就可以最后把这些半成品的目标文件“打包”成一个可执行文件了，这个工作由另一个程序负责完成，由于此过程好像是把包含可执行代码的目标文件连接装配起来，所以又称为链接（Link），而负责链接的程序就叫……就叫链接程序链接程序（Linker）。链接程序除了链接目标文件外，可能还有各种资源，像图标文件啊、声音文件啊什么的，还要负责去除目标文件之间的冗余重复代码，等等，所以……也是挺累的。链接完成之后，一般就可以得到我们想要的可执行文件了。 
 
　　现在再看看解释型。噢，从字面上看，“编译”和“解释”的确都有“翻译”的意思，它们的区别则在于翻译的时机安排不大一样。打个比方：假如你打算阅读一本外文书，而你不知道这门外语，那么你可以找一名翻译，给他足够的时间让他从头到尾把整本书翻译好，然后把书的母语版交给你阅读；或者，你也立刻让这名翻译辅助你阅读，让他一句一句给你翻译，如果你想往回看某个章节，他也得重新给你翻译。 
 
　　两种方式，前者就相当于我们刚才所说的编译型：一次把所有的代码转换成机器语言，然后写成可执行文件；而后者就相当于我们要说的解释型：在程序运行的前一刻，还只有源程序而没有可执行程序；而程序每执行到源程序的某一条指令，则会有一个称之为解释程序的外壳程序将源代码转换成二进制代码以供执行，总言之，就是不断地解释、执行、解释、执行……所以，解释型程序是离不开解释程序的。像早期的BASIC就是一门经典的解释型语言，要执行BASIC程序，就得进入BASIC环境，然后才能加载程序源文件、运行。解释型程序中，由于程序总是以源代码的形式出现，因此只要有相应的解释器，移植几乎不成问题。编译型程序虽然源代码也可以移植，但前提是必须针对不同的系统分别进行编译，对于复杂的工程来说，的确是一件不小的时间消耗，况且很可能一些细节的地方还是要修改源代码。而且，解释型程序省却了编译的步骤，修改调试也非常方便，编辑完毕之后即可立即运行，不必像编译型程序一样每次进行小小改动都要耐心等待漫长的Compiling…Linking…这样的编译链接过程。不过凡事有利有弊，由于解释型程序是将编译的过程放到执行过程中，这就决定了解释型程序注定要比编译型慢上一大截，像几百倍的速度差距也是不足为奇的。 
 
　　编译型与解释型，两者各有利弊。前者由于程序执行速度快，同等条件下对系统要求较低，因此像开发操作系统、大型应用程序、数据库系统等时都采用它，像C/C++、Pascal/Object Pascal（Delphi）、VB等基本都可视为编译语言，而一些网页脚本、服务器脚本及辅助开发接口这样的对速度要求不高、对不同系统平台间的兼容性有一定要求的程序则通常使用解释性语言，如Java、JavaScript、VBScript、Perl、Python等等。 
 
　　但既然编译型与解释型各有优缺点又相互对立，所以一批新兴的语言都有把两者折衷起来的趋势，例如Java语言虽然比较接近解释型语言的特征，但在执行之前已经预先进行一次预编译，生成的代码是介于机器码和Java源代码之间的中介代码，运行的时候则由JVM（Java的虚拟机平台，可视为解释器）解释执行。它既保留了源代码的高抽象、可移植的特点，又已经完成了对源代码的大部分预编译工作，所以执行起来比“纯解释型”程序要快许多。而像VB6（或者以前版本）、C#这样的语言，虽然表面上看生成的是.exe可执行程序文件，但VB6编译之后实际生成的也是一种中介码，只不过编译器在前面安插了一段自动调用某个外部解释器的代码（该解释程序独立于用户编写的程序，存放于系统的某个DLL文件中，所有以VB6编译生成的可执行程序都要用到它），以解释执行实际的程序体。C#（以及其它.net的语言编译器）则是生成.net目标代码，实际执行时则由.net解释系统（就像JVM一样，也是一个虚拟机平台）进行执行。当然.net目标代码已经相当“低级”，比较接近机器语言了，所以仍将其视为编译语言，而且其可移植程度也没有Java号称的这么强大，Java号称是“一次编译，到处执行”，而.net则是“一次编码，到处编译”。呵呵，当然这些都是题外话了。总之，随着设计技术与硬件的不断发展，编译型与解释型两种方式的界限正在不断变得模糊。
 
3）动态语言和静态语言
 
　　通常我们所说的动态语言、静态语言是指动态类型语言和静态类型语言。 
 1）动态类型语言： 
 　　动态类型语言是指在运行期间才去做数据类型检查的语言，也就是说，在用动态类型的语言编程时，永远也不用给任何变量指定数据类型，该语言会在你第一次赋值给变量时，在内部将数据类型记录下来。Python和Ruby就是一种典型的动态类型语言，其他的各种脚本语言如VBScript也多少属于动态类型语言。 
 2）静态类型语言： 
 　　静态类型语言与动态类型语言刚好相反，它的数据类型是在编译其间检查的，也就是说在写程序时要声明所有变量的数据类型，C/C++是静态类型语言的典型代表，其他的静态类型语言还有C#、JAVA等。
 
4）强类型定义语言和弱类型定义语言
 
1）强类型定义语言： 
 　　强制数据类型定义的语言。也就是说，一旦一个变量被指定了某个数据类型，如果不经过强制转换，那么它就永远是这个数据类型了。举个例子：如果你定义了一个整型变量a,那么程序根本不可能将a当作字符串类型处理。强类型定义语言是类型安全的语言。 
 2）弱类型定义语言： 
 　　数据类型可以被忽略的语言。它与强类型定义语言相反, 一个变量可以赋不同数据类型的值。 
 　　强类型定义语言在速度上可能略逊色于弱类型定义语言，但是强类型定义语言带来的严谨性能够有效的避免许多错误。另外，“这门语言是不是动态语言”与“这门语言是否类型安全”之间是完全没有联系的！ 
 　　例如：Python是动态语言，是强类型定义语言（类型安全的语言）; VBScript是动态语言，是弱类型定义语言（类型不安全的语言）; JAVA是静态语言，是强类型定义语言（类型安全的语言）。

最近在B站看到一个UP主做了一期关于编程语言类型的讨论视频，激发了个人的兴趣，也有一些感触，在上网学习了一些相关知识后，写一写自己对于编程语言类型的一些理解。
 
强类型：
 
维基百科的解释：大致而言，“强类型”隐含着编程语言对容许混合情况出现加上了严格的限制，以避免代码以无效的数据使用方式编译或运行。例如，整数除法运算不可用于字符串；链表上的运算步骤不可用于数字。然而，这些限制的本质和效力是极易改变的。
 
个人的理解与看法：强类型每个变量和对象都必须声明类型，在编译时确定好类型，强类型语言的一个变量在定义后，如果不进行强制类型转化，其数据类型保持不变，不支持隐式类型转化。
 
举例：Java，Python是强类型语言。
 
弱类型：
 
弱类型语言其正好与强类型语言相反，它的变量与对象编译时不确定类型，执行时根据语义确定是哪种类型​​​​​​​，而且它的变量在定义后，是支持隐式类型转化的。
 
举例：C++是弱类型语言的代表。
 
通过代码来帮助理解：
 
首先是强类型语言代表：Java
 

public class Test {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		int x=1.2;
		System.out.println(x);
	
	}

}
 
结果是无法运行，发生了报错。
 
看一下C++：
 
#include <iostream> 
using namespace std;
int main(){
	int x=1.2;
	cout<<endl<<"x:"<<x<<endl;
}
 
编译运行通过，输出 x:1。
 
两门语言都是把一个浮点数1.2赋值给一个整形变量x，Java无法编译通过，因为它变量定义为int型，作为强类型语言，没有把1.2转化为一个int型数据。相反的C++把1.2做了一个隐式类型转化，转化为一个int型的1，成功赋值给了x。
 
动态类型：
 
编译的时候不知道每一个变量的类型，因为类型错误而不能做的事情是运行时错误​​​​​​​。
 
举例：Python，JavaScript是典型的动态类型语言。
 
静态类型：
 
编译的时候就知道每一个变量的类型，因为类型错误而不能做的事情是语法错误。​​​​​​​
 
举例：C，C++是典型的静态类型语言。
 
通过代码来帮助理解：
 
动态类型语言代表：Python
 
 
注意：首先定义了两个变量字符串型x，整型y。x+y因为Python是强类型语言，所以返回报错，String型无法与int型相加。而后把a定义为了int型数据，这时二者成功相加。变量a的数据类型在运行过程中发生变化由String变为int。这是动态类型语言的特点，在运行过程中确定变量类型。
 
静态类型语言代表：C++
 
#include <iostream> 
using namespace std;
int main(){
	int x=1;
	cout<<endl<<"x:"<<x<<endl;
	char x=1;
	cout<<endl<<"x:"<<x<<endl;
}
 
代码编译时在char x=1；行发出报错：[Error] conflicting declaration 'char x'。因为静态类型语言变量类型在编译时就已确定，char x=1；是错误语法。
 
最后放张图：
 
​​​​​​​
 
 
 
以上就是我自己对编程语言类型的一些基本理解，想继续深入学习网上有很多资料，知乎上也有相关的讨论，有兴趣的可以继续深入研究。
 
知乎：https://www.zhihu.com/question/19918532；
 
掘金：https://juejin.im/post/5d6dbceef265da039d32e94c；

　　在学习JavaScript的时候，说JavaScript是弱类型语言。那为什么JavaScript是弱类型语言呢。 
 　　但是在此之前我们需要了解一下弱类型语言，和强类型语言的区别。
 
强类型定义语言和弱类型定义语言
 
1）强类型定义语言：
 
　　强制数据类型定义的语言。也就是说，一旦一个变量被指定了某个数据类型，如果不经过强制转换，那么它就永远是这个数据类型了。举个例子：如果你定义了一个整型变量a,那么程序根本不可能将a当作字符串类型处理。强类型定义语言是类型安全的语言。 
 
2）弱类型定义语言：
 
　　数据类型可以被忽略的语言。它与强类型定义语言相反, 一个变量可以赋不同数据类型的值。 
 　　强类型定义语言在速度上可能略逊色于弱类型定义语言，但是强类型定义语言带来的严谨性能够有效的避免许多错误。另外，“这门语言是不是动态语言”与“这门语言是否类型安全”之间是完全没有联系的！ 
 　　例如：Python是动态语言，是强类型定义语言（类型安全的语言）; VBScript是动态语言，是弱类型定义语言（类型不安全的语言）; JAVA是静态语言，是强类型定义语言（类型安全的语言）。 
 　　关于各种语言类型的解释，请参考：http://blog.csdn.net/aiming66/article/details/78570784#t3 
 了解了这些，我们在此说一下JavaScript为什么是弱类型语言。经过思考，我感觉通过一段代码来说明吧。可能这样更加直白。
 
<!DOCTYPE html>
<html>
    <head>
        <title>js练习</title>
        <style type="text/css">

        </style>

        <script type="text/javascript">
            var num=0;
            alert(typeof num);

            num="123";
            alert(typeof num);

            num=true;
            alert(typeof num);

            num= new Date();
            alert(typeof num);
        </script>
    </head>
</html>
 
　　其中，我来解释以下代码。下面的几句代码显示如下图，我们不能看出，我们在一开始只创建了一个变量num，为var类型，我们却可以给他赋值各种类型：数值类型，字符串，布尔类型，对象类型，为此我们可以推断出来，JavaScript为弱类型语言。
 
var num=0;
alert(typeof num);
 
 
num="123";
alert(typeof num);
 
 
 num=true;
alert(typeof num);
 
 
 num= new Date();
alert(typeof num);