Swift3.0学习笔记-The Basics（对比Java）

来源：互联网发布：rhino mac 破解编辑：程序博客网时间：2024/06/11 17:05

根据苹果官网的顺序学习Swift语言：

https://developer.apple.com/library/prerelease/content/documentation/Swift/Conceptual/Swift_Programming_Language/TheBasics.html#//apple_ref/doc/uid/TP40014097-CH5-ID309

Swift是为iOS，macOS，watchOS和tvOS应用开发设计的一种新的语言。 Swift参考了很多C和Object－C语言的做法。
Swift实现了所有C和OC的基础数据类型，包括整型Int，Double和Float作为浮点数类型，布尔类型Bool，字符串类型String。而且Swift提供了3种主要并且功能强大的集合类型，包括Array，Set和Dictionary。
跟C语言类似，Swift使用变量存值和通过变量取值。 Swift还实现了常量数据类型，即值不可更改，而且比C语言常量要更可靠。一般在你不希望值被篡改时使用常量，从而使得Swift语言更安全、清晰。

除了熟悉的数据类型， Swift还提供了OC没有的数据类型，例如元组。元组可以创建和传值多个变量。
Swift还提供可能数据类型，处理变量没赋初值的情况。Optional可能有值也可能没值，没值时等于nil。这个nil跟OC的nil不同，在Swift中nil可以赋给任意数据类型，这是Swift一个核心特性。

Swift是类型安全的语言，即Swift会确定每个变量的数据类型。如果一个参数是String类型，那么无法赋Int型赋值给它。类似的，你无法将可选字符串类型赋值给字符串类型。数据类型检查在编码阶段就会被Xcode检查出来并提示错误。

下面用Swift和Java逐一说明基本语法：

let用于声明常量（类似于Java的final关键字），var用于声明变量（Java中无类似关键字）

/** 常量和变量 let做常量 var做变量**/

let ConstantValue ="constant" //常量，隐式String类型。不可修改

var value = "value" //变量，编译器会根据之类型设置变量类型

value = "modify" //修改value变量

//ConstantValue = "modify" //这句会报错，常量不能修改

print("No1:"+value)

final String ConstantValue = "constant";String value = "value";value = "modify";System.out.println("No1:" + value);

说明：Swift没有分号、以换行符为一句代码的结束符；Java以分号作为一句代码的结束符。Swift可以不像Java那样显式的声明变量类型，初值的类型就是参数类型。

let lable = "the width is "

let width = 94

let widthLable = lable+String(width)

print(widthLable) //the width is 94

String lable = "the width is";int width = 94;String widthLable = lable + width;System.out.println(widthLable);

说明：在Swift语言中整型和字符串类型拼接时，要先将整型转换为字符串类型。（Swift是类型安全的）

var x=0.0, y=0.0, z=0, strValue="test"//声明多个变量,以逗号分隔，隐式的根据值设置变量类型。x和y是Int型，z是Double型，strValue是String型

var red, green, blue:Double //red green blue都是Double类型

var welcomeMessage:String //: 在Swift里是type of的意思，即指定数据类型

welcomeMessage = strValue

print("welcomeMessage:"+welcomeMessage) //welcomMessage:test

double x=0.0, y=0.0;int z=0;String strValue = "test";double red, green, blue;String welcomeMessage;welcomeMessage = strValue;System.out.println("welcomMessage:" + welcomeMessage);

说明：在Swift语言中，一行代码可以声明多种数据类型，而Java只能声明一种；Swift里的冒号空格对应的英文解释是type of，即后面是数据类型、前面是变量名；

let apples = 3

let oranges = 5 //Int型

let appleSummary ="I have\(apples) apples"

let fruitSummary ="I have\(apples+oranges) pieces of fruit"

print("fruitSummary"+fruitSummary)

final int apples = 3;final int oranges = 5;final String appleSummary = "I have " + apples + " apples";final String fruitSummary = "I have" + (apples+oranges) + " piece of fruit";System.out.println("fruitSummary" + fruitSummary);

说明：在Swift中字符串里添加整型变量时用\(Int)方式，例如\(apples)。

var tmp1 = 1;

var tmp2 = 2.1;

var tmp3: Double

tmp3 = Double(tmp1) +tmp2 //Swift是类型安全语言，编译器不会修改参数类型。tmp1是整型，需要强转为Double才能相加。

int tmp1 = 1;double tmp2 = 2.1;double tmp3;tmp3 = tmp1 + tmp2;

说明：Swift是类型安全语言，Java不是类型安全语言；在Swift中要先强转tmp1为Double型才能与tmp2相加，而在Java中编译器会直接将tmp1的值转换为double型，不用显式的强转。Swift和Java的强转方法有区别，Swifit是Double(tmp1），即参数外加圆括号；Java是(double)tmp1，即关键字外加括号。

//类型转换

let meaningOfLife = 42 //Int型译

let pi=3.14159 //有小数时默认数据类型总是为Double型，而不是Float

let anotherPi = 3 + 0.14159 //3是Int型，0.14159是Double型，所以anotherPi是Double型

let resultPi = pi -anotherPi //resultPi是Double型

print("pi result:"+String(resultPi)) //0.0

//进制，下面4个参数都是十进制的17

let dcimalInteger = 17 //十进制

let binaryInteger = 0b10001 //二进制，以0b开头

let octalInteger = 0o21 //八进制，以0o开头

let hexadecimalInteger = 0x11 //十六进制，以0x开头

//数字写法

let paddingDouble = 000123.456 //可以在数字前边加0

let oneMillion = 1_000_000 //西方写法一百万，Int型1000000，以_为占位符，方便理解位数

let justOverOneMillion = 1_000_000.000_000_1

let oneMillion1 = 100_0000 //中国写法，100万

let oneMillionJava = 1000000; //Java和C的写法，100万

说明：在数字里下划线是占位符，没有任何意义，只是为了提高可读性。这个设计很赞，再也不用数0了

//数字越界编译器会检查，如果出现越界时编译报错

//let cannotBeNegative: UInt8 = -1 //这样写会提示错误！

说明：Xcode和Android Studio都会检查值的范围，如果越界会给出错误提示。

//自定义关键字，类似于C语言的typedef

typealias IntType =Int //IntType等同于Int

var typeTest1: IntType //typeTest1是Int型

typeTest1 = 10

var typeTest2: Int

typeTest2 = 10

print("typealias result:"+String(typeTest2-typeTest1)) //typealias result:0

说明：在Java中没有类似功能关键字。

//布尔值

let orangesAreOrange = true //Bool型

let turnipsAreDelicious = false

if turnipsAreDelicious {

print("Mmm, tasty turnips")

} else {

print("Eww, trunips are horrible")

}

let i = 1

if i ==1 {

print("this will be executed") //this will be execute

}

final boolean orangeAreOrange = true;final boolean turnipsAreDelicious = false;if (turnipsAreDelicious) {    System.out.print("Mmm, tasty turnips");} else {    System.out.print("Eww, trunips are horrible");}final int i = 1;if (i == 1) {    System.out.println("this will be executed");}

说明：Swift的布尔关键字是Bool，等同于Java的boolean。 if的用法也都一致， 区别是Swift if判断语句没有圆括号。

//键值对

let http404Error = (404,"Not Found")//http404Error是键值对(Int, String)类型

let (statusCode, statusMsg) = http404Error //参数statusCode,statusMsg是值http404Error的类型

print("The status code is\(statusCode)") //The status code is 404

print("The status Message is\(statusMsg)")

let (justStatusCode, _) =http404Error //只需要一个值时，另一个可以用_做占位符

print("The status code is\(justStatusCode)")

print("The status code is\(http404Error.0)")//使用下标取值，"The status code is 404"

说明：类似于Java的Map，但Swift的键值对用法更加灵活方便。下划线可以作为占位符。

//Optional 不确定类型?

let possibleNumber = "123"

let convertNumber =Int(possibleNumber) //这时convertNumber是Int?型

let possibleNumber1 = "abc"

let convertNumber1 =Int(possibleNumber1) //这时convertNumber1是Int?型，值为nil

if convertNumber !=nil {

print("convertNumber:"+String(describing:convertNumber))

｝

if convertNumber1 ==nil {

print("convertNumber1 is nil") //convertNumber1 is nil

}

说明：Optional类型是指变量可能没赋初值的情况，这时值是nil。 nil的含义就是没值，在Swift里不是指针；Java里没有类似数据类型。

//nil 不是指针，可以赋值给任何数据类型，类似于Java没赋初值的情况

var serverResponseCode: Int? = 404 //声明加赋值404

serverResponseCode = nil

var nilInt: Int

//nilInt = nil //提示错误，nil不能赋给Int型

说明：对于基本数据类型，不能赋值为nil；可选数据类型（?）可以赋值为nil。

//确定数据类型！即肯定有值

let possibleString: String? ="an optional String"

let forcedString: String =possibleString!

let assumedString:String! ="An implicitly unwrapped optional String"

let implicitString: String =assumedString //不需要感叹号

说明：？和！在Swift中类似，区别是？可能为ni，而！不可能为nil，？指可能的数据类型，！是肯定的数据类型。换句话说，Optional(?)类型可能存在空值nil的情况，而！指任何时候参数里都有值。

//如果possibleNumber是个数字，那么赋值给actualNumber,且actualNumber是Int型

if let actualNumber =Int(possibleNumber) {

print("possibleNumber has an Interger value of\(actualNumber)")

} else {

print("possibleNumber could not be converted to Integer")

}

说明：如果possibleNumber由数字组成的字符串，例如”123“，那么if会为真；否则为假。

/** 数组使用[]创建一个数组或字典，通过index或key获取对应的之**/

var shoppingList = ["catfish","water","tulips"] //String数组，含有3个值

shoppingList[1] ="bottle of water" //修改第2个值

var occupations = [

"key1":"value1",

"key2":"value2",

]

occupations["key1"] ="modify value1"

var someStrs = [String]() //String类型的空数组

var someStrs1: [String] = ["first","second"]

String[] shoppingList = {"catfish", "water", "tulips"};shoppingList[1] = "bottle of water"; //通过下标修改值//使用HashMap实现...String[] someStrs = new String[3];String[] someStrs1 = {"first", "second"};

说明：Swift声明数组的方式跟Java类似，区别是Swift对关键字加方框，而Java是对值加方框；occupations类似于Java的new HashMap<String, String>()

小结：

1、Swift声明参数分为显示和隐式的方法，而Java只能是显式。

2、Swift的nil并不是空指针，可以理解为空值。因为它可以赋值给Optional类型。

3、Swift对数字添加了下划线作为占位符，提高了可读性；

4、Swift是类型安全语言，Int和Double型不能直接加减乘除；而Java是可以的。

附参考代码：

////  main.swift//  swiftdemo////  Created by brycegao on 16/11/5.//  Copyright © 2016年 brycegao. All rights reserved.//import Foundationprint("The Basics")//https://developer.apple.com/library/prerelease/content/documentation/Swift/Conceptual/Swift_Programming_Language/TheBasics.html#//apple_ref/doc/uid/TP40014097-CH5-ID309var tmp1 = 1;var tmp2 = 2.1;var tmp3: Doubletmp3 = Double(tmp1) + tmp2/** 常量和变量 let做常量 var做变量**/let ConstantValue = "constant"  //常量，隐式String类型。不可修改var value = "value"          //变量，编译器会根据之类型设置变量类型value = "modify"      //修改value变量//ConstantValue = "modify"   //这句会报错，常量不能修改print("No1:" + value)let lable = "the width is "let width = 94let widthLable = lable + String(width)print(widthLable)     //the width is 94var x=0.0, y=0.0, z=0, strValue="test" //声明多个变量,以逗号分隔，隐式的根据值设置变量类型var red, green, blue: Double  //red green blue都是Double类型var welcomeMessage: String   //: 在Swift里是type of的意思， 即指定数据类型welcomeMessage = strValueprint("welcomeMessage:" + welcomeMessage)  //welcomMessage:testlet apples = 3let oranges = 5    //Int型let appleSummary = "I have \(apples) apples"let fruitSummary = "I have \(apples+oranges) pieces of fruit"print("fruitSummary" + fruitSummary)var iTest1: Int     //在32位平台下等同于Int32， 64位平台下等同于Int64var iTest2: Int64iTest2 = 3//类型转换let meaningOfLife = 42   //Int型译let pi=3.14159   //有小数时默认数据类型总是为Double型，而不是Floatlet anotherPi = 3 + 0.14159     //3是Int型，0.14159是Double型，所以anotherPi是Double型let resultPi = pi - anotherPiprint("pi result:" + String(resultPi))  //0.0//进制let dcimalInteger = 17       //十进制let binaryInteger = 0b10001  //二进制let octalInteger = 0o21      //八进制let hexadecimalInteger = 0x11  //十六进制//数字写法let paddingDouble = 000123.456   //可以在数字前边加0let oneMillion = 1_000_000     //西方写法一百万，Int型1000000，以_为占位符，方便理解位数let justOverOneMillion = 1_000_000.000_000_1let oneMillion1 = 100_0000    //中国写法，100万let oneMillionJava = 1000000; //Java/C的写法，100万//数字越界 编译器会检查，如果出现越界时编译报错//let cannotBeNegative: UInt8 = -1   //这样写会提示错误！//整型和浮点型转换， 强转语法如Double(value)let three = 3 //Int型let pointOneFourOneFiveNine = 0.14159 //Double型let pi1 = Double(three) + pointOneFourOneFiveNine   //pi是Double型//自定义关键字，类似于C语言的typedeftypealias IntType = Int    //IntType等同于Intvar typeTest1: IntType    //typeTest1是Int型typeTest1 = 10var typeTest2: InttypeTest2 = 10print("typealias result:" + String(typeTest2-typeTest1))  //typealias result:0//布尔值let orangesAreOrange = true  //Bool型let turnipsAreDelicious = falseif turnipsAreDelicious {    print("Mmm, tasty turnips")} else {    print("Eww, trunips are horrible")}let i = 1if i == 1 {    print("this will be executed")   //this will be execute}//键值对let http404Error = (404, "Not Found") //http404Error是键值对(Int, String)类型let (statusCode, statusMsg) = http404Errorprint("The status code is \(statusCode)")  //The status code is 404print("The status Message is \(statusMsg)")let (justStatusCode, _) = http404Error  //只需要一个值时，另一个可以用_做占位符print("The status code is \(justStatusCode)")print("The status code is \(http404Error.0)") //使用下标取值，"The status code is 404"//不确定类型?let possibleNumber = "123"let convertNumber = Int(possibleNumber)    //这时convertNumber是Int?型let possibleNumber1 = "abc"let convertNumber1 = Int(possibleNumber1)  //这时convertNumber1是Int?型，值为nilif convertNumber != nil {    print("convertNumber:" + String(describing: convertNumber))}    if convertNumber1 == nil {    print("convertNumber1 is nil")  //convertNumber1 is nil}//nil 不是指针，可以赋值给任何数据类型，类似于Java没赋初值的情况var serverResponseCode: Int? = 404  //声明加赋值404serverResponseCode = nilvar nilInt: Int//nilInt = nil      //提示错误，nil不能赋给Int型//确定数据类型！ 即肯定有值let possibleString: String? = "an optional String"let forcedString: String = possibleString!let assumedString: String! = "An implicitly unwrapped optional String"let implicitString: String  = assumedString   //不需要感叹号//如果possibleNumber是个数字， 那么赋值给actualNumber, 且actualNumber是Int型if let actualNumber = Int(possibleNumber) {    print("possibleNumber has an Interger value of \(actualNumber)")} else {    print("possibleNumber could not be converted to Integer")}/** 数组 使用[]创建一个数组或字典，通过index或key获取对应的之**/var shoppingList = ["catfish", "water", "tulips"]   //String数组，含有3个值shoppingList[1] = "bottle of water"   //修改第2个值var occupations = [    "key1": "value1",    "key2": "value2",]occupations["key1"] = "modify value1"var someStrs = [String]()    //String类型的空数组var someStrs1: [String] = ["first", "second"]

0 0