Scala:访问修饰符、运算符和循环

亦凉 2022-07-15 13:09 140阅读 0赞

http://[blog.csdn.net/pipisorry/article/details/52902234  
][blog.csdn.net_pipisorry_article_details_52902234]

# 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() // 正确
            }
        }
        (new Inner).f() //错误
    }

(new Inner).f( ) 访问不合法是因为 f 在 Inner 中被声明为 private，而访问不在类Inner之内。

但在 InnerMost 里访问f就没有问题的，因为这个访问包含在 Inner 类之内。

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

## 保护(Protected)成员 ##

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

package p{
       
    class Super{
       
        protected def f() {
       println("f")}
        }
    	class Sub extends Super{
       
    	    f()
    	}
    	class Other{
       
    		(new Super).f() //错误
    	}
    }

上例中，Sub 类对 f 的访问没有问题，因为 f 在 Super 中被声明为 protected，而 Sub 是 Super 的子类。相反，Other 对 f 的访问不被允许，因为 other 没有继承自 Super。而后者在 java 里同样被认可，因为 Other 与 Sub 在同一包里。

## 公共(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{
       
             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
            }
        }
    }

上述例子中，类Navigator被标记为private\[bobsrockets\]就是说这个类对包含在bobsrockets包里的所有的类和对象可见。

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

[皮皮blog][Link 1]

# Scala运算符 #

### Scala 中的按位运算法则 ###

<table> 
 <tbody> 
  <tr> 
   <th>运算符</th> 
   <th>描述</th> 
   <th>实例</th> 
  </tr> 
  <tr> 
   <td>&amp;</td> 
   <td>按位与运算符</td> 
   <td>(a &amp; b) 输出结果 12 ，二进制解释： 0000 1100</td> 
  </tr> 
  <tr> 
   <td>|</td> 
   <td>按位或运算符</td> 
   <td>(a | b) 输出结果 61 ，二进制解释： 0011 1101</td> 
  </tr> 
  <tr> 
   <td>^</td> 
   <td>按位异或运算符</td> 
   <td>(a ^ b) 输出结果 49 ，二进制解释： 0011 0001</td> 
  </tr> 
  <tr> 
   <td>~</td> 
   <td>按位取反运算符</td> 
   <td>(~a ) 输出结果 -61 ，二进制解释： 1100 0011， 在一个有符号二进制数的补码形式。</td> 
  </tr> 
  <tr> 
   <td>&lt;&lt;</td> 
   <td>左移动运算符</td> 
   <td>a &lt;&lt; 2 输出结果 240 ，二进制解释： 1111 0000</td> 
  </tr> 
  <tr> 
   <td>&gt;&gt;</td> 
   <td>右移动运算符</td> 
   <td>a &gt;&gt; 2 输出结果 15 ，二进制解释： 0000 1111</td> 
  </tr> 
  <tr> 
   <td>&gt;&gt;&gt;</td> 
   <td>无符号右移</td> 
   <td>A &gt;&gt;&gt;2 输出结果 15, 二进制解释: 0000 1111</td> 
  </tr> 
 </tbody> 
</table>

[皮皮blog][Link 1]

# Scala循环 #

## for循环语法 ##

Scala 语言中 **for** 循环的语法：

for( var x <- Range ){
       
       statement(s);
    }

以上语法中，**Range** 可以是一个数字区间表示 **i to j** ，或者 **i until j**。左箭头 <- 用于为变量 x 赋值。

### 实例 ###

以下是一个使用了 **i to j** 语法(包含 j)的实例:

object Test {
       
       def main(args: Array[String]) {
       
          var a = 0;
          // for 循环
          for( a <- 1 to 10){
       
             println( "Value of a: " + a );
          }
       }
    }

以下是一个使用了 **i until j** 语法(不包含 j)的实例:

object Test {
       
       def main(args: Array[String]) {
       
          var a = 0;
          // for 循环
          for( a <- 1 until 10){
       
             println( "Value of a: " + a );
          }
       }
    }

## for 循环集合 ##

for 循环集合的语法如下：

for( var x <- List ){
       
       statement(s);
    }

以上语法中， **List** 变量是一个集合，for 循环会迭代所有集合的元素。

## for 循环过滤 ##

Scala 可以使用一个或多个 **if** 语句来过滤一些元素。

以下是在 for 循环中使用过滤器的语法。

for( var x <- List
          if condition1; if condition2...
       ){
       
       statement(s);

你可以使用分号(;)来为表达式添加一个或多个的过滤条件。

## for 使用 yield ##

你可以将 for 循环的返回值作为一个变量存储。语法格式如下：

var retVal = for{
        var x <- List
         if condition1; if condition2...
    }yield x

注意大括号中用于保存变量和条件，*retVal* 是变量， 循环中的 yield 会把当前的元素记下来，保存在集合中，循环结束后将返回该集合。

以下实例演示了 for 循环中使用 yield：

object Test {
       
       def main(args: Array[String]) {
       
          var a = 0;
          val numList = List(1,2,3,4,5,6,7,8,9,10);
    
          // for 循环
          var retVal = for{
        a <- numList 
                            if a != 3; if a < 8
                          }yield a
    
          // 输出返回值
          for( a <- retVal){
       
             println( "Value of a: " + a );
          }
       }
    }

from: [http://blog.csdn.net/pipisorry/article/details/52902234][blog.csdn.net_pipisorry_article_details_52902234]

ref: \[[Scala Tutorial][]\]

[blog.csdn.net_pipisorry_article_details_52902234]: http://blog.csdn.net/pipisorry/article/details/52902234
[Link 1]: http://blog.csdn.net/pipisorry
[Scala Tutorial]: https://www.tutorialspoint.com/scala/index.htm