从java中理解scala静态,从反编译中理解伴生对象与伴生类

一.java静态属性与静态方法

1.1 Java中静态方法并不是通过对象调用的，而是通过类对象调用的，所以静态操作并不是面向对象的。(因为没有显式地使用对象这一概念)

二.scala静态属性与静态方法

2.1 scala中没有关键字 ”static”

2.2为了达到面向对象目的,scala设计者设计出伴生对象和伴生类来满足静态属性与静态方法的需求

Scala语言是完全面向对象(万物皆对象)的语言，所以并没有静态的操作(即在Scala中没有静态的概念)。但是为了能够和Java语言交互(因为Java中有静态概念)，就产生了一种特殊的对象来模拟类对象，我们称之为类的伴生对象。这个类的所有静态内容都可以放置在它的伴生对象中声明和调用

 

2.2.1 伴生对象与伴生类的入门

源码

1. package edu.lulu.oop.chapter6  
2.   
3. object Test09 {  
4.   def main(args: Array[String]): Unit = {  
5.     println(Tool.userName2) //这里是通过调用伴生对象(object Tool)来调用静态属性以及静态对象  
6.     Tool.function2()  
7.   }  
8. }  
9.   
10. /* 
11. 定义一个工具类,userName1不是静态属性,function1()不是静态方法所以放在伴生类中 
12. userName2是静态属性,function2()是静态方法所以放在伴生对象中(object Tool) 
13.  */  
14.   
15. class Tool{  
16.   var userName1: String = _  
17.   def function1(): Unit ={  
18.     println("function1")  
19.   }  
20. }  
21.   
22. object Tool{  
23.   var userName2: String = _  
24.   def function2(): Unit ={  
25.     println("function2")  
26.   }  
27. }  

 

 

 

2.2.2 通过反编译了解伴生对象与伴生类

package edu.lulu.oop.chapter6;

import scala.Predef.;
import scala.reflect.ScalaSignature;

@ScalaSignature(bytes="\006\001}2A!\001\002\001\027\t!Ak\\8m\025\t\031A!\001\005dQ\006\004H/\032:7\025\t)a!A\002p_BT!a\002\005\002\t1,H.\036\006\002\023\005\031Q\rZ;\004\001M\021\001\001\004\t\003\033Ai\021A\004\006\002\037\005)1oY1mC&\021\021C\004\002\007\003:L(+\0324\t\013M\001A\021\001\013\002\rqJg.\033;?)\005)\002C\001\f\001\033\005\021\001\"\003\r\001\001\004\005\r\021\"\001\032\003%)8/\032:OC6,\027'F\001\033!\tYbD\004\002\0169%\021QDD\001\007!J,G-\0324\n\005}\001#AB*ue&twM\003\002\036\035!I!\005\001a\001\002\004%\taI\001\016kN,'OT1nKFzF%Z9\025\005\021:\003CA\007&\023\t1cB\001\003V]&$\bb\002\025\"\003\003\005\rAG\001\004q\022\n\004B\002\026\001A\003&!$\001\006vg\026\024h*Y7fc\001BQ\001\f\001\005\0025\n\021BZ;oGRLwN\\\031\025\003\021:Qa\f\002\t\002A\nA\001V8pYB\021a#\r\004\006\003\tA\tAM\n\003c1AQaE\031\005\002Q\"\022\001\r\005\nmE\002\r\0211A\005\002e\t\021\"^:fe:\013W.\032\032\t\023a\n\004\031!a\001\n\003I\024!D;tKJt\025-\\33?\022*\027\017\006\002%u!9\001fNA\001\002\004Q\002B\002\0372A\003&!$\001\006vg\026\024h*Y7fe\001BQAP\031\005\0025\n\021BZ;oGRLwN\034\032")
public class Tool
{
  private String userName1;

  public static void function2()
  {
    Tool..MODULE$.function2();
  }


  public static void userName2_$eq(String paramString)
  {
    Tool..MODULE$.userName2_$eq(paramString);
  }

  public static String userName2()
  {
    return Tool..MODULE$.userName2();
  }

  public String userName1()
  {
    return this.userName1; } 
  public void userName1_$eq(String x$1) { this.userName1 = x$1; } 
  public void function1() {
    Predef..MODULE$.println("function1");
  }
}



package edu.lulu.oop.chapter6;

import scala.Predef.;

public final class Tool$
{
  public static final  MODULE$;
  private String userName2;

  static
  {
    new ();
  }

  public String userName2()
  {
    return this.userName2; } 
  public void userName2_$eq(String x$1) { this.userName2 = x$1; } 
  public void function2() {
    Predef..MODULE$.println("function2");
  }
  private Tool$() { MODULE$ = this; }

}

单例模式饿汉式:在类初始化时初始化一个对象,并让MODULE$引用

MODULE$即静态对象,所谓的静态方法与静态变量只不过是MODULE$的成员方法与属性

2.2.3 伴生对象与伴生类注意事项

Scala中伴生对象采用object关键字声明，伴生对象中声明的全是 "静态"内容，可以通过伴生对象名称直接调用。

 

伴生对象对应的类称之为伴生类，伴生对象的名称应该和伴生类名一致。

 

伴生对象中的属性和方法都可以通过伴生对象名(类名)直接调用访问

 

从语法角度来讲，所谓的伴生对象其实就是类的静态方法和成员的集合

 

从技术角度来讲，scala还是没有生成静态的内容，只不过是将伴生对象生成了一个新的类，实现属性和方法的调用

 

从底层原理看，伴生对象实现静态特性是依赖于 public static final  MODULE$ 实现的。

 

伴生对象的声明应该和伴生类的声明在同一个源码文件中(如果不在同一个文件中会运行错误!)，但是如果没有伴生类，也就没有所谓的伴生对象了，所以放在哪里就无所谓了。

 

如果 class A 独立存在，那么A就是一个类， 如果 object A 独立存在，那么A就是一个"静态"性质的对象[即类对象], 在 object A中声明的属性和方法可以通过 A.属性 和 A.方法 来实现调用