2. 程式人生 > >Cris 的 Scala 筆記整理（七）：面向物件

Cris 的 Scala 筆記整理（七）：面向物件

阿新 • • 發佈：2018-12-19

7. 面向物件（重點）

7.1 Scala 面向物件基礎

類

[修飾符] class 類名 {

類體

}

  1. scala語法中，類並不宣告為public，所有這些類都具有公有可見性(即預設就是public)

  2. 一個Scala原始檔可以包含多個類

定義一個最簡單的類

object Demo {
  def main(args: Array[String]): Unit = {
    var man = new Man
    man.name = "cris"
    man.age = 12
    println(man.name + "----" + man.age) // cris----12
 

  }

}

class Man {
  var name = ""
  var age = 0
}
複製程式碼

反編譯對應的 class 檔案

屬性

屬性是類的一個組成部分，一般是值資料型別,也可是引用型別

  def main(args: Array[String]): Unit = {
    val man = new Man()
    val pc = new PC
    man.pc = pc
    man.pc.brand = "惠普"
    // man.pc().brand()
    println(man.pc.brand) // 惠普
 

  }

class Man {
  var name = "" // 手動設定初始值，此時可以省略成員屬性的資料型別宣告
  var age = 0
  var pc: PC = _ // _ 表示讓 Scala 自動賦預設值，此時宣告帶上成員屬性的資料型別，否則編譯器無法確定預設值
}

class PC {
  var brand: String = _
}
複製程式碼

練習

  1. 針對 for（int i = 10；i>0；i--）{System.out.println(i)} 翻譯成 Scala 程式碼

    object Practice {
  def main(args: Array
     
    [String]): Unit = {
    for (i <- 0.to(10).reverse) {
      print(i + "\t") // 10  9  8  7  6  5  4  3  2  1  0  
    }
  }
}
複製程式碼

  2. 使用過程重寫上面的 Scala 程式碼

    def func(x: Int) {
  for (i <- 0 to x reverse) {
    print(i + "\t")
  }
}
複製程式碼

  3. 編寫一個for迴圈,計算字串中所有字母的Unicode程式碼（toLong方法）的乘積。舉例來說，"Hello"中所有字串的乘積為9415087488L

    def cal(str:String): Unit ={
  var result = 1L
  for(x <- str){
    result*=x.toLong
  }
  print(result)
}
複製程式碼

  4. 使用 StringOps 的 foreach 方法重寫上面的程式碼

    var r2 = 1L
// _ 可以理解為字串的每一個字元
"Hello".foreach(r2 *= _.toLong)
print(r2)
複製程式碼

  5. 使用遞迴解決上面求字串每個字元 Unicode 編碼乘積的問題

    def recursive(str: String): Long = {
  if (str.length == 1) str.charAt(0).toLong
  /*drop(n)從索引為 1 開始切片到結尾*/
  else str.take(1).charAt(0).toLong * recursive(str.drop(1))
}
複製程式碼

  6. 編寫函式計算 x^n，其中 n 是整數(負數，0，正數)，請使用遞迴解決

    def pow(x: Int, n: Int): Double = {
  if (n == 0) 1
  else if (n < 0) {
    1.0 / x * pow(x, n + 1)
  } else {
    x * pow(x, n - 1)
  }
}
複製程式碼

物件

val | var 物件名 [：型別] = new 型別()

  1. 如果我們不希望改變物件的引用(即：記憶體地址), 應該宣告為val 性質的，否則宣告為var, scala設計者推薦使用val ,因為一般來說，在程式中，我們只是改變物件屬性的值，而不是改變物件的引用

  2. scala在宣告物件變數時，可以根據建立物件的型別自動推斷，所以型別宣告可以省略，但當型別和後面new 物件型別有繼承關係即多型時，就必須寫了

方法

Scala中的方法其實就是函式，只不過一般將物件中的函式稱之為方法

def 方法名(引數列表) [：返回值型別] = {

​ 方法體

}

練習

  1. 巢狀迴圈列印圖形

    def func1(): Unit ={
    for (i <- 1 to 4; j <- 1 to 3) {
        if (j == 3) println("*")
        else print("*\t")
    }
}
複製程式碼

  2. 計算矩形的面積

    class Test {
  def area(): Double = {
    (this.width * this.length).formatted("%.2f").toDouble
  }


  var width: Double = _
  var length: Double = _
複製程式碼

構造器

java 的構造器回顧

[修飾符] 方法名(引數列表){

​ 構造方法體

}

  1. 在Java中一個類可以定義多個不同的構造方法，構造方法過載

  2. 如果程式設計師沒有定義構造方法，系統會自動給類生成一個預設無參構造方法(也叫預設構造器)

3）一旦定義了自己的構造方法,預設的構造方法就覆蓋了，就不能再使用預設的無參構造方法，除非顯示的定義一下,即: Person(){}

Scala 構造器

和Java一樣，Scala構造物件也需要呼叫構造方法，並且可以有任意多個構造方法。

Scala類的構造器包括： 主構造器 和 輔助構造器

基礎語法

class 類名(形參列表) { // 主構造器

// 類體

def this(形參列表) { // 輔助構造器

}

def this(形參列表) { //輔助構造器可以有多個...

}

}

簡單示例

abstract class Dog {
  var name = ""
  var age = 0
  val color: String

  def this(name: String, age: Int) {
    this()
    this.name = name
    this.age = age
  }

  def eat(): Unit = {
    println("吃狗糧")
  }

  def run()
}
複製程式碼
class Cat(var name: String, val color: String) {
  println("constructor is processing")

  def describe: String = name + "--" + color
}
  def main(args: Array[String]): Unit = {
	var cat = new Cat("tom", "gray")
    println(cat.describe)
    var cat2 = new Cat("jack", "red")
    println(cat2.describe)
  }
複製程式碼

細節

  1. Scala構造器作用是完成對新物件的初始化，構造器沒有返回值。

  2. 主構造器的宣告直接放置於類名之後 [反編譯]

  3. 主構造器會執行類定義中的所有語句，這裡可以體會到Scala的函數語言程式設計和麵向物件程式設計融合在一起，即：構造器也是方法（函式），傳遞引數和使用方法和前面的函式部分內容沒有區別

  4. 如果主構造器無引數，小括號可省略，構建物件時呼叫的構造方法的小括號也可以省略

  5. 輔助構造器名稱為this（這個和Java是不一樣的），多個輔助構造器通過不同引數列表進行區分， 在底層就是java的構造器過載，輔助構造器第一行函式體必須為 this.主構造器

abstract class Dog {
    var name = ""
    var age = 0
    val color: String

    def this(name: String, age: Int) {
        this()
        this.name = name
        this.age = age
    }

    def eat(): Unit = {
        println("吃狗糧")
    }

    def run()
}
複製程式碼

6)) 如果想讓主構造器變成私有的，可以在()之前加上private，這樣使用者只能通過輔助構造器來構造物件了,說明：因為Person3的主構造器是私有，因此就需要使用輔助構造器來建立物件

class Car private(){}
複製程式碼
  1. 輔助構造器的宣告不能和主構造器的宣告一致,會發生錯誤

屬性高階

  1. Scala類的主構造器函式的形參未用任何修飾符修飾，那麼這個引數是區域性變數

  2. 如果引數使用val關鍵字宣告，那麼Scala會將引數作為類的私有的只讀屬性使用

  3. 如果引數使用var關鍵字宣告，那麼那麼Scala會將引數作為類的成員屬性使用,並會提供屬性對應的xxx()[類似getter]/xxx_$eq()[類似setter]方法，即這時的成員屬性是私有的，但是可讀寫

class Counter {

  /*1. 有公開的 getter 和 setter 方法*/
  var count = 0
  /*2. 私有化 getter 和 setter，可以手動提供 setter 和 getter*/
  private var number = 1
  /*3. 只能被訪問getter，無法修改setter,final 修飾的 age 屬性*/
  val age = 12
  /*4. 物件級別的私有*/
  private[this] var length = 12

  def compare(other: Counter): Boolean = other.number > number

  //  def compareLength(other: Counter): Boolean = length > other.length

  def increase(): Unit = {
    number += 1
  }

  /*無參方法可以省略()，{}也可以省略*/
  def current: Int = number
}

def main(args: Array[String]): Unit = {
    var c = new Counter()
    c.count = 3
    println(c.count) // 3

    c.increase()
    println(c.current) // 2

    println(c.age) // 12
}
複製程式碼

如果在主構造器中為屬性設定了預設值，那麼就不必在函式體內再去宣告屬性以及賦值了，大大簡化程式碼的書寫

def main(args: Array[String]): Unit = {
	val dog = new Dog()
    println(dog.name) // cris
    println(dog.age)  // 10
  }
}

class Dog(var name :String= "cris",var age:Int = 10){
    
}
複製程式碼

JavaBean 註解

JavaBeans規範定義了Java的屬性是像getXxx（）和setXxx（）的方法。許多Java工具（框架）都依賴這個命名習慣。為了Java的互操作性。將Scala欄位加@BeanProperty時，這樣會自動生成規範的 setXxx/getXxx 方法。這時可以使用 物件.setXxx() 和 物件.getXxx() 來呼叫屬性

給某個屬性加入@BeanPropetry註解後，會生成getXXX和setXXX的方法

並且對原來底層自動生成類似xxx(),xxx_$eq()方法，沒有衝突，二者可以共存

物件建立流程分析

請針對以下程式碼簡述物件建立流程

class Bike {
  var brand = ""
  var color = ""

  def this(brand: String, color: String) {
    this
    this.brand = brand
    this.color = color
  }
}

def main(args: Array[String]): Unit = {
   var bike = new Bike("ofo", "黃色")   
}
複製程式碼

  1. 載入類資訊(屬性資訊，方法資訊)

  2. 在堆中，給物件開闢空間

  3. 呼叫主構造器對屬性進行初始化

  4. 使用輔助構造器對屬性進行初始化

  5. 把物件空間的地址，返回給 bike 引用

7.2 面向物件進階

包（難點）

回顧 Java 的包知識

  1. 作用

    1. 區分相同名字的類

    2. 當類很多時,可以很好的管理類

    3. 控制訪問範圍

  2. 打包基本語法

    package com.cris;

  3. 打包的本質分析

    實際上就是建立不同的資料夾來儲存類檔案

  4. 示例程式碼

    先在不同的包下建立同名的類

    如果想要在一個類中同時使用上面的兩個 Pig，Java 的解決方式如下：

        public static void main(String[] args) {
        Pig pig1 = new Pig();
        cris.package2.Pig pig2 = new cris.package2.Pig();
//        pig1.getClass() = class cris.package1.Pig
        System.out.println("pig1.getClass() = " + pig1.getClass());
//        pig2.getClass() = class cris.package2.Pig
        System.out.println("pig2.getClass() = " + pig2.getClass());
    }
複製程式碼

    再來看看我們的原始碼所在路徑和位元組碼檔案所在路徑，都是一一對應的

    Java 要求原始碼所在路徑和位元組碼檔案所在路徑必須保持一致，如果我們此時去修改原始碼的打包路徑

  5. 基本語法

    import java.awt.* or import java.util.List

  6. 注意事項：java中包名和原始碼所在的系統檔案目錄結構要一致，並且編譯後的位元組碼檔案路徑也和包名保持一致

接著看看 Scala 是如何處理的

我們使用 Scala 重寫上面的 Java 包案例

def main(args: Array[String]): Unit = {
  var b1 = new cris.package1.Bird1
  var b2 = new cris.package2.Bird2
  //    class cris.package1.Bird1
  println(b1.getClass)
  //    class cris.package2.Bird2
  println(b2.getClass)
}
複製程式碼

此時我們如果修改了 Bird1 的打包路徑

再看看原始碼和位元組碼檔案所在的路徑

Scala 的包

和Java一樣，Scala中管理專案可以使用包，但Scala中的包的功能更加強大，使用也相對複雜些

  1. 基本語法 package 包名

  2. Scala包的三大作用(和Java一樣)

    1. 區分相同名字的類
    2. 當類很多時,可以很好的管理類
    3. 控制訪問範圍

  3. Scala中包名和原始碼所在的系統檔案目錄結構要可以不一致，但是編譯後的位元組碼檔案路徑和包名會保持一致(這個工作由編譯器完成)

  4. 圖示

  5. 命名規範

    只能包含數字、字母、下劃線、小圓點.,但不能用數字開頭, 也不要使用關鍵字

    一般是小寫字母+小圓點一般是 com.公司名.專案名.業務模組名

  6. Scala 自動 import 的包有：java.lang.*，scala，Predef 包

Scala 打包細節（難點）

  • 常用的兩種打包形式

    • 原始碼的路徑和位元組碼檔案路徑保持一致

    • 原始碼的路徑和位元組碼檔案路徑不一致

    • 上面的演示中已經很清楚的展示了 Scala 包的這一特點，我們繼續用下面程式碼演示 Scala 包的巢狀

      我們在 Detail 類檔案中寫入以上非常奇怪的程式碼，編譯執行後再檢視原始碼和位元組碼檔案的位置

      進一步印證了 Scala 中原始檔和位元組碼檔案路徑可以不一致

  • 包也可以像巢狀類那樣巢狀使用（包中有包）, 見上面圖示。好處是：程式設計師可以在同一個檔案中，將類(class / object)、trait 建立在不同的包中，非常靈活

  • 作用域原則：可以直接向上訪問。即: Scala中子包中直接訪問父包中的內容, 大括號體現作用域。(提示：Java中子包使用父包的類，需要import)。在子包和父包 類重名時，預設採用就近原則，如果希望指定使用某個類，則帶上包名即可

    示例程式碼

    package com.cris {

  class Apple {

  }
  package scala {
    
    class Apple {

    }

    object Boy {
      def main(args: Array[String]): Unit = {
        /*1. Scala 中子包可以直接訪問父包的內容；2. 子包和父包的類重名，預設採取就近原則；3. 可以帶上類的路徑名指定使用該類*/
        val apple = new Apple
        val apple2 = new com.cris.Apple
        //        class com.cris.scala.Apple
        println(apple.getClass)
        //        class com.cris.Apple
        println(apple2.getClass)
      }
    }
  }
}
複製程式碼

  • 父包要訪問子包的內容時，需要import對應的類

    package com.cris {
	
  import com.cris.scala.Apple

  object Apple{
    def main(args: Array[String]): Unit = {
        // 推薦只在使用的時候再引用，控制作用域
	  import com.cris.scala.Apple
      val apple = new Apple()
//      class com.cris.scala.Apple
      println(apple.getClass)
    }
  }

  package scala {

    class Apple {

    }
  }
}-
複製程式碼

  • 可以在同一個.scala檔案中，宣告多個並列的package(建議巢狀的pakage不要超過3層)

包物件

基本介紹：包可以包含類、物件和特質trait，但不能包含函式或變數的定義。這是Java虛擬機器的侷限。為了彌補這一點不足，scala提供了包物件的概念來解決這個問題

參見如下程式碼

package com.cris {

  // 不能直接在 package 中定義函式和變數
  //  var name = "cris"

  /**
    * 包物件的名字需要和包名一致
    * package object emp 會在 com.cris.emp 包下生成&emsp;package.class 和&emsp;package$.class
    */
  package object emp {
    def eat(): Unit = {
      println("eat")
    }

    val salary = 1000.0
  }

  package emp {

    object test {
      def main(args: Array[String]): Unit = {
        eat() // eat＝》等價於使用了&emsp;package$.class 中的&emsp;MODULE$.eat()
        println(salary) // 1000.0=>&emsp;等價於使用了&emsp;package$.class 中的 MODULE$.salary()
      }
    }
  }
}
複製程式碼

使用反編譯工具開啟瞧瞧

具體的執行流程第二章節已經解釋過，這裡不再贅述

注意事項：

  1. 每個包都可以有一個包物件，但是需要在父包中定義它
  2. 包物件名稱需要和包名一致，一般用來對包（裡面的類）的功能做補充

包的可見性

在Java中，訪問許可權分為: public，private，protected和預設。在Scala中，你可以通過類似的修飾符達到同樣的效果。但是使用上有區別

  1. 當屬性訪問許可權為預設時，從底層看屬性是private的，但是因為提供了xxx_$eq()[類似setter]/xxx()[類似getter] 方法，因此從使用效果看是任何地方都可以訪問)

  2. 當方法訪問許可權為預設時，預設為public訪問許可權

  3. private為私有許可權，只在類的內部和伴生物件中可用

示例：

  1. protected為受保護許可權，scala中受保護許可權比Java中更嚴格，只能子類訪問，同包無法訪問

  2. 在scala中沒有public關鍵字,即不能用public顯式的修飾屬性和方法。

包訪問許可權（表示屬性有了限制。同時增加了包的訪問許可權），這點和Java不一樣，體現出Scala包使用的靈活性

包的引入

細節說明

  1. 在Scala中，import語句可以出現在任何地方，並不僅限於檔案頂部，import語句的作用一直延伸到包含該語句的塊末尾。這種語法的好處是：在需要時在引入包，縮小import 包的作用範圍，提高效率

    示例如下：

  2. Java中如果想要匯入包中所有的類，可以通過萬用字元*，Scala中採用下 _

  3. 如果不想要某個包中全部的類，而是其中的幾個類，可以採用選取器(大括號)

  4. 如果引入的多個包中含有相同的類，那麼可以將不需要的類進行重新命名進行區分，這個就是重新命名

  5. 或者使用 import java.util.{HashMap => _ } 對衝突的包進行隱藏

練習

  1. 編寫一個Time類，加入只讀屬性hours和minutes，和一個檢查某一時刻是否早於另一時刻的方法before(other:Time):Boolean。Time物件應該以new Time(hrs,min)方式構建

    object Practice {
  def main(args: Array[String]): Unit = {
    val time1 = new Time(4, 12)
    val result = time1.before(new Time(4, 14))
    println(result)
  }
}

class Time(val hour: Int, val minute: Int) {
  
  def before(other: Time) = {
    if (this.hour < other.hour) true
    else if (this.hour > other.hour) false
    else if (this.hour == other.hour) {
      if (this.minute < other.minute) true
      else if (this.minute > other.minute) false
      else false
    }
  }
}
複製程式碼

  2. 建立一個Student類，加入可讀寫的JavaBeans屬性name(型別為String)和id(型別為Long)。有哪些方法被生產？(用javap檢視。)你可以在Scala中呼叫JavaBeans的getter和setter方法嗎？

    object Practice {
  def main(args: Array[String]): Unit = {
    var s = new Student
    println(s.getName)
    println(s.age)
  }
}

class Student {
  @BeanProperty var name = "好學生"
  @BeanProperty var age = 0

}
複製程式碼

  3. 編寫一段程式,將Java雜湊對映中的所有元素拷貝到Scala雜湊對映。用引入語句重新命名這兩個類

    object Ex extends App {

  import java.util.{HashMap => JavaHashMap}
  import scala.collection.mutable.{HashMap => ScalaHashMap}

  var map1 = new JavaHashMap[Int, String]()
  map1.put(1, "cris")
  map1.put(2, "james")
  map1.put(3, "simida")


  var map2 = new ScalaHashMap[Int, String]()
  for (key <- map1.keySet().toArray()) { // key 的資料型別是 AnyRef
    // asInstanceOf 強制資料型別轉換
    map2 += (key.asInstanceOf[Int] -> map1.get(key))
  }
  println(map2.mkString("||")) // 2 -> james||1 -> cris||3 -> simida

}
複製程式碼

抽象

我們在前面去定義一個類時候，實際上就是把一類事物的共有的屬性和行為提取出來，形成一個物理模型(模板)。這種研究問題的方法稱為抽象

示例程式碼

object Demo extends App {

  var account = new Account("招行：888888", 200, "123456")
  account.query("123456")

  account.save("123456", 100)
  account.query("123456")

  account.withdraw("123456", 250)
  account.query("123456")

}

class Account(val no: String, var balance: Double, var pwd: String) {
  def query(pwd: String): Unit = {
    if (pwd != this.pwd) {
      println("密碼錯誤！")
    } else {
      println(s"卡號：${this.no}，餘額還有：${this.balance}")
    }
  }

  def save(pwd: String, money: Double): Unit = {
    if (pwd != this.pwd) {
      println("密碼錯誤")
    } else {
      this.balance += money
      println(s"卡號：${this.no}，存入：${money}，餘額為：${this.balance}")
    }
  }

  def withdraw(pwd: String, money: Double): Unit = {
    if (pwd != this.pwd) {
      println("密碼錯誤")
    } else if (money > this.balance) {
      println("餘額不足")
    } else {
      this.balance -= money
      println(s"卡號：${this.no}，取出：${money}，餘額為：${this.balance}")
    }
  }
}
複製程式碼

相關推薦

Cris 的 Scala 筆記整理（七）：面向物件

7. 面向物件（重點） 7.1 Scala 面向物件基礎 類 [修飾符] class 類名 { 類體 } scala語法中，類並不宣告為public，所有這些類都具有公有可見性(即預設就是public) 一個Scala原始檔可以包含多個類 定義一個最簡單的類 object

Cris 的 Scala 筆記整理（九）：面向物件高階

9. 面向物件高階 9.1 靜態屬性和靜態方法 ① 回顧 Java 的靜態概念 public static 返回值型別 方法名(引數列表) {方法體} Java 中靜態方法並不是通過物件呼叫的，而是通過類物件呼叫的，所以靜態操作並不是面向物件的 ② Scala 中靜態的概念-伴生物件 Scala

Scala筆記整理（七）：模式匹配和樣例類

大數據 Scala [TOC] 可以用到switch語句 1、Scala強大的模式匹配機制，可以應用在switch語句、類型檢查以及“析構”等場合。 def swithOps: Unit ={ var sign = 0 val ch: Char = ‘+‘ ch match

Cris 的 Scala 筆記整理（十）：隱式轉換

10. 隱式轉換 隱式轉換函式是以implicit關鍵字宣告的帶有單個引數的函式。這種函式將會自動應用，將值從一種型別轉換為另一種型別 ① 隱式轉換最佳入門案例 首先看下面的程式碼 如果想要轉換成功，就需要藉助隱式轉換函式 為了更好的理解，我們看看反編譯後的位元組

Scala筆記整理（一）：scala基本知識

大數據 Scala [TOC] Scala簡介 Scala是一門多範式（multi-paradigm）的編程語言，設計初衷是要集成面向對象編程和函數式編程的各種特性。 Scala運行在Java虛擬機上，並兼容現有的Java程序。 Scala源代碼被編譯成Java字節碼，所以它可以運行於JVM之上，並

Scala筆記整理（二）：Scala數據結構—數組、map與tuple

大數據 Scala [TOC] 數組 定長數組 如果你需要一個長度不變的數組，可以用Scala中的Array。例如： val numsArray = new Array[Int] (30) //長度為30的整數數組，所有元素初始化為0 val stringArrays = new Array [St

Scala筆記整理（三）：Scala面向對象—類詳解1

大數據 Scala [TOC] getter和setter 簡單類和無參方法 需要說明的是，官方給出的參考資料對於這方面講解得十分詳細，目前入門來說，不需要達到這樣的理解，只需要可以進行開發即可，這一部分我給出的是官方的一些文檔說明，但是後面的定制和註解，就直接簡單說明能用就好了。 class

Scala筆記整理（四）：Scala面向對象—類詳解2（繼承相關）

大數據 Scala [TOC] 單例 希望某個類只存在一個使用的對象，而不管有多少個調用者在使用它，就是單例的概念。 Java中的單例 package cn.xpleaf.single; /** * 單例模式-餓漢式（在屬性中先創建好對象，不管是否調用getInstance方法） * @auth

Scala筆記整理（五）：函數式編程

大數據 Scala [TOC] 作為值傳遞的函數 測試代碼如下： package cn.xpleaf.bigdata.p4.function /** * scala中關於函數的操作 */ object _01FunctionOps { def main(args: Array[Stri

Scala筆記整理（六）：Scala集合庫

大數據 Scala [TOC] Scala主要集合結構 1、Scala中的集合體系主要包括：Iterable、Seq（IndexSeq）、Set（SortedSet）、Map（SortedMap）。其中Iterable是所有集合trait的根trait。實際上Seq、Set、和Map都是子trait

Scala筆記整理（八）：類型參數（泛型）與隱士轉換

大數據 Scala [TOC] 概述 類型參數是什麽？類型參數其實就是Java中的泛型。大家對Java中的泛型應該有所了解，比如我們有List list = new ArrayList()，接著list.add(1)，沒問題，list.add("2")，然後我們list.get(

Scala筆記整理（九）：Actor和AKKA

大數據 Scala [TOC] 概述 ? Scala的Actor有點類似於Java中的多線程編程。但是不同的是，Scala的Actor提供的模型與多線程有所不同。Scala的Actor盡可能地避免鎖和共享狀態，從而避免多線程並發時出現資源爭用的情況，進而提升多線程編程的性能。 Spark中使用

胡八一之Java（七）：面向物件的陷阱

一、instanceof的陷阱： 如果前面運算元的編譯型別與後面的型別沒有任何關係，那麼編譯將不通過。例如： String a ="aaa"; System.out.println("a是否屬於MATH的型別："+(a.instanceof Math)); Stri

Kafka筆記整理（二）：Kafka Java API使用

大數據 Kafka Java [TOC] Kafka筆記整理（二）：Kafka Java API使用 下面的測試代碼使用的都是下面的topic： $ kafka-topics.sh --describe hadoop --zookeeper uplooking01:2181,uplooking0

Kafka筆記整理（三）：消費形式驗證與性能測試

大數據 Kafka 性能測試 [TOC] Kafka筆記整理（三）：消費形式驗證與性能測試 Kafka消費形式驗證 前面的《Kafka筆記整理（一）》中有提到消費者的消費形式，說明如下： 1、每個consumer屬於一個consumer group，可以指定組id。group.id 2、消費形

Redis筆記整理（一）：Redis安裝配置與數據類型操作

數據庫 NoSQL Redis [TOC] Redis筆記整理（一）：Redis安裝配置與數據類型操作 Redis簡介 Redis是一個開源（BSD許可），內存存儲的數據結構服務器，可用作數據庫，高速緩存和消息隊列代理。 它支持字符串、哈希表、列表、集合、有序集合，位圖，hyperloglo

Redis筆記整理（二）：Java API使用與Redis分布式集群環境搭建

數據庫 NoSQL Redis [TOC] Redis筆記整理（二）：Java API使用與Redis分布式集群環境搭建 Redis Java API使用（一）：單機版本Redis API使用 Redis的Java API通過Jedis來進行操作，因此首先需要Jedis的第三方庫，因為使用的是M

Redis筆記整理（三）：進階操作與高級部分

數據庫 NoSQL Redis [TOC] Redis筆記整理（三）：進階操作與高級部分 Redis發布訂閱 Redis發布訂閱（pub/sub）是一種消息通信模式：發送者(pub)發送消息，訂閱者(sub)接收消息。 Redis客戶端可以訂閱任意數量的頻道。 下圖展示了頻道channel1，以

ElasticSearch筆記整理（一）：簡介、REST與安裝配置

大數據 ElasticSearch ELK [TOC] ElasticSearch簡介 ElasticSearch是一款基於Apache Lucene構建的開源搜索引擎，它采用Java編寫並使用Lucene構建索引、提供搜索功能，ElasticSearch的目標是讓全文搜索變得簡單，開發者可以通

ElasticSearch筆記整理（二）：CURL操作、ES插件、集群安裝與核心概念

大數據 ElasticSearch ELK [TOC] CURL操作 CURL簡介 curl是利用URL語法在命令行方式下工作的開源文件傳輸工具，使用curl可以簡單實現常見的get/post請求。簡單的認為是可以在命令行下面訪問url的一個工具。在centos的默認庫裏面是有curl工具的，如