java调用scala内部类_【Scala教程】（七）Scala面向对象之类详解

学过java的人对类再熟悉不过了，类是用class修饰的，回顾一下java中的类:

class一般用public修饰，代表公有的。

类有很多成员变量，这些变量对应着get和Set方法。像这么一对getter/setter通常被称为属性(property)，我们会说Student有一个name属性。

类也有很多成员方法。

public class Student {

//成员变量

private String name;

public String getName() {

return name;

}

public void setName(String name) {

this.name = name;

}

//成员方法

public void test() {

System.out.println("bdstar");

}

public static void main(String[] args) {

Student student = new Student();

student.setName("bdstar");

System.out.println(student.getName());

student.test();

}

}

scala中的类跟java的很相似，也有变量和方法，但是语法会简洁很多。注意对比Scala与java的区别。

class ScalaDemo {

//初始化变量

var age: Int = _

//如果是val修饰的 那么只有get没有set

val name: String = "bdstar"

//带参方法

def f1(x:Int,y:Int):Int = x+y

//无参方法

def f2():Unit = { println("bdstar good") }

}

// 伴生对象 跟类名相同 且 在同一个文件中

object ScalaDemo {

//定义在object的方法相当于java的static方法

def main(args: Array[String]): Unit = {

val scala = new ScalaDemo

//scala中的setter方法 直接用等号

scala.age = 10

//scala中的getter方法 直接通过.来获得值

println(scala.age)

println(scala.name)

//调用带参方法

scala.f1(2,3)

//调用无参方法 可以省略括号 也可以不省略

scala.f2 //等价于scala.f2()

}

}

我们发现几点不同：

class没有用public修饰，在scala中，类并不声明为public，Scala源文件可以包含多个类，所有这些类都具有可见性。

get和set方法非常简洁,setter方法 直接用”=” ,getter方法 直接通过”.”

调用无参方法 可以省略括号 java中不可以

java中类可以有main方法，然后可以直接执行。但是scala中类不能直接执行，要通过object中的main方法来执行。

接下来再深入一下scala类的使用：

私有变量

需要变量是私有的怎么办呢？

//用private[this] 修饰之后 就变为私有的了 只能在类的内部使用

private[this] var address="shenzhen"

如果不加上[this] 那么除了在类的内部，在伴生对象中也是可以使用的

class ScalaDemo {

private var address="shenzhen"

}

object ScalaDemo {

def main(args: Array[String]): Unit = {

val scala = new ScalaDemo

println(scala.address)

}

}

私有类

我想跟java一样，某些类只有在同一个包下才可以被new出来，怎么办呢？加上private之后，该类只有在同一个包下才能被new出来。

private class PrivateClass {}

构造器

java中类有构造方法，可以通过形如new Person(“Fred”,42)来创建对象。scala中呢？

在Scala中，每个类都有主构造器。它与类定义交织在一起。

//主构造器

class ScalaDemo(age:Int,name:String) {

def description = name + " is " + age + " years old "

}

object ScalaDemo {

def main(args: Array[String]): Unit = {

val scala = new ScalaDemo(22,"liuyanling")

println(scala.description)

}

}

除了主构造器外，Scala中还有辅助构造器，用于使用和主构造器不同的参数来初始化对象。

Scala 类里辅助构造器都是以def this(…)定义的。

辅助构造器，第一行必需调用主构造器或者其他已存在的辅助构造器。并且只能调用在自己之前定义的其他辅助构造器，而不能调用后面定义的辅助构造器(避免死循环调用)

class ScalaDemo(var age:Int,val name:String) {

var sex:String=_

//辅助构造器的第一行必须先调用主构造器

def this(age:Int,name:String,sex:String){

this(age,name)

this.sex = sex

}

def description = name + "--" + age + "--" + sex

}

object ScalaDemo {

def main(args: Array[String]): Unit = {

val scala = new ScalaDemo(22,"liuyanling","woman")

val scala1 = new ScalaDemo(22,"liuyanling")

println(scala.description)

println(scala1.description)

}

}

再注意几点：

辅助构造器的参数不可以用val或var来修饰！def this(var age:Int…)会报错

主构造器中如果不包含var或者val那么就是private[this]修饰。比如class ScalaDemo(var age:Int,val name:String,address:String)那么address是不能被伴生对象或者其他类访问的。

主构造器可以是私有的，形如class ScalaDemo private(var age:Int,val name:String,address:String)那么其他类中就不能访问它了。

内部类

java中有内部类，使用内部类最吸引人的原因是：每个内部类都能独立地继承一个(接口的)实现，所以无论外围类是否已经继承了某个(接口的)实现，对于内部类都没有影响。可以这样说，接口只是解决了部分问题，而内部类使得多重继承的解决方案变得更加完整。那么scala中有没有内部类呢？肯定有咯！

class Outer {

private[this] var age=12

private[this] var name="lyl"

class Inner{

//内部类可以对外部类的属性进行无缝的访问，尽管它是private修饰的

def describe()=println(name+":"+age)

}

}

object Outer{

def main(args: Array[String]): Unit = {

val outer = new Outer

val inner = new outer.Inner()

inner.describe()

}

}

BDStar原创文章。发布者：Liuyanling，转载请注明出处：http://bigdata-star.com/archives/1542