基本类的使用:(初)
package com.dtspark.scala.basics
/**
* trait是一个接口
* 接口的第一次继承用extends,多继承时用with
* 多继承时,如果这些接口中都有同样的方法时,则是从右往左的顺序执行
* 抽象类不能实例化
* 类继承的时候不继承伴生对象object,只能看见类的接口,而其父类可以使用自己伴生对象中的方法
* isInstanceOf 和 asInstanceOf的使用
* 前者是判断是不是其子类,后者是进行类型转换,但必须是父子之间的转换,不能是完全不同的类
*/
trait Logger{
def log(message:String){
println("logger "+message)
} }
/**
* override 是表示重写原有方法,(必须要写)
*/
trait RichLogger extends Logger{
override def log(message:String){
println("RichLogger:"+message)
}
} class Loggin( name:String)extends Logger{
def loggin{
println("Hi,welcome! "+name)
log(name)
} } trait Information{ val information:String //抽象属性
//def getId:String
def getInformation:String //抽象方法(不存在方法体)
def checkIn:Boolean = {
getInformation.equals("Spark")
}
} class Passenger( name:String)extends Information{
//不可以定义为val 原因是因为_的值不明确
var id:String=_ //这种方法申明的不是抽象属性,而是可变属性,其值为String的默认值null
override val information = name //重写抽象属性
override def getInformation = information //不执行任何操作,直接给返回值,相当于实现了
/**
* this关键字为构造方法,重写构造方法
* 副构造函数的第一行必须是构造函数
*/
def this(name:String,iid:String){
this(name)
id=iid;
println("hello!!")
}
def out:String={
name+" : "+id
} } object HelloTrait {
def main(args: Array[String]): Unit = {
/**
* 对象实例化之后又继承了新的接口,可以使用新的方法
* 新的接口必须继承至原有的接口,并重写新的方法
*/
val Log = new Loggin("Spark")with RichLogger
Log.loggin val person = new Passenger("zcb")
println(person.out)
person.id="123" //不具有封装性
println(person.out)
val person1 = new Passenger("zcb1","1234")
println(person1.out)
val a:Boolean=person.isInstanceOf[Information]//看它是不是其子类
println(a)
}
}
类的继承和判断对象是否相等(中)
package com.dtspark.scala.basics
/**
*class Creature {
* val range: Int = 10
* val env: Array[Int] = new Array[Int](range)
*} *class Ant extends Creature {
* override val range = 2
*}
* 在构造时,发生的过程如下:
* Ant构造器在构造自己之前,调用超类构造器;
* Creature的构造器将range字段设为10;
* Creature的构造器初始化env数组,调用range字段的getter;
* range的getter被Ant类重写了,返回的Ant类中的range,但是Ant类还未初始化,所以返回了0;
* env被设置成长度为0的数组
* Ant构造器继续执行,将range字段设为2
* -------------------------------------------------------------
* 第二种写法是先初始化sporter的成员,然后在初始化父类的成员,这样可保证将数据传给父类,with后面接要继承的类
* class Person10{
* val counter=3
* val counterArray =new Array[Int](counter)
* }
* class Sporter extends {
* override val counter = 5
* }with Person10 **/这样初始化后sporter的counterArray的长度为5
class Person10{
val counter=3
val counterArray =new Array[Int](counter)
} class Sporter extends {
override val counter = 5
}with Person10 //判断两个对象是否相同的方法
class Programmer(val name:String,val salary:Double){
final override def equals(other:Any)={
val that = other.asInstanceOf[Programmer]
if(that==null)false
else name == that.name&&salary==that.salary
}
/**
* 1.hashCode()方法存在的主要目的就是提高效率。
* 2.在集合中判断两个对象相等的条件,其实无论是往集合中存数据,
* 还是从集合中取数据,包括如果控制唯一性等,都是用这个条件判断的,条件如下:
* 首先判断两个对象的hashCode是否相等,如果不相等,就认为这两个对象不相等,就完成了。
* 如果相等,才会判断两个对象的equals()是否相等,如果不相等,就认为这两个对象不相等,
* 如果相等,那就认为这两个对象相等。 * 所以说重写equals时必须重写hashcode,这是良好的习惯
*/
final override def hashCode=name.hashCode()*5+salary.hashCode()*9 } //object OverrideField {
// def main(args: Array[String]): Unit = {
// val s = new Sporter
// println(s.counterArray.length)
// }
//}
//第二种写法,不用写main函数
object OverrideField extends App{
val s = new Sporter
println(s.counterArray.length)
}
注:对于无序表寻找是否有相同的对象时,使用hashcode可以大大提高速度。equal的比较通常比较耗资源,可以先比较hashcode后,确认hashcode相同时再用equal比较。
hashcode相同,equal不一定相同;equal相同的hashcode一定相同。
类的提取器:(中)
package com.dtspark.scala.basics
/**
* 类的提取器
* 注解要搞懂下面两个
* @transient 注解将字段标记为瞬态的
* @volatile 注解标记为易失的
*
* 自己编写的注解要继承annotation.Annotation
*/
case class Person1(name:String ,age:Int) class DTCoder(val name:String ,val salary:Int)
object DTCoder{
//复写了其apply和unapply方法
def apply(name:String,salary:Int)={
println("DTCoder apply method invoked!!!")
new DTCoder(name,salary)
}
// 方法1 (可使一个字符串转换成一个对象)
// def unapply(information:String)={
// //根据空格区分参数
// println("DTCoder unapply method invoked!!!")
// Some((information.substring(0 , information.indexOf(" ")),information.substring(information.indexOf(" ")+1)))
// }
//方法二
def unapply(information:DTCoder)={
//根据空格区分参数
println("DTCoder unapply method invoked!!!")
Some((information.name,information.salary))
}
} object HelloExtractor {
def main(args: Array[String]): Unit = {
val person=Person1("Spark",12)//调用apply的工厂构造方法,构造出类的实例
//= val person =Person1.apply("Spark",12)
val Person1(name,age)=person//调用Person1的unapply的方法把person实例中的name和age提取出来
println(person.name+" : "+person.age)//实现了name和age的赋值。 person match{ //val Person1(name,age)=person=match这个过程
case Person1(name,age)=>println(name+" : "+age)
}
//针对unapply方法一
//val DTCoder(dtname,salary) = "Spark 16000000" //针对unapply方法二
val coder = DTCoder("Spark",2999999)
val DTCoder(dtname,salary)=coder
}
}
类的伴生对象:(高)
添加类的内容:
class Marker ( color:String)
class Marker (val color:String)
class Marker (var color:String)
这两种申明是有差的,第二种和第三种申明都可以通过Marker的对象+"."直接调用(相当于这个属性是静态的),而第一种申明不行
class Marker private (val color:String) { println("创建" + this) override def toString(): String = "颜色标记:"+ color }
private写在类名和参数中间表示对主构造函数的私有化,这时是不能new出对象的(除非有伴生对象object或者有重构this构造函数)
def main(args: Array[String]) {
new Marker("black")//报错
}
第一种解决方案:
添加object后,同时要有apply方法,否则还是报错(伴生对象是不带参数的,但是apply方法需要与原类相同的参数)
由于有apply方法的存在,创建新对象时,不需要用new关键字,
用object初始化时,他会直接初始化object中存在的所有变量。
object zcb01 {
def main(args: Array[String]) {
Marker("white") //直接对象名进行初始化
} }
class Marker (val color:String) { println("创建" + this) override def toString(): String = "颜色标记:"+ color } object Marker{ private val markers: Map[String, Marker] = Map(
"red" -> new Marker("red"),
"blue" -> new Marker("blue"),
"green" -> new Marker("green")
)
private val m = Set(new Marker("black"))
def apply(color:String) = {
if(markers.contains(color)) markers(color) else null
println("我输入的颜色:"+color)
} }
结果:(先将object中的元素初始化,然后再调用apply方法初始化当前对象)
创建颜色标记:red
创建颜色标记:blue
创建颜色标记:green
创建颜色标记:black
我输入的颜色:white
第二种解决方案:
重构构造器(创建对象时必须用new,因为object(apply方法)不支持除主构造以外的任何重载构造方式)
object zcb01 {
def main(args: Array[String]) {
new Marker("white",4)
} }
class Marker private (val color:String) {//主构造的形式与类名后面的形式相同 println("创建" + this)
var a=1; def this(color:String,a:Int){
this(color)//必须先调用主构造器
this.a=a;
} override def toString(): String = "颜色标记:"+ color }