2021-05-25

Java多态和Scala多态的区别

1.要彻底明白多态的区别，两种语言的继承先要搞清楚

1）Java的继承：

修饰符 class 子类 extends 父类名 { 类体 }

（1）在进行继承的时候，子类会继承父类的所有结构（包括私有属性、构造方法、普通方法）
	- 显示继承：所有非私有操作属于显示继承（可以直接调用）。
	- 隐式继承：所有私有操作属于隐式继承（不可以直接调用，需要通过其它形式调用（get或者set））。
（2）Java是单继承
（3）子类对象在进行实例化前首先调用父类构造方法，再调用子类构造方法实例化子类对象

2）Scala的继承：

class 子类名 extends 父类名  { 类体 }

（1）子类继承父类的属性和方法（方法和属性都可被重写）
（2）scala是单继承
（3）继承的调用顺序：父类构造器->子类构造器

3）区别：Scala可以重写继承的属性

abstract class Person() {
  //定义抽象的属性
  val name: String
  var age: Int

  //定义非抽象的属性
  val name1: String = "person"
  var age1 = 16

  //定义抽象方法
  def sayHi()

  //定义非抽象方法
  def sayHi1() = {
    println("hello")
  }



}


class Emp() extends Person() {

  //重写抽象的属性
  override val name: String = "抽象属性"

  override var age: Int = 28

  //重写非抽象的属性
  override val name1: String = "非抽象属性"
  //非抽象中var不可重写，因为var修饰的为可变变量，子类继承之后就可以直接使用，没有必要重写
  //override var age : Int = 18
  age1 = 18

  //重写抽象的方法
  override def sayHi(): Unit = println("抽象方法")

  //重写非抽象的方法
  override def sayHi1(): Unit = println("非抽象方法")
}

object Test {
  def main(args: Array[String]): Unit = {
    val emp = new Emp()
    println(emp.name)
    println(emp.age)
    println(emp.name1)
    println(emp.age1)
    emp.sayHi()
    emp.sayHi1()


  }
}

结果：

2.多态

1）Java

1.向上转型：
        1.有继承
        2.有方法重写
        3.父类的引用指向子类的对象(实例)
    
向上转型 对象能够调用的资源 分为 运行时 与 编译时：
         编译看左边    参照物是 =   运行看右边 
         编译时  =  运行时
         编译时:    写完代码后
         运行时:    代码执行时
         
2.向下转型：
        前提： 先向上转型
       	将变为父亲的孩子 再变回孩子
小的数据类型  变量名 = (小的数据类型)大的数据类型的值；

3.判断左边的变量是否属于右边的类型
instance Of

2）Scala

1.语法和java一样，两种语言有完美的兼容性

2.类型检查和转换的关键字不同

（1）obj.isInstanceOf[T]：判断obj是不是T类型。
（2）obj.asInstanceOf[T]：将obj强转成T类型。

3）区别：在继承的属性上Scala中属性和方法都是动态绑定，而Java中只有方法为动态绑定

Scala：

class Person {
    val name: String = "person"

    def hello(): Unit = {
        println("hello person")
    }
}

class Teacher extends Person {

    override val name: String = "teacher"

    override def hello(): Unit = {
        println("hello teacher")
    }
}

object Test {
    def main(args: Array[String]): Unit = {
        val teacher: Teacher = new Teacher()
        println(teacher.name)
        teacher.hello()
		
        //多态：父类的引用指向子类的实例
        val teacher1:Person = new Teacher
        println(teacher1.name)
        teacher1.hello()
    }
}

java：

class Person {

    public String name = "person";
    public void hello() {
        System.out.println("hello person");
    }

}
class Teacher extends Person {

public String name = "teacher";

    @Override
    public void hello() {
        System.out.println("hello teacher");
    }

}
public class TestDynamic {
public static void main(String[] args) {

        Teacher teacher = new Teacher();   
        System.out.println(teacher.name);
        teacher.hello();
    	
    	//多态
    	Person teacher1 = new Teacher();
        System.out.println(teacher1.name);
        teacher1.hello();
    }
}

结果对比：