1.面向对象
Scala的类与java、C++的一些比起来更简洁，速度更快
对象：使用object关键字修饰的
类：使用class关键字修饰的new Person()实例对象
new类：类的实例（对象）
1.1.单例对象
（1）scala中没有静态方法和静态字段，没有static
(2) java中，没有关键字修饰的方法,只能用new class()来修饰方法
（3）队友一个class来说，所有的方法和成员变量在市里被new出来之前都无法访问
（4）虽然在class中的定义main方法，可是并没有什么用，按时可以用object达到同样的目的
（5）用object修饰的对象是单例的，成为单例对象，静态对象
（6）单例模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建，这个类提供了一种访问其唯一对象的方式，可以直接访问，不需要实例化该类的对象。注意：1.单例类只能有一个实例 2.单例类必须自己按创建自己的唯一实例 3.单例类必须给其他对象提供这一实例
代码：
object SIngeDemo { var name="娜娜" def eat():Unit={ println(name+"是吃货！") } } object test{ def main(args: Array[String]): Unit = { SIngeDemo.eat() } }
1,2.伴生对象
伴生对象是一种特殊的单例对象，是一种相对概念，需要两个条件：
条件1：在同一个源文件中
条件2：对象名和类名相同
这样的单例对象，被称为这个类的伴生对象。类被称为这个实例的单例对象的伴生类。
特点：类和伴生对象之间可以相互访问私有的方法和属性
代码：
class AssociatedDemo { private val name="笑笑" private def eat():Unit={ println(name+"是吃货！") println(name+"喜欢"+AssociatedDemo.action) } } object AssociatedDemo{ private val name="娜娜" private val action="跑步" def main(args: Array[String]): Unit = { val associatedDemo = new AssociatedDemo associatedDemo.eat() } }
运行结果：
1.3.apply方法
（1）我们通常会在伴生对象中定义apply方法，当遇到对象名（参数1，。。参数n）时apply方法会被调用
（2）当使用对象（参数列表）时，回去对象中找对应参数的apply方法，如果找到就执行相应的逻辑，如果找不到，就报错
注意：只能找到和参数列表相对应的apply方法
该语法的目的：更方便的完成类或实例对象的初始化方法，赋值等工作，类似于java的方法重载
代码：
//当scala中类或者对象有一个主要用途的时候，apply方法是一个湖人好的语法糖
class Test01(name:String) { } object Test01{ def apply(name: String): Test01 ={ new Test01 ( name ) } } //定义一个Test01类，并且在这个类中，有一个半生对象Test01,里面定义了apply方法，有了这个apply方法以后，我们在调用这个Test01类的时候，用函数方式来调用 object Client1{ def main(args: Array[String]): Unit = { val stu=Test01("娜娜") } }
总结：
（1）apply方法，是object上的方法
（2）一般情况下，对象没有构造方法，不能加参数
object Test1（name:String）写法错误{
def main(args: Array[String]): Unit = {
Test1// 这是一个对象，对象上不能有参数
Test1(a:Int) // 添加参数之后，就报错了(错误的写法)
}
}
（3）但是，如果对象（参数列表），实际上调用的是对象上的apply方法，具体会根据参数列表的个数、参数的类型去找对象上对应的apply方法，如果没有找到就会报错。返回值取决于apply的返回类型
（4）apply方法相当于java中的方法重载，可以定义多个apply方法，具体的参数类型，参数个数，以及返回值都是可以自定义。
1.4.unapply方法
unapply方法是接受一个对象，从对象中提取相应的值。主要用于模式匹配
代码：
class Money(val price:Double,val name:String) { } object Money{ def apply(price: Double, name: String): Money = new Money ( price, name ) def unapply(money: Money): Option[(Double, String)] = { if (money==null){ None }else{ Some(money.price,money.name) } } } object Client2{ def main(args: Array[String]): Unit = { val ap=Money(11.2,"书") ap match { case Money(num,"书")=>println(num) case _=>println("宝宝不开心！") } } }
结果：
1.5.应用程序对象
scala程序都必须从一个对象的main方法开始，可以通过继承APP特质，不用写main方法（APP里面封装了main方法）
object AppDemo extends App{ println("I love you ") }
2.类
2.1.类的定义
（1）在 scala中，类并不用生命为public
(2) scala源文件中可以包含多各类，所有的类都具有可见性
（3）var修饰的变量，这个变量对外提供了get set方法
（4）val修饰的变量，是只读属性，对外提供了get方法，没有set方法（相当于java中的final变量）
2.2.构造器
scala构造器分为两类：主构造器（只能有一个），辅助构造器（可以有多个）
（1）主构造器直接在类名后面定义，每个类都有主构造器，主构造器的参数直接放置雷鸣后面，与类交织在一起
class test(val name:String,var age:Int)
(2)如果没有定义构造器，类会有一个默认的空参构造器
（3）辅助函数的定义，使用dfs this关键字，而且必须调用主构造器，或者其他构造器
注意：主构造器会执行类定义中的所有语句
代码：
class ConstructorDemo(val name: String, var age: Int) { println ( "主构造器运行了。。。" ) //辅助构造器必须定义在类中(主和辅参数不能一样) def this(name: String, age: Int, sex: String) { this ( name, age ) println ( "第一个辅助构造器运行了。。。。" ) } def this(name: String, age: Int, sex: String, address: String) { this ( name, age, sex ) println ( "第二个辅助构造器运行了。。。。" ) } } object Text { def main(args: Array[String]): Unit = { new ConstructorDemo ( "娜娜", 20 ) new ConstructorDemo ( "娜娜", 20, "女" ) new ConstructorDemo ( "娜娜", 20, "女", "河南" ) } }
总结：
1.有两类构造器，主构造器和付构造器
2.构造器定义的位置，主构造器和类交织在一起，class ConstructorDemo(val name: String, var age: Int)
3.辅助构造器是一个特殊的方法，定义在类中 def this(name: String, age: Int, sex: String, address: String)
4.辅助构造器，第一行必须是主构造器（或者其他构造器）
5.辅助构造器的参数不能和主构造器的参数完全一致（参数个数、类型、顺序）
6.可以定义空参的辅助构造器，但是主构造器参数必须进行初始化赋值
7.作用域：辅助构造器的作用于，只在方法中，主构造的作用于是类中除去成员属性和成员方法之外的所有范围（可以通过反编译查看源码）
2.3.访问权限
成员变量的访问权限
1.默认权限是public,任何地方都可以访问
2.prive作用域（用于类的内部和伴生对象中）
3.private[this],作用域在当前类中，伴生对象无效
方法的访问权限
1.通用于主构造器，辅助构造器，以及普通方法
2.默认权限是共有的
3.private作用域为类和其伴生对象
4. private [this] ，作用域为当前类中，伴生对象中无效
类的访问权限：
1.默认： 共有的
2. private private[this] 在当前包及其子包范围内有效，其他地方无效
3. private [包名] 在指定包及其子包访问内有效 其他地方无效