一、类（class）和 对象（object）
1、类
类就是对客观的一类事物的抽象。用一个class关键字来描述和Java一样，在这个类中可以拥有这一类事物的属性，行为等等。
2、为什么要有对象
在java中的一个class既可以拥有非静态的成员，也可以拥有静态static的成员。但是在scala中的class结构中，只能拥有非静态。为了给scala中的类也来提供类似于java中的静态成员的功能，于是乎就有了Object对象这个结构。
3、对象
class中定义的main是无法运行，因为class结构中只能拥有非静态，而object所修饰的结构中的所有的成员都是static静态，所以object的作用1、给Scala类提供程序运行的入口，静态的main函数。2、给Scala类也来提供静态成员------Scala类的伴生对象来实现
Scala
class ScalaClassTest {
//定义属性 注解与private不能共存
@BeanProperty var id =11
//用val修饰的变量是只读变量，有getter没有setter方法，相当于Java中的final
val hobby="play"
//没有指定初始值时用下划线代替，必须补全数据类型
var age:Int=_
//private 修饰的属性只能在本类或伴生对象中进行调用
private val name="xiao"
//加this只能在本类中调用
private[this] val color ="pink"
//定义方法
def hello()={
println("我是类当中的一个方法"+color)
}
}
object ScalaClassTest{
def main(args: Array[String]): Unit = {
//创建对象
val s=new ScalaClassTest
//调用属性
println(s.id)
println(s.hobby)
println(s.name)
s.hello()
//真正的set
s.id_=(222)
println(s.id)
//调用get/set方法
s.setId(333)
println(s.getId)
}
}4、伴生类和伴生对象
同一个scala源文件中可以包含类名相同的一个class和object，这在java中是不被允许的；同时上述的这种单例的构造结果，可以看到对一个class似乎也提供了静态的功能。把这种结构，和class在同一个源文件（.scala）中同名object结构称之为该类的伴生对象，把该类称之为该object的伴生类。
注：1.伴生对象和伴生类的私有属性可以相互调用
Scala
class ClassAndObject {
var id = 13
val hobby = "read"
private val color = "blue"
def hello()={
println("dahuang"+ClassAndObject.con)
}
}
object ClassAndObject{
private val con="看大门"
def main(args: Array[String]): Unit = {
//创建对象
val c = new ClassAndObject
//调用伴生类当中的非私有属性
println(c.id)
println(c.hobby)
//调用伴生类中的私有属性
println(c.color)
//调用方法
c.hello()
}
}2.要想使用伴生对象创建本类的对象，必须要让本伴生对象复写一个apply方法，该apply方法的参数列表对应的是本类构造器的参数列表
Scala
//在类名后面，与类交织在一起的就是主构造器
//如果没加var就只是构造参数，如果加上var修饰就升级为属性
class ApplyTest(name:String,age:Int) {
println(name)
println(age)
var color="pink"
//创建辅助构造器
def this(name:String,age:Int,color:String){
//辅助构造器的首行必须调用主构造器或其他辅助构造器
this(name,age)
this.color=color
println(color)
}
}
object ApplyTest{
//使用apply方法创建
def apply(name: String, age: Int): ApplyTest = {
println("调用了主构造器")
new ApplyTest(name, age)
}
def apply(name: String, age: Int, color:String): ApplyTest ={
println("调用了辅助构造器")
new ApplyTest(name, age, color)
}
def main(args: Array[String]): Unit = {
//调用了主构造器
val a = ApplyTest("haha",32,"pin")//调用ApplyTest对象中对应的apply方法
//调用了辅助构造器
val a1= ApplyTest("na",88)
}
}二、继承
1、特点
（1）子类可以继承父类的所有非私有(private)，非静态的成员(变量和成员方法)。
（2）可以添加自己独有的成员，也可以对父类的相关方法进行覆盖/重写
（3）被final修饰的父类成员，子类不可以继承
（4）被protected修饰的父类成员，子类可以继承
（5）子类的访问权限必须要大于等于父类
Scala
class ExtentsTest {
val id = 12
protected var age:Int = 0
def hello()={
println("我是父类当中的方法")
}
}
class Test extends ExtentsTest{
val name = "xiaohuang"
age=20
def bye()={
println("我是子类当中的方法"+age)
}
}
object enter1{
def main(args: Array[String]): Unit = {
val test = new Test
//调用父类当中的属性和方法
println(test.id)
test.hello()
//调用自己本身的属性和方法
println(test.name)
test.bye()
}
}2.protected（受保护字段和方法）
特点：
(1）Java：只能被子类访问，同时必须要在本包下面被访问
（2）Scala：在Java的基础之上，可以做到更灵活、更精准的访问权限控制。scala中提供了一个更加强大的功能来精确的控制一个成员的访问权限。就只有private和protected，在后面加上中括号[],[]里面写上要在哪一个范围内可以被访问
三、抽象类
scala中的抽象类也是使用abstract关键字来进行定义；同时该抽象类中既可以有抽象方法，也可以有非抽象方法；scala中的抽象方法可以省略abstract关键字。
Scala
abstract class AbstractTest {
val name:String
def sayHello()={
println("我是父类当中原装的方法")
}
}
class test extends AbstractTest{
//子类重写父类中的抽象属性
override val name: String = "cici"
//子类重写父类当中的非抽象方法
override def sayHello(): Unit = {
println("我是父类当中被重写的方法")
}
//子类独有的方法，调用父类当中的方法
def only()=super.sayHello()
}
object test{
def main(args: Array[String]): Unit = {
val t = new test
//调用属性和方法
println(t.name)
t.sayHello()
//调用自身的方法
t.only()
}
}四、Trait（特质）
Scala中的这个继承和java的继承有一个缺陷，只能进行单继承，可以进行多层继承，但是多层继承又有要求，类与类之间必须具有继承关系，这显然不一定满足，还是有局限的。所以在java中推出了接口interface这个概念来满足多重继承，只不过这里不叫继承，而称之为多实现，使用关键字implements来连接，多个接口interface之间使用","进行分割。
Scala对于同样的需求，设计出了另外一个结构------trait，特质。trait的功能要比java中的接口强大的多，不仅仅拥有抽象方法，还可以拥有非抽象方法，同时可以多重扩展trait，扩展特质的时候使用关键extends，多个特质之间使用with进行连接。