Scala学习（二）

最新推荐文章于 2024-09-10 13:26:08 发布

Echo_y_q

最新推荐文章于 2024-09-10 13:26:08 发布

阅读量306

点赞数

分类专栏： Scala 文章标签： Scala

Scala 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

Scala变量

变量声明

var声明变量，val声明常量
变量的类型在变量名之后等号之前声明
声明变量和常量不一定要指明数据类型，数据类型可以通过变量或常量的初始值推断出来，这种情况下必须赋初始值
多个变量声明，如果方法返回值是元组，我们可以使用 val 来声明一个元组：

var myVar : String = "Foo"    // 变量
val myVal : String = "Foo"    // 常量

var VariableName : DataType [=  Initial Value]
或
val VariableName : DataType [=  Initial Value]

var myVar = 10;                   // Int
val myVal = "Hello, Scala!";      //String

val xmax, ymax = 100              // xmax, ymax都声明为100
val pa = (40,"Foo")               // pa: (Int, String) = (40,Foo)

Scala 访问修饰符

Scala 访问修饰符基本和Java的一样: private，protected，public。

默认情况下（没有指定访问修饰符），Scala 对象的访问级别都是 public。

Scala 中的 private 限定符，比 Java 更严格，在嵌套类情况下，外层类甚至不能访问被嵌套类的私有成员。

私有(Private)成员

用 private 关键字修饰，带有此标记的成员仅在包含了成员定义的类或对象内部可见，同样的规则还适用内部类。

class Outer{
    class Inner{
        private def f(){println("f")}
        class InnerMost{
            f() // 正确            // 访问包含在 Inner 类之内，所以ok
        }
    }
    (new Inner).f() //错误         // 访问不在类 Inner 之内
}

Java中允许这两种访问，因为它允许外部类访问内部类的私有成员。

保护(Protected)成员

对保护（Protected）成员的访问比 java 更严格一些。它只允许保护成员在定义了该成员的类的子类中被访问。而在java中，用protected关键字修饰的成员，除了定义了该成员的类的子类可以访问，同一个包里的其他类也可以进行访问。

package p{
    class Super{
        protected def f() {println("f")}
    }
    class Sub extends Super{
        f()                    // 子类访问，可以的
    }
    class Other{
        (new Super).f()         //错误，但是在java中可以
    }
}

公共(Public)成员

Scala中，如果没有指定任何的修饰符，则默认为 public。这样的成员在任何地方都可以被访问。

class Outer {
   class Inner {
      def f() { println("f") }
      class InnerMost {
         f() // 正确
      }
   }
   (new Inner).f() // 正确因为 f() 是 public
}

作用域保护

Scala中，访问修饰符可以通过使用限定词强调。

private[x]     或     protected[x]        //x指代某个所属的包、类或单例对象。

如果写成private[x],读作"这个成员除了对[…]中的类或[…]中的包中的类及它们的伴生对像可见外，对其它所有类都是private。

package bobsrocckets{
    package navigation{
        private[bobsrockets] class Navigator{    
        // 类Navigator被标记为private[bobsrockets]就是说这个类对包含在bobsrockets包里的所有的类和对象可见。
         protected[navigation] def useStarChart(){}
         class LegOfJourney{
             private[Navigator] val distance = 100
             }
            private[this] var speed = 200
            }
        }
        package launch{
        import navigation._
        object Vehicle{
        private[launch] val guide = new Navigator
        }
    }
}

从Vehicle对象里对Navigator的访问是被允许的，因为对象Vehicle包含在包launch中，而launch包在bobsrockets中，相反，所有在包bobsrockets之外的代码都不能访问类Navigator。

Scala 运算符

算术运算符

+、-、*、/（除）、%（取余）

关系运算符

==、！=、>、<、>=、<=

逻辑运算符

&&、||、！

位运算符

位运算符用来对二进制位进行操作，~、&、|、^分别为取反，按位与与，按位与或，按位与异或运算

<<、 >>、 >>>分别为左移、右移、无符号右移

赋值运算符

=、+=、-=、*=、/=、%=、<<=、>>=、&=，^=、|=

运算优先级

类别	运算符	关联性
1	() []	左到右
2	! ~	右到左
3	* / %	左到右
4	+ -	左到右
5	>> >>> <<	左到右
6	> >= < <=	左到右
7	== !=	左到右
8	&	左到右
9	^	左到右
10	\|	左到右
11	&&	左到右
12	\|\|	左到右
13	= += -= *= /= %= >>= <<= &= ^= \|=	右到左
14	,	左到右