scala的面向对象的相关知识

scala的相关知识

• scala类的定义

    /**
      * 1.scala定义属性的时候一定要进行初始化
      * 2.使用val修饰的属性具备get方法不具备set方法
      * 3.var修饰的具备get方法也具备set方法
      * 4.表示私有除了自己以外别人都不能方法但是和这个类同名的object可以访问
      * 5.在一个类中可以定义多个类而且这些类默认都属于public 如果出现了相同名称的类和object
      * 则说明这个类是半生类这个对象时伴生对象
      * 6.private[this] 只有自己可以访问伴生对象都不能访问
      * 7.一个类中除了属性之外还可以定义方法，方法的修饰和属性一样
      */
    class Student {
      val id = 9527
      var name = "唐伯虎"
      //表示私有除了自己以外别人都不能方法但是和这个类同名的object可以访问
      private var salary = 40000
      private[this] var age = 40
      println("hello world")
      def sum(x:Int,y:Int):Int ={
        println(x,y)
        x+y
      }
      sum(3,4)
    }
    /**
      * 如果要进行代码测试必须要有main方法而且必须在object中
      */
    object Student{
      def main(args: Array[String]): Unit = {
        //如果通过这个方法new对象则这个类中的所有代码都会执行
        val student = new Student()
        //student.id=788 不能更改
        student.name="唐嫣"
        println(student.name)
        println(student.salary)
      }
    }
  

• scala的构造器

    package cn.tedu.scala.day03
    /**
      * 在定义一个scala的类的构成中，如果这个类的后面没有跟（）我们认为这个类有一个主构造器但是（）也可以省略
      * 定义有参构造   class  student11(var id:Int,var name:String)这个都是主构造器
      * 如果在定义一个属性使用var 或者val修饰则是属于public 的
      * 如果没有var或者val修饰的则是属于private[this]的
      *
      */
    class Student11 (var id:Int,var name:String,age:Int,private val scalary
    : Int) {
    
      println("hello scala")
      //这句代码就是把这个属性使用了
      def myPrint=println(age)
    }
    /**
      * 禁止主构造器的使用 private (var id:Int,var name:String)主构造器也可以被private和priavte[this]修饰
      * @param id
      * @param name
      */
    class Student22 private[this] (var id:Int,var name:String){
      /**
        * 定义辅助构造器
        * 1.方法的名称必须是this
        * 2.必须使用def修饰
        * 3.辅助构造器一般来说都包含主构造器的参数
        * 4.辅助构造器的第一句代码一般的都是以其他的构造器开头的
        */
      def this(id:Int,name:String,age:Int)={
        //第一句使用的主构造器
        this(id,name)
      }
      def this(id:Int,name:String,age:Int,scala:String)={
        //第一句使用了辅助构造器
        this(id,name,age)
      }
    }
    object Student11{
      def main(args: Array[String]): Unit = {
        ()
        val student11: Student11 = new  Student11(9527,"唐伯虎",18,5200)
        println(student11.id)
        println(student11.name)
        println(student11.scalary)
        val student2: Student22 = new Student22(9594,"爽",18)
      }
    }
  

• scala的单利对象

    /**
      * 定义类一般把伴生类和伴生对象放在一个文件中
      * 如果属相和方法定义在object的组件中则可以通过类名来访问
      * 伴生类和伴生对象可以相互访问对方的私有属性
      */
    object ObjectTest {
      def main(args: Array[String]): Unit = {
        //实例对象
        val ot22: ObjectTest22 = new ObjectTest22()
        println(ot22.id)
        println(ot22.m1(3))
        //静态的属性和方法
        println(ObjectTest11.id1)
        println(ObjectTest11.m11(4))
        //object修饰的类是单利对象
        val ot11: ObjectTest11.type = ObjectTest11
        val ot12: ObjectTest11.type = ObjectTest11
        //在scala中== 默认比较的是内容 但前提是重写equals,就是按照equals比较的，eq和ne是比较对象的引用
        println(ot11==ot12)
        println(ot11 eq ot12)
        println(ot11 ne ot12)
        println(ot11.equals(ot12))
      }
    }
    object ObjectTest11{
      val id1:Int=11
      def m11(x:Int)=x+1
    }
    class  ObjectTest22{
      val id:Int=11
      def m1(x:Int)=x+1
    }
  

• scala的Apply方法

    object ApplyTest {
      def main(args: Array[String]): Unit = {
        //def apply(x : scala.Int, xs : scala.Int*)调用apply方法
        val array1: Array[Int] = Array(1,2,3,4,5,6,7,8,9)
        //调用构造函数
        val array2: Array[Int] =new Array[Int](10)
        println(array1.toBuffer)
        println(array2.toBuffer)
        val studentTest44: StudentTest44 = StudentTest44(11,"唐伯虎")
    
      }
    }
    
    /**
      *主构造器被private修饰之后只能在伴生对象中使用
      * @param id
      * @param name
      */
    class StudentTest44 private (val id:Int,val name:String){
    
    }
    object StudentTest44{
      //该方法可以重载
      def apply(id:Int,name:String): StudentTest44 ={
        println("调用了Apply方法")
        new StudentTest44(id,name)
      }
    }
  

• scala的应用程序App

    /**
      * App应用程序对象给测试提供了一个方便，
      * 没有必要定义main方法了
      * 这个方式比较便利但是在运行时候不能穿参数
      * app中定义的main逻辑就是把你写的代码放到main方法中执行
      */
    object AppTest extends App {
      println("Hello World")
    }
  

• scala的抽象方法

    object AbstractTest {
      def main(args: Array[String]): Unit = {
        val dog=new Dog
        println(dog.id)
        println(dog.name)
        println(dog.m1(1))
        println(dog.m2(10))
      }
    }
    
    /**
      * 抽象类不能实例化对象
      */
    abstract class Animal{
      //抽象字段
      val id:Int
      //具体字段
      val name:String="aa"
      //定义抽象方法
      def m1(x:Int)
      //定义具体方法
      def m2(x:Int)=x+2
    }
    class  Dog extends Animal{
      //这两个是Animal中为实现的
      override val id: Int = 11
      override def m1(x: Int): Unit= println("Hello World")
      //这个是Animal中已经实现的重写已经实现的方法必须要加override关键字
      override def m2(x: Int): Int = x+3
    }
  

• scala中的trait

    /**
      * 特质：最基本的功能可以作为java的接口来使用
      */
    trait Animal {
      //抽象字段
      val id:Int
      //具体字段
      val name:String="aa"
      //定义抽象方法
      def m1(x:Int)
      //定义具体方法
      def m2(x:Int)=x+2
    }
    //混入
    class AnimalImpl extends Animal with Entable {
      override val id: Int =11
      override def m1(x: Int): Unit = ()
      override def eat1(what: String): Unit = println("Hello World")
    }
    trait  Entable{
      def eat1(what:String):Unit
    }
  

• 类型检查

    object TypeCheck {
      def main(args: Array[String]): Unit = {
        val people: People = new People()
        val student: Student = new Student()
        println(people.isInstanceOf[People])//true
        println(classOf[People])//People.class
        println(student.asInstanceOf[People])//是否可以强转
      }
    }
    class People{
    
    }
    class Student extends  People{
    
    }