swift基础学习(04)[运算符、属性、属性观察器、方法、下脚标本、继承、构造器]

概述//swift恒等运算符 //===恒等，不等!== //运用这两个运算符检测两个常量或者变量是否引用同一个实例 //“等价于”表示两个类类型(class type)的常量或者变量引用同一个类实例。 //等于”表示两个实例的值“相等”或“相同”,判定时要遵照设计者定义的评判标准,因此相对于“相 等”来说,这是一种更加合适的叫法。 //类和结构体的选择 //属性的存储只能是类或者是结构体 //存储属

//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)")

//默认属性值

//自定义构造过程

总结

以上是内存溢出为你收集整理的swift基础学习(04)[运算符、属性、属性观察器、方法、下脚标本、继承、构造器]全部内容，希望文章能够帮你解决swift基础学习(04)[运算符、属性、属性观察器、方法、下脚标本、继承、构造器]所遇到的程序开发问题。

如果觉得内存溢出网站内容还不错，欢迎将内存溢出网站推荐给程序员好友。