一.面向对象编程基础
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。
@BeanProperty
var 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{
}