Scala面向对象
extend App
object ObjectTest extends App { //可不用写main方法,extend App特质也可以实现跟main方法一样的功能 println(123) }
scala中面向对象的编程语法和java基本类似,但是有区别
* 1)scala中的包和java一致
* 2) scala中import可以用于导包,但是java.lang的包自动的包含(跟java中一样,java.lang包不用导入就可直接使用)
scala中import才是真正的导包,java中import是导类(某个包中的具体类)
* 3) scala中声明类和java一致
* 4) scala中声明属性和java语法规则有变化
不需要public关键字(可以使用private、protected),类型在后,名称在前,使用var| val声明
包
java中的包:https://www.cnblogs.com/shengyang17/p/10031596.html
在使用上完全可以通过对类的起名进行约束达到对类的区分,所以包的语法就变得有点可有可无的感觉, 所以scala从语法上对包进行扩展
1) 源码所在的路径可以和包名不一致
2) 源码中package关键字可以多次声明,使用时组合在一起使用
package test
package test1
3) scala可以将包当成对象来用,但是只能声明类,接口
package test { class A { } }
package中只能声明类或接口,主要是受到JVM的限制,所以scala为了让开发方便
使用了 包对象 概念,可以声明属性和方法,类似于伴生对象
4) scala中的包有作用域的概念:子包可以直接访问父包的内容,但是父包访问子包需要导入
* package test { * class A { * } * package test1 { //可以嵌套使用,父包里边嵌套包test1 * class B { * } * } * }
比如:
package Test{ //包里边只能声明类或接口,可以嵌套包 import com.atguigu.objects.Test.test1.B class A{ def test(): Unit ={ val b = new B //父包访问子包需要导入 } } package object test1{ //包对象;可以声明属性和方法;把package去掉就是 类似伴生对象| 内部类(里边是静态属性和方法,可直接访问) var i = 123 } package test1{ class B{ def test(): Unit ={ val a = new A //子包可以直接访问父包的内容 test1.i } } } }
import
scala语法源自java,所以会自动导入java.lang包中所有的类
scala还自动导入其他的包:scala,还有伴生对象Predef(预先声明了,类似静态导入了)中所有的内容
scala如果导入某个包中所有的类,会使用下划线来代替星号:import java.util._
scala中可以将同个包中的多个类使用花括号封装(一个包中有很多很多类,_全包导入会有很多,可使用{ }): import java.util.{ HashMap, List }
scala中可以给类起别名,防止误会: import java.util.{ HashMap=>JavaHashMap } 导入的是java中的HashMap
scala可以将不想使用的类给隐藏掉:import java.util.{Date=>_}
scala为了防止使用包的时候产生误会(有可能起的包名和系统的包名一样),可以使用绝对包名:_root_.java.util.HashMap
Field
scala中声明类的属性应该明确的初始化,否则发生错误
如果不知道赋什么值,可以使用下划线由编译期赋初始值
scala中如果属性没有访问修饰符,那么默认为公共权限public,而且scala会同时为属性生成公共的set/get方法,自动生成
private int age; private int age() { return this.age; } private void age_$eq(int x$1) { this.age = x$1; }
如果声明属性的权限为私有private,那么set/get方法也是私有的
scala可以增加注解@BeanProperty 可以动态添加 set/get方法 setName, getName;@BeanProperty和private不能同时使用;
protected关键字在scala中,只能同父类,子类能访问,其他类无法访问,即使是同包也不行
scala中同包访问需要增加特殊的语法操作 权限 加[包名]
object TestField { def main(args: Array[String]): Unit = { val emp: Emp = new Emp() //emp.name = "smile" //自动为属性生成get/set方法,emp.name()可理解为它的方法,可不加() //emp.name_=("kris") //因为它的底层是$eq //println(emp.name) emp.setName("kk") // println(emp.getName) } } class Emp{ //公共的 @BeanProperty var name: String = _ //增加注解@BeanProperty 可以动态添加 set/get方法 //var name: String = _ //私有的 private var age: Int = _ //不能写null,Int值是对象属AnyVal,null是引用属AnyRef //受保护的 protected var email: String = _ //同包下的 private[objects] var address: String = _ } class EmpSub { def test(): Unit={ var emp = new Emp() emp.address= "" //子类即继承extend E可以访问,其他类不能访问,本包中的也不可以; // 要想同包可以访问需加[包名] 要先var emp = new Emp() 再emp. } }
方法
函数(功能的封装); 从属(方法中会有), 从属哪个对象
所谓的方法,其实就是函数,所以语法规则和函数是完全一样。伴生对象即伴随一个类所产生的对象;
函数没有重载、重写,把它写到Object中就是方法了,就可以进行重载了,写在main方法里边就是函数
Object-->只有伴生对象,伴随类所产生的对象;
Class-->是伴生类,伴随对象所产生的类;
可互相转换;
通过伴生对象获取创建伴生类 (静态的放在伴生对象里边); 在java中通过静态方法获得它的对象--单例模式
//伴生类 class Student { } //伴生对象 object Student{ //伴生对象中可以声明apply方法,可以通过调用此方法来构建伴生类对象 //用法:这种方式构建对象时,是可以不需要使用new关键字 def apply(name: String): Student = new Student() }
object TestMethod { def main(args: Array[String]): Unit = { // 通过伴生对象获取创建伴生类 val student: Student = Student("kris") //等同于调用apply方法 println(student) //com.atguigu.objects.Student@ea4a92b } }
for (i <- Range(1, 10, 2)){ //这里的Range也是没有用new
}
scala中构造方法比较特殊
* scala中的类其实也是函数,可以在类声明时名称后增加小括号作为参数列表,表示构造方法
// 在scala中,构建对象,等同于调用类的构造方法,执行方法体的内容 // scala中构造方法可以声明在其他位置 var a = new A("kris") var a1 = new A var a2 = new A("smile", 20) } class A(s: String){ //类也是函数,参数列表; 有参,主构造方法 // 既是类体 也是构造方法体 println("s=" + s) //s=kris def this(s: String, i: Int){ this("kris") //加this表构建对象, 从构造方法 } // 构造方法(辅助)在辅助构造方法中一定要直接或间接的调用主构造方法 def this()={ this("smile", 18) //间接调用主构造方法,它去调用的def this(s: String, i: Int)这个构造方法,它再去调用主 }
主构造器加private就变成私有化的了,外界不能去访问
object ObjectTest extends App { val clazz = new TestClasses() //这时它调用的就是def this这个辅助构造器了; too many arguments for constructor TestClasses println(clazz) } class TestClasses private(name: String){ //不想用主构造方法,就用辅助构造方法可在主构造前加上private,私有的不能在外边调用 def this(){ this("kris") //辅助构造方法无参的;要去调用主构造方法(有参) } }
外界想访问可通过伴生对象来调用伴生类中的私有属性或方法
object ObjectTest extends App { val clazz = TestClasses("alex") //这里不用加new了 直接有伴生对象不需new ,applay直接传值 println(clazz) } class TestClasses private(name: String){ //不想用主构造方法,就用辅助构造方法可在主构造前加上private,私有的不能在外边调用 def this(){ this("kris") //辅助构造方法无参的;要去调用主构造方法(有参) } } object TestClasses{ // 伴生对象可以访问伴生类中私有的属性或方法 def apply(name: String): TestClasses = new TestClasses(name) }
类
父类的抽象方法可以由子类补充完整,而不需要重写,但是如果想要重写具体的方法,需要增加override关键字(抽象方法可不加)
父类的抽象属性可以由子类补充完整,而不需要重写,如果需要重写具体的属性,属性必须声明val, 增加override关键字(抽象属性可不加)
父类| 重写,快捷键ctrl+o,IDEA工具却不认为是重写里边没有,ctrl+i可以调出来IDEA认为它叫实现;
object TestClass { def main(args: Array[String]): Unit = { val bb = new CC() bb.test println(bb.name) println(bb.age) } } // 声明父类 abstract class BB{ //声明抽象属性,如果一个属性没有初始化就称之抽象属性 var name: String val age: Int = 20 //variable age cannot override a mutable variable,应该声明为val不可变的 // 声明抽象方法 def test def test1(): Unit={ } } // 声明类 class CC extends BB{ // 类可以重写父类的属性 var name: String = "kris" // 如果子类重写父类中具体属性,必须采用override关键字 override val age: Int = 18 // 类可以重写父类的方法,抽象方法可以不加override,只要重写了就可以 def test: Unit = { println("heihei") } override def test1: Unit = { //如果一模一样的把test1拿过来在java中可以,但在scala中需要加overwrite;非抽象方法需要加overwrite }
object TestClass { def main(args: Array[String]): Unit = { val student: Student1 = new Student1 println(student.name) //null kris } } class Person{ val prefix = "person_" val name = prefix + "kris" } // 如果父类的属性依赖于子类的属性,那么运行时,会出现错误,因为子类还没初始化呢; // 可以采用特殊的语法结构提前让属性初始化,解决这个问题。 class Student1 extends Person{ override val prefix: String = "student1_" }
查看字节码
person.class public class Person{ private final String prefix = "person_"; private final String name = new StringBuilder().append(prefix()).append("kris").toString(); //这个append方法不会走下边prefix(),动态绑定技术,调用一个成员方法时会看看它的实际内存是什么-->new Student1-->有这个prefix, return this.prefix;
但父类还没初始化完成,它调了子类一次子类要等父类初始化完成再初始化,所以此时是null //上边这个它什么时候执行的呢?构造对象顺序;先构造父类的属性赋值,再构建子类的给它赋值; public String prefix(){ return this.prefix; } public String name() { return this.name; } } Student1.class public class Student1 extends Person{ private final String prefix = "student1_"; public String prefix() { return this.prefix; } //多了这样一个方法 }
先做初始化再做其他的
extend{ 直接写,马上做把这个属性给覆盖掉 },可看作代码块
class Person{ val prefix = "person_" val name = prefix + "kris" } // 如果父类的属性依赖于子类的属性,那么运行时,会出现错误 // 可以采用特殊的语法结构提前让属性初始化,解决这个问题。 class Student1 extends { override val prefix: String = "student1_" }with Person //特殊的语法结构
构造方法的构造顺序
父类--->子类
object TestClass2 { def main(args: Array[String]): Unit = { val stu = new Student2("kris") //子类的有参构造, 先调this, 走Student2,再父类 } } class Person2{ println("父类构造方法") def this(name: String){ //虽然写了但是没有调用它,应该显式的调用它 this() println("父类构造方法:有参数") } } // 显示调用父类的构造方法, 其实就是在继承父类的时候,同时传递参数; class Student2 extends Person2("kk"){ println("子类构造方法") def this(name: String){ this() println("子类构造方法:有参数") } }
如果没有 Person2("kk")它(父类的有参构造的调用),结果是:
父类构造方法
子类构造方法
子类构造方法:有参数
加上之后,调用了父类的有参构造,结果:main方法中调用的是子类的有参构造,先去执行this-->主类的Student2--->父类Person2的有参构造,它不会马上调,先this() --->调用父主构造方法;===>再去调用父类的有参构造==>子类的主构造==>子类的有参构造
父类构造方法
父类构造方法:有参数
子类构造方法
子类构造方法:有参数
object TestClass3 { def main(args: Array[String]): Unit = { val stu = new Person3("jing", 18) } } // 主构造方法不一定是无参 // 如果构造方法中的参数增加了var,val关键字,那么scala会自动添加类的属性 class Person3(var name: String, age: Int){ name是个局部变量,如果写个name属性,它们的范围是一样的,为了防止冲突,scala不让写name属性了; 加var name就可以在main中直接调用了,把它当中属性;如果是val是不能改,但是可以取 println(name + "\t" + age) }
特质trait
* java : 接口 implements
scala : 特质(特征)extends
scala中没有接口的概念,有类似的特质的概念,trait
scala中可以继承with特质,但也可以同时继承extends父类
如果一个类有父类,同时具有特质,那么在执行时,会首先执行父类的构造方法,然后执行特质的操作,接着执行类的构造方法
如果同时父类也继承了相同的特质,那么父类的特质先执行,而子类的特质就不会再执行.
scala可以将java中的接口当成特质来用 比如with Serializable
trait MyTrait { println("MyTrait") } object TestInterface { def main(args: Array[String]): Unit = { new MyPerson } } class MyParent extends MyTrait{ println("MyParent") } class MyPerson extends MyParent with MyTrait{ println("MyPerson") } /* class MyParent, 父类没有继承特质 MyParent MyTrait MyPerson * */ //如果子父类有相同特质,父类也继承了相同的特质class MyParent extends MyTrait /* MyTrait MyParent MyPerson */
object TestInterface1 { def main(args: Array[String]): Unit = {
方法一:继承 /* val mysql = new MySQL mysql.insert()*/ //方法二: 将特质动态混入到类中 val mysql = new MySQL with DB mysql.insert() //向数据库中插入数据 } } trait Operate{ def insert(): Unit = { println("插入数据") } } trait DB extends Operate{ override def insert(): Unit = { //具体的实现方法加override print("向数据库中") super.insert() //重写父类中的方法,使用super.去调用它 } } trait File extends Operate{ override def insert(): Unit = { print("向文件中") super.insert() } } /*class MySQL extends DB{ }*/ class MySQL{ }
trait中的方法可以是抽象的,也可以有具体实现,具体的类都含有相应的方法
trait在继承时,从左到右继承,但是调用方法时,从右向左调用
trait方法调用时,super不是上一级(不是它父子的上一级,是上一个)的意思,是上一个trait
如果在super关键字后面增加中括号,其中增加泛型,那么可以调用指定特质的方法
trait在scala中可以继承其他的类,比如继承trait Operate extends Exception
class MySQL extends File with DB
先DB(它的上一级是File)--->File(它的上一级是Operate)--->Operate
向数据库中向文件中插入数据
super[Operate].insert() 是明确的告诉它不走上一个,走上一级
![](https://images.cnblogs.com/OutliningIndicators/ContractedBlock.gif)
object TestInterface1 { def main(args: Array[String]): Unit = { val mysql = new MySQL mysql.insert() //将特质动态混入到类中 /* val mysql = new MySQL with DB mysql.insert() //向数据库中插入数据*/ } } trait Operate{ def insert(): Unit = { println("插入数据") } } trait DB extends Operate{ override def insert(): Unit = { //具体的实现方法加override print("向数据库中") super[Operate].insert() //重写父类中的方法,使用super.去调用它 } //加[Operate]就是不走上一个,走上一级 ===>向数据库中插入数据 } trait File extends Operate{ override def insert(): Unit = { print("向文件中") super.insert() } } /*class MySQL extends DB{ }*/ /* class MySQL{ }*/ class MySQL extends File with DB{ }
- scala中特质和接口的区别?
在Scala中没有接口的概念,因为接口并不是面向对象的,有的只是特质,当多个对象具有相同的特征(属性或行为)时,就可以声明特质(trait),然后由具体的类来继承,但是由于不是接口,所以不要实现,而是继承,多个特质使用with连接
没有父类 class 类名 extends 特质1 with 特质2 with 特质3 .. 有父类 class 类名 extends 父类 with 特质1 with 特质2 with 特质3
这种方式更灵活,不像java中,实现是多继承,类是单继承;
也可以在构建对象时,动态混入特质,这种方式非常好,可以动态给对象添加功能。
new Mysql with DB
类信息
object TestClassInfo { def main(args: Array[String]): Unit = { //val clazz: Class[_] = Student.getClass //.var // classOf[T] == T.class val studentClass: Class[Student] = classOf[Student] val student = new Student //student.asInstanceOf[Emp] //student.isInstanceOf[Emp] type S = Student val s: S = new S student.+("kris") //可省略 student + "kk",就是拼接字符串的意思 "*" * 2 "*".*(2) //只要是单一的参数都可以把()和.去掉 1.to(2) } }
类似枚举
object ObjectTest extends App { println(123) println(Color.RED) } object Color extends Enumeration{ //java中的枚举(访问对象); K V,通过K可以访问它的value val RED = Value(0, "red") val YELLOW = Value(1, "yellow") }