类(上篇)
概述
- Scala中的类和java中基本类似
- Scala中的类同样通过class来进行生命
- Scala中的类同样可以具有成员变量和成员方法
- Scala中的类同样通过new关键字来创建出对象
1、创建类
Demo01:
//创建一个类,并定义类里的两个成员变量name和age。以及一个成员方法 eat()
//需要注意的是:scala中变量(var)声明时需要指定初始值,
class Person {
var name:String="";
var age:Int=0;
def eat(){
println("吃饭")
}
}
注意:成员属性和成员方法默认都是public的,需要私有可以写private,需要保护可以写protected
Demo02:
//当成员变量或成员方法是私有属性时,外部将不能直接访问,这个同java一样
class Person {
private var name:String="";
private var age:Int=0;
private def eat(){
println("吃饭")
}
}
object Demo02 {
def main(args: Array[String]): Unit = {
val p=new Person
//p.name="tom";
//p.age=1;
//p.eat();
}
}
2、类的构造
和Java不同,Scala中的类不需要明确生命一个构造器,而是直接将构造参数通过构造参数列表声明为类的一部分。
而直接写在类的体重的既不是类的成员变量也不是成员函数的部分,会自动收集为构造函数的体
Demo03:
//scala中的类不需要明确声明一个构造器,而是直接将构造参数通过构造参数列表声明为类的一部分
class Person(var1:String,var2:Int){
var name=var1;
var age=var2;
//而直接写在类的体中的既不是类的成员变量也不是成员函数的部分,会自动收集为构造函数的体。
println("……")
println("***")
}
object Demo03 {
def main(args: Array[String]): Unit = {
//当调用构造方法时,会打印 …… 和***
val p=new Person("tom",23)
}
}
3、辅助构造器
有些时候一个类里需要多个构造器。Scala里主构造器之外的构造器被称之为辅助构造器
- Scala的辅助构造器定义开始于def this()
- Scala里每一辅助构造器的第一个动作都是调用同类的构造器
Demo04:
//scala支持辅助构造器,
class Person(var1:String,var2:Int){
private var name=var1;
private var age=var2;
//Scala的辅助构造器定义开始于 def this()
//定义一个辅助构造器,只接受姓名
def this(var1:String){
this(var1:String,0)
}
//再定义两个辅助构造器,其中一个只接受年龄。另外一个是空构造器
def this(var2:Int){
this("",var2:Int)
}
def this(){
this("",0)
}
def setName(name:String)={
this.name=name
}
def getName()={
this.name
}
def setAge(age:Int)={
this.age=age
}
def getAge()={
this.age
}
def say()={
println("hello world")
}
}
object Demo04 {
def main(args: Array[String]): Unit = {
val p1=new Person("tom")
val p2=new Person(23)
val p3=new Person()
println(p1.getName())
println(p1.say)
println(p2.getAge())
println(p3.getName())
println(p3.getAge())
}
}
4、重载和重写
- scala也支持重载和重写。定义同java。重载: def add(a:Int,b:Int)={} def add(a:Int,b:Int,c:Int)={}
- scala的class支持继承,通过extends关键字来继承。
- 在重写方法时,如果重写的是一个普通方法,则需要加override 关键字
- 如果重写的是一个抽象方法,则不需要加override
Demo05-重载:
class Person{
def add(a:Int, b:Int){
var sum = a+b
println(sum)
}
def add(a:Int, b:Int, c:Int){
var sum = a+b+c
println(sum)
}
}
object Demo05{
def main(args: Array[String]): Unit = {
var a = new Person();
a.add(10, 10);
a.add(10, 10, 10);
}
}
Demo06-重写:
class Person(var1:String,var2:Int) {
private var name=var1
private var age=var2
def say()={
println("hello world")
}
}
class Student extends Person{
override def say()={
println("hello scala")
}
}
5、单例对象(object)
-
scala中的类(class)不能定义静态成员(或静态方法),而代之以定义单例对象来替代。
-
单例对象需要通过object关键字来声明
-
一个单例对象可以单独存在,也可以绑定到一个类上
-
单例对象当中的所有方法,都可以不需要创建对象而直接通过object单例对象的名字直接来调用,用起来感觉就像一个静态方法一样。
-
当一个单例对象和某个类写在同一个源文件中且共享同一个名字时,他们就产生了一个绑定的关系
-
此时单例对象称为该类的伴生对象。类称为该对象的伴生类。
-
类和他的伴生对象可以互相访问其私有成员。
-
以伴生的方式使为类增加静态成员称为了可能
-
单例对象不能new,因此也没有构造参数。
-
可以把单例对象当作是java中可能会用到的静态方法工具类。
-
比如作为程序的入口main方法必须是静态的,所以main方法必须处在一个单例对象中,而不能写在一个类中。
-
单例对象在第一次被访问时才会被初始化。
Demo07:
//类Person
class Person{
//此私有变量,伴生类可以访问
private val namespace="1706"
}
//Person的单利对象,也即伴生类Person,
object Person{
def showTime(){
println(System.currentTimeMillis())
}
def shownamespace(){
val p=new Person
//可以访问类的私有变量
println(p.namespace)
}
}
object Demo07{
def main(args: Array[String]): Unit = {
Person.showTime(); //1595471481495
Person.shownamespace() //1706
}
}