一.面向对象编程根底
1.1 包
1）申明包：罕用命名形式 域名反写+项目名称+模块名+程序类型名称
2）根本语法：和java相似
package cn.leaf.demo033）Scala在根底语法上进行了扩大，性能更加弱小
- package关键字嵌套申明
package cn{ package leaf{ package demo03{ object Scala_Object{ def main(args: Array[String]): Unit = { println("demo") } } } }}- Scala中包和类的物理门路没有关系
- 子包能够间接拜访父包内容，不须要import导入
示例
package cn{ package leaf{ class Test{ def fun(): Unit ={ println("test") } } package demo03{ object Scala_Object{ def main(args: Array[String]): Unit = { // 间接应用父包中的Test类 val t = new Test() t.fun() } } } }}1.2 导入import
1）根本语法和Java统一
2）Scala同样对import进行扩大
- import 能够在任意地位应用
object Scala_Object{ def main(args: Array[String]): Unit = { import java.util.ArrayList new ArrayList[String]() }}- Scala中import能够在同一行导入多个类
import java.util.{List, ArrayList}- 屏蔽包
import java.sql.{ Date=>_, Array=>_}- 给包起别名
import java.util.{Date=>UtilDate}1.3 类
Scala中没有static成员存在，然而Scala能够通过某种形式达到应用static成员的目标，这个就是伴生机制。
在语法层面上，把static成员和非static成员用不同的表达方式，就是class和object。
class在编译时只会产生以后类的class文件，其作用就是润饰一般的类。
object在编译时会产生两个类文件，一个是以后类的文件，另一个是单例的类文件，object中的属性和办法都能够通过类名间接拜访，相似动态语法。
个别将object申明的类称之为伴生类，对应的单例文件称之为伴生对象。
但通常将雷同名称的class、object申明的类进行辨别：
应用class申明的类为伴生类
应用object申明的类为伴生对象
1.4 属性
示例
object Scala_Object{ def main(args: Array[String]): Unit = { // 类中申明的属性等同于类中申明局部变量，应用var和val申明 val person1 = new Person person1.name = "张三" person1.age = 18 person1.addr = "Beijing" }}class Person{ var name:String = _ // 下划线示意默认初始化 var age:Int = _ var addr:String = _ val heigh = 0 // 如果应用val申明，则须要显示赋值，同时应用val申明的属性也不能批改。}Scala类中申明的属性：
1）编译时，类中申明的属性都是private
而后同时提供公共办法进行拜访
2）编译生成的办法为：
相似java中Bean对象的get办法，用于返回属性的值相似java中Bean对象的set办法，用于设定属性的值3）在应用时
因为属性是公有，所以给属性赋值，等同于调用set办法因为属性是公有，所以获取属性值，等同于调用get办法4）应用val申明的属性
编译时，属性会被final润饰，应用过程中不提供set办法5）Scala编译生成get、set办法并不遵循bean标准，这导致在很多框架中无奈应用，为了兼容其余框架，能够采纳注解@BeanProperty。
@BeanPropertyvar name:String = _构建对象:
1) 应用class申明的类，能够间接应用new的形式
object Scala_Object{ def main(args: Array[String]): Unit = { // new 对象，构造方法无参，则小括号可省略 val person1 = new Person }}class Person{}2）应用apply构建对象，个别用于object伴生对象中构建对象。
示例
object Scala_Object{ def main(args: Array[String]): Unit = { val person = Person() val person2 = Person("张三") }}class Person{}object Person{ // apply办法能够重载 def apply(): Person = new Person() def apply(name:String): Person = { println("Person name==>"+name) new Person }}1.5 拜访权限
Scala中有4种拜访权限：
- private： 公有权限，同类中拜访
- private[包名]：包公有权限，同类或同包中拜访
- protected: 受爱护的权限，同类中拜访或者子类中拜访
- (default) : 公共权限，任意地位，留神Scala中没有public关键字
1.6 办法
Scala中类的办法就是函数，申明形式齐全一样，但Scala中的办法具备重载和重写机制，同时调用办法必须通过对象。
1.7 构造方法
当应用new关键字创建对象时，就在调用类的构造方法。
Scala中构造方法有两种类型：
1）主构造方法：在类名后的构造方法
2）辅助构造方法：为实现类的初始化提供的构造方法
class Person(){ // 主构造方法 var person_name:String = _ def this(name:String){ // 辅助构造方法 this() person_name = name }}含有参数的主构造方法
class Person(name:String){ // 主构造方法能够有参数 // name参数是作为局部变量存在，不能通过对象在内部拜访 // person_name 同样是局部变量，但同时也是类的属性，能够通过对象在内部调用 // 如果咱们须要通过对象拜访name属性，那传参时，能够应用val name:String,如下边类Person2 val person_name:String = name}class Person2(val name:String){ }二. 面向对象编程进阶
2.1 继承
这个跟Java没有多少区别，同样是单继承，应用extends关键字
class Person{}class Student extends Person{}不同之处，如果子类要重写父类的非形象办法，则必须应用overwrite关键字。
子类重写父类办法后，如果在子类中调用父类的被重写的办法，应用super关键字。
class Person{ def speak(): Unit ={ println("Person") } }class Stu extends Person{ override def speak(): Unit = { super.speak() println("Student") }}2.2 封装
面向对象编程，封装大同小异，跟没有多少差别。
2.3 形象
1）抽象类
在父类中，有某些办法没有实现，子类继承时，须要重写来实现，这类办法就是形象办法。
而含有形象办法的类，就是抽象类，须要应用abstract申明，跟Java相似。
抽象类不能实例化。
abstract class Car { def car_color():Unit}class BaoMa extends Car{ override def car_color(): Unit = { println("red") println("blue") }}2）形象属性
形象属性，就是说属性只有申明，而没有初始化
类中存在形象属性，那么这个类也是抽象类。
形象属性在编译时，不会产生类的属性，而是产生属性的get、set办法，且都是形象的。
重写形象属性，等同于重写一般属性的申明：get、set办法
子类重写父类的形象属性，那么只须要将属性申明补充残缺即可。
子类重写父类的惯例属性，则须要应用overwrite关键字润饰。
Scala中类的属性编译时，主动生成公有属性和对应的set、get办法，这点通过反编译能够查到。
示例
abstract class Car { // 形象属性 var car_height:Int // 惯例属性 @BeanProperty val car_weight:Int = 20}class BaoMa extends Car{ var car_height: Int = 30 @BeanProperty override val car_weight: Int = 30}2.4 特质
Scala没有接口的概念，也就没有interface关键字。
然而Scala提供Trait作为接口来应用，也就是特质。
简略来说，就是Scala可能从多个类中将雷同的特色抽离进去，造成非凡的语法结构。
Java中所有的接口都能够当做特质来应用。
1）特质能够看做Interface，类混入特质，就等同于实现接口interface。
示例
// 应用trait关键字申明特质trait DemoTrait{ def hello(info:String)}// 类应用extends关键字混入特质class Person extends DemoTrait{ def hello(info: String): Unit = { println("hello"+info) }2）特质中除了定义形象办法外，还能定义具体方法
示例
object Scala_Object{ def main(args: Array[String]): Unit = { // 申明实例对象，应用with关键字混入特质 val person = new Person with DemoTrait person.hello("world") }}// 应用trait关键字申明特质trait DemoTrait{ def hello(info:String):Unit = { println("hello:"+info) }}class Person{ }