scala类，继承，抽象，特质基础学习

单例对象
package com.meng.nan.day715

	import scala.collection.mutable.ArrayBuffer

	object SingletonClass {
	  def main(args: Array[String]): Unit = {
		//单例对象不需要new，用类名.方法名调用对象中的方法
	val session=SessionFactory.getSession()
		println(session.toString)
	  }
	}
	//创建类
	object  SessionFactory{
	  //该部分相当于java中的静态块
	  //object中的方法都是静态方法字段都是静态字段
	  var counts=5;
	  val sessions=new ArrayBuffer[Session]()
	  while(counts>0){
		sessions+=new Session
		println(sessions.toBuffer)
		counts-=1
	  }
	  //在object中的方法相当于java中的静态方法
	  def getSession():Session={
		sessions.remove(0)
	  }
	}
	//类
	class Session{}

//伴生对象，伴生类
/**
在 Scala 的类中，与类名相同的单例对象叫做伴生对象，也就是说如果我们在 object Dog 所
在的文件内定义了一个 class Dog，此时：
1、 object Dog 被称为 class Dog 的伴生对象
2、 class Dog 被称为 object Dog 的伴生类
3、 类和伴生对象之间可以相互访问私有的方法和属性
伴生类 和 伴生对象 之间可以互相访问对方的私有属性
*/

	package com.meng.nan.day715
	//伴生类和伴生对象
	object AssociatedClass {
	 //伴生对象的私有属性
	  private  val CONSTANT:String="小花"

	  def main(args: Array[String]): Unit = {
	val ac=new AssociatedClass
		//访问私有字段name
		ac.name="小强"
		ac.printName()
	  }
	}

	class AssociatedClass{
	  val id=100
	  private  var name="小明"
	  def printName(): Unit ={
		//在类中可以访问伴生对象的私有属性
		println(AssociatedClass.CONSTANT+name)
	  }
	}

抽象类
package com.meng.nan.day715

//scala中的抽象类与java中的抽象类基本一致
/**

• 抽象类是一种不能被实例化的类，抽象类中包括了若干不能完整定义的方法，这些方法由子
• 类去扩展定义自己的实现。
• 1、如果在父类中，有某些方法无法立即实现，而需要依赖不同的子类来覆盖，重写实现自
• 己不同的方法实现。此时可以将父类中的这些方法不给出具体的实现，只有方法签名，这
• 种方法就是抽象方法。
• 2、而一个类中如果有一个抽象方法，那么类就必须用 abstract 来声明为抽象类，此时抽象
• 类是不可以实例化的 3、在子类中覆盖抽象类的抽象方法时，不需要使用 override 关键字
  */
  object AbstractClass {
  def main(args: Array[String]): Unit = {
  val a=new Cat
  a.eat
  }
  }
  //定义抽象类
  abstract class Animal{
  //抽象字段，在抽象类中可以不必进行初始化
  //抽象方法
  def eat:Unit

}
//子类继承抽象类，实现抽象方法
class Cat extends Animal{
//可以不加override
def eat: Unit ={
println(“这是一只偷吃鱼的小猫”)
}
}

继承

	package com.meng.nan.day715

	//scala中的抽象类与java中的抽象类基本一致
	/**
	  * 抽象类是一种不能被实例化的类，抽象类中包括了若干不能完整定义的方法，这些方法由子
	  * 类去扩展定义自己的实现。
	  * 1、如果在父类中，有某些方法无法立即实现，而需要依赖不同的子类来覆盖，重写实现自
	  * 己不同的方法实现。此时可以将父类中的这些方法不给出具体的实现，只有方法签名，这
	  * 种方法就是抽象方法。
	  * 2、而一个类中如果有一个抽象方法，那么类就必须用 abstract 来声明为抽象类，此时抽象
	  * 类是不可以实例化的 3、在子类中覆盖抽象类的抽象方法时，不需要使用 override 关键字
	  */
	object AbstractClass {
	  def main(args: Array[String]): Unit = {
	val a=new Cat
		a.eat
	  }
	}
	//定义抽象类
	abstract class Animal{
	  //抽象字段，在抽象类中可以不必进行初始化
	  //抽象方法
	  def eat:Unit

	}
	//子类继承抽象类，实现抽象方法
	class Cat extends  Animal{
	  //可以不加override
	   def eat: Unit ={
		println("这是一只偷吃鱼的小猫")
	  }
	}

重写和类型检查与转换

			 package com.meng.nan.day715
	//重写
	/**
	  * 1、Scala 中，如果子类要重写一个父类中的非抽象方法，则必须使用 override 关键字
	  * 2、override 关键字可以帮助我们尽早地发现代码里的错误，比如：override 修饰的父类方法
	  * 的方法名我们拼写错了；比如要覆盖的父类方法的参数我们写错了；等等
	  * 3、此外，在子类覆盖父类方法之后，如果我们在子类中就是要调用父类的被覆盖的方法呢？
	  * 那就可以使用 super 关键字，显式地指定要调用父类的方法
	  */
	object RewriteClass {
	  def main(args: Array[String]): Unit = {
	//val sc=new SonClass
	   // sc.eat()
		val p=new Text()
		val pa=new ImTest()
		println(pa.isInstanceOf[ImTest])
		println(pa.isInstanceOf[ImTest])
		println(classOf[ImTest])
		println(pa.asInstanceOf[Text])

		/**
		  * 判断 obj.isInstanceOf[C] obj instanc转换 obj.asInstanceOf[C] (C)obj获取 classOf[C] C.class
		  */
	  }
	}
	abstract  class FatherClass{
	  def eat()
	}
	class  SonClass  extends  FatherClass{
	  override def eat(): Unit = {
		println("马上就开饭了")

	  }}

	class Text{

	}

	class ImTest extends  Text{}

特质

	package com.meng.nan.day715

	/**
	  * 特质
	  * Scala 中的 Triat 是一种特殊的概念首先我们可以将 Trait 作为接口来使用，此时的 Triat 就与 Java 中的接口非常类似
	  * 在 Triat 中可以定义抽象方法，就与抽象类中的抽象方法一样，不给出方法的具体实现
	  * 在 Triat 中也可以定义具体方法，给出方法的具体实现在 Triat 中可以定义具体字段，也可以定义抽象字段类可以使用 extends 关键字继承 trait，注意，这里不是 implement，而是 extends，
	  * 在 sca中没有 implement 的概念，无论继承类还是 trait，统一都是 extends类继承 trait 后，必须实现其中的抽象方法，实现时不需要使用 override 关键字scala 不支持对类进行多继承，但是支持多重继承 trait，
	  * 使用 with 关键字即可
	  */
	object TriatClass {
	  def main(args: Array[String]): Unit = {

	  }
	}
	trait TestTe{
	  val id:Int
	  def add(o:Any):Boolean
	  def update(o:Any):Int
	  def query(id:String):List[Any]

	}

	class Imtteait extends TestTe{
	//给父类抽象字段赋值
	  override val id: Int = 10
	  //实现父类抽象方法
	  override def add(o: Any): Boolean = true

	  override def update(o: Any): Int = 12

	  override def query(id: String): List[Any] = List(1,2,3)
	}
	//创建特质
	//在 Scala 的
	//trait 中，它不但可以包括抽象方法还可以包含字段和具体方法。
	trait DAO{
	  //抽象字段
	  val id:Int
	//具体字段
	  val name:String="hello"
	  //带实现的具体方法
	  def delete(id:String):Boolean=true
	  //定义一个抽象方法，不加abstract ，加了会报错
	  def add(o:Any):Boolean
	  def update(o:Any):Int
	  def query(id:String):List[Any]
	}
	
	
	混入特质
	package com.meng.nan.day715
	//有时我们可以在创建类的对象时，指定该对象混入某个 Trait，这样，就只有这个对象混入该
	//Trait 的方法，而类的其他对象则没有
	object TraitClass {
	  def main(args: Array[String]): Unit = {
	val sd=new SmallDog("小黑")
		sd.eat()
		//混入特质
		val sd1=new SmallDog("小白") with  Cat1
		sd1.eat()
	  }
	}

	trait  Animal1{
	  def log(msg:String){}
	}
	trait Dog1 extends  Animal1{
	 override def log(msg:String){
	   println("小狗"+msg)

	 }}

	trait  Cat1 extends  Animal1{
	  override def log(msg: String): Unit = {
		println("小猫"+msg)
	  }
	}
	class SmallDog(val name:String) extends  Dog1 {
	  def eat(): Unit ={
		println(name+"在吃东西")
		log("今天的食物挺好吃")
	  }
	}
	
	特质的调用链
	
	package com.meng.nan.day715

	trait Handler {
	  def handler(data:String){}
	}
	trait Handler_A extends Handler{
	  override def handler(data:String): Unit = {
		println("Handler_A :"+data)
		//调用父类特质
		super.handler(data)
	  } }
	trait Handler_B extends Handler{
	  override def handler(data:String): Unit = {
		println("Handler_B :"+data)
		super.handler(data)
	  } }
	trait Handler_C extends Handler{
	  override def handler(data:String): Unit = {
		println("Handler_C :"+data)
		super.handler(data)
	  } }
	class Person_TraitChain(val name:String) extends Handler_C with Handler_B with
	  Handler_A{
	  def sayHello={
		println("Hello "+name)
		handler(name)
	  } }
	object TraitChain_Test{
	  def main(args: Array[String]) {
		val p=new Person_TraitChain("zhangxiaolong");
		p.sayHello
	  } }