我的算法学习之路--02学习scala的第二天

一、类和对象

1.类的定义

就像

class Car{
    var color:String = _
}

创建类的对象和java一样是

new Car()

2.对象的定义

object Car{
    var color:String = "red"
}

和java不同，scala的对象是可以通过定义创建，这里创建的Car对象是Car类的伴生对象，而且方法和属性都是和Car不互通的，调用

Car.isInstanceOf[Car]

的返回值是false，也就意味着，通过定义创建的伴生对象，并不属于Car类

3.类的构造器

类的构造器分为主构造器和附属构造器，我们看看和java的写法有什么不同

//java

class Car{
    String color;
    String model;
    public Car(){

    }
    public Car(String color,String model){
    this.color = color;
    this.model = model;
    }
}

//scala
class Car(color1: String){//主构造器
  var color:String = color1
  var model:String = _
//附属构造器
  def this(color:String,model:String)={
    this(color)
    this.color = color
    this.model = model
  }
}

要注意的是，所有附属构造器第一行必须显式的调用其他构造器。由此可得，所有构造器都必须调用主构造器，以防止无限循环。

4.类的继承

这种东西，当然是和java对比着来看啦！直接上代码吧

//java
Class Person{
    String name;
    String id;
    public static void say(){
        System.out.print(name + " say hello ")
    }
    public void check(){
        System.out.print("my id is" + id)
    }
}
Class Student extends Person{


}

//scala
class Person{
    var name = ""
    var id:String = ""
    def say() = print("my name is " + name)
   
}
class Son{
    
}
class Student extends Person with Son{  
    
}

可见，scala是支持多继承的，而且scala的继承是可以继承属性和可以被访问的方法，注意java是不可以继承属性的。

5.方法重写

scala的方法重写是加上一个override关键字

class Person{
    var name = ""
    var id:String = ""
    def say() = print("my name is " + name)
   
}

class Student extends Person{  
    override def say() = print("I am a student")
}

也可以通过super.方法名调用父类方法 

6.伴生类和伴生对象

伴生类和伴生对象就是同名的class和object

伴生类和伴生对象可以调用对方的private属性

class Cat{
  private [Cat]var clacat = 222;
  Cat.objcat
}
object Cat{
  private var objcat = 222
  new Cat().clacat
}

7 .apply方法

方法名为apply的方法，可以直接通过对象()调用

class Cat{
    def apply() = {
        
    }
}

var cat:Cat = new Cat()
cat()//调用Cat类的apply

object Cat{
    def apply() = {
        
    }
}

Cat()//调用Cat对象的apply

8.case calss

就是在创建类时前面多个case，就可以让类具有以下功能

1、初始化不需要new，改成类名()

2.对象的toString，equel，以及hashCode方法都被重写

3.可以序列化

4.支持模式匹配（我后面会去了解模式匹配）

5.继承Serializable

9.Trait 

可以新建一个trait，里面可以有一个或者多个抽象方法(没有方法体),这样的类只能拥有实现类的对象

trait Car{
    def run(name:String)

}

二、数组和集合

 定长数组

var arr = Array[Int](23,3234,3,3)
//scala里的数组都是通过小括号来取值的
for(i  <- 0 to arr.length-1) {
    arr(i)
}

数组是()取，我学Java 学疯了，回来提醒你们

不定长数组

var arr1 = ArrayBuffer[Int](3,23,413,23,423)

arr1.addOne(22)
arr1.addAll(arr1)

list

var list = List[Int](2,4,23,3,32,3)
list.::(213)//::的意思是合并两个集合，.::就是合并到自身

set

var newset = Set[Int](22,212,2,22,2)
var newset = Set[Int](34,2,34,34,3)

newset.++newset1//两集合相加
newset.&newset1//两集合取交
newset.min //最小值
newset.sum //所有值之和

queue

var queue = Queue[Int](2,21,3,2,2,2)
queue.enqueue(2314,43)//加在队列末
queue.dequeue()//从队列头取出并返回

 stack

var stack = Stack(23,23,2,32)
stack.pull(22)//压栈顶
stack.pop()//取出栈顶元素

map

//两种创建方式
var map = Map("key1" -> "value1","key2" -> "value2")
var map2 = Map(("key1","value1"),("key2","value2"))

//取值
var value1 = map("key1")

//遍历
for((k,v) <- map){
    
}

//for循环让map k-v倒置
var map1 = for((k,v) <- map) 
      yield (v,k)

//yield我的理解呢就是配合for循环使用,可以用于修改遍历集合的值

元组

 var tuple = ("a","b")

//元组的调用
tuple._1 //a
tuple._2//b

//元组的遍历
tuple.productIterator.foreach(a =>{print(a)})


//交换元组
tuple.swap
//("a","b") --> ("b","a")

//模式匹配获取元组
var (a,b) = tuple
//a = "a" ,b ="b"

好了，今天就暂时记录这么多！！！如果喜欢我的文章欢迎关注，我会继续更新我学算法的遇到的技术点。