1 Variables miembro
package com._51doit.day05.demo.oob
import scala.beans.BeanProperty
/**
* FileName: Demo
* Author: 多易教育-DOIT
* Date: 2020/11/5 0005
* Description:
* 成员变量
* 1 位置 柱构造器
* 2 类的主体位置
* 3 val var修饰 var 修饰的可以不赋值 _ val 必须赋值 在主构造器中的除外
*/
class Demo1(val name:String){
// val name = "zss" // 一定辅助
var age:Int = _ // get 和 set
@BeanProperty
var job:String = _
}
object Demo {
def main(args: Array[String]): Unit = {
val demo1 = new Demo1("lss")
demo1.age=23
/*demo1.getJob
demo1.job*/
println(demo1.name)
println(demo1.age)
}
}
Método de 2 miembros
package com._51doit.day05.demo.oob
/**
* FileName: Demo2
* Author: 多易教育-DOIT
* Date: 2020/11/5 0005
* Description:
*/
class Demo2{
// 成员方法
def show: Unit ={
}
//成员函数
val f = (x:Int,t:Int)=>{
x+t
}
val f2:(String,String)=>String = (str1,str2)=>{
str1+str2
}
val f3= (str1:String, str2:String)=>{
str1+str2
}
val f4 = show _
}
object Demo2 {
// 成员方法
def show2: Unit ={
}
//成员函数
val f2 = (x:Int,t:Int)=>{
x+t
}
}
3 Bloque de código de miembro
package com._51doit.day05.demo.oob
/**
* FileName: Demo3
* Author: 多易教育-DOIT
* Date: 2020/11/5 0005
* Description:
*/
class Demo3 {
//每次创建实例都会执行
{
println("hello")
}
}
object Demo3 {
// 只在加载的时候执行一次
{
println("hello2")
}
}
4 aplicar función
Este es un método especial
1 Sin método de llamada declarativa
2 No utilice nuevos al crear objetos
Al usar este método, puede crear un objeto en la función principal sin usar new, es decir, puede instanciarlo uno a la vez sin especializarse.Cuando se carga la clase que crea el objeto, se llama automáticamente al método de aplicación, similar a Java bloque estático estático.
Se recomienda escribir este método en objetos de vida media. Si este método está escrito en una clase sin objetos de vida media, no se puede utilizar.
package com._51doit.day05.demo.oob
/**
* FileName: AppDemo
* Author: 多易教育-DOIT
* Date: 2020/11/5 0005
* Description:
* apply方法建议定义在object中
*/
class AppDemo {
// 定义两个成员属性
var x:Int = _
var y:Int = _
// 定义一个两个参数的构造器
def this(x:Int,y:Int){
this()
this.x=x
this.y=y
}
// 普通的方法
def show(): Unit ={
println("show....")
}
}
object AppDemo{
// 在伴生对象中实现apply方法
def apply(): AppDemo ={
new AppDemo
}
// 在伴生对象中实现apply方法 连个参数 调用两个参数的构造器
def apply(x:Int,y:Int): AppDemo ={
new AppDemo(x,y)
}
def main(args: Array[String]): Unit = {
val demo1 = new AppDemo
val demo2 =AppDemo() //-->apply new AppDemo -->
val demo3: AppDemo = AppDemo(22, 33)
println(demo3.x)
}
}
object TestApply {
def main(args: Array[String]): Unit = {
val demo: AppDemo = AppDemo(33, 44)
println(demo.x)
}
}5 classOf 、 isInstanceOf 、 comoInstanceOf
package com._51doit.day05.demo.oob
/**
* FileName: TestInstance
* Author: 多易教育-DOIT
* Date: 2020/11/5 0005
* Description:
*/
object TestInstance {
/**
*
* @param args
*
*/
def main(args: Array[String]): Unit = {
val a = new A
println(a.isInstanceOf[A])
val b = new B
// 强制类型转换 有继承关系的强转
b.asInstanceOf[A]
// 数值类型 toInt toDouble .....
// 集合类型 toArray toList toMap ....
println(classOf[A]) // 类似于全类名
println(Class.forName("com._51doit.day05.demo.oob.A"))
val clazz: Class[_] = Class.forName("com._51doit.day05.demo.oob.A")
clazz.getName
// 获取类的字节码
val c: Class[A] = classOf[A]
}
}
6 modificador de permiso
package com._51doit.day05.demo.xsf
/**
* FileName: Demo1
* Author: 多易教育-DOIT
* Date: 2020/11/5 0005
* Description:
* 1 成员变量 定义在类中 (或者主构造器中使用val|var)
* 2 private 修饰 private val gender:String = "M"
* 1) private修饰的变量可以在本类和伴生对象中直接访问 , 其他类无法访问
*/
class Demo1(private val name:String) {
val ID:Int=123456
//私有的属性
private val gender:String = "M"
def show(): Unit ={
// 在本类中可以访问
print(gender)
print(name)
}
}
object Demo1{
def main(args: Array[String]): Unit = {
val demo = new Demo1("zss")
}
}
7 rasgos y clases abstractas
package com._51doit.day05.demo.trait_dmeo
/**
* FileName: Animal
* Author: 多易教育-DOIT
* Date: 2020/11/5 0005
* Description:
* 特质 就是接口
*/
trait Animal {
def name:String
}
package com._51doit.day05.demo.trait_dmeo
/**
* FileName: T1
* Author: 多易教育-DOIT
* Date: 2020/11/5 0005
* Description:
*/
trait T1 {
def i:Int
}
package com._51doit.day05.demo.trait_dmeo
/**
* FileName: Dog
* Author: 多易教育-DOIT
* Date: 2020/11/5 0005
* Description:
*/
class Dog extends Animal with T1 {
// 方法的重写
override def name: String = {
"汪汪....."
}
override def i: Int = {
12
}
}
8 Clase de muestra
package com._51doit.day05.demo.case_class
/**
* FileName: People
* Author: 多易教育-DOIT
* Date: 2020/11/5 0005
* Description:
* 样例类 : 用来防止数据使用 就是javaBean
* 必须声明主构造器
* 1 样例类实现了序列化接口
* 2 toString
* 3 hashCode equals
* 4 属性() set属性()
* 5 可以指定排序规则
* 隐式转换 ????
*/
case class People(val id:Int , val name:String , val age:Int)
/* extends Ordered[People] {
override def compare(that: People): Int = {
-1
}
}*/
9 funciones de orden superior
El parámetro de método o valor de retorno es un método de función
Codificación flexible Especificar reglas de operación
Collecttions.sort (lista, reglas de clasificación): clasificación en java. El parámetro uno ordena el conjunto, el parámetro dos; la regla de clasificación especificada se pasa en una clase interna anónima [hinchada], lo cual es ineficiente
Función: puede realizar la función del método, existir solo, objeto especial, se puede utilizar como parámetro del método
Collecttions.sort (lista, 函数) // f: String => String = <función>
package com._51doit.day05.demo.hi_func
/**
* FileName: Demo1
* Author: 多易教育-DOIT
* Date: 2020/11/5 0005
* Description:
*/
object Demo1 {
val f = (x: Int) => x * 100
val f1 = (x: Int) => x * 10
val f2 = (x: Int) => x * x
def main(args: Array[String]): Unit = {
val ls = List(1, 2, 3, 4)
println(ls.map(f).map(f1).map(f2))
}
}
package com._51doit.day05.demo.hi_func
/**
* FileName: Demo2
* Author: 多易教育-DOIT
* Date: 2020/11/5 0005
* Description:
*/
class Demo2 {
/**
* 方法返回值是一个函数
* 参数Int 返回值是Int
* @param x
* @return
*/
def opt(x:Int) ={
(y:Int)=>y*x
}
}
object Demo2{
def main(args: Array[String]): Unit = {
val demo = new Demo2
val f: Int => Int = demo.opt(12)
val res: Int = f(22) // 高级
println(res)
println(demo.opt(10)(11))
}
}10 Función parcial
La función parcial es una característica, una función que se utiliza específicamente para procesar un determinado tipo de datos. Tenga en cuenta que map no admite funciones parciales. Collect admite funciones parciales.
package com._51doit.day05.demo.part
/**
* FileName: Demo1
* Author: 多易教育-DOIT
* Date: 2020/11/5 0005
* Description:
*/
object Demo1 {
def main(args: Array[String]): Unit = {
val ls: List[Any] = List[Any](1, 2, 3, 4, "java", "js", true, 12.34)
// 1 使用过滤器
/* val ls2: List[Any] = ls.filter(_.isInstanceOf[Int])
println(ls2.map(_.asInstanceOf[Int] * 10).toList)*/
// 2 可以使用偏函数处理
/**
* 偏函数 特质 new 特质() 重写抽象方法
* 泛型:
* 1参数一 集合存储的数据类型 Any
* 2参数二 需要处理的数据类型
*/
val f = new PartialFunction[Any, Int] {
// x:接收每个元素 每个元素都会调用一次这个方法 判断元素的数据类型是否是要处理的类型
override def isDefinedAt(x: Any): Boolean = {
// 如果是true 执行下一个方法进行处理数据
x.isInstanceOf[Int]
}
// v1 接收上个方法返回true数据
override def apply(v1: Any): Int = {
//将接收数据强制转换成 对应的类型
val i: Int = v1.asInstanceOf[Int]
i * 10
}
}
/**
* collect和map的执行一样的 但是接收的是偏函数
* map是不支持偏函数
*/
println(ls.collect(f))
val res = ls.collect({
// 遍历集合中的每个元素 判断每个元素是否是 Int 如果是 =>
case x: Int => x * 100
// case x:String=> (x+"sadsfds").toUpperCase
})
res.foreach(println)
}
}
11 modo de coincidencia
11.1 Tipo de datos
package com._51doit.day05.demo.cas
/**
* FileName: Demo1
* Author: 多易教育-DOIT
* Date: 2020/11/5 0005
* Description:
* 匹配模式 很灵活的匹配需要处理的数据 减少判断和循环次数 简洁 效率高
* 1 匹配数据类型
*/
object Demo1 {
def main(args: Array[String]): Unit = {
val arr = Array(1, 2, 3, "hello", "java", 12.12d)
/*val res1: Array[Int] = arr.filter(_.isInstanceOf[Int]).map(_.asInstanceOf[Int] * 10)
val res2: Array[String] = arr.filter(_.isInstanceOf[String]).map(_.asInstanceOf[String].toUpperCase)
val res3: Array[Double] = arr.filter(_.isInstanceOf[Double]).map(_.asInstanceOf[Double] * 100)
val res: Array[Any] = res1 ++ res2 ++ res3
val array: Array[Any] = res1.union(res2).union(res3)
res.foreach(println)*/
val res = arr.map(e=>e match {
case x:Int=>x*10
case x:String=>x.toUpperCase
case x:Double=>x*100
})
res.foreach(println)
}
}
package com._51doit.day05.demo.cas
/**
* FileName: Demo2
* Author: 多易教育-DOIT
* Date: 2020/11/5 0005
* Description:
*/
object Demo2 {
def main(args: Array[String]): Unit = {
val ls = List(
List[Int](1,2,3,4),
List[String]("a","b","c","d"),
"hello",
Array[Int](2,4,6,8) ,
Map[String ,Int]("a"->22,"b"->33) ,
Map[Int,Int]((11,11) ,(22,22))
)
val res = ls.map(e=>e match {
case x:List[Int]=> x // 无法匹配几集合的泛型
case x:Array[Int]=>x.map(_*100)
case x:Map[_,_]=>x.keys // 无法匹配map几集合的泛型
case _ => "a"
})
res.foreach(println)
}
}
package com._51doit.day05.demo.cas
/**
* FileName: Demo3
* Author: 多易教育-DOIT
* Date: 2020/11/5 0005
* Description:
*/
object Demo3 {
def main(args: Array[String]): Unit = {
val ls = List(new A, new B, new A)
val res = ls.map(e => e match {
case x: A => "aaaa"
case x: B => "bbbb"
})
res.foreach(println)
}
}
11.2 Animal original
package com._51doit.day05.demo.cas
/**
* FileName: Demo4
* Author: 多易教育-DOIT
* Date: 2020/11/5 0005
* Description:
* 元组匹配
* 1 (x,y,z) 匹配指定个数的元祖
* 2 (x:Int,y:Int,z:Int) 匹配指定个数指定类型的元祖
* 3 case 从上向下执行 , 上面匹配过的元素 下面不会再匹配
* 4 不仅可以指定元祖的个数 指定元祖对应位置的数据类型
*/
object Demo4 {
def main(args: Array[String]): Unit = {
val arr = Array(
(1, 5, 4),
(1, "a", 4),
("hello", "tom", "jim") ,
("hello", 23, "tom", 33)
)
val res = arr.map(tp=>tp match {
case (x,y:String,z)=>(x,y,z)
// case (x,y,z)=>(x,y,z)
case (x,y,z,a)=>(x,y,z,a)
case _ => // 一定有
})
res.foreach(println)
}
}