chen1231、Hello world
java
public class HelloWorld{
public static void main(String args[]){
System.out.println("Hello world!");
}
}python
print("Hello world!");Go
package main
import "fmt"
func main() {
fmt.Println("Hello world!")}Go里面的程序入口包名需为main，且需提供main方法;
java中只需提供main方法入口;
python中可任意在python文件中定义需要执行的代码。
2、行代码标记结束
java
System.out.println("Hello world!");python
print("Hello world")
Go
fmt.Println("Hello world!")
java是以分号;来标记结束，而python和Go则是以换行来作为标记，当然，python和Go也可以添加分号在语句的末尾，但是一般不推荐。
3、代码块
java
if(true){
System.out.println("Hello world!");
System.out.println("Hello world,again!");
}python
if True:
print("Hello world!");
print("Hello world, again!");Go
if true {
fmt.Println("Hello world!")
fmt.Println("Hello world, again！")
}java以及Go是以花括号{}来标记代码块逻辑层次，而python则是以tab键缩进来标记代码块的逻辑层次。需要注意的是，Go中，“{”不能单独占用一行，而Java中则可以。
4、注释
Java
/**
* 这是一个文本注释，
* 当然，文本注释也是可以多行的
*/
public static void main(String args[]){
//这是一个行注释
System.out.println("以上是一个行注释");
/*
这是第一行注释
这是第二行注释
*/
System.out.println("以上是一个多行注释");
} python
def test():
'''
这是一个多行注释的第一行
这是一个多行注释的第二行
'''
print("以上是一个多行注释方式1")
"""
这是一个多行注释的第一行
这是一个多行注释的第二行
"""
print("以上是一个多行注释的方式2")
#这是一个行注释
print("以上是一个行注释")
#这是第一行注释
#这是第二行注释
print("以上是一个多行注释方式3")Go
func main(){
// 单行注释
fmt.Println("上面是一个单行注释！")
/*
这是一个多行注释
*/
fmt.Println("上面是一个多行注释！")
}5、标识符
python、java以及Go所有组成部分都需要名字：变量，函数...姑且都统称他们作标识符好了。
Java
所有的标识符都应该以字母（A-Z或者a-z）,美元符（$）、或者下划线（_）开始。
首字符之后可以是字母（A-Z或者a-z）,美元符（$）、下划线（_）或数字的任何字符组合。
关键字不能用作标识符。
标识符是大小写敏感的。Python
第一个字符必须是字母表中字母或下划线 _ 。
标识符的其他的部分由字母、数字和下划线组成。
关键字不能用作标识符。
标识符对大小写敏感。GO
可以由字母，数字，下划线组成。
首字母必须是字母。
关键字不能用作标识符。
标识符是大小写敏感的不同之处在于，java可以包含$字符，Go只能以字母开头。
6、基本常用数据类型
6.1、基本数字类型
java
public static void main(String args[]){
byte b = 100; //整数类型，占用空间只有int的1/4，8位
short s = 1000; //整数类型，占用空间只有int的1/2，16位
int i = 100000; //整数类型，32位
Long l = 100000L; //整数类型，64位
float f = 123.5f; //单精度浮点类型，32位
double d = 123.5; //双精度浮点类型，64位
}python
i = 10 # 整数
f = 0.0 #浮点数
c = 3.14j #复数Go
func main(){
// 无符号 8 位整型 (0 到 255)
var uint8Val uint8 = 100
fmt.Printf("无符号uint8类型值：%v\n", uint8Val)
// 无符号 16 位整型 (0 到 65535)
var uint16Val uint8 = 100
fmt.Printf("无符号uint16类型值：%v\n", uint16Val)
// 无符号 32 位整型 (0 到 4294967295)
var uint32Val uint8 = 100
fmt.Printf("无符号uint32类型值：%v\n", uint32Val)
// 无符号 64 位整型 (0 到 18446744073709551615)
var uint64Val uint8 = 100
fmt.Printf("无符号uint64类型值：%v\n", uint64Val)
// 有符号 8 位整型 (-128 到 127)
var int8Val int8 = 100
fmt.Printf("有符号int8类型值：%v\n", int8Val)
// 有符号 16 位整型 (-32768 到 32767)
var int16Val int16 = 100
fmt.Printf("有符号int8类型值：%v\n", int16Val)
// 有符号 32 位整型 (-2147483648 到 2147483647)
var int32Val int32 = 100
fmt.Printf("有符号int8类型值：%v\n", int32Val)
// 有符号 64 位整型 (-9223372036854775808 到 9223372036854775807)
var int64Val int64 = 100
fmt.Printf("有符号int8类型值：%v\n", int64Val)
// IEEE-754 32位浮点型数
var float32Val float32 = 100.1
fmt.Printf("32位浮点类型值：%v\n", float32Val)
// IEEE-754 64位浮点型数
var float64Val float64 = 100.1
fmt.Printf("32位浮点类型值：%v\n", float64Val)
// 32 位实数和虚数
var complex64Val complex64 = 100.1
fmt.Printf("32 位实数和虚数值：%v\n", complex64Val)
// 64 位实数和虚数
var complex128Val complex128 = 100.1
fmt.Printf("32位浮点类型值：%v\n", complex128Val)
}java中有6中数字类型，python中只有4种，但是python支持复数，而java则不支持。Go中对于数值类型则会按占用空间做了更多的区分，这大概也是go之所以高效率的原因之一。
上面提到了一些python中的数字类型，但是其实还有一种：布尔类型。这里单独放到下面举例。
6.2、布尔类型
java
boolean b = false; //只有两种可能，true 或者falsepython
b = False #注意，这里的F是大写的，python3中，布尔类型也是一种数字类型，False可以是数字0，True可以是数字1Go
var b bool = true; //只有两种可能，true或者false6.3、字符类型/字符串类型
java
public static void main(String args[]){
char c1 = 'a'; //java中，字符为基本类型，这里的c1指代任意一个在ASCII编码表中的字符,用单引号括起来
System.out.println("打印一个字符："+c1);
chat c2 = 111; //这里的c2指代在ASCII编码表中索引为111的字符，即a
System.out.println("打印一个字符数值在ASCII编码表中对应的字符："+ c2); //
String str = "Hello world!"; //java中，字符串并非基本类型，而是属于引用类型，表示多个字符拼接在一起
System.out.println("打印一串字符："+str);
}python
str1 = 'Hello world!' #字符串定义方式1
str 2 = "Hello world!"; # 字符串定义方式2Go
var str = "Hello World" python中没有字符类型，只有字符串类型，并且字符串类型是python的基本类型之一。
6.4、List（列表）
java
int array[] = {1,2,3,4}; //方式1：定长数组
array[0] = -1; //修改数组第0个元素的值
System.out.println("第一个值为："+array[0]);
System.out.println("数组长度为："+array.length);
list = new ArrayList(); //方式2：可变列表
list.add(1);
list.add(2);
list.add(3);
list.add(4); //设置初始化值
list.set(0,-1); //修改第0个元素的值
System.out.println("第一个值为："+list.get(0));
System.out.println("列表长度为："+list.size());
python
list1 = ['Google', 'Runoob', 1997, 2000] #列表1,同时参杂字符串 和 数字
list2 = [1, 2, 3, 4, 5 ] #列表2,只包含数字
list3 = ["a", "b", "c", "d"] #列表3,只包含字符串
list1[0] = 'Nemo'
list1.append('Hello') #往列表最后新增一个元素
print('第一个值为：%s'%(list1[0]))
print('列表长度为：%d'%(len(list1)))
for item in list1:
print('遍历打印：%s'%(item))Go
// 数组定义，必须指定长度，如果不确定数组长度，可以用...代替数组长度，编译器会根据实际元素指定长度： var balance [...]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0}
balance[1] = 999 // 通过下标访问数组元素
for item := range balance{
fmt.Println(balance[item])
}
// 切片定义，不需指定长度，可根据需要随意修改
var numbers = []int{100,200,500,300,400}
numbers[1] = 999
numbers = append(numbers, 555555)
for item := range numbers{
fmt.Println(numbers[item])
}
可以看到，java的数组、列表与python、Go的列表都有相似之处：
1、都是属于有序列表。
2、索引都是从0开始。
3、里面的值都可以修改。
不同的地方大概就在于
1、java数组和Go数组是定长的，并且元素类型一般一致（Java Object泛型除外）。
2、java列表和Go列表是可变长度的，并且元素类型一般一致（Java Object泛型除外）。
3、python列表是可变长度，并且里面的元素类型不需要一致。
6.5、Tuple（元组）
java/Go中与python元组类似的也就是列表和数组，关于java以及Go中的列表和数组以上已做过说明，此处暂且略去。
python
tup1 = ('Google', 'Runoob', 1997, 2000) #元组1,同时参杂字符串 和 数字
tup2 = (1, 2, 3, 4, 5) #元组2,只包含数字
tup3 = ("a", "b", "c", "d") #元组3,只包含字符串
#tup1[0] = 'Nemo' #此操作会导致异常
#tup1.append('Hello') #往元组最后新增一个元素 #异常
print('第一个值为：%s'%(tup1[0]))
print('列表长度为：%d'%(len(tup1)))
for item in tup1:
print('遍历打印：%s'%(item))可以看到，python中的元组和Java列表其实非常类似的，区别之处就在于：
元组元素不可以修改，而列表可以。所以总结下来java中，列表、数组与python中的元组的区别就在于：
1、都是属于有序列表。
2、索引都是从0开始。
不同的地方大概就在于：
1、java数组和Go数组是定长的，并且元素类型一般一致（Java Object泛型除外）。
2、java列表和Go列表是可变长度的，并且元素类型一般一致（Java Object泛型除外）。
3、python元组是定长的，并且里面的元素类型不需要一致，且元素不可修改。
6.6、Set（集合）
java
//这里只用HashSet做说明，TreeSet不做涉及
Set set = new HashSet();
set.add("Nemo");
set.add("Nemo");
set.add("Kira");
set.add("1");
set.add("2");
System.out.println("集合长度 ：" + set.size()); //输出：
for(String val : set){
System.out.println("值输出："+val);
}
（某次）最终输出：
集合长度：4
值输出：1
值输出：2
值输出：Nemo
值输出：Kirapython
bus = {'Nemo','Kira',1,2,'Nemo'}
bus.add('Nemo')
print('集合长度：%d'%(len(bus)))
for item in bus:
print('值输出%s'%(item))
（某次）最终输出：
集合长度：4
值输出：1
值输出：2
值输出：Nemo
值输出：KiraGo
Go中并无如Java/Python中的Set类型定义，如需参考，可使用切片做示例。可以看到，Java和Python的集合是非常类似的。
1、元素都不可重复。
2、元素都无序。
不同之处在于：
1、python的集合里面的元素类型可以不一致，而java则一般一致（Java Object泛型除外）。
6.7、Dictionary/Map（字典/集合）
//这里只用HashMap作为说明
Map<String,String> map = new HashMap<>;
map.put("name","Nemo");
map.put("name","Kira");
map.put("age","Nemo");
map.put("age","17");
System.out.println("字典长度："+map.size());
for(String key : map.keySet()){
System.out.println("键："+key + " - 值："+map.get(key));
}
(某次)最终输出：
字典长度：2
键：name - 值：Kira
键：age - 值：17python
// Python中称之为字典
dict = {'name':'Nemo','age':17}
dict['name'] = 'Kira'
print('字典长度：%d'%(len(dict)))
for (key,val) in dict.items():
print('键：%s - 值：%s'%(key,val))
（某次）最终输出：
字典长度：2
键：name - 值：Kira
键：age - 值：17GO
// Go中称之为集合
// 创建集合
var countryCapitalMap map[string]string
countryCapitalMap = make(map[string]string)
countryCapitalMap [ "France" ] = "巴黎"
countryCapitalMap [ "Italy" ] = "罗马"
countryCapitalMap [ "India " ] = "新德里"
countryCapitalMap [ "Japan" ] = "东京"
for country := range countryCapitalMap {
fmt.Println(country, "首都是", countryCapitalMap [country])
}(某次)最终输出：
Italy 首都是 罗马
India 首都是 新德里
Japan 首都是 东京
France 首都是 巴黎可以看到，三者的是非常类似的。
1、元素都不可重复。
2、元素都无序。
不同之处在于：
1、python的集合里面的元素类型可以不一致，而java和Go中则一般一致（Java Object泛型除外）。
7、运算符
7.1、算术运算符
java
+（加法）、-（减法）、*（乘法）、/（除法）、%（取余）、++（自增1）、--（自减1）python
+（加法）、-（减法）、*（乘法）、/（除法）、%（取余）、**（幂）、//（取整除）Go
+（加法）、-（减法）、*（乘法）、/（除法）、%（取余）、++（自增1）、--（自减1）7.2、关系运算符
== 检查两个操作数是否相等
!= 检查两个操作数是否不相等
> 检查左边的操作数是否大于右边的操作数
< 检查左边的操作数是否小于右边的操作数
>= 检查左边的操作数是否大于或者等于右边的操作数
<= 检查左边的操作数是否小于或者等于右边的操作数python、java、Go三者基本一致。
7.3、位运算符
java
& 按位与运算符
| 按位或运算符
^ 按位异或运算符
~ 按位取反运算符
<< 按位左移运算符
>> 按位右移运算符
>>>按位右移补零操作符python
& 按位与运算符
| 按位或运算符
^ 按位异或运算符
~ 按位取反运算符
<< 按位左移运算符
>> 按位右移运算符Go
& 按位与运算符
| 按位或运算符
^ 按位异或运算符
<< 按位左移运算符
>> 按位右移运算符python较java少按位右移补零操作符，而Go则相较之下支持的操作更少。
7.4、逻辑运算符
java
&& 逻辑与运算符
|| 逻辑或操作符
! 逻辑非运算符python
and 逻辑与运算符
or 逻辑或运算符
not 逻辑非运算符Go
&& 逻辑与运算符
|| 逻辑或操作符
! 逻辑非运算符7.5、赋值预算符
java
= 简单的赋值运算符
+= 加和赋值操作符
-= 减和赋值操作符
*= 乘和赋值操作符
/= 除和赋值操作符
(%)=取模和赋值操作符
<<= 左移位赋值运算符
>>= 右移位赋值运算符
&= 按位与赋值运算符
^= 按位异或赋值操作符
|= 按位或赋值操作符python
= 简单的赋值运算符
+= 加法赋值运算符
-= 减法赋值运算符
*= 乘法赋值运算符
/= 除法赋值运算符
%= 取模赋值运算符
**= 幂赋值运算符
//= 取整除赋值运算符Go
= 简单的赋值运算符
+= 加和赋值操作符
-= 减和赋值操作符
*= 乘和赋值操作符
/= 除和赋值操作符
%= 求余后赋值操作符
<<= 左移位赋值运算符
>>= 右移位赋值运算符
&= 按位与赋值运算符
^= 按位异或赋值操作符
|= 按位或赋值操作符8、条件控制
java
public class Test {
public static void main(String args[]){
int x = 30;
if( x == 10 ){
System.out.print("Value of X is 10");
}else if( x == 20 ){
System.out.print("Value of X is 20");
}else if( x == 30 ){
System.out.print("Value of X is 30");
}else{
System.out.print("这是 else 语句");
}
}
}
python
x = 30
if x == 10:
print('Value of x is 10')
elif x == 20:
print('Value of x is 20')
elif x == 30:
print('Value of x is 30')
else:
print('这是 else 语句')
Go
package main
import "fmt"
func main() {
x := 30
if x == 10 {
fmt.Println("Value of X is 10")
} else if x == 20 {
fmt.Println("Value of X is 20")
} else if x == 30 {
fmt.Println("Value of X is 30")
} else {
fmt.Println("这是 else 语句")
}
}9、循环控制
9.1、while/do...while/while...else
java
//java:while
public class Test {
public static void main(String args[]) {
int x = 10;
while( x < 20 ) {
System.out.print("value of x : " + x );
x++;
System.out.print("\n");
}
}
}
python
# python: while
x = 10
while x < 20:
print('Value of x:%d'%x)
x = x + 1
java
// java: do...while
public class Test {
public static void main(String args[]){
int x = 10;
do{
System.out.print("value of x : " + x );
x++;
}while( x < 20 );
}
}
python
# python: while...else
x = 10
while x < 20:
print('value of x : %d',x)
x = x + 1
else:
print(' else ')
Go
Go中无while关键字，可参考for true {...} 实现。9.2、for
java
public class Test {
public static void main(String args[]) {
//普通for：
for(int x = 10; x < 20; x = x+1) {
System.out.println("value of x : " + x );
}
//增强for：
int numbers = {10,20,30,40,50};
for(int x : numnbers){
if(x == 20){
continue;
}
if(x == 40){
break;
}
System.out.println("value of x : " + x);
}
}
}
python
numbers = [10,20,30,40,50]
for x in numbers:
if x == 20:
continue
if x == 40:
break
print('value of x : %d'%x)
Go
var names = []string{"Tom", "Nemo", "Eva"}
for i:=0;i<len(names);i++{
fmt.Println(names[i])
}
for index,value := range names{
fmt.Println(index, "=>", value)
}
var num = 100;
for true {
if num % 2 == 0 {
fmt.Println(num)
}else if num % 7 == 0{
break
}else{
continue
}
num --
}10、函数/方法
java
基本语法：
修饰符 返回值类型 方法名(参数类型 参数名, 参数类型 参数名){
// 方法体
return 返回值;
}
public class MyClass{
//ex 1:
public static int sum(int num1,int num2){
int result = num1 + num2;
return result;
}
//ex 2:
public void stdout(int sum){
System.out.println("The sum is:" + sum);
}
//ex 3:
public void stdlog(){
System.out.println("Log is here");
}
// call
public static void main(String[]args){
MyClass myClass = new MyClass();
//call ex1:
int num1 = 100;
int num2 = 200;
int sum = myClass.sum(num1, num2);
// call ex2:
myClass.stdout(sum);
// call ex3
myClass.stdlog();
}
}
Python
基本语法：
def 方法名(参数列表):
# 方法体
return 返回值1, 返回值2
# ex1
def sum(num1, num2):
return num1 + num2
# ex2
def stdout(sum):
print('The sum is: ' + str(sum))
# ex3
def stdlog():
print('Log is here"')
// call
num1 = 100
num2 = 200
sum = sum(num1, num2)
stdout(sum)
stdlog()
Go
基础语法：
func 函数名(参数名 参数类型, 参数名 参数类型) 返回值类型,返回值类型{
// 方法体
return 返回值1, 返回值2
}
func sum(num1 int, num2 int)int{
return num1 + num2
}
func stdout(sum int){
fmt.Println("The sum is : " + strconv.Itoa(sum))
}
func stdlog(){
fmt.Println("Log is here")
}
func main() {
num1 := 100
num2 := 200
sum := sum(num1, num2)
stdout(sum)
stdlog()
}
11、访问控制
Java
public //公开访问，任意类可访问
private //私有访问，仅本类可访问
default //本包可访问，默认不写修饰符即为default
protected //本包可访问，不能用于类(内部类除外)和接口方法修饰Python
Python并无修饰符，访问权限仅有两种：
1、公开访问：不以_开头命名的方法、成员变量等。
2、私有访问：以_开头命名的方法、成员变量等。Go
Go中并无修饰符，访问权限仅有两种：
1、公开访问：方法、成员变量等以大写字母开头。
2、私有访问：方法、成员变量等不以大写字母开头。