Java对比Scala之面向对象

前面的内容中,我已将java和scala基本语法的部分做了对比。接下来，我会谈谈关于面向对象的部分。面向对象是使得程序功能更加强大，更加丰富的基础。得益于面向对象,我们才可以完成更加复杂的人机交互程序。

类的定义

JAVA中如何定义一个对象类型呢？其实，主要包括：类名，属性（数据域），方法，这三个部分。

public class People {//生成一个类
    String name;
    int age;
    String sex;

    public People() {
        //无参构造
    }

    public People(String name, int age, String sex) {//含参数构造
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    @Override
    public String toString() {
        return "People{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sex='" + sex + '\'' +
                '}';
    }
    public void JavaPeopleEat(String name){
        System.out.println(name +" can eat food .");
    }

    public static void main(String[] args) {
        People p1=new People();
        p1.name="skj";
        p1.JavaPeopleEat(p1.name);
    }
}

java的已经看过了,scala的其实也是类似,只不过是有些关键字不同而已.

package HomeWork

object ScalaPeople {
  class People{
    var name:String=null
    var age :Int = _ //_是给age初始化用的
    val school :String ="zut" //用val修饰的属性不能修改
    def ScalaPeopleEat(): Unit ={//自定义方法
      println(this.name + " can eat food too.")
    }
    override def toString = s"People($name, $age, $school)"
  }

  def main(args: Array[String]): Unit = {
    val peo1=new People
    println(peo1)//打印的是默认值
    peo1.name="skj"
    peo1.age=20
    println(peo1)//传入参数之后打印的是相关参数
    peo1.ScalaPeopleEat()//调用方法
  }
}

对比一下,不难看出.scala的代码要比java精简很多.为什么呢?

其实,Scala 的类中底层会自动生成类似 Java 中的公共的 getter 和 setter 方法。所以我们不用再写get和set方法了.

修饰符

访问修饰符

Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。

default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。

private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）

public : 对所有类可见。使用对象：类、接口、变量、方法

protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。

scala中也有四种访问权限修饰符： 公共的 ， protected (只能子类访问)， private[] 包访问权限 ， private(私有访问权限)

但是区别是:公共的是默认的访问权限，scala没有这个关键public

非访问修饰符

为了实现一些其他的功能，Java 也提供了许多非访问修饰符。

1. static 修饰符，用来修饰类方法和类变量。

2. final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。

3. abstract 修饰符，用来创建抽象类和抽象方法。

4. synchronized 和 volatile 修饰符，主要用于线程的编程。

5. 其他

来展示一下java的修饰符

public class JavaModifier {
    private int IDcard=2020001;//私有属性
    public String name = "skj";//公共属性
    protected void fun(){//java的protected 可以修饰数据成员，构造方法，方法成员，不能修饰类（内部类除外）
        System.out.println("this is a protected function");
    }
    /*static 修饰符*/
    private static int numInstances = 0;//静态变量
    protected static int getCount() {//静态方法,可以用类名直接调用
        return numInstances;
    }
    /*final 修饰符*/
    //final 修饰符通常和 static 修饰符一起使用来创建类常量。
    static final String FINE = "I am fine";//和C语言类似,变量名通常大写
    /*abstract 修饰符*/
    //abstract 修饰符用来定义抽象类和抽象方法
    /*synchronized 关键字*/
    //synchronized 声明的方法同一时间只能被一个线程访问。synchronized 修饰符可以应用于四个访问修饰符。
    public static void main(String[] args) {
        System.out.println(JavaModifier.getCount());
        System.out.println(FINE);
    }
}

接下来,对比一下scala的:

在 Scala 语法中没有 static 修饰的方法和字段，那么就可以创建一个和类名一样的 object 作为伴生对象，以此达到静态内容的实现。同名的 class 创建的类称为伴生类。

package HomeWork

object ScalaAssociated {
  val stu="skj"
  def fun1: Unit ={
    println("object ScalaAssociated 相当于伴生对象")
  }

  def main(args: Array[String]): Unit = {
    //调用伴生对象的方法
    fun1
    val sa=new ScalaAssociated
    sa.fun2
  }
  /*伴生类*/
  class ScalaAssociated{
      def fun2: Unit ={
        println("class ScalaAssociated 是伴生对象的伴生类")
      }
  }
}

scala得apply方法

package HomeWork

object ScalaEmail {

  object Email {
    def apply(user: String, domain: String): String = {
      println("apply  method")
      user + "@" + domain
    }
    def apply(user:String):String={
      user
    }
    def fun(user:String):String={
      user
    }
  }

  def main(args: Array[String]): Unit = {
    val email = Email //单例对象
    println(email.apply("skj", ".com"))//带apply方法
    println(email.apply("skj"))
    println(email.fun("com"))
    val email2= Email("skj")//假如我们把中间的apply方法注释掉,该句就会报错,why?
    println(email2)
  }
}

构造方法

java得构造已经在类的定义里面写过了,现在我们直接写scala得构造函数

object demo01{
  def main(args: Array[String]): Unit = {
    val stu1=new student("skj",20)
    println(stu1.name+" "+stu1.age+" "+stu1.classroom)
    val stu2=new student("arimakose",14,"child")
    println(stu2.name+" "+stu2.age+" "+stu2.sex)
    val monitor1=new Monitor("tenglinxing",18,"girl","boss")
    println(monitor1.position)
  }
}
//主构造器:student(var name:String,var age:Int)
class student(var name:String,var age:Int){
  println("student in ....")
  var classroom:Int = 182
  var sex:String= _
  //附属构造器,附属构造器必须先调用主构造器
  def this(name:String,age:Int,sex:String){
    this(name,age)
    this.sex=sex
  }
  println("student out ....")
}
//继承的话,如果之类有特有的属性,必须加上var
class Monitor(name:String,age:Int,sex:String,var position:String) extends student(name:String,age:Int,sex:String){
  println("Monitor in ....")
  println("继承的类如果运行,必须会先调用他的父类")
  println("Monitor out ....")
}