scalaOOP编程

最新推荐文章于 2024-08-05 20:09:54 发布

BigEpicure

最新推荐文章于 2024-08-05 20:09:54 发布

阅读量283

点赞数 1

分类专栏： scala 文章标签： scala OOP 面向对象面向对象编程类

本文链接：https://blog.csdn.net/weixin_44147632/article/details/108622429

版权

scala 专栏收录该内容

7 篇文章 3 订阅

订阅专栏

Scala面向对象

类(class)

1、类通过class关键字定义
2、类通过new关键字创建实例
3、类拥有成员变量和方法
4、类的成员默认为public，也支持private、protected
5、类中无法定义静态成员变量和方法
6、类无需明确定义构造方法，通过构造参数列表声明为类的一部分
类成员访问修饰符
JAVA

Modifier	Class	Package	Subclass	World
public	Y	Y	Y	Y
protected	Y	Y	Y	N
default	Y	Y	N	N
private	Y	N	N	N

SCALA

Modifier	Class	Companion	Subclass	Package	World
default	Y	Y	Y	Y	Y
protected	Y	Y	Y	N	N
private	Y	Y	N	N	N

普通类的定义
构造器包括主构造器和辅助构造器

//主构造器执行类定义中的所有语句
class Point(xc: Int, yc: Int) {
  var x: Int = xc	//成员变量
  var y: Int = yc 
  //辅助构造器
  def this() ={
    this(0, 0)	//第一句必须调用其他构造器
  }
  //成员方法
  def move(dx: Int, dy: Int) ={
    x = x + dx
    y = y + dy
  }  
}

var p=new Point()
p.x
p.y
p=new Point(12,11)
p.x
p.y
p.move(1,2)

类的继承
1、Scala使用extends关键字实现继承
2、子类重写父类方法必须使用“override”关键字

class BlackPoint() extends Point {
    private var color="black"   
    override def move(dx: Int, dy: Int) ={
    x = x + dx
    y = y + dy
    println("moved to x:"+x+" y:"+y)
  }  
}

抽象类（abstract class）

1、抽象类可包含未实现的方法，即抽象方法
2、抽象类无法实例化
3、抽象类使用abstract关键字修饰
子类重写抽象父类抽象方法时，override关键字可选
子类重写抽象父类非抽象方法，override关键字必写

abstract class MyFather {//抽象父类
  def seeBook()={//父类非抽象方法
    println("father look book")
  }
  def draw():Unit//父类抽象方法
}

//子类继承父类，实现父类方法override
class Son extends MyFather {
  override def seeBook(): Unit = {//子类重写父类非抽象方法，必须用override
    super.seeBook();//子类调用父类方法，用super
    println("son look book")
  }
  def draw()={
   //子类重写父类抽象方法，可不用override
  }
}

单例对象（object）

Java中的单例模式介绍

//单例模式
public class MyConnection{
	private MyConnection(){}//私有构造器，单例就是不能让别人new，只有一个实例对象
	//静态保证只有一个对象，饿汉模式，先new一个
	private static MyConnection mc = new MyConnection();
	public MyConnection getInstance(){
		return mc;
	}
}
/**public class MyConnection{
	private MyConnection(){}//私有构造器，单例就是不能让别人new，只有一个实例对象
	//静态保证只有一个对象
	private static MyConnection mc;
	public MyConnection getInstance(){
		if(mc == null ){//懒汉模式
			mc  = new MyConnection();
		}
		return mc;
	}
}
*/

Scala的类中无法定义静态成员，即无static关键字，使用object关键字声明，可包含变量、方法与代码定义
scala中的单例
1、单例对象中的成员变量、成员方法通过单例对象名直接调用
2、单例对象第一次被访问时初始化，并执行全部代码块
3、单例对象不能new，且无构造参数
4、程序入口main()方法必须定义在单例对象中
5、单例对象与同名类定义在同一文件中时形成绑定关系

//定义单例对象
object Blah {
  println("Blah initializing...")
  def sum(l: List[Int]): Int = l.sum//静态方法
}

伴生对象
1、单例对象与同名类定义在同一文件中时形成绑定关系.同名类称为单例对象的伴生类（class）；单例对象称为同名类伴生对象（object）
2、伴生类与伴生对象可相互访问各自私有成员
3、伴生对象可为伴生类增加静态成员

class Student(name:String,age:String) {
  var stu_name = name;
  var stu_age = age;
  //class里全是成员方法
  //成员方法（水杯）
  def learn()={
    println(stu_name+"认真学习")
    //成员可以调用静态，即水杯可以到水桶里打水
    println("成员可以调用静态")
    Student.eat()
  }
}
//伴生类
object Student{
  //伴生需要apply方法
  def apply(name: String, age: String): Student = new Student(name, age)

  //静态方法（水桶），静态不可调用成员，即水桶到水杯里打水不行
  def eat()={
    println("吃饭")
  }

  def main(args: Array[String]): Unit = {
    var stu=Student("张三丰","300岁")
    stu.learn()
//===============================================
    //类名调用静态方法
    println("类名调用静态方法")
    Student.eat()
    //直接调用静态方法
    println("直接调用静态方法")
    eat()
  }
}

特质（trait）

Scala中没有接口（interface）的概念，特质用于在类之间共享程序接口和字段，类似Java接口，是字段和方法的集合，可以提供字段和方法实现。类和单例对象都可以扩展特质（extends，可多继承，用with隔开又称混入特质），特质不能被实例化，因此没有构造参数，特质使用trait关键字定义，实现特质中的方法使用override。
混入特质
1、当某个特质被用于组合类时，被称为混入
2、一个类只能有一个父类但是可以有多个混入（分别使用关键字extends和with）

//抽象方法
abstract class A {
  def eat():Unit
}
//普通类继承抽象A
trait B extends A{
  override def eat(): Unit = {
    println("B吃饭")
  }
}
//特质，继承抽象A
trait C extends A {
  def sleep():Unit = {
    println("C睡觉")
  }
  override def eat(): Unit = {
    println("C吃饭")
  }
}
//D继承C,B又称混入特质 同一个eat方法,B中方法覆盖C
class D extends C with B {}

object K{
  def main(args: Array[String]): Unit = {
    val d = new D()
    d.sleep()
    d.eat()
  }
}

动态混入特质

class MyTrait {
  self:Eat=>		//this:Type=> 自身类型，表示该类实例化时必须混入相应特质或子特质，self是this的别名。
  def show()={
    myeat()
  }
}

trait Eat{
  def myeat():Unit
}

trait Person extends Eat{
  override def myeat(): Unit = {
    println("Person eat")
  }
}

trait Pig extends Eat{
  override def myeat(): Unit ={
    println("Pig eat")
  }
}

object MyTest{
  def main(args: Array[String]): Unit = {
  //动态混入，MyTrait()对象的show方法，虽然指向Eat中的myeat方法，实际是调用了Pig/Person中的myeat方法
    (new MyTrait() with Pig).show()
    (new MyTrait() with Person).show()
  }
}

内部类

概念：一个类可以作为另一个类的成员，称为内部类
Java内部类是外部类的成员
Scala内部类绑定到外部类的对象实例

样例类（case class）

概念：样例类常用于描述不可变的值对象（Value Object），类似于实体类

case class Student(name:String,age:Int)      //定义样例类
val stu=Student("Jason",19)      //创建样例类的实例，无需new关键字
println(stu.name)       //访问对象属性

1、样例类构造参数默认声明为“val”，自动实现类构造参数的getter
2、样例类构造参数声明为“var”时，自动实现类构造参数的setter和getter
3、样例类自动创建伴生对象
4、样例类自动实现的其他方法toString()、equals()、copy()、hashCode()，伴生对象中的apply()、unapply()
样例类和普通类的区别
1、样例类通常用于描述不可变的数据，数据完全依赖构造参数
2、样例类默认不可变，通过模式匹配可分解
3、两个样例类“==”操作时，通过按值比较而不是按引用
4、样例类操作更简单

泛型类

概念：泛型类指可以接受类型参数的类，泛型类在集合类中被广泛使用，与Java不同，定义泛型类使用[]。

类型边界和协变
在Scala中，类型参数可以有一个类型边界约束
1、类型上界：将类型限制为另一种类型的子类
T<:A表示类型变量T应该是类型A的子类，A是具体类型，T是泛型
2、类型下界：将类型声明为另一种类型的超类
T>:A 表示类型变量T应该是类型A的超类，A是具体类型，T是泛型

class MyTt {
  //泛型方法
  //上界<:
  //下界>:,没有控制，不如直接写T
  def abc[T<:Father](t:T) ={
    //List<Integer> lst = new New ArrayList<Integer>()
    val lst:ListBuffer[Int] = ListBuffer.empty[Int]
    //val lst:ListBuffer[Int] = ListBuffer[Int]()
    print("ttt")
  }
  def main(args: Array[String]): Unit = {
//    new MyTt().abc(new Object())//Object执行错误
    //协变类向上转型（+T）
    val kt1 = new KTest[Father]
    val kt2 = new KTest[Son]
    //kt1是kt2的父类

    //逆变，向下转型（-T）