标签：
import Foundation
print("Hello, World!")
let a = 10
var b = 20
var c = a + b;
c = 3000
//重载:函数名相同, 函数类型不同(参数, 返回值不同), 构成重载, 调用的时候, 根据参数确定调用那个函数
func helloworld(a:Int)->Int {
return a * 100
}
func hellowold(a:String)->Int {
return 100
}
print(hellowold("123"))
//for 循环
//区间0...10 = [0, 10] 0..<10 = [0, 10)
for i in 0...10 {
print("i = \(i)")
}
//1.枚举
//2.类 和 结构
//定义枚举值
enum Direction : String {
case East = "东"
case West = "西"
case South = "南"
case North = "北"
}
//定义变量接受枚举值
//如果给一个变量赋值过一次枚举值, 下次赋值可以直接使用.进行赋值
var dir = Direction.East
print(dir)
var dir2 = dir
dir = .North
print("dir = \(dir.rawValue), dir2 = \(dir2.rawValue)")
//枚举值的原始值
enum Season: Int{
case Spring = 100
case Snmmer
case Fall
case Winter
}
var se = Season.Spring
//rawValue, 原始值
print(se.rawValue)
//通过枚举值的原始值找到枚举值
let sea = Season(rawValue: 100)
print(sea)
//隐式解析
if let s = sea {
print("s = \(s)")
} else {
print("无法找到枚举值")
}
enum Student: String{
case Primary = "小学"
case junior
case senior
case university
}
var stu = Student.Primary
print( stu.rawValue)
let student = Student(rawValue:"小学")
print(student)
if let st = student {
print("st = \(st)")
} else {
print("无法找到枚举值")
}
enum FourFlower : String {
case 闯神 = "尼古拉斯·闯"
case 龙神 = "龙神"
case 宗主 = "宗主"
case 半张 = "半张"
}
let flower = FourFlower.闯神.rawValue
print("闯神\(flower)")
//类 和 结构体
struct Person{
var height = 1.8
var weight = 75
var age = 25
}
//实例结构体化
//()就是结构体的一个初始化方法
var 广恩 = Person()
print(广恩.weight)
广恩.weight = 90
print("广恩的体重 = \(广恩.weight)KG")
//逐一构造器
//构造 = alloc...init = 初始化
//析构 = dealloc = 释放
var 康康 = Person (height: 178, weight: 70, age: 23)
let str = "康康的身高为\(康康.height), 体重为\(康康.weight)" + ", 年龄为\(康康.age)"
print(str)
var 李阳 = 康康
康康.height = 180
print("李阳.height = \(李阳.height)")
//类
class Student1{
var num = 12345
var name = "万宝"
var GoodFriend = "闯神"
}
//系统没有给类自动添加逐一构造器
var 万少 = Student1()
万少.GoodFriend = "越南"
print(万少.GoodFriend)
var 龙神 = 万少
万少.GoodFriend = "Xcode"
print(龙神.GoodFriend)
//A = B
//值类型 : 赋值完成以后, B 修改, A不变. 枚举值 和 结构体就是值类型. 类似 copy 的过程
//引用类型 : 赋值完成以后, B 修改, A 随着 B 改变, 类就是引用类型. 类似 retain 的过程
//属性
//存储属性:用来存值和取值
//计算属性:计算属性的值通过 GET 方法, 用其他因素获取, set方法一般用来处理事务. 只写 GET, 这个属性是只读的; 不能只写 set
class Animal {
//存储属性
var type = "Elephant"
var weigh = 1000
//计算属性
var leg : Int {
get {
if type == "Elephant" {
return 4
} else if type == "bird" {
return 2
} else {
return 3
}
}
//set 方法需要一个 新值 参数
set(newValue){
if(newValue >= 4){
print("不可能是人")
} else {
print("有可能是人")
}
}
}
}
var per = Animal()
per.type = "老人"
print("per.leg = \(per.leg)")
per.leg = 10
print("per.leg = \(per.leg)")
//练习
//1.定义一个名字为rect的结构体
//2.属性包括 存储属性, x, y, with, height 计算属性 centerX, centerY
//3.centerX 和 centerY 由存储属性计算得出
//4.centerX 和 centerY 的 set 方法内分别依据 x/y 和 新值计算width/height
struct Rect {
//属性包括 存储属性, x, y, with, height
var x = 0.0
var y = 0.0
var width = 0.0
var height = 0.0
//在类内部使用属性的时候, 可以省略 self.
//只有涉及到参数名字和属性相同的时候, 建议加上 self.以示
//计算属性 centerX, centerY
var centerX :Double {
get{
//centerX 和 centerY 由存储属性计算得出
return self.x + self.width/2.0
}set{
//centerX 和 centerY 的 set 方法内分别依据 x/y 和 新值计算width/height
width = (newValue - x)*2
}
}
var centerY :Double {
get{
return y + height/2.0
}set{
height = (newValue - y)*2
}
}
}
//属性观察器
class Plant {
var type = "绿色植物"{
willSet(newType) {
print("newType = \(newType), 当前值\(type)")
} didSet(oldType) {
print("oldType = \(oldType), 当前值\(type)")
}
}
var hasFlower : Bool = false {
willSet {
print("新值为\(newValue), 当前值为\(hasFlower)")
} didSet {
print("旧值为\(oldValue), 当前值为\(hasFlower)")
}
}
}
var appleTree = Plant()
appleTree.type = "苹果树"
appleTree.hasFlower = true
//类型属性
class Fruit {
//是否有皮
static var hasRind = true
}
print("水果是否有皮: \(Fruit.hasRind)")
//方法
class Computer{
var brand = "美帝良心想"
var price = 6888
func des(name:String){
print("\(name)买了\(brand), 花了￥\(price)")
}
}
var compu = Computer()
compu.des("闯神")
class Car {
var brand = "奥迪"
var color = "黑色"
func TYPE(name:String){
print("\(name)买了颜色为\(color)的车, 牌子是\(brand)")
}
}
var car = Car()
car.TYPE("外星人")
//继承
//定义父类
class Teacher {
var academic = "教授"
var offer = 8888
func teach(){
print("某\(academic)的薪资是\(offer)")
}
//禁止被重写的方法
//final 禁止被重写的关键字
final func study(bookName:String){
print("某\(academic),刻苦钻研\(bookName)")
}
var num : Int {
get {
return 100
} set {
}
}
}
//定义一个子类
//讲师
class Lecturer: Teacher {
var industry = "iOS"
//重写父类方法
//override 重写父类方法关键字
override func teach() {
//调用父类方法
super.teach()
print("从事行业是\(industry)")
}
}
let lec = Lecturer()
lec.academic = "两院院士"
lec.teach()
lec.study("<<论持久战>>")
//重写属性
//把存储属性重写为计算属性
//不能把计算属性重写为存储属性
class ChildrenTeacher:Teacher {
override var offer: Int {
get{
return 10000
} set {
}
}
// override var num = 100
}
//构造
//除了可选类型属性, 在构造过程中, 必须给各个属性赋初始值
class Hero{
var age :Int?
var name : String
var equipment = "金箍棒"
var saddleHorse : String
init(){
name = "孙悟空"
saddleHorse = "筋斗云"
}
//自定义一个构造方法
init(name:String, equipment:String, saddleHorse:String ){
self.name = name
self.equipment = equipment
self.saddleHorse = saddleHorse
}
}
let 孙悟空 = Hero()
print(孙悟空.saddleHorse)
let 大禹 = Hero(name: "大禹", equipment: 孙悟空.equipment, saddleHorse: "11路公交")
class Film {
var name : String
var price : Float
var director : String
init (name:String, price:Float, director:String){
self.name = name
self.price = price
self.director = director
}
func description(){
print("电影名字\(name), 价格为\(price), 导演是\(director)")
}
//遍历构造器
//和 OC 的不是一回事, OC的是 类方法
//convenience 在构造方法前添加 convenience代表当前构造器为便利构造器
//遍历构造器必须调用自身的指定构造器
convenience init(){
self.init(name:"123", price:22, director:"王晶")
// name = "123"
// price = 22
// director = "王晶"
}
}
let 澳门风云三 = Film(name: "澳门风云三", price: 33, director: "尔冬升")
print(澳门风云三.price)
澳门风云三.description()
let 恶棍天使 = Film()
恶棍天使.description()
Swift中enum, struct, class的有关使用方法
标签：
原文地址：http://www.cnblogs.com/wsn1993/p/5064945.html
