import Foundation
// 1.类
// 1.根类:不再拥有父类的类:NSObject
// 2.基类:拥有多个子类,并且拥有父类,如:UIView,NSOperation
// 类的写法:关键字:class
class Person{
//声明属性
//类中自带的构造函数不带参数,所以要给每个变量设置为可空的,可以用‘?’或'!'修饰,但用'!',要在使用之前必须赋值
var name: String?
var age: Int?
//声明类属性
static var country: String?
//声明方法
func sayHi(){
print("你好,name : \(name),age :\(age)")
}
//声明类方法
//方法一:(在子类中不能重写,只能使用)
static func sayHello(){
print("country : \(country)")
}
//方法二:(可以在子类中重写)
class func sayHello1(){
print("country : \(country)")
}
//类中自带了一个无参的构造函数,要使用有参的构造函数,要自己声明
init(name: String, age: Int){
self.name = name
self.age = age
}
}
var person = Person(name: "大华子", age: 1)
print(person.age)
//子类继承父类的属性和方法,而static修饰的方法不能继承,class修饰的方法可以重写
//子类重写父类的方法,要有关键字override
class Student: Person {
override func sayHi() {
print("重写了sayHi方法")
}
override class func sayHello1(){
print("这是重写的方法")
}
}
class Rect {
//声明属性
var x: Int?
var y: Int?
var weidth: Int!
var height: Int?
//计算属性
//可以直接通过其他属性计算出来的属性,但不保存该属性值
//只读属性就是不写set方法,只有get方法
var centerX: Int {
get{
return self.x! + weidth/2
}
set{
//此时newValue存的就是中心点x的值
print(newValue)
}
}
var centerY: Int {
get{
return self.y! + height!/2
}
set{
print(newValue)
}
}
//声明构造函数
init(x: Int, y: Int, weidth: Int, height: Int){
self.x = x
self.y = y
self.weidth = weidth
self.height = height
}
}
// 2.值类型和引用类型
//结构体:值类型,每赋值一次,都会拷贝一份新的内容,修改原来的,不会影响新的副本的内容
struct YaBo1 {
var price: Double
}
//类:引用类型,赋值就像是OC中的指针指向,无论通过哪个变量名修改,始终操作的都是该对象
class LuDan1 {
var price: Double!
}
//
var YaBo = YaBo1(price: 100.0)
print(YaBo)
// 3.协议
protocol MarryProtocol {
//声明协议方法
func test1()
func test2()
}
//声明可选协议方法
//如果协议里有可选协议方法,则声明协议之前要加关键字 @objc
//swift协议方法中要声明可选方法时,每个方法前都要加 optional , 不然默认是必须实现的
@objc protocol MarryProtocol2 {
//可选方法
optional func test3()
//必须实现的方法
func test4()
}
//协议名也是直接写在冒号后面,多个协议时直接加","和协议
//注意:如果有父类,父类必须写在协议之前
class LaTiao: MarryProtocol{
func test1() {
}
func test2() {
}
//如果实现可选协议的方法,在没有父类的情况下,需要添加 @objc 关键字
//如果实现可选协议的方法,有父类,直接写就可以了
@objc func test4() {
}
}
// 4.Extension
//给类或结构体拓展方法
extension LuDan1 {
func sayHello() {
print("Hello,我是卤蛋")
}
}
//给结构体拓展方法
extension Int{
func test(a: Int) -> Int{
var sum: Int = 1
for _ in 0..<a {
sum *= self
}
return sum
}
}
print(2.test(2))
let luDan = LuDan1()
luDan.sayHello()
// 拓展协议方法
extension LaTiao:MarryProtocol2
{
@objc func test3() {
print("lallalaaaaaa")
}
}
let latiao = LaTiao()
latiao.test3()
//声明闭包变量
var sumClosure: ((a: Int, b: Int) -> Int)?
//可以省略参数,只写参数类型
var maxClosure: ((Int, Int)) -> Int?
//赋值
sumClosure = { (a: Int, b: Int) -> Int in
return a + b
}
sumClosure = { (a, b) -> Int in
return a + b
}
sumClosure = { (a, b) -> Int in
a + b
}
sumClosure = { (a, b) in
a + b
}
sumClosure = { a, b in
return a + b
}
sumClosure = {
return $0 + $1
}
sumClosure = {
$0 + $1
}
//调用
var sum = sumClosure!(a: 1,b: 2)
print(sum)
//给闭包变量起别名
//关键字:typealias
typealias Sum = (Int, Int) -> Int
//声明闭包变量
var sumA: Sum?
//定义
sumA = {(a, b) -> Int in
a * b
}
//调用
print(sumA!(2,5))