Java Scala面向对象怎么使用

今天小编给大家分享一下Java Scala面向对象怎么使用的相关知识点，内容详细，逻辑清晰，相信大部分人都还太了解这方面的知识，所以分享这篇文章给大家参考一下，希望大家阅读完这篇文章后有所收获，下面我们一起来了解一下吧。

Scala包：

基础语法：

package 包名.类名

Scala包的三大作用：

区分相同名字的类

当类很多时，可以很好的管理类

控制访问范围

包名的命名规范：

一般是小写字母+小圆点

com.公司名.项目名.业务模块名

写包的好处：

在Maven中可以将自己写的包通过maven导入到项目中

在Scala中独有的包的写法  和文件夹不对应  可以独立存在

下图是我在类下边建的包，和正常的包一样使用 

包是可以嵌套的

内层调用外层 不需要导包  atguigu包在techer下

外层调用内层 对象 需要导包

 如下代码：

package chapter04object Test_01_package {  def main(args: Array[String]): Unit = {  }}//Scala独有的package techer {  import chapter04.techer.atguigu.Inner  object test01t {    def main(args: Array[String]): Unit = {      println("hello  我是大哥 pack")      //外层调用内层 对象 需要导包          //Inner.main是下边那个包中的      Inner.main(args)    }  }  package atguigu {    object Inner {      def main(args: Array[String]): Unit = {        println("Inner")        //内层调用外层 不需要导包  atguigu包在techer下        test01t.main(args)      }    }  }}

包对象：

在Scala中包也是面向对象的，只要在包的内部（只要在内部都可以，内层的嵌套也可以），都可以直接调用包对象的属性和方法

如果包有嵌套，会出现覆盖的情况，则会调用距离最近的包的属性与方法（包距离最近则会后调用，会覆盖先前调用的）

导包说明：

导包是不支持嵌套的（导包后只能用它下边的类和对象，不能再用它下边的包，如果想使用它下边包中的方法，就需要使用   .   但是当我们导包直接导入它下边的包  就可以直接调用，不需要用  .     来使用）

Scala 中的三个默认导入分别是
import java.lang._
import scala._
import scala.Predef._

类和对象：

类：可以看成一个模板
对象：表示具体的事物
我们在使用对象的时候，会以类为模板创建对象

定义类：

在Java中一个文件中只能有一个public    

在Scala中 默认的是public 但是它在一个文件中可以创建多个伴生类和伴生对象

封装：

在Scala中属性只有两种  可变（var）与不可变（val）（分离了读写权限----类似与面向对象中的封装（封装get  set  方法  是为了分离读写权限））

在Scala直接通过属性的类型来分离

在Scala中属性的类型已经封装成    var----private       val----private final         

并且get  set方法也已经封装（封装成了注解，在使用get  set方法的时候需要 先引入注解@BeanProperty----不过该注解的作用域只有一个属性  意思是  一个属性需要设置一个注解）

构造器：

面向对象的语言基本都有构造器（构造方法），如果在类中不写构造方法  默认构造器为空参构造方法

在Scala中也有构造器，与Java不同，

Scala的构造器是在类名上加个()   是主构造器（主构造器无参的时候可以省略()  表示默认是可以无参构造的  类同Java）

有主构造器就一定有从构造器

在主构造器的内部可以定义辅助构造器 定义的格式是固定的，在从构造器的内部第一行代码必须是直接或者间接的调用主构造器

class Person03(name:String){  var name1:String=namedef this()  {    this("唐不唐")    println("hello world")  }}

主从构造器的加载机制：

在Scala中没有类加载机制，所以在代码直接调用辅助构造器的时候它是不知道类中的内容的， 所以上边要求（从构造器的内部第一行代码必须是直接或者间接的调用主构造器），这就是原因所在，获取类信息（加载一遍），调用完后才会返回从构造器继续执行

根据main方法中你的参数决定你调用那个构造器

从构造器是有先后顺序的，后边的只能调用前面的（所调用的构造器必须在本构造器之前）

从构造器的名称统一为this（根基参数的个数来区分）

主构造器是可以传参的 参数可以当作属性来使用（参数类型如果省略，默认val）

继承：

继承关键字：extends

基础语法：

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

子类继承父类的属性和方法

scala 是单继承

继承的本质：其实与Java是完全不一样的

在创建子类的对象时，Scala会先创建父类的对象让后在外层创建子类对象（同Java）

Scala继承的本质就是继承父类的一个构造器（继承那个构造器（参数个数来区别）就会调用那个）

抽象属性：

就是不写等号，写抽象方法需要把类改成抽象类

抽象属性在使用的时候需要继承它   让后需要重写属性和方法（在Java中是不需要重写属性的，因为Scala底层是对属性进行封装，自带方法）

在重写抽象类中的非抽象方法的时候需要在重写的方法前面加上    override   关键字

子类调用父类的方法的时候使用关键字super  

子类对抽象属性进行实现，父类抽象属性可以用 var 修饰；

子类对非抽象属性重写，父类非抽象属性只支持 val 类型，而不支持 var。
因为 var 修饰的为可变变量，子类继承之后就可以直接使用(可以直接进行修改)，没有必要重写    

多态：

父类的引用指向子类的实例

Java中的多态测试

：在父子共有的属性和方法调用的是父类还是子类：

public class Polymorphic {    public static void main(String[] args) {        Person person=new Student();        System.out.println(person.name);        person.sayhi();    }    public static class Person{     String   name="Person";     public void sayhi()     {         System.out.println("person  sayhi");     }    }public static class Student extends Person{        String name="Student";        public void sayhi()        {            System.out.println("student sayhi");        }} }

属性是调用父类   方法是调用子类   

在进行多态的时候是先将整个内存先把父类写入里面，再把子类嵌套到外边

引用是使用栈 把地址值是先指向父类的   指向谁就调用谁的属性，但是调用方法是一层一层的调用，是不断的被重写的，所以方法是调用子类

而Scala与Java不同 都是调用的子类的

Scala测试如下：

package chapter04 object Test07_Polymorphic {  def main(args: Array[String]): Unit = {       val  per:Person07=new Student07       per.sayhi();    println(per.name)  }}class Person07(){  val name:String="dsdsd"def sayhi():Unit={  println("hi person")}}class Student07 extends Person07{  override val name: String = "Student"override def sayhi(): Unit =  {    println("Student say hi")  }}

匿名子类：

可以使用匿名子类直接调用抽象类

也可以直接new这个抽象子类

匿名子类是自动使用多态的

多态无法调用子类独有的属性和方法，外部无法使用匿名子类中特有的（它自己的）方法和属性

以上就是“Java Scala面向对象怎么使用”这篇文章的所有内容，感谢各位的阅读！相信大家阅读完这篇文章都有很大的收获，小编每天都会为大家更新不同的知识，如果还想学习更多的知识，请关注编程网精选频道。