回顾：IDEA直接生成默认返回值是unit，导致没有返回值：
def main(args: Array[String]) :unit = {
}
val属性 = _ _表示占位符，占个坑
例如 var name = _ ，出现如下报错
未指定name的类型：unbound placeholder parameter
进行如下修改：var name：String = _
链式编程：
val conf = new SparkConf
conf.setAppName("").setMaster("")..........
原生代码使用Scala链接MySQL
1)MySQL的驱动
2)获取Connection 重量级的获取过程，借助于POOL连接池
3)Statement
4)ResultSet 结果集
5)Close 释放资源
POOL连接池先创建一批，初始化的时候初始化进去，用的时候直接在里面拿，比如有1000个请求，直接在池子里用，性能比1000个请求高
IO编程：打开资源、业务处理、释放资源
package com.ruozedata.bigdata
import java.sql.DriverManager
object ScalaJDBCApp {
def main(args: Array[String]): Unit = {
var url = "jdbc:mysql://hadoop004:3306/ruoze_g6"
var user = "root"
val password = "960210"
val sql = "select DB_LOCATION_URI,DB_ID,NAME from dbs;"
classOf[com.mysql.jdbc.Driver]
val connection = DriverManager.getConnection(url,user,password)
val stmt = connection.createStatement()
val rs = stmt.executeQuery(sql)
while (rs.next){
val location = rs.getLong(1)
val dbid = rs.getString(2)
val name = rs.getString(3)
}
}
}
主构造器和附属构造器都是在一个类里面的：
伪代码：
Class(xx:Int){
field
method/funcrion
def this(xx:Int,yy:String) //附属构造器
this(xx)
…
}
父类和子类：两个类之间
子类extends父类
如下是子类：
package com.ruozedata.bigdata
import com.ruozedata.bigdata.FunctionApp.People
object ExtendsApp {
def main(args: Array[String]): Unit = {
//new子类()会先触发new父类()
val bt1 = new BigTree("大树","北京",100000.0f)
println("bt1.money")
println("bt1.age")
}
}
class BigTree(name:String,city:String,Money:Float)
extends People(name,city){
println("john here")
def toString() = "bigtree to string" //method toString needs override modifier，override是在子类中重写父类的方法或者属性
money = 100
age = 30
println("john leave")
}
输出如下：
person laizi here
person here
john here
john leave
如下是父类：
package com.ruozedata.bigdata
object FunctionApp {
def main(args: Array[String]): Unit = {
// val people = new People("ruoze","北京")
// println(people.name + ":" + people.city )
val people = new People("黄帆","苏州",30)
println(people.name + ":" + people.city + ":" + people.age)
}
//主构造器、跟在class后面的
class People(val name:String, val city:String){
println("person laizi here")
var age:Int = _
var money = 100000
//附属构造器，第一行必须调用主构造器或者其他附属构造器
def this(name:String,city:String,age:Int){
this(name,city)
this.age = age
}
println("person here")
}
}
//override def toString() = “bigtree to string” 这段话注释掉后输出的是[email protected]
在object.java中去找：
public String toString() {
return getClass().getName() + “@” + Integer.toHexString(hashCode());
}
默认的toString方法返回的是：完整的报名@+此对象哈希码的无符号十六进制
println(bt1.toString) 默认走的是父类的方法，如果子类重写了，那么调用的就是子类的方法。
假设定义了一个父类Animal:定义了一个吃的方法
Dog eat
Cat eat
pig eat
.....
Dog类是从animal中继承过来的，对于猫狗来说他们的爱好是不同的，只需要用override把eat方法重写即可，override出来的走的是自己的方法。
在框架中定义一些接口或者抽象类，具体实现是由子类来实现的.
记住一句话:override可以重写父类的方法，属性指的是 class People(val name:String, val wife:String)
scala中有两种赋值：var 和val，var在生命周期中可以被多次赋值，val就不能再赋值了。
当一个类extends另外一个类的时候：override的基本规则如下：
1、子类中的方法要覆盖父类中的方法，必须写override
2、子类中的属性val要覆盖父类中的属性时，要override
3、父类中的变量不可以覆盖
MenoryManager.scala 父类
StaticMemoryManager.scala 子类
spark中的内存管理
抽象类
1、object AbstractApp{
def main(args: Array[String]): Unit = {
def speak() //函数的定义但没有实现，此时只能被修饰为一个抽象类
val name:String // 没有赋值的属性
val a = new B()
a.speak() // 调用B中的speak
}
}
2、abstract class A {
def speak() //函数的定义但没有具体的实现
val name:String //没有具体实现的方法，没有具体赋值的属性
}
3、class B extends A{
override def speak(): Unit = {
println("people here")
} //B继承A后需要重写这个方法
}
抽象类不能直接new，而是通过子类来new（且子类不能还是抽象类），一定是要通过底层的能具体实现的子类来new
上述代码的A和B也是一个父子关系。