面向对象编程
包
语法
package com.pac1.pac2.pac3
package com
package pac1 {
package pac2 {
package pac3 {
object ScalaPackage {
def test(): Unit = {
println("test...")
}
}
}
}
}
注意
-
包和类的物理路径没有关系
-
同一个源码文件中子包可以直接访问父包中的内容，而无需import
-
package也可以看作对象，并声明属性和函数
package big { class Test{ def test() :Unit = { printf("test...") } } package object ob_pack{ val name : String = "ob_pack" def getname(): String = { name } } package ob { object ob01 { def main(args: Array[String]): Unit = { new Test().test() printf(ob_pack.getname()) } } } }
导入
语法
import java.util.List
import java.util._ // Scala中使用下划线代替Java中的星号
注意
-
import语法可以在任意位置使用
-
可以导包，而不是导类
object ScalaImport{ def main(args: Array[String]): Unit = { import java.util new util.ArrayList() } } -
可以在同一行中导入相同包中的多个类，简化代码
import java.util.{List, ArrayList} -
可以屏蔽某个包中的类
import java.sql.{ Date=>_, Array=>_, _ } -
可以给类起别名，简化使用
import java.util.{ArrayList=>AList} -
可以使用类的绝对路径而不是相对路径
import _root_.java.util.ArrayList -
默认情况下，Scala中会导入如下包和对象
import java.lang._ import scala._ import scala.Predef._
类
语法
// 声明类：访问权限 class 类名 { 类主体内容 }
class User {
// 类的主体内容
}
// 对象：new 类名(参数列表)
new User()
注意
- 一个源文件中可以声明多个公共类
属性
语法
class User {
var name : String = _ // 类属性其实就是类变量
var age : Int = _ // 下划线表示类的属性默认初始化
}
注意
-
属性其实在编译后也会生成方法
public static class User { private String name; private int age; public String name() { return this.name; } public void name_$eq(final String x$1) { this.name = x$1; } public int age() { return this.age; } public void age_$eq(final int x$1) { this.age = x$1; } }
访问权限
语法
private : 私有访问权限 => 同类
private[包名]: 包访问权限 => 同包，包私有
protected : 受保护权限，不能同包 => 受保护的， 同类，子类，没有同包
: 公共访问权限
方法
类的方法其实就是函数，所以声明方式完全一样，但是必须通过使用对象进行调用
object ScalaMethod{
def main(args: Array[String]): Unit = {
val user = new User // new 对象 才可以使用方法
user.login("zhangsan", "000000")
}
}
class User {
def login( name:String, password:String ): Boolean = {
false
}
}
对象
语法
val / var 对象名 [：类型] = new 类型()
var user : User = new User()
补充
生成对象的操作
- 反射
- new
- 反序列化
- clone
构造方法(class)
语法
构造对象也需要调用类的构造方法来创建。并且一个类中可以有任意多个不相同的构造方法。这些构造方法可以分为2大类：主构造函数与辅助构造函数
class User() { // 主构造函数 ----用于完成类的初始化操作的构造方法称之为主构造方法
var username : String = _ // TODO 在构造参数前使用var或val声明
def this( name:String ) { // 辅助构造函数，使用this关键字声明 ----其他的构造方法就称之为辅助构造方法
this() // 辅助构造方法在执行之前，应该首先调用主构造方法完成类的初始化
username = name
}
def this( name:String, password:String ) {
this(name) // 构造器调用其他另外的构造器，要求被调用构造器必须提前声明
}
}
// 辅助构造方法可以重载的,并且可以互相调用,但是调用的辅助构造方法应该提前声明
def main(args: Array[String]): Unit = {
new User("zhangsan"); // 先执行父类构造方法
// * 子类所有的 构造函数 默认调用父类的无参构造函数（其实是默认省略掉了一行代码：super();）;省略掉的这行super()代码可以自行添加到构造函数的第一行（必须是第一行，否则报错）
// aaaaa
// ccccc
new User()
//aaaaa
//ccccc
//ddddd
}
class Person(s:String) {
println("aaaaa")
def this() {
this("lisi")
println("bbbbb")
}
}
class User(var name:String) extends Person(name){
println("ccccc")
def this() {
this("wangwu")
println("ddddd")
}
}
伴生类与伴生对象(object)
构造方法私有化: 在参数列表前增加private关键字
声明一个公共的，静态的，返回本类型的方法，用于获取对象
scala中没有静态语法,但是可以直接使用java中的静态操作
scala采用了一种特殊的处理方式来代替静态语法 ：object
object关键字可以用于创建对象，对象的名字就是声明的名字
使用object关键字声明的类和对象有关系的。这个对象等同于伴随着这个类创建时所产生的，所以将这个对象称之为：伴生对象，这个类称之为伴生类