经常用到多种编程语言,时间长了容易搞混,整理一下不用语言语法的异同点,方便快速学习或温习。
根据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 月编程语言排行榜:
Oct 2018 | Oct 2017 | Programming Language | Ratings | Change | 主要使用场景 |
---|---|---|---|---|---|
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)类型
- 常量
- 运算符
- 判断
- 循环
- 字符串
- 数组
- 结构体
- 指针
- 函数(方法)
- 异常处理
- 包
- 接口(抽象类,协议)
- 枚举
- 泛型
- 面向对象
基础语法
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, C, C++, C#, PHP, JavaScript, Swift, Go)
发布评论