关于Swift(二)基础部分和swift基础的问题就给大家分享到这里，感谢你花时间阅读本站内容，更多关于01、基础部分、6.Scala面向对象编程(基础部分)、DB2学习记录：基础部分、GitKrak
关于Swift(二)基础部分和swift 基础的问题就给大家分享到这里，感谢你花时间阅读本站内容，更多关于01、基础部分、6. Scala面向对象编程(基础部分)、DB2学习记录：基础部分、GitKraken使用教程-基础部分(2)等相关知识的信息别忘了在本站进行查找喔。
本文目录一览：
Swift(二)基础部分（swift 基础）
数据类型
Swift 包含了 C 和 Objective-C 上所有基础数据类型。它还增加了 Objective-C 中没有的高阶数据类型比如元组（Tuple）
1、基础类型
Int整形和UInt无符号整形Float和Double浮点型Bool布尔型Character字符型String字符串类型
2、集合类型
Array数组Set集合Dictionary字典
3、高阶类型
Tuple元组
声明常量和变量
常量和变量必须在使用前进行声明，Swift中使用 let 声明常量，使用 var 声明变量
类型标注
当你声明常量或者变量的时候可以加上类型标注（type annotation），说明常量或者变量中要存储的值的类型。如果要添加类型标注，需要在常量或者变量名后面加上一个冒号和空格，然后加上类型名称。
类型安全和类型推断
Swift 是一个类型安全（type safe）的语言。类型安全的语言可以很清楚地知道代码要处理的值的类型。
由于 Swift 是类型安全的，所以它会在编译你的代码时进行类型检查（type checks），并把不匹配的类型标记为错误。这可以让你在开发阶段就会发现并修复错误。当你要处理不同类型的值时，类型检查可以帮你避免错误。
然而，在声明常量和变量的时候如果你没有显式指定类型，Swift 会使用类型推断（type inference）来选择合适的类型。有了类型推断，编译器可以在编译代码的时候自动推断出表达式的类型。原理很简单，只要检查你赋的值即可。
因为有类型推断，和 C 或者 Objective-C 比起来 Swift 很少需要声明类型。常量和变量虽然需要明确类型，但是大部分工作并不需要你自己来完成。
整数
整数可以是有符号（正、负、零）或者 无符号（正、零）。Swift 提供了8，16，32和64位的有符号和无符号整数类型。可以访问不同整数类型的 min 和 max 属性来获取对应类型的最小值和最大值。一般来说，你不需要专门指定整数的长度。但是Swift 提供了特殊的整数类型Int和无符号整型UInt，它们的长度和当前平台的原生字长相同。
注意：尽量不要使用UInt，除非你真的需要存储一个和当前平台原生字长相同的无符号整数。除了这种情况，最好使用Int，即使你要存储的值已知是非负的。统一使用Int可以提高代码的可复用性，避免不同类型数字之间的转换，并且匹配数字的类型推断
浮点数
浮点数是有小数部分的数字，浮点类型比整数类型表示的范围更大，可以存储比 Int 类型更大或者更小的数字。Swift 提供了两种有符号浮点数类型：
Double表示64位浮点数。当你需要存储很大或者很高精度的浮点数时请使用此类型。Float表示32位浮点数。精度要求不高的话可以使用此类型。
注意：Double精确度很高，至少有15位数字，而Float只有6位数字。根据代码需要处理的值的范围来选择使用哪个类型，在两种类型都匹配的情况下，将优先选择 Double。
布尔值
Swift 有一个基本的布尔（Boolean）类型，叫做Bool。布尔值指逻辑上的值，因为它们只能是真或者假。
Swift 有两个布尔常量，true 和 false：
// 布尔值 let trueResult = true let falseResult = false
元组
元组（tuples）把多个值组合成一个复合值。元组内的值可以是任意类型，并不要求是相同类型。
可选类型
在Swift中，可选类型是为了表达当一个变量值为空的情况。当一个值为空时，它就是nil。Swift中无论是值类型或者引用类型的变量，都可以是可选类型。
可选绑定
使用 可选绑定 来判断可选类型是否包含值，如果包含就把值赋给一个临时常量或者变量。可选绑定可以用在 if 和 while 语句中，这条语句不仅可以用来判断可选类型中是否有值，同时可以将可选类型中的值赋给一个常量或者变量。
隐式解析可选类型
如上所述，可选类型表明了常量或者变量可以“没有值”。可以通过if语句来判断是否有值，如果有值的话可以通过可选绑定来解析值。但是在项目中，当一个可选类型被第一次赋值后，可选类型肯定有值，那这个时候如果每次判断和解析值就会很低效。
如此，我们可以将用作可选的类型的后面的问号 ? 改为感叹号 ! 来声明一个隐式解析可选类型。
01、基础部分
转：
01、基础部分
基础部分
01、相关概念
DB
数据库（database），存储数据的仓库，数据库容器
DBMS：
数据库管理系统（Database Management System），数据库是通过 DBMS 创建和操作的容器，常见的有 MySQL、Oracle、DB2、SqlServer
1、 基于共享文件系统的DBMS
2、 基础客户机------服务器的DBMS（C/S）
SQL
结构化查询语言（Structure Query Language），专门用于与数据库通讯的语言
特点：
1、 不是特有的语言，几乎所有DBMS都支持SQL语言
2、 简单易学
3、 虽然简单，但是强有力
数据库存储数据的特点
0、 数据库中可以有多个库，每个库可以有多个表，每个表可以有多个列，其中列也被称为字段
1、 将数据放到表中，表再放到库中
2、 一个数据库中可以有多个表，每个表都有自己的名字，具有唯一性
3、 表由列组成，也称为字段。所有的表都是由一个或者多个列组成的
4、 表中数据按行存储
MySQL
1、 成本低
2、 性能高
3、 简单
02、基本操作
MySQL 服务的启动与停止
方式一：计算机管理 ——> 服务和应用程序 ——> 服务 ——> 找到端口号进行操作
方式二：
1、 以管理员的身份打开命令行
2、 启动：net start 名（MySQL7810）
3、 停止：net stop 名（MySQL7810）
MySQL 服务的登录和退出
登录之前，服务必须是启动状态，必须有权限的人才可以登录进入
目前：用户名（root）密码（7810）
方式一：打开 MySQl 的自己的命令行，输入密码即可
方式二：（mysql -h 主机名 -P 端口号 -u 用户名 -p 密码）
1、 以管理员身份启动命令行
2、 输入：mysql -h localhost -P 3306(端口号) -u root(用户名) -p 7810(密码)
3、 如果连接本机的3306，可以直接：mysql -u root(用户名) -p 7810(密码)
键 值
-h localhost
-P 3306
-u root
常见命令
命令 意义
show datebases; 查看所有的库
use test; 打开库
show tables; 查看所有表
show tables from 库名; 从指定库中查看所有表格
select database(); 查看当前在哪个库中
desc 表名; 查看表的结构
create table 表名 (id int, name varchar (20) ); 创建表
select * from 表名；展示表的数据
insert into 表名 (键 1, 键 2) values (值 1, 值 2); 插入
update 表名 set 键 1='' 值 1'' where 键 2 = 值 2; 修改（修改了键 1 的值 1）
delect from 表名 where 属性 = 值；删除
select version (); 查看当前 mysql 的版本
drop table 库名；删除库
SQL 语言规则
1、 不区分大小写
2、 用 ";" 结尾，表示一条命令的结束
3、 注释：单行 “#” 或者 “--空格”；多行”/* */“
4、 命令可以换行书写
DOS 命令查看 SQL 的版本
mysql --verson mysql --V 查看当前 MySQL 的版本
转：
01、基础部分
--Posted from Rpc
6. Scala面向对象编程(基础部分)
6.1 基本介绍
6.1.1 Scala语言是面向对象的
1) Java时面向对象的编程语言，由于历史原因，Java中海存在着非面向对象的内容：基本类型，null，静态方法等
2) Scala语言来自于Java，所以天生就是面向对象的语言，而且Scala时纯粹的面相对象的语言，即在Scala中，一切皆为对象
3) 在面向对象的学习过程中可以对比着Java语言学习
6.1.2 类和对象的区别和联系
1) 类是抽象的，概念的代表一类事物，比如人类，猫类...
2) 对象是具体的，实际的，代表一个具体事物
3) 类是对象的模版，对象是类的一个个体，对应一个实例
4) Scala中类和对象的区别和联系和Java是一样的
6.1.3 如何定义类
－基本语法
[修饰符] class 类名 {
类体
}
－定义类的注意事项
1) Scala语法中，类并不声明为public，所有这些类都具有公有可见性(默认就是public)
2) 一个Scala源文件可以包含多个类，而且默认都是public
6.1.4 属性
－基本介绍
属性是类的一个组成部分，一般是值数据类型，也可是引用类型
－案例演示
class Dog {
var name = "Tom"
var lover = new Fish
}
class Fish {
}6.1.5 属性/成员变量
－注意事项和细节说明
1) 属性的定义语法同变量，示例：[访问修饰符] var 属性名称 [: 类型] = 属性值
2) 属性的定义类型可以为任意类型，包含值类型或引用类型
3) Scala中声明一个属性，必须显示的初始化，然后根据初始化数据的类型自动推断，属性类型可以省略(这点和Java不同)
4) 如果赋值为null，则一定要加类型，因为不加类型，那么该属性的类型就是Null类型
5) 如果在定义属性时，暂时不赋值，也可以使用符号_(下划线)，让系统分配默认值
class A {
var a1: String = _ //null
var a2: Byte = _ // 0
var a3: Double = _ // 0.0
var a4: Boolean = _ // false
}6.1.6 属性的高级部分
说明：属性的高级部分和构造器(构造方法/函数)相关，具体介绍将在构造器部分详解
6.1.7 如何创建对象
－基本语法
val | var 对象名 [: 类型] = new 类型()
－说明
1) 如果我们不希望改变对象的引用(即：内存地址)，应该声明为val性质的，否则声明为var，Scala设计者推荐使用val，因为一般来说，在程序中，我们只是改变对象属性的值，而不是改变对象的引用
2) Scala在声明对象变量时，可以根据创建对象的类型自动推断，所以类型声明可以省略，但当类型和后面new对象类型有继承关系时即多态，就必须写了
3) 案例演示
object boke_demo01 {
def main(args: Array[String]): Unit = {
val emp = new Emp // emp 类型就是Emp
//如果我们希望将子类对象，交给父类的引用，这时就需要写上类型
val emp2: Person = new Emp
}
}
class Person {
}
class Emp extends Person {
}6.1.8 类和对象的内存分配机制
－案例演示
object boke_demo01 {
def main(args: Array[String]): Unit = {
val p1 = new Person2
p1.name = "jack"
p1.age = 10
val p2 = p1
println(p1 == p2) // true
p1.name = "tom"
println("p2.name=" + p2.name) // p2.name=tom
}
}
class Person2 {
var name = ""
var age: Int = _ //如果是用 _ 方式给默认值，则属性必须指定类型
}－案例演示对应的内存布局图
6.2 方法
6.2.1 基本说明
Scala中的方法其实就是函数，声明规则请参考函数式编程中的函数声明
6.2.2 基本语法
def 方法名[: 返回值类型] = {
方法体
}
6.2.3 方法案例演示
给Cat类添加cal方法，可以计算两个数的和
object MethodDemo01 {
def main(args: Array[String]): Unit = {
val cat = new Cat
println(cat.cal(10, 20))
}
}
class Cat {
private var sal: Double = _
var food: String = _
//方法
def cal(n1: Int, n2: Int): Int = {
return n1 + n2
}
}6.3 构造器
6.3.1 看一个需求
我们来看一个需求：前面我们在创建Person的对象时，是先把一个对象创建好后，再给他的姓名和年龄属性赋值，如果现在要求，在创建Person类对象时，就直接制定这个对象的姓名和年龄，该怎么做？这时就可以使用构造方法/构造器
6.3.2 回顾-Java构造器基本语法
[修饰符] 方法名 (参数列表) {
构造方法体
}
6.3.3 回顾-Java构造器的特点
1) 在Java中一个类可以定义多个不同的构造方法，构造方法重载
2) 如果程序员没有定义构造方法，系统会自动给类生成一个无参构造方法(也叫默认构造器)，比如：Person(){}
3) 一旦定义了自己的构造方法(构造器)，默认的构造方法就覆盖了，就不能使用默认的无参构造方法，除非显示的定义一下，即：Person(){}
6.3.4 Java构造器案例
在前面定义的Person类中添加两个构造器
第一个无参构造器：利用构造器设置所有人的age属性初始值都为18
第二个带name和age两个参数的构造器：使得每次创建Person对象的同时初始化对象的name属性值和age属性值
public class Person {
public String name;
public int age;
public String getInfo() {
return name + "\t" + age;
}
public Person() {
age = 18;
}
public Person(String name, int age) {
this.name = name;
this.age = age;
}
}6.3.5 Scala构造器的介绍
和Java一样，Scala构造对象也需要调用构造方法，并且可以有任意多个构造方法(即Scala中构造器也支持重载)，Scala类的构造器包括：主构造器和辅助构造器
6.3.6 Scala构造器的基本语法
class 类名(形参列表) { //主构造器
def this(形参列表){ //辅助构造器
}
def this(形参列表){ //辅助构造器可以有多个...
}
}
辅助构造器的函数名this，可以有多个，编译器通过不同参数来区分
6.3.7 Scala构造器的快速入门
创建Person对象的同时初始化对象的name属性和age属性，案例演示
object boke_demo01 {
def main(args: Array[String]): Unit = {
// val p1 = new Person("Jack", 20)
// println(p1)
//下面这句话就会调用def this(name:String)
val p2 = new Person("Tom")
println(p2)
}
}
//构造器的快速入门
//创建Person对象的同时初始化对象的age属性值和name属性值
class Person(inName: String, inAge: Int) {
var name: String = inName
var age: Int = inAge
age += 10
println("~~~~~~~~~~")
//重写了toString，便于输出对象的信息
override def toString: String = {
"name=" + this.name + "\t age" + this.age
}
println("ok~~~~~")
println("age=" + age)
def this(name: String) {
//辅助构造器，必须在第一行显式调用主构造器(可以是直接，也可以是间接)
this("Jack", 10)
//this
this.name = name //重新赋值
}
}6.3.8 Scala构造器注意事项和细节说明
1) Scala构造器的作用是完成对新对象的初始化，构造器没有返回值
2) 主构造器的声明直接放置于类名之后
3) 主构造器会执行类定义中的所有语句，这里可以体会到Scala的函数式编程和面向对象编程融合在一起，即：构造器也是方法(函数)，传递参数和使用方法和前面的函数部分内容没有区别
4) 如果主构造器没有参数，小括号可以省略，构建对象时调用的构造方法的小括号也可以省略
class AA {
}
val a = new AA
val b = new AA()5) 辅助构造器名称为this(这个和Java是不一样的)，多个辅助构造器通过不同参数列表进行区分，在底层就是构造器重载
object boke_demo01 {
def main(args: Array[String]): Unit = {
val p1 = new Person2("jack")
p1.showInfo()
}
}
//定义了一个Person类
//Person 有几个构造器 4
class Person2 private() {
var name: String = _
var age: Int = _
def this(name: String) {
//辅助构造器无论是直接或间接，最终都一定要调用主构造器，执行主构造器的逻辑
//而且需要放在辅助构造器的第一行[这点和java一样，java中一个构造器要调用同类的其它构造器，也需要放在第一行]
this() //直接调用主构造器
this.name = name
}
//辅助构造器
def this(name: String, age: Int) {
this() //直接调用主构造器
this.name = name
this.age = age
}
def this(age: Int) {
this("匿名") //调用主构造器,因为 def this(name : String) 中调用了主构造器!
this.age = age
}
def showInfo(): Unit = {
println("person信息如下:")
println("name=" + this.name)
println("age=" + this.age)
}
}6) 如果想要主构造器编程私有的，可以在()之前加上private，这样用户只能通过辅助构造器来构造对象了，比如： class Person2 private(){}
7) 辅助构造器的声明不能和主构造器的声明一致，会发生错误(即构造器名重复)
6.4 属性高级
对属性的内容做一个加强
6.4.1 构造器参数
1) Scala类的主构造器的形参未用任何修饰符修饰，那么这个参数是局部变量
2) 如果参数使用val关键字声明，那么Scala会将参数作为类的私有只读属性使用
3) 如果参数使用var关键字声明，那么Scala会将参数作为类的成员属性使用，并会提供对应的xxx()[类似getter]/xxx_$eq()[类似setter]方法，即这时的成员属性是私有的，但是可读写
4) 案例演示
object boke_demo01 {
def main(args: Array[String]): Unit = {
val worker = new Worker("smith")
worker.name //不能访问 inName
val worker2 = new Worker2("smith2")
worker2.inName //可以访问 inName
println("hello!")
val worker3 = new Worker3("jack")
worker3.inName = "mary"
println(worker3.inName)
}
}
//如果 主构造器是Worker(inName: String) ，那么 inName就是一个局部变量
class Worker(inName: String) {
var name = inName
}
//如果 主构造器是Worker2(val inName: String) ，那么 inName就是Worker2的一个private的只读属性
class Worker2(val inName: String) {
var name = inName
}
// 如果 主构造器是Worker3(var inName: String) ，那么 inName就是Worker3的一个
// 一个private 的可以读写属性
class Worker3(var inName: String) {
var name = inName
}6.4.2 Bean属性
JavaBean规范定义了Java的属性是像getXxx()和setXxx()方法。许多Java工具(框架)都依赖这个命名习惯。为了Java的互操作性。将Scala字段加@BeanProperty时，这样会自动生成规范的setXxx/getXxx方法。这时可以使用 对象.setXxx()和 对象.getXxx()来调用属性
注意：给某个属性加入@BeanPropetry注解后，会生成getXxx和setXxx的方法，并且对原来底层自动生成类似xxx()，xxx_$eq()方法，没有冲突，二者可以共存
import scala.beans.BeanProperty
object boke_demo01 {
def main(args: Array[String]): Unit = {
val car = new Car
car.name = "宝马"
println(car.name)
//使用 @BeanProperty 自动生成 getXxx 和 setXxx
car.setName("奔驰")
println(car.getName())
}
}
class Car {
@BeanProperty var name: String = null
}6.5 Scala对象创建的流程分析
6.5.1 看一个案例
class Person {
var age: Short = 90
var name: String = _
def this(n: String, a: Int) {
this()
this.name = n
this.age = a
}
}
var p: Person = new Person ("小倩", 20)6.5.2 流程分析(面试题-写出)
1) 加载类的信息(属性信息，方法信息)
2) 在内存中(堆)开辟空间
3) 使用父类的构造器(主和辅助)进行初始化
4) 使用主构造器对属性进行初始化[age:90, name:null]
5) 使用辅助构造器对属性进行初始化[age:20, name:小倩]
6) 将开辟的对象的地址赋给p这个引用
DB2学习记录：基础部分
常用命令
DB2是什么
IBM公司研制的关系型数据库系统
DB2是一种关系数据库管理系统(RDBMS)，被认为是第一种使用SQL的数据库产品。它具有许多的优点：
开放性高，能在所有主流平台上运行，最适于海量数据，在企业级的应用最为广泛。
具有很好的并行性，把数据库管理扩充到并行、多节点的环境。数据库分区是数据库的一部分，包含自己的数据、索引、配置文件、和事务日志。数据库分区有时被称为节点。
具有跨平台、多层结构等特点，支持ODBC、JDBC客户。
性能较高，适用于数据仓库和在线事物处理。
操作简单，同时提供GUI和命令行，在Windows NT和Unix下操作相同。
DB2的访问
db2的登录
节点目录、系统数据库目录和本地数据库目录间关系
DB2数据库对象
系统是DB2体系结构中最高一层，一个系统表示一个DB2的安装
实例也称数据管理器，是管理数据的DB2代码，一个系统可包含多个彼此相互独立的实例，每个实例可以管理多个数据库
db2icrt 创建实例
db2idrop 删除实例
db2start 启动实例
create database 创建数据库
数据库体系
系统
实例
数据库
数据库对象
表、视图、索引、模式、存储过程、程序包等
缓冲池、日志文件、表空间
物理存储、表空间容器、目录、文件系统或裸设备
请输入代码db2start 启动数据库实例
db2stop force 停止数据库实例
db2 connect to xxx 连接xxx数据库
db2 get dbm cfg 显示库实例的配置
db2 get db cfg for iacidb 显示iacidb数据库配置
db2 list applications show detail 查看数据库连接详细信息
db2 get instance 获取数据库实例
db2 list active databases 列出当前实例中正在使用的数据库
db2 list tables 列出数据库中的表（需要先连接数据库）
db2 list db directory 查看当前实例下有哪些数据库
db2 -tvf scripts.sql 执行脚本
db2move <db name> export 导出数据库文件
db2move <db name> import/load 导入数据库文件
参考：
http://www.yiibai.com/db2/
DB2基础知识
DB2 命令大全
GitKraken使用教程-基础部分(2)
3. 修改用户名
为了方便项目中代码的管理，需要重新编辑用户名。
点击右上角的图像即可看到如下图 3‑1所示的下拉菜单，鼠标悬于Profile上，会出现一个Edit按钮。
图 3‑1 编辑个人信息
点击Edit按钮将会出现如图 3‑2所示的信息编辑窗口：
图 3‑2 信息编辑窗口
我们需要把图中的Name和Email改成自己的姓名（中英文名皆可）和邮件。点击“Save changes”保存修改。
4. 初始化本地仓库
如果你需要在自己本地代码的目录下新建一个Git仓库，点击左上角的 File => Init Repo，点击 
按钮选择需要初始化仓库的目录，然后点击 
即会出现如下图所示的界面。
图 4‑1 初始化本地仓库
图中的.gitignore 和 License 都是可选的。.gitignore文件是git在提交时会读取的一个文件，现在可以不用管它的作用是什么（如果项目是一个C++工程，我们可以选用预设好的C++.gitignore）。当然如果有兴趣对此深入了解的话，建议去看一看progit这本书，这本书详细了介绍了Git。
下一节：
GitKraken使用教程-基础部分(3)
我们今天的关于Swift(二)基础部分和swift 基础的分享已经告一段落，感谢您的关注，如果您想了解更多关于01、基础部分、6. Scala面向对象编程(基础部分)、DB2学习记录：基础部分、GitKraken使用教程-基础部分(2)的相关信息，请在本站查询。
本文标签：
![[转帖]Ubuntu 安装 Wine方法（ubuntu如何安装wine）](https://www.gvkun.com/zb_users/cache/thumbs/4c83df0e2303284d68480d1b1378581d-180-120-1.jpg)
