package 包名.类名
区分相同名字的类
当类很多时，可以很好的管理类
控制访问范围
一般是小写字母+小圆点
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中包也是面向对象的，只要在包的内部（只要在内部都可以，内层的嵌套也可以），都可以直接调用包对象的属性和方法
如果包有嵌套，会出现覆盖的情况，则会调用距离最近的包的属性与方法（包距离最近则会后调用，会覆盖先前调用的）
导包是不支持嵌套的（导包后只能用它下边的类和对象，不能再用它下边的包，如果想使用它下边包中的方法，就需要使用 . 但是当我们导包直接导入它下边的包 就可以直接调用，不需要用 . 来使用）
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=name
def 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 修饰的为可变变量，子类继承之后就可以直接使用(可以直接进行修改)，没有必要重写
父类的引用指向子类的实例
：在父子共有的属性和方法调用的是父类还是子类：
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不同 都是调用的子类的
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这个抽象子类
匿名子类是自动使用多态的
多态无法调用子类独有的属性和方法，外部无法使用匿名子类中特有的（它自己的）方法和属性
Das obige ist der detaillierte Inhalt vonWie Java und Scala objektorientierte Programmierung implementieren. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
