目录
Scala包：
基础语法：
Scala包的三大作用：
包名的命名规范：
写包的好处：
包对象：
导包说明：
类和对象：
定义类：
封装：
构造器：
主从构造器的加载机制：
继承：
基础语法：
抽象属性：
多态：
Java中的多态测试
Scala测试如下：
Scala的面向对象思想和Java是一致的
Scala包：
基础语法：
package 包名.类名
Scala包的三大作用：
区分相同名字的类
当类很多时，可以很好的管理类
控制访问范围
包名的命名规范：
一般是小写字母+小圆点
com.公司名.项目名.业务模块名
写包的好处：
在maven中可以将自己写的包通过maven导入到项目中
在Scala中独有的包的写法 和文件夹不对应 可以独立存在
下图是我在类下边建的包，和正常的包一样使用
包是可以嵌套的
内层调用外层 不需要导包 atguigu包在techer下
外层调用内层 对象 需要导包
如下代码：
package chapter04
object 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中包也是面向对象的，只要在包的内部（只要在内部都可以，内层的嵌套也可以），都可以直接调用包对象的属性和方法
如果包有嵌套，会出现覆盖的情况，则会调用距离最近的包的属性与方法（包距离最近则会后调用，会覆盖先前调用的）
导包说明：
导包是不支持嵌套的（导包后只能用它下边的类和对象，不能再用它下边的包，如果想使用它下边包中的方法，就需要使用 . 但是当我们导包直接导入它下边的包 就可以直接调用，不需要用 . 来使用）
类和对象：
我们在使用对象的时候，会以类为模板创建对象
定义类：
在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=name
def this()
{
this("唐不唐")
println("hello world")
}
}主从构造器的加载机制：
在Scala中没有类加载机制，所以在代码直接调用辅助构造器的时候它是不知道类中的内容的， 所以上边要求（从构造器的内部第一行代码必须是直接或者间接的调用主构造器），这就是原因所在，获取类信息（加载一遍），调用完后才会返回从构造器继续执行
根据main方法中你的参数决定你调用那个构造器
从构造器是有先后顺序的，后边的只能调用前面的（所调用的构造器必须在本构造器之前）
从构造器的名称统一为this（根基参数的个数来区分）
主构造器是可以传参的 参数可以当作属性来使用（参数类型如果省略，默认val）
继承：
继承关键字：extends
基础语法：
子类继承父类的属性和方法
继承的本质：其实与Java是完全不一样的
在创建子类的对象时，Scala会先创建父类的对象让后在外层创建子类对象（同Java）
Scala继承的本质就是继承父类的一个构造器（继承那个构造器（参数个数来区别）就会调用那个）
抽象属性：
就是不写等号，写抽象方法需要把类改成抽象类
抽象属性在使用的时候需要继承它 让后需要重写属性和方法（在Java中是不需要重写属性的，因为Scala底层是对属性进行封装，自带方法）
在重写抽象类中的非抽象方法的时候需要在重写的方法前面加上 override 关键字
子类调用父类的方法的时候使用关键字super
子类对抽象属性进行实现，父类抽象属性可以用 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这个抽象子类
匿名子类是自动使用多态的文章来源：https://www.toymoban.com/news/detail-414151.html
多态无法调用子类独有的属性和方法，外部无法使用匿名子类中特有的（它自己的）方法和属性文章来源地址https://www.toymoban.com/news/detail-414151.html
到了这里，关于Scala之面向对象的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
