Scala 的学习
Scala
只是学习无基本理论
安装Scala
装前必须有jdk
windows安装
解压缩 D:dev/scala
配置环境变量
SCALA_HONE
path
cmd检查
Scala -version
直接输入Scala 控制台运行
idea安装与运行Scala
idea-->插件-->scala-->安装-->重启
新建maven项目
catalog-->maven
archetype-->
项目结构-->全局库-->添加Scala
添加应用支持-->scala
add开头
新建Scala类 选择 object
scala 完全面向对象
scala风格与java风格
public class JavaDemo01 {
public static void main(String[] args) {
System.out.println("我爱你中国");
}
}
javac JavaDemo01
object ScalaDemo01{
def main(args: Array[String]): Unit = {
print("我爱你中国")
}
}
scalac ScalaDemo01
终端运行Scala
编码 utf-8
scalac 文件名字--> 生成 文件名字$.class 与 文件名字.class-->调用 文件名字.class
Scala项目启动方式
main函数与extends app特质的区别：
App是scala语言内置的一个特质，使用它，则把对应object内部的整体作为scala main的一部分，有延迟启动的特性。
同时，命令行参数args也作为App特质的一部分，可以被开发者直接使用。而main函数则是scala的默认启动方式。
使用main函数
object ScalaDemo02{
def main(args: Array[String]): Unit = {
print("我爱你中国")
}
}
使用App特质
object ScalaDemo03 extends App{
print("我爱你中国")
}
object ScalaDemo04 extends App{
print(args(0))
}
终端运行：
scalac ScalaDemo04.scala
scala ScalaDemo04 lhz
Scala代码与Java代码混用
object ScalaDemo05{
def main(args: Array[String]): Unit = {
System.out.println("我爱你中国")
}
}
在 Scala 代码中 可以直接使用 Java 代码
注意：main 方法使用Scala 风格
变量与常量
object ScalaDemo06{
def main(args: Array[String]): Unit = {
// var 变量 修饰符
var a:Int = 10
// val 常量 修饰符
val b:Int = 10
a = 20
println(a)
/**
*报错
*reassignment to val
*/
// b = 20
}
}
字符串基本使用
object ScalaDemo07{
def main(args: Array[String]): Unit = {
var str01:String = "我爱你"
var str02:String = "中国"
// java 风格
println (str01 + str02)
// 插值方式 与 python 风格比较相像
var slogan:String = "桃李不言下自成蹊"
println(s"slogan >>> $slogan")
println("""
|我爱你中国
|亲爱的母亲
""".strpMargin)
}
}
选择结构
object ScalaDemo08{
def main(args: Array[String]): Unit = {
var weekDay:Int = 1
if (weekDay == 1){
println("周一")
}else if (weekDay == 2){
println("周二")
}else if (weekDay == 3){
println("周三")
}else if (weekDay == 4){
println("周四")
}else if (weekDay == 5){
println("周五")
}else if (weekDay == 6){
println("周六")
}else{
println("周日")
}
}
}
循环结构
object ScalaDemo09{
def main(args: Array[String]): Unit = {
var count:Int = 0
while(count<5){
println(count)
count += 1
}
}
}
object ScalaDemo10{
def main(args: Array[String]): Unit = {
//Range 1 to 5
println(1 to 5)
println(1.to(5))
println(1 until 5)
println(1.until(5))
// <- 赋值
for (i <- 0 until 5){
println(i)
}
println("--------------------^_ ~ _^----------------------")
// 求偶数值
for (i <- 0 until 10){
if (i % 2 == 0){
println(i)
}
}
println("--------------^_ ~ _^----------------")
for (i <- 0 until 10 if i % 2 == 0){
println(i)
}
println("--------------^_ ~ _^----------------")
for (i <- 0 until 10 by(2)){
println(i)
}
println("--------------------^_ ~ _^----------------------")
// 增强for循环
var courses = Array("Hadoop","Hive","Sqoop","Flume","Hbase","Phoenix","Presto")
for (course <- courses){
println(course)
}
}
}
函数
无参数 无返回值
object ScalaDemo01{
def main(args: Array[String]): Unit = {
sayHi()
}
// def 函数定义关键字
// sayHI 函数名称
// () 函数参数
// ：后面的数据类型为返回值数据类型
// : Unit 无返回值的数据类型占位符
// {} 方法体
private def sayHi(): Unit = {
println("无参数 无返回值 函数 sayHi")
}
}
有参数 无返回值
object ScalaDemo02{
def main(args: Array[String]): Unit = {
sayHi(msg = "hello word")
}
private def sayHi(msg:String): Unit = {
println("有参数 无返回值 函数 sayHi")
println(s"参数是 >>> ${msg}")
}
}
默认参数 无返回值
object ScalaDemo03{
def main(args: Array[String]): Unit = {
sayHi()
sayHi(msg = "hello")
}
private def sayHi(msg:String = "hi"): Unit = {
println("默认参数 无返回值 函数 sayHi")
println(s"参数是 >>> ${msg}")
}
}
# 输出结果：
默认参数 无返回值 函数 sayHi
参数是 >>> hi
默认参数 无返回值 函数 sayHi
参数是 >>> hello
有参数 有返回值
object ScalaDemo04{
def main(args: Array[String]): Unit = {
println(sum(10,20))
}
def sum(a:Int , b:Int): Int ={
// 函数的最后一行为返回值
a+b
}
}
可变参数 无返回值
public class JavaDemo04{
public static void main(String[] args) {
}
private static String
}
object ScalaDemo05{
def main(args: Array[String]): Unit = {
println(format())
println(format(numbers = 1))
println(format(numbers = 1,2))
}
def format(numbers: Int*): String = {
// var result:String = null
var result:Int = 0
if(numbers.size > 0){
for(number <- numbers){
result += number
}
}
result
}
}
面向对象
类与对象
object ScalaDemo01{
def main(args: Array[String]): Unit = {
val person = new Person01
person.name = "lhz"
println(person.name)
}
class Person01{
// _ 代表着 占位符 占位
var name:String = _
}
}
封装
scala中属性、方法默认为public
private只在类的内部和伴生对象中可用
protected，同类、子类可以访问，同包无法访问
private[包名]，增加包访问权限，包名下的其他类也可以使用
Scala提供进一步的封装，“public”属性底层实际上都是private，访问时本质上是调用了xxx(get) 和 xxx_eq$(set) 方法，
但这里的方法名并不是getXXX和setXXX，由于一些Java框架会利用反射调用getXXX和setXXX，
因此Scala也提供了上面提到过的@BeanProperty注解去生成某属性的这两个方法，
但注意@BeanProperty不能加在private修饰的属性上，
可以理解为由于“public”本身就是private，将变量修饰为private然后再提供getter、setter方法比较冗余，Scala不推荐这样做。
// 假 封装
object ScalaDemo02{
def main(args: Array[String]): Unit = {
val person = new Person02
person.setName("lhz")
println(person.getName)
person.name = "lz"
println(person.name)
}
class Person02{
// _ 代表着 占位符 占位
@BeanProperty
var name:String = _
}
}
// private 不推荐
// 手写 set get 方法
object ScalaDemo03 {
def main(args: Array[String]): Unit = {
val person = new Person03
person.setName("lhz")
println(person.getName)
}
class Person03{
private var name: String = _
def getName: String = {
this.name
}
def setName(name: String): Unit ={
this.name = name
}
}
}
java代码混用
public class Person04 {
private String realName;
public String getRealName() {
return realName;
}
public void setRealName(String realName) {
this.realName = realName;
}
}
object ScalaDemo04 {
def main(args: Array[String]): Unit = {
val person = new Person04
person.setRealName("李昊哲")
println(person.getRealName)
}
}
构造函数
object ScalaDemo05{
def main(args: Array[String]): Unit = {
val person01 = new Person05("person01","220422198311222011")
val person02 = new Person05("person02","220422198311222011",15311484567L)
val person03 = new Person05("person02","220422198311222011","我爱你中国")
val person04 = new Person05("person02","220422198311222011",15311484568L,"我爱你中国")
println(person01)
println(person02)
println(person03)
println(person04)
}
}
//主构造函数
class Person05(val realName:String, val idCard:String){
println("Person05 主构造器 执行了")
var mobile: Long= _
var slogan: String= _
// 辅助构函数 辅助构函数不能有类型注解
def this(realName: String , idCard: String, mobile: Long)={
// 辅助构函数 的 第一行代码必须调用 主构造函数 或者其他 辅助构函数
this(realName,idCard)
this.mobile = mobile
}
def this(realName: String , idCard: String, Slogan: String)={
// 辅助构函数 的 第一行代码必须调用 主构造函数 或者其他 辅助构函数
this(realName,idCard)
this.slogan = slogan
}
def this(realName: String , idCard: String, mobile: Long, slogan: String)={
// 辅助构函数 的 第一行代码必须调用 主构造函数 或者其他 辅助构函数
this(realName,idCard,mobile)
this.slogan = slogan
}
override def toString: String =
this.getClass.getSimpleName +
", realName:" + realName +
", idCard:"+ idCard +
", mobile:" + mobile +
", slogan:" + slogan
}
运行结果
Person05 主构造器 执行了
Person05 主构造器 执行了
Person05 主构造器 执行了
Person05 主构造器 执行了
Person05, realName:person01, idCard:220422198311222011, mobile:0, slogan:null
Person05, realName:person02, idCard:220422198311222011, mobile:15311484567, slogan:null
Person05, realName:person02, idCard:220422198311222011, mobile:0, slogan:我爱你中国
Person05, realName:person02, idCard:220422198311222011, mobile:15311484568, slogan:我爱你中国
继承
object ScalaDemo06 {
def main(args: Array[String]): Unit = {
val worker = new Worker("李昊哲", "15311484568", "架构师")
println(worker)
}
}
// 主构造函数
class Person06(val realName: String, val mobile: String) {
println("Person06 主构造器 执行了")
override def toString: String =
this.getClass.getSimpleName +
", realName:" + realName +
", mobile:" + mobile
}
class Worker(realName: String, mobile: String, job: String) extends Person06(realName, mobile) {
println("Worker 主构造器 执行了")
override def toString: String =
this.getClass.getSimpleName +
", realName:" + realName +
", mobile:" + mobile +
", job:" + job
}
抽象类
object ScalaDemo07 {
def main(args: Array[String]): Unit = {
val teacher = new Teacher
teacher.realName = "李昊哲"
teacher.mobile = "15311484568"
println(teacher)
teacher.hi()
}
}
abstract class Person07() {
println("Person07 主构造器 执行了")
var realName: String
var mobile: String
def hi(): Unit
override def toString: String =
this.getClass.getSimpleName +
", realName:" + realName +
", mobile:" + mobile
}
class Teacher extends Person07 {
println("Teacher 主构造器 执行了")
override def toString: String =
this.getClass.getSimpleName +
", realName:" + realName +
", mobile:" + mobile
override var realName: String = _
override var mobile: String = _
override def hi(): Unit = {
println("接着奏乐 接着舞")
}
}
伴生类与伴生对象
scala中的类不能定义静态成员，而代之以定义单例对象来替代
单例对象通过object关键字来声明
单例对象中的所有方法，可以直接通过object单例对象的名字直接来调用。
一个单例对象可以绑定在一个类，当单例对象和某个类写在同一个源文件且共享一个名字，它们就产生了绑定关系。
此时单例对象称之为该类的伴生对象，类称之为该对象的伴生类。
类和它的伴生对象可以互相访问其私有成员
单例对象不能new，所以也没有构造参数
可以把单例对象当做java中可能会用到的静态方法工具类。
作为程序入口的方法必须是静态的，所以main方法必须处在一个单例对象中，而不能写在一个类中。
object ScalaDemo08 {
def main(args: Array[String]): Unit = {
Food.printMsg()
new Food().printSlogan()
}
}
class Food {
private val msg: String = "hello"
def printSlogan(): Unit = {
println(Food.slogan)
}
}
object Food {
private val slogan: String = "桃李不言下自成蹊"
def printMsg(): Unit = {
println(new Food().msg)
}
}
apply
object ScalaDemo09 {
def main(args: Array[String]): Unit = {
// Drink() 相当于 Drink.apply
Drink()
new Drink().apply()
}
}
class Drink{
def apply(): Unit = {
println("class Food 执行...")
}
}
object Drink {
def apply(): Unit = {
println("object Food 执行...")
}
}
本文来自博客园，作者：JD_L，转载请注明原文链接：https://www.cnblogs.com/dream-come-true/p/17389339.html
热门相关：骑士归来 夫人你马甲又掉了 名门天后：重生国民千金 惊世毒妃：轻狂大小姐 战神