admin管理员组文章数量:1794759
主流编程语言语法简单总结（Java, C, C++, C#, PHP, JavaScript, Swift, Go）
经常用到多种编程语言，时间长了容易搞混，整理一下不用语言语法的异同点，方便快速学习或温习。
根据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 月编程语言排行榜：
| 1 | 1 | Java | 17.801% | +5.37% | web后端，游戏后端，大数据，Android |
| 2 | 2 | C | 15.376% | +7.00% | 各种核心库，嵌入式 |
| 3 | 3 | C++ | 7.593% | +2.59% | 各种后端（除web） |
| 4 | 5 | Python | 7.156% | +3.35% | 机器学习，大数据 |
| 5 | 8 | Visual Basic .NET | 5.884% | +3.15% | Win平台下的APP、web后端 |
| 6 | 4 | C# | 3.485% | -0.37% | Win平台下的APP、web后端，Unity3D |
| 7 | 7 | PHP | 2.794% | +0.00% | web后端 |
| 8 | 6 | JavaScript | 2.280% | -0.73% | web前端，Node.js |
| 9 | - | SQL | 2.038% | +2.04% | 数据库 |
| 10 | 16 | Swift | 1.500% | -0.17% | iOS |
| 11 | 13 | MATLAB | 1.317% | -0.56% | 数学计算 |
| 12 | 20 | Go | 1.253% | -0.10% | 高性能分布式后端 |
主要参考：菜鸟教程（Java 教程，C 语言教程，C++ 教程，Python 3 教程，C# 教程，PHP 教程，JavaScript 教程，Node.js教程，SQL 教程，Swift 教程，Go 语言教程）
文章目录- 基础语法
- Hello World
- 标识符
- 空格
- 注释
- 数据类型
- 变量类型
- Swift 可选(Optionals)类型
- 常量
- 运算符
- 判断
- 循环
- 字符串
- 数组
- 结构体
- 指针
- 函数（方法）
- 异常处理
- 包
- 接口（抽象类，协议）
- 枚举
- 泛型
- 面向对象
类名、变量名以及方法名都被称为标识符。
- 所有的标识符都以字母（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 的可选（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#特有)
指针是一个变量，其值为另一个变量的地址，即，内存位置的直接地址。
//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 ( ypareTo( max ) > 0 ){ max = y; //y 更大 } if ( zpareTo( 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") } }本文标签： 语法编程语言主流简单JavaScript
版权声明：本文标题：主流编程语言语法简单总结（Java, C, C++, C#, PHP, JavaScript, Swift, Go） 内容由林淑君副主任自发贡献，该文观点仅代表作者本人， 转载请联系作者并注明出处：http://www.xiehuijuan.com/baike/1686514810a76254.html， 本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌抄袭侵权/违法违规的内容，一经查实，本站将立刻删除。
发表评论