//swift恒等运算符
//===恒等，不等!==
//运用这两个运算符检测两个常量或者变量是否引用同一个实例
//“等价于”表示两个类类型(class type)的常量或者变量引用同一个类实例。
//等于”表示两个实例的值“相等”或“相同”,判定时要遵照设计者定义的评判标准,因此相对于“相
等”来说,这是一种更加合适的叫法。
//类和结构体的选择
//属性的存储只能是类或者是结构体
//存储属性：变量存储属性var
常量存储属性let
//常量属性
struct FixedLengthRange {
var first:
Int
let length:
Int
}
var range = FixedLengthRange(first:
5,length: 69)
range.first =
7
//对于常量赋值则不允许
//常量结构体的存储属性
//延迟存储属性：延迟存储属性是指当第一次被调用的时候才会计算其初始值的属性。
class DataImporter {
var fileName =
"lihuan.txt"
}
class DataManager {
lazy
var importer = DataImporter()
var data = [String]()//提供数据管理功能
}
let manager = DataManager()
manager.data.append("some data")
manager.data.append("some more data")
print(manager.importer.fileName)
//存储属性和实例变量
//计算属性
struct Point {
var x =
0.0,y = 0.0
}
struct Size {
var width =
0.0,height = 0.0
}
struct Rect {
var origin =
Point()
var size =
Size ()
var center:Point {
get {
let centerX =
origin.x + (size.width /
2)
let centerY =
origin.y + (size.height /
2)
return
Point(x:centerX,y: centerY)
}
set(newCenter) {
origin.x = newCenter.x - (size.width
/ 2)
origin.y = newCenter.y - (size.height
/ 2)
}
}
}
var square = Rect(origin:
Point(x: 0.0,y:
0.0),size:Size(width:
10.0,height: 10.0))
let initialSquareCenter =
square.center
square.center =
Point(x: 15.0,y:
15.0)
print("square.origin is now at (\(square.origin.x),\(square.origin.y))")
//只读计算属性,只读计算属性的声明可以去掉get关键字和花括号
struct Cuboid {
var width = 0.0,height =
0.0,depth = 0.0
var volume:Double {
return
width*height*depth
}
}
let fourByFiveByTwo = Cuboid(width:
4.0,height: 5.0,depth:
2.0)
print("\(fourByFiveByTwo.volume)")
//属性观察器:属性观察器监控和响应属性值的变化,每次属性被设置值的时候都会调用属性观察器,甚至新的值和现在的值相同的时候也不例外
//可以为除了延迟存储属性之外的其他存储属性添加属性观察器,也可以通过重写属性的方式为继承的属性(包括
存储属性和计算属性)添加属性观察器
// willSet在新的值被设置之前调用,didSet在新的值被设置之后立即调用
class StepCounter {
var totalSteps:Int =
0 {
willSet(newTotalSteps){
print("will set
\(newTotalSteps)")
}
didSet{
if
totalSteps > oldValue {
print("did set
\(totalSteps - oldValue)")
}
}
}
}
let setpCounter = StepCounter()
setpCounter.totalSteps =
200
setpCounter.totalSteps =
360
//全局变量和局部变量
//类型属性，类型属性语法
struct SomeStructure {
static
var storedTypeProperty =
"some value"
static
var computedTypeProperty:
Int {
return
6
}
}
class SomeClass {
static
var storedTypeProperty =
"some value"
static
var computedTypeProperty:
Int {
return
104
}
}
//获取和设置类型属性的值
print(SomeStructure.storedTypeProperty)
SomeStructure.storedTypeProperty =
"another value"
print(SomeStructure.storedTypeProperty)
print(SomeClass.computedTypeProperty)
//eg
struct AudioChannel {
static let thresholdLevel =
10
static
var maxInputLevelForAllChannels =
0
var currentLevel:
Int = 0 {
didSet {
if
currentLevel > AudioChannel.thresholdLevel {
currentLevel =
AudioChannel.thresholdLevel
}
if
currentLevel > AudioChannel.maxInputLevelForAllChannels {
AudioChannel.maxInputLevelForAllChannels =
currentLevel
}
}
}
}
var leftChannel = AudioChannel()
var rightChannel = AudioChannel()
leftChannel.currentLevel =
7
print(leftChannel.currentLevel)
//方法
//实例方法
实例方法不能脱离于现存的实例而被调用
class Counter {
//类中定义了三个实例话方法
var count =
0
func increment() {
count +=
1
}
func incrementBy(amount:Int) {
self.count += amount
}
func reset() {
count =
0
}
}
//通过.语法来调用实例话方法
let counter = Counter()
counter.increment()
counter.incrementBy(5)
counter.reset()
print(counter.count)
class CounterTwo {
var count:
Int = 0
func incrementBy(amount:Int,numberOfTimes:Int) {
count += amount*numberOfTimes
}
}
//默认的情况下第一个参数被认为是局部名称，第二个参数被认为既可以看作内部也可以看做外部
let counterTwo = CounterTwo()
counterTwo.incrementBy(5,numberOfTimes:9)
print(counterTwo.count)
////修改方法的外部参数名称
//self属性
//在实例方法中修改值类型
//类型方法调用也是.语法
实例方法是被类型的某个实例调用的方法。你也可以定义类型本身调用的方法,这种方法就叫做类型方法
class SomeOtherClass {
static
func someMethod() {
print("类型方法")
}
}
SomeOtherClass.someMethod()
//水平
struct LevelTracker {
static
var highestUnlockedLevel =
1
static
func unlockLevel(level:Int){
highestUnlockedLevel = level
}
static
func levelIsUnlocked(level:Int) ->
Bool {
return level <= highestUnlockedLevel
}
var currentLevel =
1
mutating
func advanceToLevel(level:Int) ->
Bool {
if
LevelTracker.levelIsUnlocked(level) {
currentLevel = level
return
true
}else {
return
false
}
}
}
//监测进度
class Player {
var tracker =
LevelTracker()
let playName:String
func completedLevel(level:Int){
LevelTracker.unlockLevel(level +
1)
tracker.advanceToLevel(level +
1)
}
init(name:String) {
playName = name
}
}
var player = Player(name:"lihuan")
if player.tracker.advanceToLevel(6)
{
print("player is now on level 6")
}
else{
print("level 6 has not yet been unlocked")
}
//下标脚本下标脚本
可以定义在类(Class)、结构体(structure)和枚举(enumeration)这些目标中,可以认为是访问
集合(collection),列表(list)或序列(sequence的快捷方式,使用下标脚本的索引设置和获取值,不需要
再调用实例的特定的赋值和访问方法。举例来说,用下标脚本访问一个数组(Array)实例中的元素可以这样写
meArray[index] ,访问字典(Dictionary)实例中的元素可以这样写 someDictionary[key]
//下标脚本语法
//subscript(index:Int) -> Int {
// get{
// //返回与入参匹配的Int类型的值
// }
// set(newValue){
//
// //执行赋值操作
// }
//
//}
//eg
struct TimesTable {
let multiplier:Int
subscript(index:Int) ->
Int {
return
multiplier * index
}
}
let threeTimesTable = TimesTable(multiplier:
3)
//根据角标找到然后返回
print("3的6倍是\(threeTimesTable[6])")
//下标脚本用法
var numberOfLegs = ["splider":8,"ant":6,"cat":4]
numberOfLegs["bird"] =
2
print(numberOfLegs)
//继承
//基类:不继承其它类的类
class Vehicle {
var currentSpeed =
0.0
var description:String {
return
"traveling at \(currentSpeed) miles per hour"
}
func makeNoise() {
//
print("我有噪音");
}
}
let someVehicle = Vehicle()
print("vehicle :\(someVehicle.description)")
//子类生成
子类生成(Subclassing)指的是在一个已有类的基础上创建一个新的类
class Bicycle:Vehicle {
//继承父类的子类
var hasBasket =
false
}
let bicycle = Bicycle()
bicycle.hasBasket =
true;
bicycle.currentSpeed =
15.0
print("vehicle :\(bicycle.description)")
class Tandem: Bicycle {
var currentNumberOfPages =
0
override
func makeNoise() {
print("hello")
}
}
let tandem = Tandem()
tandem.hasBasket =
true
tandem.currentSpeed =
22.0
print("\(tandem.hasBasket)")
tandem.makeNoise()
//重写属性,防止重写的话天假final
//构造过程
//存储属性的初赋值
//构造器构造器在创建某特定类型的新实例时调用。它的最简形式类似于一个不带任何参数的实例方法,以关键字
init 命
名。
struct Fathreheit {
var temperature :Double
init() {
temperature =
32.0
}
}
var f = Fathreheit()
print("\(f.temperature)")
//默认属性值
//自定义构造过程