Scala(八)【面向对象总结】

面向对象总结

面向对象
	1、scala包
		1、声明包
			1、在文件第一行通过package 包名
			2、package 包名{
				....
			}
			第二种方法，包名只能在target目录才能看到
		2、导入包
			1、导入包下所有类: import 包名._
			2、导入包下多个类: import 包名.{类名1,类名2,..}
			3、导入包下除开个别类的所有类型: import 包名.{不导入的类名=>_,_}
			4、给类起别名: import 包名.{类名=>别名}
		3、包对象
			1、语法: package object 包名
			包对象中定义变量、方法、函数在包中任何地方都可以使用
	2、类和对象
		1、类
			1、语法: class 类名
			2、定义属性:
				class 类名{
					val/var 变量:变量类型 = 值
					//var定义的变量可以通过_赋予初始值：null、0、false、0.0
				}
			3、定义方法: 与之前定义方法的语法一样
		2、对象: new 类名
		3、构造器
			1、主构造器: 列名后面的()代表主构造器。在主构造器中可以定义成员属性
				class 类名(val 属性名:类型[= 默认值],var 属性名:类型 [= 默认值], 属性名:类型[=默认值])
					在主构造器中定义属性的时候:val\var\不带val、var的区别：
						val:不可修改，有默认的get方法
						var：可以修改，有默认的get\set方法
						不带val、var: 只能在类中使用。而且如果该属性没有在class中使用，相当于没有。如果使用，则会生成一个private的属性。只是这个属性没有get/set方法
			2、辅助构造器：
				1、语法: def this(参数名:参数类型,...) = {
					//第一行调用其他的辅助构造器或者主构造器
				}
				辅助构造器可以重载
		4、构造器参数:
			1、主构造器中属性可以给默认值
			2、在创建对象的时候，可以通过带名参数来指定将值赋给哪个属性
		5、封装:  *****
			为了兼容java，生成java的get/set方法。
			只需要在属性名上面添加注解:@BeanProperty。
		6、继承: 语法和java一样,都是通过extends关键字实现继承
			哪些不能够被继承:
				1、final修饰的class不能被继承
				2、private修饰的成员变量、成员方法不可被继承
			哪些不能够被重写
				1、final修饰的val定义的属性不可用被重写
				2、var修饰的属性不可以被重写
			重写: 通过override关键字标识方法/属性被重写
		7、多态:
			1、java中多态是表现在方法上
			2、scala中方法和属性都会多态
		8、抽象类: 通过abstract关键字标识类为抽象类
			1、抽象类中既可以定义抽象方法[没有方法体]也可以定义具体方法
			2、抽象类中既可以定义抽象属性[没有赋初始值的属性]也可以定义具体属性
			3、匿名子类:
				new 抽象类{
					//实现抽象类的抽象方法和抽象属性
				}
		9、伴生类和伴生对象
			需要满足两个条件:
				1、class名和object名一样
				2、class与object在同一个源文件中
				class称之为伴生类，object伴生对象
				伴生类和伴生对象相互之间可以调用对方的私有属性或者方法
			apply方法: 
				apply方法定义在伴生对象中
				使用来简化伴生类实例的创建
				
				def apply(变量名:变量类型,..) = new 伴生类(变量名,..)
			有了apply方法之后，后续创建伴生类实例的时候就可以通过以下方式创建:
				1、类名.apply(值,..)
				2、类名(值,...)
				上面两种形式是完全等价
		10、特质
			1、定义语法： trait 特质名{...}
			2、scala中是单继承，多混入
			3、特质和抽象类很像，都是既可以定义抽象方法也可以定义具体的方法
									既可以定义抽象属性也可以定义具体的属性
			4、如何混入特质？
				1、如果子类需要继承父类,先通过extends关键字继承父类，后面通过with关键字混入特质
				2、如果子类不需要继承父类,第一个特质通过extends关键字混入，其他的特质通过with关键字混入
			5、子类混入多个特质，这多个特质中都是同名的方法,如何处理？
				1、如果这多个特质没有关系[没有相同的父类/父特质]: 
					直接重写同名方法。如果重写之后,在方法体中需要调用父特质同名的方法。只会调用最后一个特质的同名方法
				2、如果这多个特质有关系[属于同一个父特质]
					直接重写同名方法。如果重写之后,在方法体中需要调用父特质同名的方法。根据混入的顺序，从右往左开始调用，共同父特质的同名方法最后才调用
					class A extends B with C with D{
						overirde def m1() = {
							println("...")
							super.m1()
						}
					}
					B、C、D继承AA
					A[m1]->D[m1]->C[m1]->B[m1]->AA[m1]
			6、对象混入:
				语法: new 对象 with 特质名
				通过对象混入，可以实现将某些对象有特质的特征[属性/方法/函数]
			7、特质的自身类型:
				语法:  
					trait 特质名{
						this:类型=>  //子类要想混入当前的特质，必须继承/混入指定的class/trait
					}
		11、扩展
			1、类型检查、转换  *****
				对象.isInstanceOf[类型] : 用来判断对象是否属于某个类型
				对象.asInstanceOf[类型]: 用来将对象转为指定的类型
				对象.getClass: 获取对象的class形式
				classOf[类名]： 获取类的class形式
			2、枚举类、应用类：
				枚举类: 继承 Enumeration 
				应用类: 继承 App
					继承App之后，就可以不用写main方法。在object中的代码就是相当于写在main方法里面
			3、type定义新类型: 给类起别名
				type s = String
				val name:s = "xxx"