首页 文章 精选 留言 我的

精选列表

搜索[学习],共10000篇文章
优秀的个人博客,低调大师

18.Swift学习之属性与方法

类的属性介绍 Swift中属性有多种 存储属性:存储实例的常量和变量 计算属性:通过某种方式计算出来的属性 类属性:与整个类自身相关的属性 存储属性 存储属性是最简单的属性,它作为类实例的一部分,用于存储常量和变量 可以给存储属性提供一个默认值,也可以在初始化方法中对其进行初始化 下面是存储属性的写法 age和name都是存储属性,用来记录该学生的年龄和姓名 chineseScore和mathScore也是存储属性,用来记录该学生的语文分数和数学分数 class Student { // 存储属性 var age : Int = 0 var name : String? var chineseScore : Double = 0.0 var mathScore : Double = 0.0 } // 创建学生对象 let stu = Student() // 给存储属性赋值 stu.age = 10 stu.name = "why" stu.chineseScore = 89.0 stu.mathScore = 98.0 计算属性 计算属性并不存储实际的值,而是提供一个getter和一个可选的setter来间接获取和设置其它属性 计算属性一般只提供getter方法 如果只提供getter,而不提供setter,则该计算属性为只读属性,并且可以省略get{} 下面是计算属性的写法 averageScore是计算属性,通过chineseScore和mathScore计算而来的属性 在setter方法中有一个newValue变量,是系统指定分配的 class Student { // 存储属性 var age : Int = 0 var name : String? var chineseScore : Double = 0.0 var mathScore : Double = 0.0 // 计算属性 var averageScore : Double { get { return (chineseScore + mathScore) / 2 } // 死循环,在内部又会调用set方法 // newValue是系统分配的变量名,内部存储着新值 set { self.averageScore = newValue } } } // 获取计算属性的值 print(stu.averageScore) 类属性 类属性是与类相关联的,而不是与类的实例相关联 所有的类和实例都共有一份类属性.因此在某一处修改之后,该类属性就会被修改 类属性的设置和修改,需要通过类来完成 下面是类属性的写法 类属性可以使用static来修饰 courseCount是类属性,用来记录学生有多少门课程 class Student { // 存储属性 var age : Int = 0 var name : String? var chineseScore : Double = 0.0 var mathScore : Double = 0.0 // 计算属性 var averageScore : Double { return (chineseScore + mathScore) / 2 } // 类属性 static var englishScore:Double = 95.5 } // 设置类属性的值 Student.englishScore = 90.5 // 取出类属性的值 print(Student.englishScore) 懒加载属性 苹果的设计思想:希望所有的对象在使用时才真正加载到内存中 在OC中我们可以重写get方法来进行懒加载 Swift用lazy关键字可以用于定义某一个属性懒加载 lazy的作用是只会赋值一次 懒加载的本质是,在第一次使用的时候执行闭包,将闭包的返回值赋值给属性 懒加载的使用 格式 lazy var 变量: 类型 = { 创建变量代码 }() 案例 lazy var teacher:[String] = { ()->[String] in return ["Mr Zhang", "Mr Li", "Mr Yang"] }() student.teacher 几种属性的区别 存储属性 —— 实实在在存储常量和变量的 计算属性 —— 依赖于存储属性,通过计算得出来,它提供getter和setter方法间接访问和设置值 类属性 —— 本质是一个全局属性,在类里限定了其作用域,用关键字static修饰 懒加载属性 —— 用关键字lazy修饰,必须进行初始化,非实例属性懒加载时在大括号{}后面要加上() 全局属性 —— 类外面的属性,作用域全局 总结: 存储属性,最先被初始化 构造方法,仅次于存储属性调用,可以在这里对存储属性进行赋值 懒加载属性、类属性、全局属性都是在第一次使用的时候初始化一次,以后调用都不再初始化 当懒加载属性是基于一个存储属性计算的时候,切勿使用懒加载属性,采用计算属性 监听属性的改变 在OC中我们可以重写set方法来监听属性的改变 Swift中可以通过属性观察者来监听和响应属性值的变化 通常是监听存储属性和类属性的改变.(对于计算属性,不需要定义属性观察者,因为可以在计算属性的setter中直接观察并响应这种值的变化) 定义观察者 willSet:在属性值被存储之前设置。此时新属性值作为一个常量参数被传入。该参数名默认为newValue,可以自定义 didSet:在新属性值被存储后立即调用。与willSet相同,此时传入的是属性的旧值,默认参数名为oldValue,可以自定义 willSet与didSet只有在属性改变时才会调用,在初始化时不会去调用这些监听方法 class Student { var name:String?{ // 属性即将改变,还未改变时会调用的方法 // 可以给newValue自定义名称 willSet(new){ print("willSet---") // 在该方法中有一个默认的系统属性newValue,用于存储新值 if let new = new { print(new) } } // 属性值已经改变了,会调用的方法 didSet{ print("didSet---") // 在该方法中有一个默认的系统属性oldValue,用于存储旧值 if let oldValue = oldValue { print(oldValue) } } } } var student = Student() // 在赋值时,监听该属性的改变 student.name = "Zhangsan" student.name = "Lisi" 属性继承与重写 属性继承:子类可以继承父类的属性,包括存储属性、计算属性和类型属性,还可以继承父类的属性观察器。 属性重写 无论继承的是存储属性还是计算属性,子类都可以通过提供getter和setter对属性进行重写 可以将一个继承的属性重写为一个读写属性 不可以将继承来的读写属性重写为只读属性 如果重写时提供了setter方法,一定要提供getter方法 属性观察器重写 无论父类有没有为该属性添加属性观察器,子类都可以添加属性观察器 如果父类已经添加了属性观察器,当属性发生变化时,父类与子类都会得到通知 属性观察器不能用于计算属性,只能用于存储属性,因为计算属性在setter里就可以获取到属性的变化 实例方法 实例方法属于特定类实例、结构体实例或者枚举实例的函数 这里的方法其实就是函数,只不过放在类、结构体和枚举中时称之为方法 self 属性 每一个类的实例都隐含一个叫做 self的属性,可以使用 self访问当前类中的属性和方法 class Student { var str = "Hello, playground" func say(info:String) { print(info) } func eat(food:String){ //self指向的是当前类的实例 self.say(info: food) print("吃\(food)") } } var stu = Student() stu.eat(food: "米饭") 值类型在实例方法中修改属性和调用方法 值类型默认情况下,不能在实例方法中修改属性 不能用self调用其他的函数 可以在函数前放一个mutating关键字来实现 struct Student { var str = "Hello, playground" mutating func say(info:String) { print(info) self.str = "Hello World" print(self.str) } mutating func eat(food:String){ self.say(info: food) print("吃\(food)") } } 类型方法 在函数前使用 static关键字(能在类、结构体中使用) 在函数前使用 class关键字(只能在类中使用) static func play(){ print("play") } class func study(){ print("study") } class 和 static 总结 class 和 static 相同点 可以修饰方法,static 修饰的方法叫做静态方法,class修饰的叫做类方法 都可以修饰计算属性 class 和 static 不同点 class 不能修饰存储属性,static 可以修饰存储属性,static修饰的存储属性称为静态变量(常量) class 修饰的计算属性可以被重写,static 修饰的不能被重写 static 修饰的静态方法不能被重写,class 修饰的类方法可以被重写 class 修饰的类方法被重写时,可以使用static 让方法变为静态方法 class 修饰的计算属性被重写时,可以使用static 让其变为静态属性,但它的子类就不能被重写了 class 只能在类中使用,但是static 可以在类,结构体,或者枚举中使用

优秀的个人博客,低调大师

swift4.1 系统学习十四 协议

// 协议 /* OC中也有协议,swift中的协议的作用与OC中基本一样,只是在写法上有一点区别。 我们使用 protocol关键字来定义一个协议。在一个协议中只能存放计算式属性以及方法的声明, 而不能对他们进行定义。 */ // 1. 协议的定义 // 定义一个协议 protocol MyProt { /// 声明一个普通的方法 func foo() /// 声明一个可修改存储式实例属性的方法 mutating func doSomething(a: Int) -> Int? /// 声明一个静态方法 static func typeMethod() /// 声明一个初始化器方法 init(a: Int) /// 声明一个下标 subscript(index: Int) -> Int {get set} /// 声明一个计算式属性 var property: Int { get set } /// 声明一个计算式属性,并且是只读的 static var typeP: Double { get } } // 2. 协议的遵循 /* 只有协议是没有意义的,协议是用来遵循的,是需要实现的。 swift中,枚举、类以及结构体类型都可以遵循协议。 遵循了某一协议的类型必须实现该协议中所生命的所有方法与计算式属性,其中也包括初始化器 */ do { struct Test: MyProt { /// 定义自己的存储式属性a var a = 100 func foo() { print("foo") } mutating func doSomething(a: Int) -> Int? { print("doSomething") self.a = a return a == 0 ? nil : self.a } static func typeMethod() { print("study") } init(a: Int) { self.a = a } subscript(index: Int) -> Int { get { return a + index } set { a = newValue + index } } var property: Int { get { return self.a / 2 } set { self.a = newValue / 2 } } static var typeP: Double { return Double.pi } } var t = Test(a: 10) t.foo() print("---- \(t.doSomething(a: 100))") t.property = 12 print("a: \(t.a)") print("p: \(t.property)") } /* 协议是一种比较灵动的动态类型,根据为它所初始化的对象实例的性质不同,它所采取的拷贝与引用 策略也会有不同。 */ protocol P { func foo() } do { print("\n") struct TestA: P { var a: Int = 0 func foo() { print("这是一个foo") print("a = \(a)") } } /// 定义枚举类型,遵守协议P enum TestB: Int, P { case one = 1, two, three func foo() { print("enum = \(self)") print("value = \(self.rawValue)") } } var a = TestA() // 声明P协议类型的对象p,用a对它初始化 var p: P = a p.foo() withUnsafePointer(to: a.foo) { print("\($0)") } withUnsafePointer(to: p.foo) { print("\($0)") } withUnsafePointer(to: &a) { print("p:\($0)") } withUnsafePointer(to: &p) { print("p:\($0)") } a.a = 10 p.foo() withUnsafePointer(to: &a) { print("\($0)") } withUnsafePointer(to: &p) { print("p:\($0)") } /* 打印: 这是一个foo a = 0 这是一个foo a = 0 */ /* 结果说明,p对象不受对象a的影响,为什么呢? 因为结构体和枚举都是值类型,值类型和引用类型是不一样的。 执行var p: P = a的时候,系统已经分别给 p开辟了新的空间,所以,改变a,并不会对p造成什么影响。 */ p = TestB.two p.foo() } /* 写时拷贝 由于协议类型是一种抽象类型,swift在实现它的时候采用了一种十分灵活的机制——写时拷贝。 对于像枚举、结构体这种值类型的对象实例,即便用一个他们所遵循的协议去指向值类型的对象实例, 当协议类型自身或它所指向的对象实例任一方修改了存储式实例属性的值的时候,此时就会发生写时拷贝。 这时,swift会将协议类型对象分配一个新的存储空间,然后将它所指向的值类型的对象实例的当前状态 拷贝过去。 */ // 一个类型可以遵循多个协议,我们可以用逗号来分割遵循的多个协议的名称。一个类型若遵循了多个协议 //,那么它必须实现它所遵循的所有协议中声明的所有方法和属性。 protocol ProtA { func foo() func method() var property: Int { get set } } protocol ProtB { mutating func method(a: Int) static var property: Double { get } } do { print("\n") struct Test: ProtA, ProtB { var a = 0 func foo() { print("协议A的方法,foo") } func method() { print("协议A的方法, method") } var property: Int { get { return a } set { a = newValue } } mutating func method(a: Int) { print("协议B的方法,method,a = \(a)") self.a = a } static var property: Double { return M_E } } let a: ProtA = Test() a.foo() a.method() print("a = \(a.property)") var b: ProtB = Test() b.method(a: 10) print("a = \(type(of: b).property)") } // 3. 协议继承 /* 在swift编程中,一个协议可以继承自另一个协议或者其他多个协议。当一个协议继承了其他协议的时候,该 协议会将它所继承的其他协议中的所有声明的方法与属性全部包含在自己的协议之中。 注意: 设计的时候,注意命名。 */ /// 定义一个协议C,继承自协议A和协议B protocol ProtC: ProtA, ProtB { /// 重载了ProtA的方法 func foo() /// 自己的方法 func Coo() } do { print("\n") /// 自定义结构体,遵守了ProtC协议 struct Test: ProtC { var x = 100 // 以下是要实现的协议方法和属性 func foo() { print("我就是个方法,foo") } func Coo() { print("我是C协议的方法,Coo") } func method() { print("我是A的方法,method") } var property: Int { get { return x } set { x = newValue } } mutating func method(a: Int) { print("我是B的方法,method, 参数a = \(a)") x = a } static var property: Double { get { return 0 } } } var t = Test() t.foo() t.Coo() t.method() t.method(a: 60) print("property: \(t.property)") print("static property: \(Test.property)") } // 4. class协议 /* 我们可以将一个协议限定为只适用于类类型。我们只需要在一个协议后面使用:class 即可将该协议声明 为类协议,这样只有类类型才能遵守该协议。 */ /// 定义一个协议ProtD,是一个类协议 protocol ProtD: class { /// 声明类型计算式属性 static var type: String { get set } func hello() } /// 定义一个协议ProtE,普通协议 protocol ProtE { func welcome() } /// 定义一个协议ProtF, 是一个类协议,继承自ProtE protocol ProtF: class, ProtE { var property: Int { get set } } /// 定义一个协议ProtG,继承自ProtD和ProtE protocol ProtG: ProtD, ProtE { } do { print("\n") class Dog: ProtF { var name: String = "ww" /// 使用class覆盖协议中的类类型属性 class var type: String { get { return "中华田园犬" } set { } } var property: Int { get { return 10 } set { } } /// 实现ProtE的方法 func welcome() { print("欢迎来到狗狗之家") } } let dog = Dog() dog.name = "小花花" dog.welcome() print("这只小狗已经 \(dog.property) 岁了") print("这只狗狗的品种是 \(Dog.type)") /// 定义了结构体 Cat,并实现ProtE struct Cat: ProtE { var name = "mimi" /// 定义自己的方法 func eat(fishCount: Int) { print("给猫咪喂了 \(fishCount) 只小鱼") } /// 实现ProtE协议的方法 func welcome() { print("你们好,这里是猫咪的乐园") } } var cat = Cat() cat.name = "小黄" cat.welcome() cat.eat(fishCount: 3) /* 注意,如果一个协议继承了某个类协议,那么他自己也就成了类协议。 如果一个非类类型遵循了一个类协议,那么就会引发编译报错。 */ } // 5.协议组合 /* 有时,我们需要声明一个对象,其类型需要遵循多个协议,以便能够调用这些协议中的方法或者访问属性。 我们可以在定义一个协议,然后继承我们想要遵循的协议,但是这会显得很繁琐。swift中提供了“协议组合” 这一语法特性,使得我们能够很轻松的将所要遵循的协议给组合起来。 */ protocol P1 { func foo() func method() } protocol P2 { mutating func method(a: Int) var age: Int { get set } } do { print("\n") // 定义结构体Test,遵循了p1,p2协议 struct Test: P1,P2 { /// 自己的属性a var a = 0 /// 以下是实现协议的方法和属性 func foo() { print("P1:这个世界怎么了,这个世界上的人太疯狂了") } func method() { print("P1: 还能怎么办呢?沧海一粟,宇宙一蜉蝣而已,小小屁民,苟活于世") } mutating func method(a: Int) { print("p2: 好好生活,好好挣钱吧,多挣一点,养活好自己和家人。a: \(a)") self.a = a } var age: Int { get { return a } set { self.a = newValue } } } var t = Test() t.a = 100 t.foo() t.method() t.method(a: 50) print("age: \(t.age)") t.age = 102 print("向天再借: \(t.age) 年") /// 声明一个对象p,遵循了P1和P2,这里就使用了协议组合的语法特性。 var p: P1 & P2 = Test() p.foo() p.age = 100 p.method(a: 6) print("age = \(p.age)") } // 6.关联类型 /* 我们在协议中声明一些方法,这些方法的参数类型根据不同的实现可能会有所不同,此时swift提供了协议的 “关联类型”语法特性,使得我们可以在协议中声明泛化的抽象类型,每个遵循它的类型可以指定其自己的 具体类型。 */ protocol P6A { /// 声明了关联类型DataType associatedtype DataType /// 声明了实例方法method,具有一个关联类型参数value func method(value: DataType) } do { print("\n") struct MyStruct:P6A { /// 通过typealias指定协议关联类型的具体类型,这里把DataType指定为Int类型 typealias DataType = Int let data: DataType = 100 func method(value: Int) { print("哈哈哈哈,这里是关联类型的测试场地: \(data + value)") } } /// 在定义一个枚举类型 enum MyEnum: String, P6A { // 这里把DataType指定为String类型 typealias DataType = String case one = "1", two = "2", three = "3" func method(value: String) { print("这里是一个枚举,\(self.rawValue + value)") } } // 定义一个函数test // 泛型 T 必须遵循P6A协议 func test<T>(prot: T, param: T.DataType) where T: P6A { prot.method(value: param) } test(prot: MyStruct(), param: -1) test(prot: MyEnum.two, param: "apple") } // 7.关于协议中的self类型 /* 在swift编程语言的协议中有一个内建的关联类型——self,用于指代遵循该协议的具体类型。 */ protocol P7A { mutating func method(obj: Self) } do { print("\n") struct MyStruct:P7A { var data = 1 mutating func method(obj: MyStruct) { data += obj.data } } enum MyEnum: String, P7A { case red = "red", green = "green",blue = "blue" case red_and_green = "red and green" case red_and_blue = "red and blue" case green_and_blue = "green and blue" mutating func method(obj: MyEnum) { guard let newValue = MyEnum(rawValue: self.rawValue + "and" + obj.rawValue) else { return } self = newValue } } func test<T>(dst: inout T, src: T) where T: P7A { dst.method(obj: src) } var sd = MyStruct() let ss = MyStruct(data: 100) test(dst: &sd, src: ss) print("sd = \(sd.data)") var ed = MyEnum.red let es = MyEnum.green test(dst: &ed, src: es) print("ed = \(ed)") }

优秀的个人博客,低调大师

4.Swift学习之数据类型

Swift类型的介绍 Swift中的数据类型也有:整型/浮点型/Bool型/元组/枚举/结构体/对象类型等 基本类型 整型 有符号 Int8 : 有符号8位整型 Int16 : 有符号16位整型 Int32 : 有符号32位整型 Int64 : 有符号64位整型 Int : 和平台相关(默认,相当于OC的NSInteger) 无符号 UInt8 : 无符号8位整型 UInt16 : 无符号16位整型 UInt32 : 无符号32位整型 UInt64 : 无符号64位整型 UInt :和平台相关(默认,相当于OC的NSUInteger) 浮点型 Float : 32位浮点型 Double : 64浮点型(默认) Bool型 true : 真 false : 假 // 定义一个Int类型的变量m,并且赋值为10 var m : Int = 10 // 定义一个Double类型的常量n,并且赋值为3.14 let n : Double = 3.14 //定义一个Bool类型 let t : Bool = true Swift中的类型推导 Swift是强类型的语言,强类型语言也称为强类型定义语言。是一种总是强制类型定义的语言,要求变量的使用要严格符合定义,所有变量都必须先定义后使用 Swift中任何一个变量/常量都有明确的类型 注意: 如果定义一个标识符时有直接进行赋值,那么标识符后面的类型可以省略 Swift有类型推导,会自动根据后面的赋值来决定前面的标识符的数据类型 可以通过option+鼠标左键来查看变量的数据类型 查看类型 // 定义变量时没有指定明确的类型,但是因为赋值给i一个20是一个Int类型的数据.因此i为Int类型 var i = 20 // 错误写法:如果之后赋值给i一个浮点型数值,则会报错 // i = 30.5 // 正确写法 var j = 3.33 j = 6.66 Swift中基本运算 Swift中在进行基本运算时必须保证数据的类型一致,否则会出错 只有相同类型的数据才可以进行运算 Swift中没有隐式转换,数据类型的转化必须显示: 类型() Int类型转成Double类型:Double(标识符) Double类型转成Int类型:Int(标识符) let a = 10 let b = 3.14 // 错误写法 // let c = a + b // let c = a * b // 正确写法 let c = Double(a) + b let d = a + Int(b)

优秀的个人博客,低调大师

8.Swift学习之字符串

字符串的介绍 字符串在开发中使用得非常频繁 OC和Swift中字符串的区别 在OC中字符串类型是NSString,在Swift中字符串类型是String OC中字符串@"",Swift中字符串"" 使用 String 的原因 String 是一个结构体,性能更高 NSString 是一个 OC 对象,性能略差 String 支持直接遍历 字符的定义 定义不可变字符串 let str = "hello Objective-C" 定义可变字符串 var str = "hello Swift" 多行字符串 """ 静夜思 作者:李白 床前明月光,疑是地上霜。 举头望明月,低头思故乡。 """ 字符串的常用操作 长度 let str = "12345678" let len2 = str.count //8 let len3 = (str as NSString).length //8 拼接 +号 append let str1 = "abc" + "cde" var str = "abc" str.append("cde") 遍历 let str = "abcdefg" for char in str { print(char) } --------------------- let str = "abcdefg" for (index, value) in str.enumerated() { print("\(index) --- \(value)") } 大写或小写 let str = "abcdefg" print(str.lowercased()) //全部小写 print(str.uppercased()) //全部大写 含有字符串 let str = "abcdefg" print(str.contains("cd")) //true print(str.contains("c")) //true print(str.contains("o")) //false 串分割 import Foundation let str = "abcdefg$$aaaa$$bbbb$$ccc" let desc = str.components(separatedBy: "$$") for item in desc { print(item) } 替换 import Foundation let str = "abcdefg$$aaaa$$bbbb$$ccc" let dest11 = str.replacingOccurrences(of: "$$", with: "**") print(dest11) 子串 let str = "Hello World" //截取某字符串的前5个字符串 let sub1 = str.prefix(5) //截取某字符串的后5个字符串 let str1 = str.suffix(5) //也可以换种写法 let index2 = str.index(str.endIndex, offsetBy: -5) let sub2 = str[index2..<str.endIndex] //截取某字符串的第3个字符到第6个字符范围的字符串 let index3 = str.index(str.startIndex, offsetBy: 3) let sub3 = str[str.startIndex..<index3] let index4: String.Index = str.index(str.endIndex, offsetBy: -3) //从某个位置开始 到某个位置结束 let sub4 = str[index3..<index4]

优秀的个人博客,低调大师

3.Swift学习之常量&变量

什么是常量和变量 在Swift中规定:在定义一个标识符时必须明确说明该标识符是一个常量还是变量 使用let来定义常量,定义之后不可以修改 使用var来定义变量,定义之后可以修改 变量的基本使用 import UIKit let a : Int = 10 //报错——当一个字段定义为常量时不可以修改 // a = 20 var b : Int = 20 // 因为b定义为变量,因此是可以修改的 b = 30 常量和变量的使用注意: 注意: 在真正的开发过程中,建议先定义常量,如果需要修改再修改为变量(更加安全) 声明为常量不可以修改的意思是指针不可以再指向其他对象,但是可以通过指针拿到对象,修改其中的属性 //定义一个UIView let view : UIView = UIView() //定义一个普通UIView let redView : UIView = UIView(frame: CGRect(x: 0, y: 0, width: 100, height: 100)) redView.backgroundColor = UIColor.red view.addSubview(redView) // 枚举类型的用法:类型.枚举的值 let btn : UIButton = UIButton(type: UIButtonType.custom) btn.backgroundColor = UIColor.blue btn.setTitle("按钮", for: .normal) btn.frame = CGRect(x: 20, y: 20, width: 60, height: 30) view.addSubview(btn)

优秀的个人博客,低调大师

SQL Serever学习10——T-SQL语句

在sqlserver2018中使用的是Transact-SQL语言,简称T-SQL。 数据库的创建和管理 数据定义语言DDL DDL功能包括数据库,表,索引,视图,存储过程 数据库:CREATE DATABASE , DROP DATABASE 表:CREATE TABLE , DROP TABLE , ALTER TABLE 索引:CREATE INDEX , DROP INDEX 视图:CREATE VIEW , DROP VIEW 数据库创建 创建数据库包括:数据库名,文件位置,大小,事务日志文件位置和大小 数据库定义需要注意: 定义数据库名,sqlserver中,数据库名称最多为128字符,每个系统最多可以管理用户数据库32767个 定义数据文件,数据库文件最小为3MB,文件增长10%,可以定义多个数据文件,默认第一个为主文件 定义日志文件,在LOG ON子句中,日志文件的长度最小值为1MB 创建数据库 数据库名是销售管理,文件位置保存到D盘根目录下的销售数据库文件夹下,文件名为销售管理_data,初始值为16MB,每次增长为6MB,上限为100MB。 日志文件名是销售管理_log,初始值1MB,最大为5MB,每次增长10% /*创建数据库*/ CREATE DATABASE 销售管理 ON (NAME=销售管理_data, FILENAME='d:\销售管理数据库\销售管理_data.mdf', SIZE=16, MAXSIZE=100, FILEGROWTH=6) LOG ON (NAME=销售管理_log, FILENAME='d:\销售管理数据库\销售管理_log.ldf', SIZE=1, MAXSIZE=5, FILEGROWTH=10%) GO 删除数据库 /*删除数据库*/ DROP DATABASE 销售管理 GO 数据表的创建和管理 数据表的创建 每一个数据表有一个名称,叫做表名,或者关系名,表名必须以字母开头,最大长度为30个字符,一张表包括若干字段,字段名唯一。 在销售管理数据库中创建5个表:商品表,买家表,买家级别表,商品类型表,销售表。 /*切换到数据库*/ USE 销售管理 GO /*创建 商品表*/ CREATE TABLE 商品表 (商品编号 CHAR(3), 商品名称 VARCHAR(50), 品牌 VARCHAR(20), 型号 VARCHAR(20),类型 CHAR(3), 进价 MONEY, 销售价 MONEY, 库存 INT) GO /*创建 买家表*/ CREATE TABLE 买家表 (买家编号 CHAR(3), 买家名称 VARCHAR(50), 电话 VARCHAR(20), 级别 CHAR(3)) GO /*创建 买家级别表*/ CREATE TABLE 买家级别表 (级别编号 CHAR(3), 级别名称 VARCHAR(50), 享受折扣 FLOAT, 特权 VARCHAR(50)) GO /*创建 商品类型表*/ CREATE TABLE 商品类型表 (类型编号 CHAR(3), 类型名称 VARCHAR(50), 级别 VARCHAR(20)) GO /*创建 销售表*/ CREATE TABLE 销售表 (ID INT, 商品编号 CHAR(3), 买家编号 CHAR(3), 实际销售价格 MONEY, 销售日期 DATETIME, 销售数量 INT) GO 添加约束 在创建表的时候,可以在字段后添加约束,但是一般不这样混用,推荐奖添加约束和创建表的语句分开,首先创建数据表,然后通过修改数据表的结构来添加约束。 常用的约束有5个: 主键约束,就是添加主键,要求主键字段唯一并且不为空 唯一约束,要求字段唯一 检查约束,就是CHECK约束,限制字段格式 默认约束,就是DEFAULT约束,给字段默认值 外键约束,就是FOREIGN约束,2个表之间的关系 刚才创建了数据表,现在来给数据表添加约束条件 添加主键约束 买家表的买家编号色设置为主键,商品表的商品编号设置为主键 注意:设置为主键的字段需要NOT NULL /*切换到数据库*/ USE 销售管理 GO /* 商品表*/ ALTER TABLE 商品表 ADD CONSTRAINT PK_商品编号 PRIMARY KEY(商品编号) /* 买家表*/ ALTER TABLE 买家表 ADD CONSTRAINT PK_买家编号 PRIMARY KEY(买家编号) 添加默认约束 设置商品表的品牌字段默认为A牌 /*切换到数据库*/ USE 销售管理 GO /* 商品表*/ ALTER TABLE 商品表 ADD CONSTRAINT DF_品牌 DEFAULT('A牌') FOR 品牌 添加条件约束 要求商品表的进价>0,买家表的买家编号为M**格式 /*切换到数据库*/ USE 销售管理 GO /* 商品表*/ ALTER TABLE 商品表 ADD CONSTRAINT CK_进价 CHECK(进价>0) /* 买家表*/ ALTER TABLE 买家表 ADD CONSTRAINT CK_编号 CHECK(买家编号 like 'M__') 添加外键约束 建立买家表和买家类型表之间的关联,建立商品表和商品类型表的关联 注意:外键表不能有数据,否则报错的! /*切换到数据库*/ USE 销售管理 GO /* 商品表*/ ALTER TABLE 商品表 ADD CONSTRAINT FK_sp FOREIGN KEY (类型) REFERENCES 商品类型表(类型编号) GO /* 买家表*/ ALTER TABLE 买家表 ADD CONSTRAINT FK_mj FOREIGN KEY (级别) REFERENCES 买家级别表(级别编号) GO 数据表的删除 删除买家表 /*切换到数据库*/ USE 销售管理 GO /* 买家表*/ DROP TABLE 买家表 GO 视图的创建和管理 因为公司的很多日常工作是经常性的,如果引入一些视图机制,会大大提高工作效率。 创建视图 创建高价商品视图,显示所有进价在4000元以上的商品名称,品牌和进价 /*切换到数据库*/ USE 销售管理 GO /* 创建视图*/ CREATE VIEW 高价商品_view AS SELECT 商品名称,品牌,进价 FROM 商品表 WHERE 进价>4000 GO 使用视图 查看高价商品的名称 /*切换到数据库*/ USE 销售管理 GO /* 使用视图*/ SELECT 商品名称 FROM 高价商品_view GO 删除视图 删除高价商品视图 /* 删除视图*/ DROP VIEW 高价商品_view 规则和默认的创建和管理 在某一个字段建立规则,属于列级约束,而表级约束单独存在数据库中,是一个约束文件,将这个约束文件绑定到相应的字段,即可对该字段约束。 创建规则 要求字段的值大于0 /*切换到数据库*/ USE 销售管理 GO /*创建规则*/ CREATE RULE 数值_rule AS @SZ>0 GO 绑定规则 使用存储过程sp_bindrule 将数值_rule绑定到商品表的进价和销售价字段上 /*切换到数据库*/ USE 销售管理 GO /*绑定规则*/ sp_bindrule 数值_rule,'商品表.进价' GO sp_bindrule 数值_rule,'商品表.销售价' GO 执行后的提示 查看字段属性,确认绑定 解除绑定 使用存储过程sp_unbindrule 解除商品表的销售价字段上的绑定 /*切换到数据库*/ USE 销售管理 GO /*解除绑定规则*/ sp_unbindrule '商品表.销售价' GO 执行成功会有解除绑定信息提示 删除规则 当需要删除一个规则时,首先需要将规则从绑定的字段上全部解除后方可删除 /*切换到数据库*/ USE 销售管理 GO /*删除规则*/ DROP RULE 数值_rule GO 如果没有删除报错 默认对象的管理 默认对象的使用和管理方式和规则相似 默认规则可以在表定义的时候申明,也可以使用命令创建 创建默认对象 /*切换到数据库*/ USE 销售管理 GO /*默认规则*/ CREATE DEFAULT 男_DF AS '男' GO 绑定默认对象 /*切换到数据库*/ USE 销售管理 GO /*默认规则*/ sp_bindefault 男_DF,'用户表.性别' GO 解除绑定 /*切换到数据库*/ USE 销售管理 GO /*默认规则*/ sp_unbindefault '用户表.性别' GO 删除默认对象 删除前也应该先解除所有的绑定,否则报错 /*切换到数据库*/ USE 销售管理 GO /*默认规则*/ DROP DEFAULT 男_DF GO

资源下载

更多资源
Mario

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长,特征是大鼻子、头戴帽子、身穿背带裤,还留着胡子。与他的双胞胎兄弟路易基一起,长年担任任天堂的招牌角色。

腾讯云软件源

腾讯云软件源

为解决软件依赖安装时官方源访问速度慢的问题,腾讯云为一些软件搭建了缓存服务。您可以通过使用腾讯云软件源站来提升依赖包的安装速度。为了方便用户自由搭建服务架构,目前腾讯云软件源站支持公网访问和内网访问。

Spring

Spring

Spring框架(Spring Framework)是由Rod Johnson于2002年提出的开源Java企业级应用框架,旨在通过使用JavaBean替代传统EJB实现方式降低企业级编程开发的复杂性。该框架基于简单性、可测试性和松耦合性设计理念,提供核心容器、应用上下文、数据访问集成等模块,支持整合Hibernate、Struts等第三方框架,其适用范围不仅限于服务器端开发,绝大多数Java应用均可从中受益。

Sublime Text

Sublime Text

Sublime Text具有漂亮的用户界面和强大的功能,例如代码缩略图,Python的插件,代码段等。还可自定义键绑定,菜单和工具栏。Sublime Text 的主要功能包括:拼写检查,书签,完整的 Python API , Goto 功能,即时项目切换,多选择,多窗口等等。Sublime Text 是一个跨平台的编辑器,同时支持Windows、Linux、Mac OS X等操作系统。

用户登录
用户注册