Scala面向对象:

类:

声明类(一个源文件中可以包含很多public的类)

getter和setter

构造函数(主构造器和附属构造器)

继承(extends)

重写父类方法(override def)

重写字段(override val,override var)

1.声明类

/**
*
* 在scala 中,类默认是public,而且一个源文件可以包含多个public,源文件名可以和文件中定义的类名不一致
*/
class Person {
val name:String = "jack"
//普通类不允许声明一个变量不给任何值的指定
var age:Int = _ //var 可以不指定值,给个占位符
//定义一个私有成员
// private[this] val gender:String = "male" //private 在哪个包能访问,其他的包不能访问
private[this] var gender:String = "male"
//可以通过暴露一个getter来访问类中的私有成员
def getGender:String = {
this.gender
}
def setGender(gender:String){
this.gender = gender
}
//定义成员方法
def sayHello(msg:String){
println(msg)
}
}
object Person{
def main(args: Array[String]): Unit = {
//默认无参构造函数,可以不用带括号
val p = new Person
println(p.name)
p.age = 18
println(p.age)
//跟java中一样,不能对私有成员进行访问 p.gender
println(p.getGender)
p.setGender("nonFemale")
println("new Gender: "+p.getGender)
p.sayHello("today is very fine,i like it")
}
}

2.构造函数:

//class 有一个默认的无参构造器
//带参的主构造器,就是在类名后指定参数,主构造器的参数会被编译成类的成员变量(前提:参数必须有val或者var)
class Book(val name :String ,var price:Float) {
    //类定义中的语句其实就是在主构造器方法体中
    println("这是在Book类的主构造器")
    private[this] var author :String = _
  //附属构造器,名称一定是this,参数不能带var或者val
   def this (name:String,price:Float,author:String){
       //一定要在第一行调用主构造器
     this(name,price);
     this.author = author
     println("这是在Book类附属构造器中")
  }
    def  sayHello{
        println("hello world")
    }
   sayHello
}
object Book{
    def  main(args:Array[String]):Unit = {
     val b  = new Book("hadoop权威",100,"张三")
      println(b.name)
      println(b.price)
      b.price=80F;
      println("new price " + b.price);
    }
}

3.继承:

class TestExtends {
}
//先执行父类的构造函数,在执行子类的构造函数
//子类继承父类的成员变量,所以在主类构造器中的相应参数可以不带val或者var,子类特有的成会员变量应该带val或者var
class Teacher(val name:String,val  age :Int ){
    val major :String = "math";
    println("在Teacher的主构造器中......")
}
class CollegeTeacher(name:String,age:Int,school:String) extends  Teacher(name,age){
//重写父类中的成员变量, 必须加override修饰符
    override  val major:String = "HighLevelMath"
    println("在CollegeTeacher的主构造器中......")
//在父类中已经实现的方法,子类重写时一定要加override
  override def toString: String="override toString......"
}
object  Runner{
  def main(args: Array[String]): Unit = {
    val ct = new CollegeTeacher("tom",33,"TsingHua")
    println(ct.toString)
    println(ct.major)
  }
}

抽象类(abstract class):

类的一个或者多个方法没有完整的定义

声明抽象方法不需要加abstract关键字,只需要不写方法体

子类重写父类的抽象方法时不需要加override

父类可以声明抽象字段(没有初始值的字段)

子类重写父类的抽象字段时不需要加override,否则需要override

class TestAbstractClass {
}
//定义抽象类,要加abstract关键字
abstract class AbstractParent {
  //可以定义有初始化的成员
  val name: String = "jack"
  //也可以定义没有初始化的成员,即抽象成员
  val age: Int
  //可以定义有具体是实现的方法
  def add(x: Int, y: Int) = x + y
  //也可以定义抽象方法
  def concat(a: String, b: String): String
  println("in the abstract parent......")
}
class son extends AbstractParent {
  //抽象的成员或者方法 在子类中实现时,不需要加override
  //抽象父类中的抽象成员在子类中必须实现
  //给个占位符或者具体值
  val age:Int = 18
  //抽象父类中的抽象方法必须在子类中实现
  def concat(a:String,b:String):String = a+b
  //重写抽象父类中的成员或者方法 ,必须加override
  override  val name :String = "tom"
  override  def add(x:Int,y:Int)= x+ y + 10
  println("in the son")
}
object son{
  def main(args: Array[String]): Unit = {
    val s = new son
    println("add function " + s.add(4,5))
  }
}

特质(trait)—-对比java8中的接口

字段和方法的集合

混入类中

通过with关键字,一个类可以扩展多个特质

class TestTrait {
}
class AbstractParent01 {}
//定义一个trait特质
trait Logger {
//trait 中也可以定义抽象方法
  def append(msg: String): Unit
//trait 中可以定义具体实现的方法
  def log(info: String) {
    println("INFO: logging in traint Logger......" + info)
  }
}
trait ConsoleLogger extends Logger {
//子trait中可以实现父trait中的抽象方法,也可以不去实现,保持抽象
  def append(msg: String): Unit = {
    println("append in the ConsoleLogger......")
  }
//子trait可以重写父trait中有具体实现的方法,一定要加override关键字
  override def log(info: String) {
    println("INFO: logging in traint Logger......" + info)
  }
}
//通常用with来“继承”trait, 但是如果子类没有其他的父类,则用extends 关键字来“继承”trait
class ClassA extends AbstractParent01 with Logger {
//必须实现trait中的抽象方法
  def append(msg: String) {}
  val name: String = "jack"
}
class ClassB extends ConsoleLogger {
}
//定义一个普通类,在定义时没有指定继承任何trait,但是在创建时,可以临时混入trait
class ClassC{
}
object Runner01 {
  def main(args: Array[String]): Unit = {
    val ca = new ClassA
    println(ca.name)
    ca.log("Successfully with a trait")
    println("-------------------")
    val b = new ClassB
    b.log("User zhangsan loged in")
    println("------------------")
//可以在创建对象时混入trait,扩展类的功能
    val c = new ClassC with ConsoleLogger
    c.log("Successful with  a trait  when instaniating a class")
  }

apply方法

单例对象

class TestApply {
}
class AAA{
  def test(): Unit ={
    println("worked in class AAA")
  }
  def apply(): Unit ={
    println("apply in  class AAA")
  }
}
object  AAA{
//注意:此处的new AAA()是调用class AAA的构造器,返回的是AAA的是实例对象
//相当于一个创建类实例的普通工厂方法
//def apply()= new AAA()
//改造一下,就成了一个创建单例对象的工厂方法
  var aaa:AAA = _
  def apply() =  if(aaa == null ){aaa= new AAA();aaa}else aaa
}
object  AAA0{
  def apply(): Unit ={
    println("apply in object AAAo")
  }
}
object Runner{
  def main(args: Array[String]): Unit = {
//apply方法可以被显示调用
      AAA0.apply()
//更多地是通过对象名加圆括号来调用
      AAA0()
//对象是一样的道理
      val a  = new AAA
      a.apply()
      a()
//通过调用类AAA的伴随object AAA的apply方法来初始化一个AAA类的实例对象
//apply方法通常就是通过这样一种模式来为一些类进行实例对象的创建
      val aaa = AAA()
      aaa.test
      val aaa1 = AAA()
      println(aaa.toString)
      println(aaa1.toString)
  }
}

模式匹配

标准用法(match)

使用守卫

匹配类型

object TestMatchCaseDemo {
  def main(args: Array[String]): Unit = {
    val a = 1
    a  match {
      case 1 => println("it is 1")
      case 2 => println("it is 2")
      case _ => println("other thing ")
    }
    a match{
      case x if x==1 => println("it is 1 again")
      case x if x==2 => println("it is 2 again")
      case _  => println("other thing again ")
    }
    def test(a:Int) =a match{
      case 1 => println("it is 1 in  function ")
      case 2 => println("it is 2 in function")
      case _ => println("other thing in function")
    }
    test(3)
    def t(obj:Any) = obj match{
      case x:String => {println("it is a String ");x}
      case x:Int => println("it is a Int")
      case _ => println("it is some other ")
    }
    t(Array("tom"))
    println(t("jack"))
    }
}

case class(多用在模式匹配中)

构造器中的每一个类型默认都为val

不用new就可以直接产生对象(为什么?apply方法)

class TestCaseClass {
}
//case class 用关键字 case 来定义
//主构造器中的参数不应加val或者var,也会被自动地编辑成成员变量
//在case class中,主构造器中的参数默认是val ,且不建议用var
case class User(name:String,psw:String){
}
object TestCaseClass {
  def main(args: Array[String]): Unit = {
    //获得一个case class 的实例对象,不用显示new,而是直接"类名(参数)"就可以(为什么?apply()方法)
       val u = User("tom","a good boy")
        u  match {
          //匹配类型的标准写法
          //case  i:User  => println("it is a User......")
          //匹配类型的另一种写法,可以根据传入构造函数的具体字段进行精确匹配
          case User("tom","a good boy") => println("it is a User of tom  and 123")
          case User("jack","a good boy") => println("it is a User of jack and 123")
          case  x:TestCaseClass => println("it is a TestCaseClass......")
          case _ => println("it is some other thing......")
        }
       //在scala中很多场景下可能会看到两个case class:Some(代表有值) 和 None(代表无值),它们都是option的子类
       val m = Map(1->2,3->4);
       var x :Int = 0
       m.get(x) match {
         case Some(_) => println("key exists......")
         case None =>println("key not exists.....")
         case _  => println("other......")
       }
  }
}

文件访问

按行读取

按字符读取

从网络读取

import scala.io.{Codec, Source}
class TestFileRead {
}
object  TestFileRead{
  def main(args: Array[String]): Unit = {
    //读取本地文件
    val file = Source.fromFile("F:\\上网账号.txt")(Codec("GBK"))
    //按字符访问
//    for(c <- file){
//        println(c)
//    }
    //按行访问
//    for( file <- file.getLines()){
//      println(file)
//    }
    //读取网页
    val   webHtml = Source.fromURL("http://www.www.163.com/","GBK");
    for (line <- webHtml.getLines()){
        println(line)
    }
  }
}

Scala学习笔记(二)的更多相关文章

  1. scala 学习笔记二 方法与函数

    1.介绍 Scala 有方法与函数,二者在语义上的区别很小.Scala 方法是类的一部分,而函数是一个对象可以赋值给一个变量.换句话来说在类中定义的函数即是方法. Scala 中的方法跟 Java 的 ...

  2. [Scala]Scala学习笔记二 数组

    1. 定长数组 如果你需要一个长度不变的数组,可以使用Scala中的Array. val nums = new Array[Int](10) // 10个整数的数组 所有元素初始化为0 val str ...

  3. 基于.net的分布式系统限流组件 C# DataGridView绑定List对象时,利用BindingList来实现增删查改 .net中ThreadPool与Task的认识总结 C# 排序技术研究与对比 基于.net的通用内存缓存模型组件 Scala学习笔记:重要语法特性

    基于.net的分布式系统限流组件   在互联网应用中,流量洪峰是常有的事情.在应对流量洪峰时,通用的处理模式一般有排队.限流,这样可以非常直接有效的保护系统,防止系统被打爆.另外,通过限流技术手段,可 ...

  4. WPF的Binding学习笔记(二)

    原文: http://www.cnblogs.com/pasoraku/archive/2012/10/25/2738428.htmlWPF的Binding学习笔记(二) 上次学了点点Binding的 ...

  5. AJax 学习笔记二(onreadystatechange的作用)

    AJax 学习笔记二(onreadystatechange的作用) 当发送一个请求后,客户端无法确定什么时候会完成这个请求,所以需要用事件机制来捕获请求的状态XMLHttpRequest对象提供了on ...

  6. [Firefly引擎][学习笔记二][已完结]卡牌游戏开发模型的设计

    源地址:http://bbs.9miao.com/thread-44603-1-1.html 在此补充一下Socket的验证机制:socket登陆验证.会采用session会话超时的机制做心跳接口验证 ...

  7. JMX学习笔记(二)-Notification

    Notification通知,也可理解为消息,有通知,必然有发送通知的广播,JMX这里采用了一种订阅的方式,类似于观察者模式,注册一个观察者到广播里,当有通知时,广播通过调用观察者,逐一通知. 这里写 ...

  8. java之jvm学习笔记二(类装载器的体系结构)

    java的class只在需要的时候才内转载入内存,并由java虚拟机的执行引擎来执行,而执行引擎从总的来说主要的执行方式分为四种, 第一种,一次性解释代码,也就是当字节码转载到内存后,每次需要都会重新 ...

  9. Java IO学习笔记二

    Java IO学习笔记二 流的概念 在程序中所有的数据都是以流的方式进行传输或保存的,程序需要数据的时候要使用输入流读取数据,而当程序需要将一些数据保存起来的时候,就要使用输出流完成. 程序中的输入输 ...

  10. 《SQL必知必会》学习笔记二)

    <SQL必知必会>学习笔记(二) 咱们接着上一篇的内容继续.这一篇主要回顾子查询,联合查询,复制表这三类内容. 上一部分基本上都是简单的Select查询,即从单个数据库表中检索数据的单条语 ...

随机推荐

  1. maven指定部署的服务器类型

    <!-- 指定部署的服务器类型 --> <plugins> <!-- <plugin> <groupId>org.apache.tomcat.ma ...

  2. 用batch调用DB2 CLPPlus执行多个SQL文

    不啰嗦直接上技能. 大概三部分组成: 1.bat文件.(run.bat) 2.辅助SQL文.(AllRun.sql) 3.要执行的SQL文.(S1.sql,S2.sql,S3.sql) +++++++ ...

  3. ErrorKiller:Failed to decode response: zlib_decode(): data error

    先更新composer自己,composer self-update 然后再更新依赖关系 composer update

  4. Nginx和php是怎么通信的?

    先来看一下搭建好PHP运行环境的Nginx配置文件. 非常重要的就是 fastcgi_pass 指令了,这个指令用于指定 fpm 进程监听的地址,Nginx 会把所有的 php 请求翻译成 fastc ...

  5. 4.3 lambda表达式

    函数,封装的代码块可以很复杂,也可以很简单.当函数的代码块简单到只有一个表达式,就可以考虑用lambda表达式,也称匿名函数. 1 lambda表达式基础 #首先需要声明一点:lambda是表达式而非 ...

  6. SIFT解析(三)生成特征描述子

    以上两篇文章中检测在DOG空间中稳定的特征点,lowe已经提到这些特征点是比Harris角点等特征还要稳定的特征.下一步骤我们要考虑的就是如何去很好地描述这些DOG特征点. 下面好好说说如何来描述这些 ...

  7. 我的Java设计模式-单例模式

    就算不懂设计模式的兄弟姐妹们,想必也听说过单例模式,并且在项目中也会用上.但是,真正理解和熟悉单例模式的人有几个呢?接下来我们一起来学习设计模式中最简单的模式之一--单例模式 一.为什么叫单例模式? ...

  8. Linux基础三

    cat:查看全部(缺点:内容较多时不方便查看) 格式:cat [选项] 文件名 常用命令选项 -n:在每一行前加上行号 [root@localhost 桌面]# cat -n /etc/passwd ...

  9. Mycat 分布式事务的实现

    引言:Mycat已经成为了一个强大的开源分布式数据库中间件产品.面对企业应用的海量数据事务处理,是目前最好的开源解决方案.但是如果想让多台机器中的数据保存一致,比较常规的解决方法是引入"协调 ...

  10. 让UltraEdit成为java编译器

      1. ?        配置命令: 选择[高级]->[工具栏配置] ?        选择插入按钮进行命令添加: ?        依次填写命令内容: 解释:菜单项目名称:命令的名字,建议使 ...