Scala2.11.7学习笔记(六）类和对象

鲁春利的工作笔记，好记性不如烂笔头

1、扩展类    

    extends是Scala中实现继承的保留字；

class week extends month{......}

    week类继承了month类所有非私有成员；

    week类是month类的子类，month类是week类的超类；

    子类能重写超类的成员（字段、方法）；

class week(val num : Int) extends month(val num : Int) {......}

    单例对象同样能从类中继承，与类的继承语法相同：object day extends week {......}

重写

    Scala中使用override保留字进行方法、字段重写

class week extends month {     override def firstday () {......} }

    override保留字声明其后的字段或方法是对超类的重写，也可以写在类定义参数中。

class week (override val lastday : String) extends month(val lastday : String)

    重新定义的字段和方法不可重写（override），方法不同（参数类型或个数）不可重写。

scala> class month {      |     def secondary(m : String) {      |         println("secondary is " + m);      |     }      | } defined class month   scala>   scala> class week extends month {      |     override def secondary(m : String) {    // 重写该方法      |         println("secondary is " + m);      |     }      | } defined class week

2、重写规则

   重写def

    用val：利用val能重写超类没有参数的方法；

    用def：子类方法与超类成员重名；

    用var：同时重写getter、setter方法，只重写getter方法报错。

   重写val：

    用val：子类的一个私有字段与超类的字段重名，getter方法重写超类的getter方法

   重写var：

    用var：当超类的var是抽象的才能被重写，否则超类的var都会被继承。

// 新建文件month.scala，内容为： abstract class month {     val zero : Int;     val one = 25;         // 可在子类中用val重写     var two = 15;         // 不可在子类中用var重写，因为不是抽象的     var three : Int;     def firstday ;        // 可在子类中用val重写     def now ;             // 可在子类中用var重写     def now_ ;             def lastday(m : Char) = {}    // 可在子类中用def重写 } // 通过scalac命令编译该文件 D:\LuclAppServ\scala-SDK\source>scalac month.scala D:\LuclAppServ\scala-SDK\source>javap.exe -private month.class // 通过javap命令查看生成的文件 Compiled from "month.scala" public abstract class month {   // val变量且被初始化了   private final int one;   // var变量且被初始化了   private int two;   // val变量但为抽象的，直接生成了getter方法   public abstract int zero();   // 只有getter方法   public int one();   // 同时具有getter和setter方法（=被转义为$eq）   public int two();   public void two_$eq(int);   // var变量但为抽象的，直接生成了getter和setter方法   public abstract int three();   public abstract void three_$eq(int);   // 其他抽象的方法   public abstract void firstday();   public abstract void now();   public abstract void now_();   // 具有方法体，非抽象方法   public void lastday(char);   // 构造函数   public month(); }

    通过IDE工具生成的week.scala代码如下

/**  * @author lucl  */ class week extends month {   override val zero : Int = 10;   override var three : Int = 3;   override def firstday : Unit = {     println("method of  firstday.");   }   override def now : Unit = {     println("method of now.");   }   override def now_ : Unit = {     println("method of now_.");   }    } object week {   def main (args : Array[String]) {     var w = new week();     println(w.zero + "\t" + w.now);   } }

    查看生成的week子类代码

D:\LuclAppServ\workspaces\scala\scalaproj\bin>javap -private week.class Compiled from "week.scala" public class week extends month {   private final int zero;   private int three;      public int zero();      public int three();   public void three_$eq(int);      public void firstday();      public void now();   public void now_();      public week();      public static void main(java.lang.String[]); } D:\LuclAppServ\workspaces\scala\scalaproj\bin>javap -private week$.class Compiled from "week.scala" public final class week$ {   public static final week$ MODULE$;   public static {};   public void main(java.lang.String[]);   private week$(); }

说明：

    子类构造器运行在超类构造器之后，在超类的构造器调用的子类被重写后，返回值可能不正确。

/**  * @author lucl  */ class A {   val num = 31;   val days = new Array[Int](num);   println("When invoke Class A the length of days is " + days.length + ".");   def dayLength = {     println("Class A : the length of days is " + days.length + ".")   } } /**  * @author lucl  */ object B extends A {   override val num = 7;      def main (args : Array[String]) {     dayLength;     println("The finally value of num is " + num);   } }

    运行结果：

    构造B对象前先执行A的构造器，num被初始化为31，days被初始化为Array数组；

    Array数组初始化时需要调用num，但num被子类重写了，但此时B的构造器还未被调用，num被初始化为0，days被初始化为长度为0的数组；

    A的构造器执行完毕，执行B的构造器，num被初始化为7，但此时A中days已初始化过不会再更新其初始化信息，days的数组长度为0。

    解决方法：

        将超类的val声明为final（不可再被子类重写）；

        将超类的val声明为lazy；

        在子类中使用提前定义语法。

    a. final

        当A类中的num声明为final val num : Int = 7,则子类中不可再重写该字段；

    b. lazy

/**  * @author lucl  */ class A {   lazy val num = 31;   // 通过lazy标注   val days = new Array[Int](num);   println("When invoke Class A the length of days is " + days.length + ".");   def dayLength = {     println("Class A : the length of days is " + days.length + ".")   } } /**  * @author lucl  */ object B extends A {   override lazy val num = 7;      def main (args : Array[String]) {     dayLength;     println("The finally value of num is " + num);   } }

    运行结果

    c. 提前定义

    把需要提前定义的语句块放在extends与超类之间，并后接with保留字。
    class B extends {override val num = 7; } with A {......}

/**  * @author lucl  */ object B extends {override val num = 7; } with A {   def main (args : Array[String]) {     dayLength;     println("The finally value of num is " + num);   } }

    执行结果：

3、抽象类

    不能被实例的类叫做抽象类，用保留字abstract标记；

    抽象类的某个或某几个成员没有被完整定义，这些没有被完整定义的成员为抽象字段或方法。

/**  * @author lucl  */ abstract class year {   val name : Array[String];  // 抽象的val，带有一个抽象的getter方法   var num : Int;             // 抽象的var，带有抽象的getter/setter方法   def sign;                  // 没有方法体/函数体，是一个抽象方法 }

    只要类中有任意一个抽象成员，必须使用abstract标记；

    重写抽象方法、抽象字段不需要使用override保留字。

保护

    当一个类不希望被集成、拓展时，可在类声明前加上final保留字

final class year {......}

    当一个类的某些成员不希望被重写时，可在成员声明前加上final保留字

class year {final def sign {......}}

    当超类中的某些成员需要被子类继承，又不想对子类以外成员可见时，在成员声明前加上protected保留字；

    protected[this],将访问限定于当前对象(子类也不可访问)，类似于private[this];

/**  * @author lucl  * 只要类中有一个成员是抽象的，则类就需要声明为抽象类  */ abstract class Human {   var name : String;      // 抽象字段   def sleep() : String;   // 抽象方法   def info (address : String); } /**  *   */ abstract class Teacher (tname : String, age : Int) extends Human {   println(tname + "\t" + age);      override var name : String = tname;      // 若将类声明为def sleep = "8 hours"，在下面调用super.sleep()的位置会提示返回的为Unit   override def sleep() : String = "8 hours.";      def info (address : String); } /**  * Worker继承Teacher时有两个参数name和age需要从Worker中传递参数  * Worker的的参数名字需要与Teacher中一致，否则IDE会提示错误  */ class Worker(tname : String, age : Int, salary : Int) extends Teacher (tname, age) {   override def info (address : String) {     println(tname + "' home is in " + address);     println(tname + "'s age is " + age + ", earn ￥" + salary + ".");   }      override def toString = {     tname + " is a worker， sleep " + super.sleep;   } } object AbstractClassOps {   def main(args : Array[String]) {     val w = new Worker ("zhangsan", 25, 3000);     w.info("BeiJing");     println(w);   } } /**   zhangsan  25   zhangsan' home is in BeiJing   zhangsan's age is 25, earn ￥3000.   zhangsan is a worker， sleep 8 hours. */

4、类的private属性

/**  * @author lucl  */ // 默认是public类型的 class Person {   // age必须赋值，否则该类必须为abstract的   private var age : Int = 0;        // 没有private修饰默认是public的   // 无参的方法可以省略()，调用时可以省略()；   def increment() = age += 1;   // 若声明的方法不带()，则调用时不可带()   def current = age;      // 类可以直接访问伴生对象的私有属性   def speak = Person.sayHello; } class Student {   /**    * 声明为private类型的参数，只能通过当前类的函数来访问    */   private var privateAge : Int = 0;   // 仅限于类的当前实例对象访问，其他传入的对象（如下面的other）将不可访问private[this]修饰的变量   private [this] val name : String = "";      // 自定义的getter/setter方法 ，用来操作私有字段    def age = privateAge;      def age_ (newAge : Int) {     privateAge = newAge;   }      /**    * this对象的使用，表示调用该方法的当前对象    */   def sameStudent (other : Student) = {       // 上面的等号表示有返回结果，否则最后的true会提示：     // a pure expression does nothing in statement position;      // you may be omitting necessary parentheses     if (this.privateAge != other.privateAge) {       false;     }     /**      *  此时通过other将无法访问该name对象      *  value name is not a member of Student      */     /*if (this.name != other.name) {       false;     }*/     true;   }      // 在student中则不可通过Person类直接访问sayHello方法，提示：   // method sayHello in object Person cannot be accessed in object Person   // def speak = Person.sayHello;   // 但可以通过如下方式访问：   var p = new Person;   p.speak;  // 这里会直接执行 } /**  * 对象为类的伴生对象，类为对象的伴生类  */ object Person {   def main (args : Array[String]) {     var p = new Person();     println("age is : " + p.age);    // 可以访问到私有属性     p.increment;     println("age is : " + p.age);     println("current is : " + p.current);          // 带有()则提示“Int does not take parameters”     // p.current();          val s = new Student();     // variable privateAge in class Student cannot be accessed in Student     // s.privateAge;     println(s.age);     s.age_(20);     println(s.age);   }   private def sayHello () {     println("Singleton object Person to say.");   } } /**  // 输出结果   age is : 0   age is : 1   current is : 1   Singleton object Person to say.   0   20 */

5、嵌套类

    Scala允许任何语法结构中嵌套任何语法结构，因此能在类中定义类，类似于Java中的内部类。

    内部类中可以访问外部类的成员，利用外部类.this或指针实现。

scala> class HelloWorld {pointto =>     val value2 = "HelloWorld";     class HI {         var value3 = HelloWorld.this.value2;         var value4 = pointto.value2;     } }  scala> var one = new HelloWorld; one: HelloWorld = HelloWorld@4b134f33 scala> one.value2; res52: String = HelloWorld scala> class Family (val hname : String, val wname : String) {     class Husband (var name : String) {         println("Husband is : " + name);     }          class Wife (var name : String) {         println("Wife is " + name);     }          def info () {         var husband = new Husband(hname);         var wife = new Wife(wname);         println("This family holds husband " + husband.name + ", wife " + wife.name);     } } scala> val f = new Family("Tom", "Jerry"); f: Family = Family@62de96e8 scala> f.info(); Husband is : Tom Wife is Jerry This family holds husband Tom, wife Jerry

Java内部类：内部类是属于外部类的；

/**  *   * @author lucl  * Java内部类示例  * 说明：Java内部类是从属于外部类的  */ public class JavaOuter {     private String name;     public JavaOuter (String name) {         this.name = name;     }     /**      * 内部类      */     // 一旦用static修饰内部类，它就变成静态内部类了。     class Inner {         private String name;         public Inner (String name) {             this.name = name;         }         public void foo (Inner inner) {             System.out.println("\t" + JavaOuter.this.name + "\t" + inner.name);         }     }          public void foo () {         System.out.println("Outer : " + this.name);     }     /**      * @param args      */     public static void main(String[] args) {         JavaOuter outer1 = new JavaOuter("Spark");         JavaOuter outer2 = new JavaOuter("Hadoop");                  JavaOuter.Inner inner1 = outer1.new Inner("scala");         JavaOuter.Inner inner2 = outer2.new Inner("java");                  outer1.foo();         inner1.foo(inner1);         outer2.foo();         inner2.foo(inner2);                  outer1.foo();         inner1.foo(inner2);    // 在这里inner1可以调用inner2     } } /**      // 输出结果     Outer : Spark             Spark    scala     Outer : Hadoop             Hadoop    java     Outer : Spark             Spark    java */

Scala内部类：内部类是属于外部类的对象的；

/**  * @author lucl  * Scala内部类示例  * 说明：Scala内部类是从属于外部类的对象的  */ class ScalaOuter(val name : String) {outer =>   /**    * 内部类    */   class Inner (val name : String) {     def foo (inner : Inner) {       println("\t" + outer.name + "\t" + inner.name + ".");     }   }      def foo () {     println("Outer : " + outer.name);   } } object OOPInScala {     /**    * main方法    */   def main (args : Array[String]) {     val outer1 = new ScalaOuter ("Spark");     val outer2 = new ScalaOuter ("Hadoop");         val inner1 = new outer1.Inner("scala");     val inner2 = new outer2.Inner("java");     outer1.foo;     inner1.foo(inner1);          outer2.foo;     inner2.foo(inner2);          // 对于scala来说，这inner1调用foo方法传递参数时，是不可以将inner2作为参数传递的     // IDE提示：type mismatch; found : outer2.Inner required: outer1.Inner     // inner1.foo(inner2);   } } /**     // 输出结果     Outer : Spark           Spark scala.     Outer : Hadoop           Hadoop  java. */