1.类
1.1类的定义
//在Scala中,类并不用声明为public。
//Scala源文件中可以包含多个类,所有这些类都具有公有可见性。
class Student {
//用val修饰的变量是只读属性,就是java中的public修饰的final变量
//(相当与Java中用final修饰的变量)
val id = 666
//用var修饰的变量就是java中的public修饰的变量
var age: Int = 20
//类私有字段,只能在类的内部使用,和伴生对象中使用
private var name: String = "tom"
//对象私有字段,访问权限更加严格的,只能在类的的实例中【当前实例中使用】
private[this] val pet = "小强"
//private 和 private[this]同样可以修饰方法
//类和伴生对象中的属性和方法都可以用访问权限控制符修饰
//类和伴生对象可以相互访问private修饰的变量和方法
//private[this]如果在类中定义,就只能在当前类的实例中使用
//private[this]如果在object中定义,就只能在当前的object中使用
}
1.2构造器
注意:主构造器会执行类定义中的所有语句
/**
*每个类都有主构造器,主构造器的参数直接放置类名后面,与类交织在一起
*/
class Person(val name: String, val age: Int){
//主构造器会执行类定义中的所有语句
println("执行主构造器")
try {
println("读取文件")
throw new IOException("io exception")
} catch {
case e: NullPointerException => println("打印异常Exception : " + e)
case e: IOException => println("打印异常Exception : " + e)
} finally {
println("执行finally部分")
}
private var gender = "male"
//用this关键字定义辅助构造器
def this(name: String, age: Int, gender: String){
//每个辅助构造器必须以主构造器或其他的辅助构造器的调用开始
this(name, age)
println("执行辅助构造器")
this.gender = gender
}
}
//在类名后面加private就变成了私有的
class People private(val name: String, private var age: Int = 18){
object People{
def main(args: Array[String]) {
//私有的构造器,只有在其伴生对象中使用
val q = new People("hatano", 20)
}
}
2.对象
2.1 单例对象
在Scala中没有静态方法和静态字段,但是可以使用object这个语法结构来达到同样的目的
- 存放工具方法和常量
- 高效共享单个不可变的实例
- 单例模式
import scala.collection.mutable.ArrayBuffer
object SingletonDemo {
def main(args: Array[String]) {
//单例对象,不需要new,用【类名.方法】调用对象中的方法
val session = SessionFactory.getSession()
println(session)
}
}
object SessionFactory{
//该部分相当于java中的静态块
var counts = 5
val sessions = new ArrayBuffer[Session]()
while(counts > 0){
sessions += new Session
counts -= 1
}
//在object中的方法相当于java中的静态方法
def getSession(): Session ={
sessions.remove(0)
}
}
class Session{
}
2.2 伴生对象
在Scala的类中,与类名相同的对象叫做伴生对象,类和伴生对象之间可以相互访问私有的方法和属性
class Dog {
val id = 1
private var name = "xiaoqing"
def printName(): Unit ={
//在Dog类中可以访问伴生对象Dog的私有属性
println(Dog.CONSTANT + name )
}
}
/**
* 伴生对象
*/
object Dog {
//伴生对象中的私有属性
private val CONSTANT = "汪汪汪 : "
def main(args: Array[String]) {
val p = new Dog
//访问私有的字段name
p.name = "123"
p.printName()
}
}
2.3 apply方法
通常我们会在类的伴生对象中定义apply方法,当遇到类名(参数1,...参数n)时apply方法会被调用
object ApplyDemo {
def main(args: Array[String]) {
//调用了Array伴生对象的apply方法
//def apply(x: Int, xs: Int*): Array[Int]
//arr1中只有一个元素5
val arr1 = Array(5)
println(arr1.toBuffer)
//new了一个长度为5的array,数组里面包含5个null
var arr2 = new Array(5)
}
}
2.4 应用程序对象
Scala程序都必须从一个对象的main方法开始,可以通过扩展App特质,不写main方法。
object AppObjectDemo extends App{
//不用写main方法
println("I love you Scala")
}
3.继承
object ClazzDemo {
def main(args: Array[String]) {
}
}
trait Flyable{
def fly(): Unit ={
println("I can fly")
}
def fight(): String
}
abstract class Animal {
def run(): Int
val name: String
}
class Human extends Animal with Flyable{
val name = "abc"
//打印几次"ABC"?
val t1,t2,(a, b, c) = {
println("ABC")
(1,2,3)
}
println(a)
println(t1._1)
//在Scala中重写一个非抽象方法必须用override修饰
override def fight(): String = {
"fight"
}
//在子类中重写超类的抽象方法时,不需要使用override关键字,写了也可以
def run(): Int = {
1
}
}