主流编程语言语法简单总结（Java, C, C++, C#, PHP, JavaScript, Swift, Go）

拼搏现实的明天。 2022-05-16 15:58 153阅读 0赞

经常用到多种编程语言，时间长了容易搞混，整理一下不用语言语法的异同点，方便快速学习或温习。

根据TIOBE编程语言排行榜，语言顺序是Java, C, C++, Python, Visual Basic .NET, C\#, PHP, JavaScript（简称JS）, SQL, Swift,MATLAB, Go，其中Python和Visual Basic .NET语法比较特别，SQL主要是访问和处理数据库，MATLAB主要是数学方面，所以只整理八种语言。

TIOBE 发布的2018年10 月编程语言排行榜：

<table> 
 <thead> 
  <tr> 
   <th>Oct 2018</th> 
   <th>Oct 2017</th> 
   <th>Programming Language</th> 
   <th>Ratings</th> 
   <th>Change</th> 
   <th>主要使用场景</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td>1</td> 
   <td>Java</td> 
   <td>17.801%</td> 
   <td>+5.37%</td> 
   <td>web后端，游戏后端，大数据，Android</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>2</td> 
   <td>C</td> 
   <td>15.376%</td> 
   <td>+7.00%</td> 
   <td>各种核心库，嵌入式</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>3</td> 
   <td>C++</td> 
   <td>7.593%</td> 
   <td>+2.59%</td> 
   <td>各种后端（除web）</td> 
  </tr> 
  <tr> 
   <td>4</td> 
   <td>5</td> 
   <td>Python</td> 
   <td>7.156%</td> 
   <td>+3.35%</td> 
   <td>机器学习，大数据</td> 
  </tr> 
  <tr> 
   <td>5</td> 
   <td>8</td> 
   <td>Visual Basic .NET</td> 
   <td>5.884%</td> 
   <td>+3.15%</td> 
   <td>Win平台下的APP、web后端</td> 
  </tr> 
  <tr> 
   <td>6</td> 
   <td>4</td> 
   <td>C#</td> 
   <td>3.485%</td> 
   <td>-0.37%</td> 
   <td>Win平台下的APP、web后端，Unity3D</td> 
  </tr> 
  <tr> 
   <td>7</td> 
   <td>7</td> 
   <td>PHP</td> 
   <td>2.794%</td> 
   <td>+0.00%</td> 
   <td>web后端</td> 
  </tr> 
  <tr> 
   <td>8</td> 
   <td>6</td> 
   <td>JavaScript</td> 
   <td>2.280%</td> 
   <td>-0.73%</td> 
   <td>web前端，Node.js</td> 
  </tr> 
  <tr> 
   <td>9</td> 
   <td>-</td> 
   <td>SQL</td> 
   <td>2.038%</td> 
   <td>+2.04%</td> 
   <td>数据库</td> 
  </tr> 
  <tr> 
   <td>10</td> 
   <td>16</td> 
   <td>Swift</td> 
   <td>1.500%</td> 
   <td>-0.17%</td> 
   <td>iOS</td> 
  </tr> 
  <tr> 
   <td>11</td> 
   <td>13</td> 
   <td>MATLAB</td> 
   <td>1.317%</td> 
   <td>-0.56%</td> 
   <td>数学计算</td> 
  </tr> 
  <tr> 
   <td>12</td> 
   <td>20</td> 
   <td>Go</td> 
   <td>1.253%</td> 
   <td>-0.10%</td> 
   <td>高性能分布式后端</td> 
  </tr> 
 </tbody> 
</table>

> 主要参考：菜鸟教程（[Java 教程][Java]，[C 语言教程][C]，[C++ 教程][C_]，[Python 3 教程][Python 3]，[C\# 教程][C_ 1]，[PHP 教程][PHP]，[JavaScript 教程][JavaScript]，[Node.js教程][Node.js]，[SQL 教程][SQL]，[Swift 教程][Swift]，[Go 语言教程][Go]）

### 文章目录 ###

*  基础语法
 *   *  Hello World
     *  标识符
     *  空格
 *  注释
 *  数据类型
 *  变量类型
 *   *  Swift 可选(Optionals)类型
 *  常量
 *  运算符
 *  判断
 *  循环
 *  字符串
 *  数组
 *  结构体
 *  指针
 *  函数（方法）
 *  异常处理
 *  包
 *  接口（抽象类，协议）
 *  枚举
 *  泛型
 *  面向对象

# 基础语法 #

## Hello World ##

//java
    public class HelloWorld { 
        public static void main(String []args) { 
            System.out.println("Hello, World!");
        }
    }

//c
    #include <stdio.h>
    int main(){ 
       printf("Hello, World! \n");
       return 0;
    }

//cpp
    #include <iostream>
    using namespace std;
    int main(){ 
       cout << "Hello, World!";
       return 0;
    }

//csharp
    using System;
    namespace HelloWorldApplication{ 
       class HelloWorld{ 
          static void Main(string[] args){ 
             Console.WriteLine("Hello, World!");
             Console.ReadKey();
          }
       }
    }

<!DOCTYPE html> 
    <html> 
    <body> 
    <?php
    	echo "Hello, World!"; 
    ?> 
    </body> 
    </html>

//Node.js
    console.log("Hello, World!");
    
    //javascript
    <!DOCTYPE html>
    <html>
    <body>
    <script>
    	document.write("<p>Hello, World!</p>");
    </script>
    </body>
    </html>

//swift
    import UIKit
    var myString = "Hello, World!"//Swift语言没有";"
    print(myString)

//go
    func main(){   
    //{ //{不能在单独的行上，其他语言没这个问题
        fmt.Println("Hello, World!")//Go语言没有";"
    }

## 标识符 ##

类名、变量名以及方法名都被称为标识符。

*  所有的标识符都以字母（A-Z或者a-z）或下划线（\_）开始（Java、JS可用$，C\#可用@开始）
 *  首字符之后可以是字母（A-Z或者a-z）、下划线（\_）或数字（0-9）的任何字符组合（Java、JS可用$，C\#可用@）
 *  关键字不能用作标识符
 *  标识符是大小写敏感的
 *  合法标识符举例：age、\_value、\_\_1\_value
 *  非法标识符举例：123abc、-salary

## 空格 ##

空格分隔语句的各个部分。

int age;//age前至少一个空格
    fruit = apples + oranges; //fruit 和 =，或者 = 和 apples 之间的空格字符不是必需的，只是为了增强可读性
    
    let a= 1 + 2 //在Swift中，运算符不能直接跟在变量或常量的后面，这样会报错

# 注释 #

//这是单行注释
    /*这也是单行注释*/
    /* 这是多行注释 * 这是多行注释 */

# 数据类型 #

*  java: byte, short, int, long, float, double, boolean, char, 引用类型（类似C的指针，对象、数组）
 *  C: char, unsigned char, signed char, int, unsigned int, short, unsigned short, long, unsigned long, float, double, long double, void
 *  C++: bool, char, int, float, double, void, wchar\_t, （可加signed, unsigned, short, long修饰）, (typedef int feet; feet varA;//定义新类型),
 *  C\#: bool, byte, char, decimal, double, float, int, long, sbyte, short, uint, ulong, ushort
 *  PHP: String, Integer, Float, Boolean, Array, Object, NULL
 *  JS: String, Number, Boolean, Null, Undefined, Symbol, 引用类型（Object, Array, Function）
 *  Swift: Int, UInt, Int8, UInt8, Int32, UInt32, Int64,UInt64, Float, Double, Bool, String, Character, Optional
 *  Go: bool, int, uint8(byte), uint16, uint, unit32, uint64, int8, int16, int32(rune), int64, float32,float64, complex64, complex128, uintptr(无符号整型，用于存放一个指针), 派生类型（指针Pointer，数组，结构化struct，Channel，函数，切片，接口类型interface，Map ）

# 变量类型 #

*  Java, C, C++, C\#: `int varA;`, `int varA = 42;`
 *  PHP: `$varA=42;`
 *  JS: `var varA;`, `var varA = 42;`, `let varA = 42;`（let是ES6引入，声明的变量只在代码块有效，不影响同名块外变量）
 *  Swift: `var varA:Int`, `var varA = 42`
 *  Go: `var varA int`, `var varA = 42`, `varA := 42`

## Swift 可选(Optionals)类型 ##

Swift 的可选（Optional）类型，用于处理值缺失的情况。可选表示"那儿有一个值，并且它等于 x “或者"那儿没有值”。  
Swfit语言定义后缀？作为命名类型Optional的简写，换句话说，以下两种声明是相等的：

var optionalInteger: Int?
    var optionalInteger: Optional<Int>

当你确定可选类型确实包含值之后，你可以在可选的名字后面加一个感叹号（!）来获取值。这个感叹号表示"我知道这个可选有值，请使用它。"这被称为可选值的强制解析（forced unwrapping）。

var myString:String?
    myString = "Hello, Swift!"
    print(myString)//正常输出
    print( myString! )// 强制解析

程序执行结果为：

Optional("Hello, Swift!")
    Hello, Swift!

# 常量 #

*  Java：使用 final 关键字来修饰常量，`final int CONSTA = 42;`
 *  C, C++: `#define CONSTA 42`, `const int CONSTA = 42;`
 *  C\#: `const int constA = 42;`
 *  PHP: `define("CONSTA", 42);`
 *  JS: `const constA=42;`（ES6引入）
 *  Swift: `let constA = 42`
 *  Go: `const CONSTA int = 42`, `const CONSTA = 42`

# 运算符 #

*  算术运算符: `+`, `-`, `*`, `/`, `%`, `++`(Swift3取消), `--`(Swift3取消)
 *  关系运算符: `==`, `!=`, `>`, `<`, `>=`, `<=`, `===`(绝对等于，PHP、JS特有), `!==`(绝对不等于，PHP、JS特有), `<>`(不等于，PHP特有)
 *  逻辑运算符: `&&`与, `||`或, `!`非,（PHP特有：`and`, `or`, `xor`)
 *  位运算符: `&`与, `|`或, `^`异或,`~`反, `<<`左移, `>>`右移,`>>>`右移补0(Java特有) ，（PHP、JS没有位运算符）
 *  赋值运算符: `=`, `+=`, `-=`, `*=`, `/=`, `%=`, `<<=`, `>>=`, `&=`, `^=`, `|=`, (PHP、JS没有移位和逻辑赋值)
 *  其他运算符:
    
     *  `? :`(条件运算符，JS、Go没有)
     *  `instanceof`(检查对象类型，Java特有)
     *  `&`(返回变量地址，C、C++、C\#、Go特有)
     *  `*`(指针变量，C、C++、C\#、Go特有)
     *  `sizeof()`(返回字节数，C、C++、C\#特有)
     *  `,`(顺序执行一系列运算，只返回最后表达式的值，C++特有)
     *  `Cast`(强制转换，C++特有))
     *  `.=`(连接字符串，PHP特有)
     *  `typeof()`(返回class类型，C\#特有)
     *  `is`(检查对象类型，C\#特有),
     *  `as`(强制转换，C\#特有)

# 判断 #

if(布尔表达式){ //Swift、Go表达式外面没括号
    	//如果布尔表达式为true将执行的语句
    }
    
    if(布尔表达式){ 
       	//如果布尔表达式的值为true
    }else{ 
       	//如果布尔表达式的值为false
    }
    
    if(布尔表达式 1){ 
       	//如果布尔表达式 1的值为true执行代码
    }else if(布尔表达式 2){  //PHP也可以写成elseif
       	//如果布尔表达式 2的值为true执行代码
    }else if(布尔表达式 3){ 
       	//如果布尔表达式 3的值为true执行代码
    }else { 
       	//如果以上布尔表达式都不为true执行代码
    }
    
    if(布尔表达式 1){ 
    	//如果布尔表达式 1的值为true执行代码
       	if(布尔表达式 2){ 
          	//如果布尔表达式 2的值为true执行代码
      	}
    }
    
    switch(expression){ 
    	case value :
           	//语句
           	break; //可选
        case value :
           	//语句
           	break; //可选
        //你可以有任意数量的case语句
        default : //可选
           //语句
    }

# 循环 #

//好像Go没有
    while( 布尔表达式 ) { 
      	//循环内容
    }
    
    //Swift不用do，用repeat
    //好像Go没有
    do { 
    	//代码语句
    }while(布尔表达式);
    
    //Swift3已弃用
    //for(初始化; 布尔表达式; 更新)
    for(int x = 10; x < 20; x = x+1) { 
        //代码语句
    }
    
    //for/in Java5以上
    //for(声明语句 : 表达式)
    for(int x : numbers ){ 
       //代码句子
    }
    for(Iterator i = list.iterator(); i.hasNext(); ) { 
       Object listElement = i.next();
    }
    
    //forEach，Java8以上
    List<Integer> numbers = new ArrayList<>();
    numbers.forEach((Integer integer) -> { //第一种
        System.out.println(integer);
    });
    numbers.forEach(integer -> { //第二种
        System.out.println(integer);
    });
    numbers.forEach(integer -> System.out.println(integer));//第三种
    numbers.forEach(System.out::println);//第四种
    
    numbers.forEach(new MyConsumer());第五种，基于MyConsumer类
    class MyConsumer implements Consumer<Integer>{ 
        @Override
        public void accept(Integer integer) { 
            System.out.println(integer);
        }
    }
    
    //stream,Java8以上
    arrayList.stream().filter(i -> i > 0);
    arrayList.stream().forEach(s -> System.out.println(s));
    
    //C#
    foreach (int element in fibarray){ 
    	System.Console.WriteLine("Element #{0}", element);
    }
    
    //PHP
    foreach ($array as $value){ 
       //要执行代码;
    }
    
    //JS
    for (x in person){   // x 为属性名
        txt=txt + person[x];
    }
    
    //Swift
    for index in 1...5 { 
        print("\(index) 乘于 5 为：\(index * 5)")
    }
    var someInts:[Int] = [10, 20, 30]
    for index in someInts { 
       print( "index 的值为 \(index)")
    }

# 字符串 #

//java
    String hello = "Hello, world!";
    char[] helloArray = { 'H', 'e', 'l', 'l', 'o'};
    hello = new String(helloArray);
    hello.concat(", ");
    hello + "world!";
    
    //C, C++
    char hello[12] = { 'H', 'e', 'l', 'l', 'o', '\0'};
    char world[] = " world";
    strcat(hello, world);
    
    //C++, C#
    string hello = "Hello";
    string world = " world";
    string str
    str = hello + world;
    
    //php
    $hello="Hello";
    $world="World";
    echo $hello . " " . $world;
    
    //JS
    var hello = "Hello";
    var hello1 new String("Hello");
    (hello === hello1) //结果为 false，因为hello是字符串，hello1是对象
    
    //Swift
    var hello = "Hello";
    var hello1 = String("Hello");
    
    //Go
    var hello string
    hello = "Hello"
    world := "world"

# 数组 #

//Java, C, C++, C#
    dataType[] arrayRefVar = new dataType[arraySize];//C, C++不需要new
    double[] myList = { 1.9, 2.9, 3.4, 3.5};
    
    //PHP
    $cars=array("Volvo","BMW","Toyota");
    
    //JS
    var myCars=new Array("Saab","Volvo","BMW");
    var myCars=["Saab","Volvo","BMW"];
    
    //Swift
    var someArray = [SomeType](repeating: InitialValue, count: NumbeOfElements)
    var someInts = [Int](repeating: 0, count: 3)//类型为Int数量为 3，初始值为0的数组：
    var someInts:[Int] = [10, 20, 30]
    
    //Go
    var variable_name [SIZE] variable_type
    var balance = [4]float32{ 2.0, 3.4, 7.0, 50.0}
    var balance = [...]float32{ 2.0, 3.4, 7.0, 50.0}//Go语言会根据元素的个数来设置数组的大小

# 结构体 #

//Java要用第三方库Javastruct，用于像处理 C 或者 C++ 结构体那样处理 java 对象
    	@StructClass 
    	public class Foo { 
    		@StructField(order = 0)
    		public byte b;
    		@StructField(order = 1)
    		public int i;
    	}

//C, C++
    struct { //这个结构体并没有标明其标签
        int a;
        char b;
        double c;
    } s1;//同时又声明了结构体变量s1
     
    struct SIMPLE{  //结构体的标签被命名为SIMPLE
        int a;
        char b;
        double c;
    };//没有声明变量
    struct SIMPLE t1, t2[20], *t3;//用SIMPLE标签的结构体，声明变量t1、t2、t3
    
    typedef struct {  //也可以用typedef创建新类型
        int a;
        char b;
        double c; 
    } Simple2;
    Simple2 u1, u2[20], *u3;//现在可以用Simple2作为类型声明新的结构体变量
    
    //C位域
    struct{ 
      unsigned int width : 16;//带有预定义宽度的变量被称为位域
      unsigned int height : 16;
    } Rect;//总共占用32位，即4个字节
    
    //C共用体是一种特殊的数据类型，允许你在相同的内存位置存储不同的数据类型
    union Data{ 
       int i;
       char  str[20];
    } data;
    union Data data;        
    data.i = 10;
    strcpy( data.str, "C Programming");//data.i会改成1917853763

//C#
    struct Books{  //类是引用类型，结构是值类型
       private string title;
       private int book_id;
       public void getValues(string t, int id){ //可带有方法
          title = t;
          book_id =id; 
       }

//Swift
    struct MarksStruct { 
       var mark: Int
       init(mark: Int) { 
          self.mark = mark
       }
    }
    var aStruct = MarksStruct(mark: 98)
    var bStruct = aStruct //aStruct和bStruct是使用相同值的结构体！

//Go
    type Books struct { 
       title string
       book_id int
    }
    var Book1 Books/* 声明 Book1 为 Books 类型 */
    Book1.title = "Go 语言"

# 指针 #

指针是一个变量，其值为另一个变量的地址，即，内存位置的直接地址。

//C, C++
    int  a = 20;	/* 实际变量的声明 */
    int  *ip;     	/* 指针变量的声明 */
    ip = &a;  	/* 在指针变量中存储 a 的地址 */
    int *ptr = NULL;//NULL 指针是一个定义在标准库中的值为零的常量, ptr的地址是 0x0
    printf("Address of a variable: %p\n", &a  );
    printf("Address stored in ip variable: %p\n", ip );/* 在指针变量中存储的地址 */  
    printf("Value of *ip variable: %d\n", *ip ); /* 使用指针访问值 */

//Go
    var a int= 20   /* 声明实际变量 */
    var ip *int        /* 声明指针变量 */
    ip = &a  /* 指针变量的存储地址 */
    var  ptr *int//空指针，当一个指针被定义后没有分配到任何变量时，它的值为 nil
    fmt.Printf("a 变量的地址是: %x\n", &a  )
    fmt.Printf("ip 变量储存的指针地址: %x\n", ip )/* 指针变量的存储地址 */
    fmt.Printf("*ip 变量的值: %d\n", *ip )/* 使用指针访问值 */

# 函数（方法） #

//Java, C, C++, C#
    修饰符 返回值类型 方法名(参数类型 参数名){ 
        方法体
        return 返回值;
    }
    
    //PHP, JS
    function functionName(){ 
        // 要执行的代码
    }
    
    //Swift
    func funcname(Parameters) -> returntype { 
        //要执行的代码
        return parameters
    }
    
    //Go
    func function_name( [parameter list] ) [return_types] { 
       函数体
    }

# 异常处理 #

//Java
    public void deposit(double amount) throws RemoteException{ 
    //如果一个方法没有捕获到一个检查性异常，那么在方法签名的尾部使用throws关键字来声明。
       	// Method implementation
       	int a[] = new int[2];
        try{ //使用 try 和 catch 关键字可以捕获异常
           System.out.println("Access element three :" + a[3]);
        }catch(ArrayIndexOutOfBoundsException e){ 
           System.out.println("Exception thrown :" + e);
        }finally{ //无论是否发生异常，finally 代码块中的代码总会被执行。
           a[0] = 6;
           System.out.println("First element value: " +a[0]);
        }
        throw new RemoteException();//也可以使用 throw抛出一个异常，无论它是新实例化的还是刚捕获到的。
    }

//C
       pf = fopen ("unexist.txt", "rb");
       if (pf == NULL){ 
          errnum = errno;
          fprintf(stderr, "错误号: %d\n", errno);//错误号: 2
          perror("通过 perror 输出错误");//通过 perror 输出错误: No such file or directory
          fprintf(stderr, "打开文件错误: %s\n", strerror( errnum ));//打开文件错误: No such file or directory
       }

//C++
    struct MyException : public exception{ 
      	const char * what () const throw ()  { 
        	return "C++ Exception";
      }
    };
    try{ 
      	throw MyException();
    }catch(MyException& e){ 
      	std::cout << e.what() << std::endl;//C++ Exception
    }

//C#
    try{ 
        result = num1 / num2;
    }catch (DivideByZeroException e){ 
        Console.WriteLine("Exception caught: {0}", e);
    }finally{ 
        Console.WriteLine("Result: {0}", result);
    }

//PHP
    try { 
        echo inverse(5) . "\n";
    } catch (Exception $e) { 
        echo 'Caught exception: ',  $e->getMessage(), "\n";
    } finally { 
        echo "First finally.\n";
    }

//JS
    try {  
      	if(x == "")  throw "值为空";
    } catch(err) { 
        message.innerHTML = "错误: " + err;
    } finally { 
      	document.getElementById("demo").value = "";
    }

//Swift
    let tmpX = try? canThrowErrors(type: 1)  //如果抛出异常程序正常运行并赋值nil给左侧， 如果没抛异常则将返回值赋给左侧
    let tmpY = try! canThrowErrors(type: 2)  //你很确定不会抛出异常时这样用，但如果运行时抛异常会导致程序崩溃
    
    func canThrowErrors() throws -> String //throws后面不用跟着异常类
    
    do { 
        var data = try canThrowErrors(type: 3)//函数可能抛出异常
        print("after execute canThrowErrors")
        if data != nil { 
            print("Error test data:\(data)")
        }
    } catch VendingMathineError.outOfStack { 
        print("outOfStack")
    } 
    
    defer { //类似finally,抛出异常就执行defer，未抛出异常就最后执行defer
    	print("testDefer exit")
    }

//Go
    //错误处理
    type error interface { 
        Error() string
    }
    func Sqrt(f float64) (float64, error) { 
        if f < 0 { 
            return 0, errors.New("math: square root of negative number")
        }
        // 实现
    }
    
    //Go语言追求简洁优雅，所以，Go语言不支持传统的 try…catch…finally 这种异常，因为Go语言的设计者们认为，将异常与控制结构混在一起会很容易使得代码变得混乱。因为开发者很容易滥用异常，甚至一个小小的错误都抛出一个异常。在Go语言中，使用多值返回来返回错误。不要用异常代替错误，更不要用来控制流程。在极个别的情况下，也就是说，遇到真正的异常的情况下（比如除数为0了）。才使用Go中引入的Exception处理：defer（类似finally）, panic（类似throw）, recover（恢复错误）。
    func main() { 
    	funcA()
    	funcB()
    	funcC()
    }
    //Go没有异常机制，但有panic/recover模式来处理错误
    func funcA() { 
    	fmt.Println("没有发生异常，funcA正常执行。")
    }
    func funcB() { 
    	defer func() { //必须先声明defer，否则不能捕获到panic异常
    		if err := recover(); err != nil { //recover只有在defer调用的函数中有效
    			fmt.Println("捕获到panic产生的异常：", err) // 这里的err其实就是panic传入的内容
    			fmt.Println("recover恢复过来")
    		}
    	}() //()就是调用该匿名函数的，必须写 
    	//panic一般会导致程序挂掉（除非recover），然后Go运行时会打印出调用栈
    	//但是，关键的一点是，即使函数执行的时候panic了，函数不往下走了，运行时并不是立刻向上传递panic，而是到defer那，等defer的东西都跑完了，panic再向上传递。所以这时候defer有点类似 try-catch-finally 中的 finally。panic就是这么简单。抛出个真正意义上的异常。
    	panic("funcB要抛出一个异常了，等下defer会通过recover捕获这个异常，捕获到时，在funcB不会输出，会在defer里被捕获输出，然后正常处理，使后续程序正常运行。注意，在funcB函数里，排在panic后面的代码不会执行。")
    	fmt.Println("funcB里panic后面要打印出的内容。但是永远也打印不出来。因为逻辑并不会恢复到panic那个点去，函数还是会在defer之后返回，也就是说执行到defer后，程序直接返回到main()里，接下来开始执行funcC()")
    } 
    func funcC() { 
    	fmt.Println("没有defer来recover捕获panic的异常，funcC不会被正常执行.")
    }

# 包 #

//Java
    package net.java.util;//Java 提供了包机制，用于区别类名的命名空间。
    public class Something{ 
       ...
    }
    
    //引用其他包中的类
    payroll.Employee//使用类全名描述
    import payroll.*;//用import关键字引入，使用通配符"*"
    import payroll.Employee;//使用import关键字引入Employee类

//C++
    #include <iostream>
    using namespace std;//使用using namespace指令，这样在使用命名空间时就可以不用在前面加上命名空间的名称。
     
    // 第一个命名空间
    namespace first_space{ 
       void func(){ 
          cout << "Inside first_space" << endl;
       }
    }
    // 第二个命名空间
    namespace second_space{ 
       void func(){ 
          cout << "Inside second_space" << endl;
       }
    }
    int main ()
    { 
       // 调用第一个命名空间中的函数
       first_space::func();
       // 调用第二个命名空间中的函数
       second_space::func(); 
       return 0;
    }

//C#
    using System;
    namespace first_space{ 
       class namespace_cl{ 
          public void func(){ 
             Console.WriteLine("Inside first_space");
          }
       }
    }
    namespace second_space{ 
       class namespace_cl{ 
          public void func(){ 
             Console.WriteLine("Inside second_space");
          }
       }
    }   
    class TestClass{ 
       static void Main(string[] args){ 
          first_space.namespace_cl fc = new first_space.namespace_cl();
          second_space.namespace_cl sc = new second_space.namespace_cl();
          fc.func();
          sc.func();
          Console.ReadKey();
       }
    }

# 接口（抽象类，协议） #

public interface NameOfInterface{ //接口定义
       //任何类型 final, static 字段
       //抽象方法
    }
    public interface Football extends Sports, Event//接口继承
    public class MammalInt implements Animal//接口实现

//C++
    class Shape{ //类中至少有一个函数被声明为纯虚函数，则这个类就是抽象类
       public:      
          virtual int getArea() = 0;//提供接口框架的纯虚函数
    };
    class Rectangle: public Shape{ //派生类
    public:
       int getArea(){  //在派生类中重载纯虚函数
          return (width * height); 
       }
    };

//C#
    interface IParentInterface{ //定义接口
        void ParentInterfaceMethod();
    }
    
    interface IMyInterface : IParentInterface{ //接口继承
        void MethodToImplement();
    }
    class InterfaceImplementer : IMyInterface{ //实现接口
        public void MethodToImplement(){ 
            Console.WriteLine("MethodToImplement() called.");
        }
        public void ParentInterfaceMethod(){ 
            Console.WriteLine("ParentInterfaceMethod() called.");
        }
    }

//PHP
    interface iTemplate{ 
        public function setVariable($name, $var);
    }
    class Template implements iTemplate{ 
        private $vars = array();
        public function setVariable($name, $var){ 
            $this->vars[$name] = $var;
        }
    }

//Swift
    protocol SomeProtocol { //协议定义
        // 协议内容
    }
    protocol InheritingProtocol: SomeProtocol, AnotherProtocol { //协议继承
        // 协议定义
    }
    class SomeClass: SomeSuperClass, FirstProtocol, AnotherProtocol { //协议实现，父类名放在协议名之前，以逗号分隔
        // 类的内容
    }

//Go
    type Phone interface { //定义接口
        call()
    }
    type IPhone struct { //定义结构体
    }
    func (iPhone IPhone) call() { //实现接口方法
        fmt.Println("I am iPhone, I can call you!")
    }
    func main() { 
        var phone Phone		//定义接口变量
        phone = new(IPhone)	//变量赋值为IPhone
        phone.call()		//调用Iphone的call方法
    }

# 枚举 #

public enum Color { //常量枚举
      RED, GREEN, BLANK, YELLOW  
    } 
    
    public enum Color { //有方法的枚举，有点像类了，都继承自java.lang.Enum类，可以实现接口
        RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);//必须有;
        // 成员变量 
        private String name;  
        private int index;  
        // 构造方法 
        private Color(String name, int index) {   
            this.name = name;  
            this.index = index;  
        }  
        // 普通方法 
        public static String getName(int index) {   
            for (Color c : Color.values()) {   
                if (c.getIndex() == index) {   
                    return c.name;  
                }  
            }  
            return null;  
        }  
        // get set 方法 
        public String getName() {   
            return name;  
        }  
        public void setName(String name) {   
            this.name = name;  
        }  
        public int getIndex() {   
            return index;  
        }  
        public void setIndex(int index) {   
            this.index = index;  
        }  
    }  
    
    public enum Singleton { //单例模式最佳方法，线程安全，支持序列化
        INSTANCE;  
        public void whateverMethod() {   
        }  
    }

//C, C++
    enum DAY{ 
          MON=1, TUE, WED, THU, FRI, SAT, SUN//默认从0开始，这样就从1开始了
    } day;
    day = WED;
    printf("%d",day);

enum Days {  Sun, Mon, tue, Wed, thu, Fri, Sat };
    int WeekdayStart = (int)Days.Mon;

//可以遵守协议（protocols）来提供标准的功能。
    //可以定义构造函数（initializers）来提供一个初始成员值
    enum Student{ //相关值枚举
        case Name(String)
        case Mark(Int,Int,Int)
    }
    var studDetails = Student.Name("Runoob")
    var studMarks = Student.Mark(98,97,95)
    switch studMarks { 
    case .Name(let studName):
        print("学生的名字是: \(studName)。")
    case .Mark(let Mark1, let Mark2, let Mark3):
        print("学生的成绩是: \(Mark1),\(Mark2),\(Mark3)。")//学生的成绩是: 98,97,95。
    }
    
    enum Month: Int { //原始值枚举
        case January = 1, February, March, April, May, June//不会隐式地赋值为0，1，……和6
    }
    let yearMonth = Month.May.rawValue
    print("数字月份为: \(yearMonth)。")//数字月份为: 5。

# 泛型 #

//Java（C++, C#, Swift也支持泛型，使用方式差不多）
    public class MaximumTest{ 
       // 比较三个值并返回最大值，传入参数限制为Comparable类型
       public static <T extends Comparable<T>> T maximum(T x, T y, T z){ //泛型方法
          T max = x; // 假设x是初始最大值
          if ( y.compareTo( max ) > 0 ){ 
             max = y; //y 更大
          }
          if ( z.compareTo( max ) > 0 ){ 
             max = z; // 现在 z 更大 
          }
          return max; // 返回最大对象
       }
       public static void main( String args[] ){ 
          System.out.printf( "%d, %d 和 %d 中最大的数为 %d\n\n",3, 4, 5, maximum(3, 4, 5));
          System.out.printf( "%.1f, %.1f 和 %.1f 中最大的数为 %.1f\n\n",6.6, 8.8, 7.7, maximum(6.6, 8.8, 7.7));
          System.out.printf( "%s, %s 和 %s 中最大的数为 %s\n","pe","ap", "or", maximum("pe", "ap", "or"));
       }
    }
    public class Box<T> { //泛型类 
      private T t; 
      public void add(T t) { 
        this.t = t;
      } 
      public T get() { 
        return t;
      } 
      public static void main(String[] args) { 
        Box<Integer> integerBox = new Box<Integer>();
        Box<String> stringBox = new Box<String>();
     
        integerBox.add(new Integer(10));
        stringBox.add(new String("菜鸟教程"));
     
        System.out.printf("整型值为 :%d\n\n", integerBox.get());
        System.out.printf("字符串为 :%s\n", stringBox.get());
      }
    }
    
    public static void getData(List<?> data)//类型通配符一般是使用?代替具体的类型参数。例如 List<?> 在逻辑上是List<String>,List<Integer> 等所有List<具体类型实参>的父类

# 面向对象 #

//java
    import java.io.*;//提供一个合理的路径，使得编译器可以找到某个类。
    public interface Run{   
       	void run ();
    } 
    public interface Jump{   
       	void jump ();
    } 
    abstract class Animal { //抽象类，抽象类不能被实例化
      	void eat() { 
        	System.out.println("Animal : 吃");
      	}
      	abstract void work(){ }//抽象方法，抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
    }
    public class Dog extends Animal implements Run, Jump{ //Animal是父类，Java不支持多继承父类，但可以多继承接口
       	int age;//成员变量
       	public Dog(String name){ //构造方法
          	System.out.println("狗的名字是 : " + name ); 
       	}
       	public void setAge( int age ){ //set方法
           age = age;
       	}
       	public int getAge( ){ //get方法
           	System.out.println("狗的年龄为 : " + age ); 
           	return age;
       	}
      	public void eat() { //重写(Override)，覆盖父类方法
        	System.out.println("Dog : 吃骨头");
      	}
      	public void eat(int a) { //重写(Override)，方法名相同而参数不同
        	System.out.println("Dog : 吃骨头(a)");
      	}
       	public void run (){ //实现Run接口方法
           	System.out.println("狗跑"); 
       	} 
       	public void jump (){ //实现Jump接口方法
           	System.out.println("狗跳"); 
       	} 
       	public void work (){ //重写抽象方法
           	System.out.println("看家"); 
       	} 
    	void test(){ 
    		this.eat();   // this 调用自己的方法
    	    super.eat();  // super 调用父类方法
    	}
    	public static void main(String []args){ //加static是类方法
          	Dog dog = new Dog("tommy");//创建对象
          	dog.setAge(2);//通过方法来设定age
          	dog.getAge();//调用另一个方法获取age
          	System.out.println("变量值 : " + dog.age ); //也可以这样访问成员变量
    
          	Animal a = new Dog("pubby");
          	a.eat();//虚拟方法(virtual)，编译器使用Animal类中的eat()方法验证,运行的时候JVM调用的是Dog类中的eat()方法。
       	}
    }

//C++
    #include <iostream>
    using namespace std;
    class Dog{ 
       	public:
       		static int dogCount;//无论创建多少个类的对象，静态成员都只有一个副本。
       	 	Dog(string name){ //构造函数
       	 		cout << "狗的名字是 : " + name << endl;
        		ptr = new int;
       		}
       		Dog( const Dog &obj){ //拷贝构造函数
       		    cout << "调用拷贝构造函数并为指针 ptr 分配内存" << endl;
    			    ptr = new int;
    			    *ptr = *obj.ptr;//拷贝值
    		}
       		~Dog(){   //析构函数,每次删除所创建的对象时执行
       		    cout << "释放内存" << endl;
        		delete ptr;
    		}
    		friend void printAge(Dog dog);//友元函数是定义在类外部，但有权访问类的所有私有(private)成员和保护(protected)成员。友元函数并不是成员函数。友元可以是函数(友元函数)；可以是类(友元类)，整个类及其所有成员都是友元。
    		int getAge(){ 
    			return age;
    		}
    		int getAge(int a);//重载
    		int compare{ Dog dog){ 
    			return this->getAge() > dog.getAge();//对象通过this指针来访问自己的地址，是所有成员函数的隐含参数。友元函数没有this指针。访问指向类的指针的成员，需要使用成员访问运算符 ->
    		}
    		static int getCount(){ //静态成员函数没有 this 指针，只能访问静态成员
             	return dogCount;
          	}
       	protected:
       	private: //默认私有
       		int age;
          	int *ptr;//成员变量
    }
    void Dog::run (){ //成员函数可以定义在类定义内部，或者单独使用范围解析运算符::来定义
       	 		cout << "狗跑"<< endl;
    } 
    
    class B : protected A{ //这种继承，A中的public方法，在B中是protected的
    
    inline int Max(int x, int y)//内联函数(inline)，一般都是1-5行的小函数，编译器会把该函数的代码副本放置在每个调用该函数的地方。在类定义中的定义的函数都是内联函数，即使没有使用 inline 说明符。
    
    int Dog::dogCount = 0;//初始化类Dog的静态成员
    
    Dog::getCount();//静态函数只要使用类名加范围解析运算符 :: 就可以访问。
    
    class Rectangle: public Shape, public PaintCost//Rectangle（派生类）继承了Shape（基类）,C++可以多继承
    class Triangle: public Shape
    Shape *shape; Rectangle rec(10,7); Triangle tri(10,5); shape=&rec; shape=&tri;//多态
    
    //接口。如果类中至少有一个函数被声明为纯虚函数，则这个类就是抽象类。抽象类不能被用于实例化对象，它只能作为接口使用
    virtual int area() = 0;//虚函数(virtual)。在派生类中重新定义，编译器不静态链接到该函数，调用时动态链接，或后期绑定。
    
    Box operator+(const Box& b){ //重载 + 运算符，用于把两个 Box 对象相加
       	Box box;
       	box.length = this->length + b.length;
       	return box;
    }
    Box3 = Box1 + Box2;//把两个对象相加，得到 Box3

//C#
    using System;
    namespace LineApplication{ 
    	class Shape{ }//基类
    	public interface PaintCost{ }//接口
       	class Line : Shape, PaintCost{ 
    	   	private double length;// 线条的长度
    	   	public Line(){   // 构造函数 
    	      	Console.WriteLine("对象已创建");
    	   	}
    	   	~Line(){  //析构函数 
    	      	Console.WriteLine("对象已删除");
    	   	}
    	   	public void setLength( double len ){ 
    	      	length = len;
    	   	}
    	   	public double getLength(){ 
    	      	return length;
    	   	}
    	   	static void Main(string[] args){ //关键字 static 意味着类中只有一个该成员的实例
    	      	Line line = new Line();
    	      	// 设置线条长度
    	      	line.setLength(6.0);
    	      	Console.WriteLine("线条的长度： {0}", line.getLength());           
    	   	}
    	}
    }
    //多态、运算符重载与C++一样

//php5起
    <?php
    interface iTemplate{ }//接口
    class BaseClass implements iTemplate{ //实现接口
    	const constant = 'constant value';//类常量
       	function __construct() { //构造函数
           	print "In constructor\n";
           	$this->name = "MyDestructableClass";
       	}
       	function __destruct() { //析构函数
           	print "Destroying " . $this->name . "\n";
       	}
    }
    class SubClass extends BaseClass { //继承
        // inherits BaseClass's constructor
    }
    $obj = new BaseClass();// In BaseClass constructor
    $obj = new SubClass();// In BaseClass constructor，In SubClass constructor
    
    echo $classname::CONST_VALUE; // 自 PHP 5.3.0 起
    
    public static $my_static = 'foo';//static 也可用于定义静态变量以及后期静态绑定
    
    abstract protected function getValue();//抽象方法，强制要求子类定义这些方法
    
    // 匿名类，使用了 PHP 7+ 后的代码
    $util->setLogger(new class { 
        public function log($msg){ 
            echo $msg;
        }
    });
    ?>

//Swift
    class mainClass { 
        var no1 : Int // 局部存储变量
        init(no1 : Int) { //构造过程
            self.no1 = no1 // 初始化
        }
        deinit { //析构过程
        	// 执行析构过程
    	}
        func show() { 
            print("这是超类 SuperClass")
        }
    }
    class subClass : mainClass { //继承
        var no2 : Int // 新的子类存储变量
        init(no1 : Int, no2 : Int) { 
            self.no2 = no2 // 初始化
            super.init(no1:no1) // 初始化超类
        }
        override func show() { //重写（Overriding）,使用 final 关键字防止它们被重写。
            print("这是子类 SubClass")
        }
    }

[Java]: http://www.runoob.com/java/java-tutorial.html
[C]: http://www.runoob.com/cprogramming/c-tutorial.html
[C_]: http://www.runoob.com/cplusplus/cpp-tutorial.html
[Python 3]: http://www.runoob.com/python3/python3-tutorial.html
[C_ 1]: http://www.runoob.com/csharp/csharp-tutorial.html
[PHP]: http://www.runoob.com/php/php-tutorial.html
[JavaScript]: http://www.runoob.com/js/js-tutorial.html
[Node.js]: https://www.runoob.com/nodejs/nodejs-tutorial.html
[SQL]: http://www.runoob.com/sql/sql-tutorial.html
[Swift]: http://www.runoob.com/swift/swift-tutorial.html
[Go]: http://www.runoob.com/go/go-tutorial.html