1、单例类
package com.zzzy
class AAA {//单例
/*//java 思路--私有化构造方法，提供公开的getAAA 行不通
private def this(){
this()
}
def getAAA():AAA={
val aaa = new AAA()
return aaa
}
*/
}
package com.zzzy
//单例类 //伴生类
class BBB private(){//1私有化构造方法 } //伴生对象
object BBB{ //不写apply
private val bbb=new BBB()//2创建一个私有对象
def getBBB:BBB={//3提供了一个公开的get方法
bbb
} }
package com.zzzy
object test {
def main(args: Array[String]): Unit = { val b1 = BBB.getBBB
val b2=BBB.getBBB
println(b1==b2)//true } }
2、object的继承和App
package com.zzzzy
abstract class Register {//定义一个抽象类
//抽象方法（没有方法体，只有方法定义）
def regist(name:String)
def unregist(name:String)
}
package com.zzzzy
//实现用extends
object User1 extends Register {
override def regist(name: String): Unit = {
println(name+"注册了") } override def unregist(name: String): Unit = {
println(name+"注销了") }
}
package com.zzzzy
class User2(n:String) extends Register {//主构造方法
override def regist(name: String): Unit = {
println(name+"注册"+n)
}
override def unregist(name: String): Unit ={
println(name+"注销"+n)
}
}
package com.zzzzy
object test extends App {//1如果一个对象继承App可以不需要main方法直接运行
/*def main(args: Array[String]): Unit = {
println("aaa")
}*/
println("bbb")
//2让一个object实现一个抽象类用关键字extends 重写未实现的方法
User1.regist("小敏")
User1.unregist("笑笑")
//3让一个class实现一个抽象类用关键字extends 重写未实现的方法可以有构造方法
new User2("白白").regist("lili")
new User2("白白").unregist("jack")
}
3、类的继承
package com.zzzzzy
class Person {
var name:String=_//必须给类型，无法推断
var age:Int=_
private var num=99
def show(): Unit ={
print("父类的方法")
}
}
package com.zzzzzy
class Student extends Person {
//不能重写被final修饰的方法 var sex:Char='男' override def show(): Unit = {
println("重写父类的方法show")
} def speak(): Unit ={
//调用了父类的属性 实测在运行中无法使用
/*println(super.age)
print(super.name)*/
//私有属性num无法通过super找到 super.show()//父类的方法
show()//子类重写的
} }
package com.zzzzzy
object test extends App {
val stu = new Student
stu.speak()
//多态的向上转型
var s:Person=new Student()
//还能得到子类特有的方法和属性吗？不能
s.show()//调用的为子类重写的方法
println(s.name)//null
println(s.age)
}
4、类型检查和类型转换
package com.zzzzzzy
class Person(name:String,age:Int){
var name1="小明"
var age1=50
def show(): Unit ={
println(name+"\t"+age)
}
}
package com.zzzzzzy //在一个scala文件中可以定义n个类 写在一行必须写； 大括号可以省略
class Emp extends Person("李四",40)
class Student extends Person("张三",30)
package com.zzzzzzy
object test extends App {
val em = new Emp
em.show()
val stu = new Student
stu.show()
println("---------------------")
//判断某个对象是否是某个类型
val ss= new Student()
//继承关系上 is a
println(ss.isInstanceOf[Person])
//转换--向上转型
val pp: Person = ss.asInstanceOf[Person]
pp.show()
}
5、protected关键字
package com.yz.extendz
class Animal {//父类 A和B都不是Animal的子类。那么属性的可使用情况如下
val a=100 //A类可用 //B类可用
protected val b=200
protected [this] val c=300
protected [extendz] val d=400//yz为包名 //A类可用
//这里四个属性，只要是Animal的子类都可以使用，无论在不在同一个包中
}
package com.yz.extendz
class Cat extends Animal{
val y=888
def show: Unit ={
println(s"$a-------$b------$c---------$d")
}
}
package com.yz.extendz
class Dog extends Animal {
val x=999
def show: Unit ={
println(s"$a-------$b------$c---------$d")
}
}
package com.yz.extendz
class A {
def show: Unit ={
val animal = new Animal
println(animal.a)
println(animal.d)
}
}
package com.yz2
import com.yz.extendz.Animal
class B {
def show: Unit ={
val animal = new Animal
println(animal.a)
}
}
6、匿名子类
package com.yz3
class Person {
def aaa="中国"
}
package com.yz3
object test extends App {
val pp= new Person {
override def aaa: String = "新中国"
}
//这个过程中产生了一个匿名子类【发生重写，子类重写父类方法但是又没有显示的定义处理----匿名】
val result = pp.aaa
println(result)
//定义方法
println("-------------------")
def show(p:Person): Unit ={
println(p.aaa)
}
//调用
show(new Person)
}
7、抽象
package com.yz4
abstract class Animal {//可以用于抽象或非抽象方法 拥有抽象字段/非抽象字段
//抽象字段(没有初始值)
val count:Int
//非抽象字段
val num=100
//抽象方法
def aaa:String
//非抽象方法
def bbb: Int ={
10
}
}
package com.yz4
class Cat extends Animal {
//重写抽象方法
override def aaa: String = {"你好"}
override val count: Int = 666
}
package com.yz4
object test extends App {
val cat = new Cat
val aaa: String = cat.aaa
val bbb: Int = cat.bbb
println(aaa+bbb)
}
8、特质（java接口）
package com.yz5
trait Log {
//非抽象方法 抽象时super调用时会出错
def showa:String={
"原始的"
}
}
package com.yz5
trait ALog extends Log {
override def showa: String = {
super.showa
println("ALog重写的方法")
"ALog"
}
}
package com.yz5
trait BLog extends Log {
override def showa: String = {
println("BLog重写的方法")
super.showa
"BLog"
}
}
package com.yz5
class CCC extends ALog with BLog {//继承两个特质
//showa()//默认应该调用最右边的特质中的同名方法【发生同名，以右边为主】
override def showa: String = {
super.showa
}
}
package com.yz5
object test extends App {
val ccc = new CCC
//条件：ALog和BLog重写方法中调用了super.showa
ccc.showa//默认把所有的都运行出来(ALog和BLog中的都运行了)没办法只运行左边的 }