2016-02-19 09:52:31 damys 阅读数 271
  • Kubernetes Master Class

    为了帮助大家完成Kubernetes从入门到进阶的全过程,让企业IT人员能更快上手并落地Kubernetes,Rancher Labs【Kubernetes Master Class】已经正式启航!整季培训将有共计8期课程,课程内容包括大量生产环境操作,指导学员熟练掌握Kubernetes部署及管理技巧 。

    2249 人正在学习 去看看 Rancher

感谢Github上The Swift Programming Language开源翻译的中文版,感谢极客学院wiki提供的PDF版本
SwiftTour是对Swift主要的语言特性有个速览,后续的教程会逐个展开阐述。
代码上传至Github,有兴趣的可以下载下来试试

// 使用class和类名创建一个类
class Shape {
    var numberOfSides = 0
    func simpleDescription() ->String {
        return "A Shape with \(numberOfSides) sides"
    }
}

var shape = Shape()
shape.numberOfSides = 7
var shapeDescription = shape.simpleDescription()

// 使用init创建构造器,使用deinit创建一个析构函数
class NameShape {
    var numberOfSides: Int = 0
    var name: String
    init(name: String) {
        self.name = name
    }
    func simpleDescription() ->String {
        return "A Shape with \(numberOfSides) sides"
    }
}

// 子类重写父类的方法需要用override标记
class Squre: NameShape {
    var sideLength: Double
    init(sideLength: Double, name: String){
        self.sideLength = sideLength
        super.init(name: name)
        numberOfSides = 4
    }
    func area()->Double {
        return sideLength * sideLength
    }
    override func simpleDescription() -> String {
        return "A square with sides of length \(sideLength)"
    }
}
let test = Squre(sideLength: 5.2, name: "My test Square")
test.area()
test.simpleDescription()

// 类的getter和setter
class EquilateralTriangle: NameShape {
    var sideLength: Double = 0.0
    init(sideLength: Double, name: String){
        self.sideLength = sideLength
        super.init(name: name)
        numberOfSides = 3
    }
    var perimeter: Double {
        get {
            return 3.0 * sideLength
        }
        set {
            sideLength = newValue / 3.0
        }
    }
    override func simpleDescription() -> String {
        return "An equilateral triangle with sides of length \(sideLength)"
    }
}
var triangel = EquilateralTriangle(sideLength: 3.1, name: "a triangle")
print(triangel.perimeter)
triangel.perimeter = 9.9
print(triangel.sideLength)

// 不需要计算属性,仍然需要在设置新值之前或之后运行代码,使用willset和didset
// 确保三角形的边长综合正方形的边长相同
class TriangleAndSquare {
    var triangle: EquilateralTriangle {
        willSet {
            square.sideLength = newValue.sideLength
        }
    }
    var square: Squre {
        willSet {
            triangel.sideLength = newValue.sideLength
        }
    }
    init(size: Double, name: String) {
        square = Squre(sideLength: size, name: name)
        triangle = EquilateralTriangle(sideLength: size, name: name)
    }
}
var triangleAndSquare = TriangleAndSquare(size: 10, name: "Another tested Shape")
print(triangleAndSquare.square.sideLength)
print(triangleAndSquare.triangle.sideLength)
triangleAndSquare.triangle = EquilateralTriangle(sideLength: 30, name: "Other")
print(triangleAndSquare.triangle.sideLength)
print(triangleAndSquare.square.sideLength)

// 处理变量的可选值时,可以在操作前加?
let optionalSquare: Squre? = Squre(sideLength: 2.5, name: "Optional square")
let sideLength = optionalSquare?.sideLength
print(sideLength)
2018-03-01 18:59:21 longshihua 阅读数 2335
  • Kubernetes Master Class

    为了帮助大家完成Kubernetes从入门到进阶的全过程,让企业IT人员能更快上手并落地Kubernetes,Rancher Labs【Kubernetes Master Class】已经正式启航!整季培训将有共计8期课程,课程内容包括大量生产环境操作,指导学员熟练掌握Kubernetes部署及管理技巧 。

    2249 人正在学习 去看看 Rancher

static 和 class

在Swift中static和class都表示“类型范围作用域”的关键字。在所有类型中(class、static、enum)中,我们可以使用static来描述类型作用域。class是专门用于修饰class类型的。


static可以修饰属性和方法

class Person {
    // 存储属性
    static let age: Int = 20

    // 计算属性
    static var wotkTime: Int {
         return 8
    }
    // 类方法
    static func sleep() {
        print("sleep")
    }
}

但是所修饰的属性和方法不能够被重写,也就是说static修饰的类方法和属性包含了final关键字的特性。重写会报错如下:


class修饰方法和计算属性

我们同样可以使用class修饰方法和计算属性,但是不能够修饰存储属性


而且类方法和计算属性是可以被重写的,可以使用class关键字也可以是static

class Student: Person {
    
//    使用class
//    override class func sleep() {
//    }
//    override class var workTime: Int {
//        return 10
//    }

    // 使用static
    override static func sleep() {
    }
    override static var workTime: Int {
        return 10
    }
}

static和protocol

Swift中的class,struct,enum都可以实现某个指定的协议。如果我们想在protocol中定义一个类型作用域上的方法或者计算属性,应该使用哪个关键字?答案显而易见,肯定是static,因为static是通用的。注意:在使用protocol的时候,在enum和struct中仍然使用static进行修饰,在class中,class和static都可以使用。

protocol MyProtocol {
    static func foo() -> String
}

struct MyStruct: MyProtocol {
    static func foo() -> String {
        return "MyStruct"
    }
}

enum MyEnum: MyProtocol {
    static func foo() -> String {
        return "MyEnum"
    }
}

class MyClass: MyProtocol {
    // 在 class 中可以使用 class
    class func foo() -> String {
        return "MyClass.foo()"
    }

    // 也可以使用 static
    static func bar() -> String {
        return "MyClass.bar()"
    }
}

参考:

static和class


2018-03-23 09:04:14 lvchenqiang_ 阅读数 331
  • Kubernetes Master Class

    为了帮助大家完成Kubernetes从入门到进阶的全过程,让企业IT人员能更快上手并落地Kubernetes,Rancher Labs【Kubernetes Master Class】已经正式启航!整季培训将有共计8期课程,课程内容包括大量生产环境操作,指导学员熟练掌握Kubernetes部署及管理技巧 。

    2249 人正在学习 去看看 Rancher

代码实例:

 /// 获取并打印方法
        var m_count:UInt32 = 0;

        if let methods = class_copyMethodList(type(of: self.app), &m_count){
            debugPrint(methods[0]);

            for i in 0..<m_count{
                let m = methods[Int(i)];
                let sel = method_getName(m);
                let name = sel_getName(sel);
                debugPrint("方法:\(name): \(NSStringFromSelector(sel))");


            }
        }
       /// 获取并打印属性
        var p_count : UInt32 = 0;

        if let propertys = class_copyPropertyList(type(of: self.app), &p_count)
        {
            for i in 0..<p_count{
                let p = propertys[Int(i)];
                let name = ivar_getName(p);
                debugPrint("成员变量:\(describing: name): \(String(cString:property_getName(p)))");
            }
        }

打印实例:
这里写图片描述

2016-04-26 11:41:53 u010731949 阅读数 782
  • Kubernetes Master Class

    为了帮助大家完成Kubernetes从入门到进阶的全过程,让企业IT人员能更快上手并落地Kubernetes,Rancher Labs【Kubernetes Master Class】已经正式启航!整季培训将有共计8期课程,课程内容包括大量生产环境操作,指导学员熟练掌握Kubernetes部署及管理技巧 。

    2249 人正在学习 去看看 Rancher

⭐️在Objective-C中,我们可以用[Object Class]来建class
EX:[tableView registerClass:[UITableViewCell class] forCellReuseIdentifier:”identifer”]

⭐️Swift中怎么用呢,然而并不是Object.Class(),试了很久,才特么发现是一个我cnm的格式:
Object.self。受不了!!!!!!!!!
EX:self.tableView.registerClass(UITableViewCell.self, forCellReuseIdentifier: “reuseIdentifier”)

2014-11-27 11:36:51 u013736404 阅读数 559
  • Kubernetes Master Class

    为了帮助大家完成Kubernetes从入门到进阶的全过程,让企业IT人员能更快上手并落地Kubernetes,Rancher Labs【Kubernetes Master Class】已经正式启航!整季培训将有共计8期课程,课程内容包括大量生产环境操作,指导学员熟练掌握Kubernetes部署及管理技巧 。

    2249 人正在学习 去看看 Rancher
// Playground - noun: a place where people can play

import UIKit

//结构体&类的使用
struct NewStruct {
    var name:String = "";
    var age:Int = 18;
}

class Person{
    var person:NewStruct = NewStruct(name: "MichaelZero", age: 20);
    
    var className:String?;
    
    var friendIds:[Int]?;
    
    init(className:String){
        self.className = className;
    }
}

var person0 = Person(className:"C1");
println("PName:\(person0.person.name)");

//如果能够判定两个常量或者变量是否引用同一个类实例将会很有帮助。为了达到这个目的,Swift 内建了两个恒等运算符

var person1 = person0;
if person0 === person1{
    println("this is a same class.");
}else{
    println("this is a not same class.");
}

//结构体实例总是通过值传递,类实例总是通过引用传递。这意味两者适用不同的任务。当你在考虑一个工程项目的数据构造和功能的时候,你需要决定每个数据构造是定义成类还是结构体。

//结构体的主要目的是用来封装少量相关简单数据值。
//有理由预计一个结构体实例在赋值或传递时,封装的数据将会被拷贝而不是被引用。
//任何在结构体中储存的值类型属性,也将会被拷贝,而不是被引用。
//结构体不需要去继承另一个已存在类型的属性或者行为。

//合适的结构体候选者包括:
//几何形状的大小,封装一个width属性和height属性,两者均为Double类型。
//一定范围内的路径,封装一个start属性和length属性,两者均为Int类型。
//三维坐标系内一点,封装x,y和z属性,三者均为Double类型。

struct StaticStr {
    var name:Int;
    let systemName:String;
}

//除存储属性外,类、结构体和枚举可以定义计算属性,计算属性不直接存储值,而是提供一个 getter 来获取值,一个可选的 setter 来间接设置其他属性或变量的值。
class ParamsCount{
    var x:Int = 10;
    var y:Int = 10;
    var (x0, y0):(Int, Int);
    
    init(){
        (x0, y0) = (0 , 0);
    }
    
    var pointLink:(Int , Int){
        get {
            let x_link = self.x - self.x0;
            let y_link = self.y - self.y0;
            
            return (x_link , y_link);
        }
        
        set(newPoint){
            self.x = newPoint.0;
            self.y = newPoint.1;
        }
    }
}

//计算中心点坐标
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)
println("square.origin is now at (\(square.origin.x), \(square.origin.y))");


//结构体和枚举是值类型。一般情况下,值类型的属性不能在它的实例方法中被修改。
//但是,如果你确实需要在某个具体的方法中修改结构体或者枚举的属性,你可以选择变异(mutating)这个方法,然后方法就可以从方法内部改变它的属性;并且它做的任何改变在方法结束时还会保留在原始结构中。方法还可以给它隐含的self属性赋值一个全新的实例,这个新实例在方法结束后将替换原来的实例。
struct PointS {
    var x = 0.0, y = 0.0
    mutating func moveByX(deltaX: Double, y deltaY: Double) {
        x += deltaX
        y += deltaY
    }
}
var somePoint = PointS(x: 1.0, y: 1.0)
somePoint.moveByX(2.0, y: 3.0)
println("The point is now at (\(somePoint.x), \(somePoint.y))");

struct PointN {
    var x = 0.0, y = 0.0
    mutating func moveByX(deltaX: Double, y deltaY: Double) {
        self = PointN(x: x + deltaX, y: y + deltaY)
    }
}

//实例方法是被类型的某个实例调用的方法。你也可以定义类型本身调用的方法,这种方法就叫做类型方法。声明类的类型方法,在方法的func关键字之前加上关键字class;声明结构体和枚举的类型方法,在方法的func关键字之前加上关键字static。
struct LevelTracker {
    static var highestUnlockedLevel = 1
    static func unlockLevel(level: Int) {
        if level > highestUnlockedLevel { 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 playerName : String;
    func completedLevel(level:Int){
        LevelTracker.unlockLevel(level+1);
        tracker.advanceToLevel(level+1);
    }
    
    init(name:String){
        playerName = name;
    }
}

var player = Player(name: "Zero");
player.completedLevel(1);
println("highest unlocked level is now \(LevelTracker.highestUnlockedLevel)");

player = Player(name: "Michael")
if player.tracker.advanceToLevel(6) {
    println("player is now on level 6");
} else {
    println("level 6 has not yet been unlocked");
}

//下标脚本允许你通过在实例后面的方括号中传入一个或者多个的索引值来对实例进行访问和赋值。语法类似于实例方法和计算型属性的混合。与定义实例方法类似,定义下标脚本使用subscript关键字,显式声明入参(一个或多个)和返回类型。
//这种是用于基于一个固定的数学公式
struct Times{
    let basicNum:Int;
    
    subscript(index:Int) -> String{
        return String.convertFromStringInterpolationSegment(index * basicNum);
    }
}

var times = Times(basicNum: 10);
println("testing Value\(times[5])");

//根据使用场景不同下标脚本也具有不同的含义。通常下标脚本是用来访问集合(collection),列表(list)或序列(sequence)中元素的快捷方式。你可以在你自己特定的类或结构体中自由的实现下标脚本来提供合适的功能。
struct Matrix {
    let rows: Int, columns: Int
    var grid: [Double]
    init(rows: Int, columns: Int) {
        self.rows = rows
        self.columns = columns
        grid = Array(count: rows * columns, repeatedValue: 0.0)
    }
    func indexIsValidForRow(row: Int, column: Int) -> Bool {
        return row >= 0 && row < rows && column >= 0 && column < columns
    }
    subscript(row: Int, column: Int) -> Double {
        get {
            assert(indexIsValidForRow(row, column: column), "Index out of range")
            return grid[(row * columns) + column]
        }
        set {
            assert(indexIsValidForRow(row, column: column), "Index out of range")
            grid[(row * columns) + column] = newValue
        }
    }
}

var matrix = Matrix(rows: 10, columns: 10);

matrix[0 , 0] = 10;

println("value\(matrix[0 , 0])");

Swift Struct Class

阅读数 20

swift singleton class

阅读数 350

swift class

阅读数 305

没有更多推荐了,返回首页