Groovy語法基礎

来源:https://www.cnblogs.com/skymxc/archive/2019/08/18/groovy-basic.html
-Advertisement-
Play Games

Groovy語法，變數定義，方法聲明，集合操作，閉包，運算符，斷言等基礎知識。 ...


先來一張思維導圖

Groovy 簡介

Groovy 是一種基於 JVM 的動態語言，他的語法和 Java 相似，最終也是要編譯 .class 在JVM上運行。

Groovy 完全相容 Java 並且在此基礎上添加了很多動態類型和靈活的特性，比如支持閉包，支持DSL，是一門非常靈活的動態腳本語言。

這篇文章是為了能看懂在 Gradle腳本中的代碼，知道怎麼寫。所以不會深入Groovy。

每個 build 腳本配置文件都是一個 Groovy腳本文件。在裡面可以寫任何符合 Groovy 語法的代碼。
例如定義類，方法，變數等。又因為Groovy 是完全相容Java的，故也可以寫任何Java代碼，是完全相容的。

DSL

DSL（Domain Specific Language) 中文意思是 領域特定語言，專門關註某一領域，在於專而不是全。所以才是領域特定的。

Gradle 的腳本就是基於 Groovy 的DSL，專門解決自動化構建的DSL。
我們只需要按照相應的語法，配置相應的 Gradle 腳本就可以達到自動化構建的目的，這也是 DSL 的初衷。

註釋

單行註釋

//這裡是註釋
def name = "佛系編碼"

多行註釋

/* 這裡是多行註釋
   啦啦啦啦 */

doc 註釋

/**
 * 這裡是 doc 註釋
 * 啦啦啦啦
 */

數據類型

Java中的基本數據類型，對象它都支持；另外還有
閉包
加強的 List，Map的集合
加強的File，Stream等IO類型

類型可以顯式聲明，也可以用 def 來聲明，用 def 聲明的類型Groovy將會進行類型推斷。

基本數據類型都是和Java 中的一致，就不拿出來說了。下麵說一下，對象，字元串，閉包等;

另外：Groovy 中的分號是可以省略的；

字元串

使用單引號和雙引號都可以定義一個字元串常量。

差別是 單引號只是單純的字元串，不能使用表達式，運算，求值，正則等。

task character(){
  doLast{
      def name = '張三'
      def address ="北京市"
      def age = 19
      println "單引號雙引號都是字元串 name is ${name}; age is $age ; address is ${address}"
      println '單引號里無法運算表達式例如 name is ${name}'
  }
}

執行 character

gradle character

得到結果如下

單引號雙引號都是字元串 name is 張三; age is 19 ; address is 北京市
單引號里無法運算表達式例如 name is ${name}

雙引號的字元串可以直接進行表達式計算，規則是一個美元符號緊跟一個花括弧: ${expression} ，如果只有一個變數可以省略花括弧。例如上面的 $age

集合

集合預設是 java.util.ArrayList 類型的

def nums = [1,2,4,5,6]
println "nums is ${nums.getClass().getName()} size = ${nums.size()}"

輸出結果為

nums is java.util.ArrayList size = 5

也可以顯式指定集合類型 使用 as 關鍵字；

def nums1 = [0,"23",4,5,62,false] as LinkedList
println "nums1 is ${nums1.getClass().getName()};size = ${nums1.size()}"

輸出為

nums1 is java.util.LinkedList;size = 6

或者在前面顯式指定類型

LinkedList otherLinked = [3, 4, 5]

訪問元素

元素的訪問是通過下標訪問的

println "第三個元素是 ${nums1[2]},倒數第一個是 ${nums1[-1]};第一個和倒數第一個：${nums1[0,-1]}"
println "第二個到第四個：${nums1[1..3]}"

輸出為：

第三個元素是 4,倒數第一個是 false;第一個和倒數第一個：[0, false]
第二個到第四個：[23, 4, 5]

遍歷元素

使用 each 方法遍歷集合 參數預設是 it

//遍歷
nums1.each {
  print "$it, "
}

輸出為：

0, 23, 4, 5, 62, false,

帶有下標的遍歷：使用 eachWithIndex 方法

numList.eachWithIndex { int value ,int index->
    println "list[$index] = $value"
    }

數組

數組的定義要明確的指定數組類型

String [] strings = ["I","'","m","is","a","dog","."]
   println "\n 數組 :${strings.getClass().getName()}"
   strings.each{
       print "$it "
   }

   def multi = [5,7,5,8,54,87] as int[]

   println "\n使用 as 顯式指定類型: ${multi.getClass().getName()}"
   multi.each{
       print "$it "
   }

輸出是

數組 :[Ljava.lang.String;
I ' m is a dog .
使用 as 顯式指定類型: [I
5 7 5 8 54 87

添加元素

使用 List.add() 添加元素

numList.add(-11)

使用 可以使用 << 操作符添加一個

numList << 13

修改元素

numList[0] = 0

不用擔心下標越界；Groovy就自動增加到所需的下標,中間的會設置為 null

def numList = [0,1,2,3,4,5] as LinkedList

        numList.each{
            print "$it "
        }

        println "\n 在 10位置添加一個 11"

        numList[10] =11

        println "添加後的："

        numList.each{
            print "$it "
        }

輸出為：

> Task :collect1
0 1 2 3 4 5 
 在 10位置添加一個 11
添加後的：
0 1 2 3 4 5 null null null null 11 
BUILD SUCCESSFUL in 0s

刪除元素

使用 List.remove() 移除元素 參數可以是 下標，可以是值

numList.remove 0
numList.remove((Object)10)

使用 List.removeLast() 移除最後一個元素

numList.removeLast()

查找元素

使用 List.find() 查找第一個符合條件的元素

print "\n list.find() 查找第一個符合條件的元素 numList.find { it%2==0}"
print numList.find { it%2==0}

使用 List.findAll() 查找所有符合條件的元素

print "\n list.findAll() 查找所有符合條件的元素 numList.findAll {it % 2 ==0 }"
print numList.findAll { it % 2 ==0}

使用 List.any() 查找元素，只要有一個元素符合就返回 true

print "\n list.any() 只要有一個元素符合條件就返回 true numList.any { it % 2 ==1} "
print numList.any { it % 2 ==1}

使用 List.every() 查找元素，必須所有元素都符合條件才會返回 true

print "\n list.every() 必須所有元素都符合條件才會返回 true numList.every {it % 2 == 0} "
print numList.every { it % 2 == 0}

統計元素

統計符合條件的元素個數：使用 List.count()

print numList.count { it % 2 ==0 }

統計最大值：List.max()，最小值：List.min()

print "\n 最大值是 ${numList.max()} ,最小值是 ${numList.min()}， 最小的絕對值是 "
print numList.min { Math.abs it}

Map

Map 的定義是鍵值對的方式，使用逗號隔開

def colors = [red:'#FF0000',green:'#00FF00',blue:'#0000FF']

訪問 Map 中的元素有三種方式：

  • map.key
  • map[key]
  • map.get(key)

例如：

task map{
    doLast{
        def colors = [red:'#FF0000',green:'#00FF00',blue:'#0000FF']
        println " map calss is ${colors.getClass().getName()}"
        println "通過 map.key 的方式訪問 colors.red = ${colors.red}"
        println "通過 map[key] 的方式訪問 colors['red'] = ${colors['red']}"
        println "通過 map.get(key) 的方式訪問 colors.get(red) = ${colors.get('red')}"
    }
}

輸出為 ：

> Task :map
 map calss is java.util.LinkedHashMap
通過 map.key 的方式訪問 colors.red = #FF0000
通過 map[key] 的方式訪問 colors['red'] = #FF0000
通過 map.get(key) 的方式訪問 colors.get(red) = #FF0000


BUILD SUCCESSFUL in 0s
1 actionable task: 1 executed

添加元素

//添加元素
colors['pink'] = '#FF00FF'
colors.yellow = '#FFFF00'

修改元素

//修改元素
colors.red = 'red'
colors['blue'] = 'blue'
println "修改後的元素是 colors.red = ${colors.red},colors.blue = ${colors.blue}"

刪除元素

//刪除元素
colors.remove('red')

遍歷元素

和上面的一樣 使用 each 方法

//遍歷 
colors.each{
    println "${it.key} :${it.value}"
}

查找元素

查找的方法 和 上面的都一樣，只是 參數換成了 Map.Entry 或者 key,value ;
這裡只用 find 做一個示例：

find 方法

def green = colors.find { key ,value ->
  if(key.equals('green')) {
      return colors[key]
  }
  return null
}

println "查找結果是 ${green}"


def blue = colors.find { Map.Entry entry ->
    if(entry.key.equals('blue')){
        return entry.value
    }
    return null
}
println "查找的結果是 ${blue}"

方法

方法也是使用 def 定義的

/*
 * 返回大的那個
 */
def max(int a ,int b){
    if(a>b){
      return   a
    }else{
      return   b
    }
}

return 是可以省略的

Groovy 會把執行過程中的最後一句代碼作為返回值

/*
 * 返回大的那個
 */
def max(int a ,int b){
    if(a>b){
         a
    }else{
       b
    }
}

括弧是可以省略的；

在調用方法時括弧是可以省略的；使用 空格間隔開參數即可

def printMaximum(int a,int b){
    if(a>b){
        println "The maximum value of $a and $b is $a"
    }else{
        println "The maximum value of $a and $b is $b"
    }
}

task method {
    doLast{
        println "max is ${max(0,1)}"
        printMaximum 10,20
    }
}

輸出是

> Task :method
max is 1
The maximum value of 10 and 20 is 20

BUILD SUCCESSFUL in 0s
1 actionable task: 1 executed

代碼塊是可以作為參數傳遞的

代碼塊就是一段被花括弧包圍的代碼，其實就是閉包；

例如 each 方法

最原始的應該是這樣的

colors.each({println it})

格式化後

colors.each({
    println it
})

Groovy 規定最後一個參數是閉包,可以將閉包放在方法外面

colors.each(){
    println it
}

調用時方法的括弧是可以省略的 就成了這樣

colors.each {
    println it
}

閉包

閉包是 Groovy 的一個重要特性，可以說是 DSL 的基礎。

閉包其實就是一段匿名代碼塊。

閉包在 Groovy 中是 groovy.lang.Closure 類的實例，這使得閉包可以賦值給變數或欄位。

定義一個閉包

def hello = { println "Hello 佛系編碼" }

調用這個閉包

hello.call()

另一種調用方式 直接在後面跟上 ()

hello()

下麵模擬一個 each 的執行，定一個方法迭代集合中的元素

/*
  * closure 就是 閉包參數
  */
def customEach(closure){
    //迭代元素
    for(int i in 1..10){
    //在閉包後跟上 () 就是調用了 括弧里的參數就是閉包要接收的參數
        closure(i)
    }
}

調用這個方法，傳入一個閉包列印元素; 如果閉包只有一個參數，那麼預設就是 it

// 如果只有一個參數 預設就是 it
customEach {
     println it
}

如果閉包要接收多個參數，那就必須把參數顯式的列出來，使用 -> 將參數和主體分開

再次模擬一個 map 的 迭代:

def eachMap(closure){
    def map1 = [name:'佛系編碼',age:666]
    map1.each {
        closure(it.key,it.value)
    }
}
·····

//如果有多個參數，就必須要把參數列出來，使用 -> 將 參數和主體分開
eachMap { key,value ->
    println "$key:$value"
}

閉包委托

Groovy 閉包的強大之處在於它支持閉包方法的委托。

Groovy 的閉包有三個重要屬性

  • thisObject 閉包定義所在的類
  • owner 表示閉包定義所在的對象或閉包（閉包內還是可以定義閉包的），這個是最近原則，下麵會做說明
  • delegate 預設和 owner 一致，可以手動修改。

如果將閉包定義在一個類中，預設三個屬性都是相等的；

舉個例子： 在 Person 類中 定義了 一個 act 閉包

class Person{
    private String name

    public int getAge(){
       12
    }

    Closure act ={
         println "thisObject:${thisObject.getClass()}"
        println "owner:${owner.getClass()}"
        println "delegate:${delegate.getClass()}"
    }
}

調用這個閉包，將會有下麵的輸出

> Task :test
thisObject:class Person
owner:class Person
delegate:class Person

BUILD SUCCESSFUL in 0s
1 actionable task: 1 executed

如果將 閉包定義在一個 閉包里，那麼 thisOjbect 就和 其他兩個不一樣，因為 thisObject 是表示的定義閉包所在的類，而 owner 表示 類或閉包

這次在 一個閉包里再定一個閉包看一下

class Person{
    private String name

    public int getAge(){
       12
    }

    Closure act ={
        println "thisObject:$thisObject"
        println "owner:$owner"
        println "delegate:$delegate"
    }

    Closure eat = {
        def test = {
            println "thisObject:${thisObject.getClass()}"
            println "owner:${owner.getClass()}"
            println "delegate:${delegate.getClass()}"
        }
        test()
    }
}

執行這個 eat 閉包，將會得到以下結果

> Task :test
thisObject:class Person
owner:class Person$_closure2
delegate:class Person$_closure2

BUILD SUCCESSFUL in 0s
1 actionable task: 1 executed

可以看到 thisObject 和 owner 已經不一樣了，因為 thisObject 表示的是 所在的類，而 owner 表示的定義所在的類或閉包（最近原則）

三個屬性已經很明白了吧，

委托策略

無論什麼時候在閉包中訪問某屬性或調用某方法時，若沒有明確的設置對象，那麼就會調用一個委托策略。通過這個委托策略來決定如果訪問屬性或調用方法。

有以下幾個策略，可以通過 閉包的屬性更改：resolveStrategy

下麵通過一個嵌套類演示一下 策略更改的實際應用。

定義兩個類 Person 和 內部類 Foot ，並且兩者都有 name 屬性。Person 多一個 age 屬性。

class Person{
    private String name

    public int getAge(){
       12
    }

    class Foot {
      String name
      Closure walk = { it ->
          println "name is $name,age is $age ,delegate is ${delegate.getClass()}"
          //設置 delegate 屬性
          delegate = it;
          resolveStrategy = Closure.DELEGATE_FIRST
          println "修改策略為 Closure.DELEGATE_FIRST delegate 優先"
          println "name is $name, age is $age ,delegate is ${delegate.getClass()}"

      }
    }

    void walk(){
        Foot foot = new Foot(name:'腳');
        foot.walk(this)
    }
}

調用 Person 的 walk 方法

Person person = new Person()
person.name ="佛系編碼"
person.walk()

將會得到下麵的輸出

> Task :test
name is 腳,age is 12 ,delegate is class Person$Foot
修改策略為 Closure.DELEGATE_FIRST delegate 優先
name is 佛系編碼, age is 12 ,delegate is class Person

BUILD SUCCESSFUL in 0s
1 actionable task: 1 executed

我來解釋一下這個輸出

第一個name 是 腳 ；這是因為預設策略是 Closure.OWNER_FIRST 是在 owner 尋找屬性的；owner 當然是 Foot了。

第二個 name 是 佛系編碼;這是因為 策略改為了 Clousre.DELEGATE_FIRST 是優先在 delegate 上尋找的，而又把 delegate 屬性修改為了傳進去的 Person 實例，他的值在上面已經明確聲明為了 佛系編碼 。

而 age 只有在 Person 中聲明瞭 getAge() 方法，明確返回了 12.所以即使更改了策略，換了delegate 的值，仍然是 12.

註：三個屬性中 只有 delegate 屬性可以修改。

在 Gradle 中，我們一般會指定 delegate 為當前的 it,這樣在閉包中就可以對 it 進行配置

定義一個 User 類

class User{

    String name
    int age
    
    def dumpUser(){

        println "name is $name,age is $age ."
    }

}

在構建配置腳本中定義一個方法，傳入一個閉包參數用來配置 User 類

將閉包委托策略更改，並設置 delegate 屬性

def user(Closure<User> closure){
    User user = new User()
    closure.delegate = user
    closure.resolveStrategy = Closure.DELEGATE_FIRST
    closure(user)
}

在使用的時候就是這樣的了，Gradle 中就有很多這種的 DSL 配置，例如我們創建的 task

task configClosure(){
    doLast{
      user {
        name = '佛系編碼'
        age = 0
        dumpUser()
      }
    }
}

輸出為

> Task :configClosure
name is 佛系編碼,age is 0 .

BUILD SUCCESSFUL in 0s
1 actionable task: 1 executed

閉包 API 傳送門

類

這裡只介紹和 Java 中不同的地方.

先看段代碼：

task obj{
    doLast{
        Person p = new Person()
        println "沒賦值前的 ：${p.name}"
        p.name = '佛系編碼'
        println "賦值後的 ：${p.name}"

        println "age is ${p.age}"
    }
}

class Person{
    private String name

    public int getAge(){
       12
    }
}

執行 obj 任務的輸出

Task :obj
沒賦值前的 ：null
賦值後的 ：佛系編碼
age is 12

BUILD SUCCESSFUL in 0s
1 actionable task: 1 executed

在 Person 類中並沒有定義 name 屬性的 get/set 方法；卻可以設置和修改它的值；

這是因為 Groovy 幫我們搞定了 get/set 方法。

age 屬性也沒有在 Person 類中定義，只是定義了一個 getAge() 方法卻可以使用 age 屬性。

但是,因為沒有定義 set 方法，所以 age 屬性只能訪問。

運算符

這裡只列出來和 Java 不同且常用的運算符

可空運算符

對象非空時使用對象本身，對象為空時使用給定值；常用於給定某個可空變數的預設值。

task operator {
    doLast{
        Person person = new Person();
        //person.name 為 null 所以會使用 佛系編碼
        def name = person.name ? person.name:'佛系編碼'
        // getAge 返回 12 不為空 所以使用本身
        def age = person.age ?:10
        println "name is $name , age is $age"
    }
}

輸出

> Task :operator
name is 佛系編碼 , age is 12

BUILD SUCCESSFUL in 0s
1 actionable task: 1 executed

安全導航運算符

當調用一個對象上的屬性或方法時，如果對象是空的，就會拋出空異常，這個使用 ?. 運算符，當對象為空時，表達式的值也是空，就不會拋出異常。

task operator {
    doLast{
        User user
        println "user.name is ${user?.name}"
    }
}

輸出是

> Task :operator
user.name is null

BUILD SUCCESSFUL in 0s
1 actionable task: 1 executed

斷言

斷言是用於驗證假設條件是否為真，在Groovy的斷言中，如果假設的條件不為真，那麼就會拋出java.lang.AssertionError異常。

Groovy斷言和Java斷言完全不同。Groovy斷言是一項語言功能，一直處於開啟狀態，和JVM的斷言功能-ea完全無關。所以它是我們進行單元測試的首選方式。

例如

assert 1==2 :"1不等於2"

會拋出以下異常

FAILURE: Build failed with an exception.

······

* What went wrong:
Execution failed for task ':operator'.
> 1不等於2. Expression: (1 == 2)

當然不給出消息也是可以的

assert 1==2

那麼異常就是這樣的。

Execution failed for task ':operator'.
> assert 1==2
          |
          false

在使用斷言時最好是給出一條消息，此消息可以幫助其他人理解和維護你的代碼，理清你的意圖。

Groovy API 查詢方式

對於閉包的參數，只能在 API 查詢了，沒有什麼好的辦法。

這裡把 Groovy 文檔地址列出來，方便大家查詢相關 API

運行須知

要使用 gradle 或者 ./gradle 或者 gradlew 命令，必須是要安裝Gradle 並設置過環境變數的，當然在Gradle所在的目錄也是可以的。

build.gradle 是Gradle 的預設構建腳本文件，在執行 Gradle 命令的時候會預設找在當前目錄下的 build.gradle 文件。

也可以通過 -b 參數指定載入執行的文件。

例如 要執行 groovu-basic.build 里的 operator 任務

gradle -b groovy-basic.gradle operator

如果要執行上面的測試代碼，步驟是

  1. 新建一個 build.grale 文件 或者是通過 gradle 新建一個項目 看這篇
  2. 定義一個任務，添加動作
task test{
    doLast{
        //這裡是代碼
    }
}
  1. 粘貼代碼
  2. 運行任務
gradle test

附上我的 Gradle 版本

版本


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • 入門MySQL——查詢語法練習
    前言： 前面幾篇文章為大家介紹了DML以及DDL語句的使用方法，本篇文章將主要講述常用的查詢語法。其實MySQL官網給出了多個示例資料庫供大家實用查詢，下麵我們以最常用的員工示例資料庫為準，詳細介紹各自常用的查詢語法。 1.員工示例資料庫導入 官方文檔員工示例資料庫介紹及下載鏈接： "https:/ ...
  • 入門MySQL——DML語句篇
    前言： 在上篇文章中，主要為大家介紹的是DDL語句的用法，可能細心的同學已經發現了。本篇文章將主要聚焦於DML語句，為大家講解表數據相關操作。 這裡說明下DDL與DML語句的分類，可能有的同學還不太清楚。 DDL(Data Definition Language)：數據定義語言，用於創建、刪除、修改 ...
  • MYSQL入門操作和常規DML、DDL、DQL使用
    刷新許可權，將某些許可權從硬碟刷新到記憶體中(修改root密碼自帶隱式刷新許可權操作) mysql> flush privileges; Query OK, 0 rows affected (0.00 sec) mysql> 查看服務埠 mysql> show variables like 'port';... ...
  • MySQL管理——操作和查看資料庫的命令
    MySQL管理——操作和查看資料庫的命令 摘要：本文主要學習了操作和查詢資料庫的常用命令。 查看資料庫的基本信息 查詢所有的資料庫 語法： 示例： 指定要使用的資料庫 語法： 示例： 查詢指定資料庫所有的表 語法： 示例： 查詢指定表的欄位 語法： 示例： 查詢指定表的索引 語法： 示例： ...
  • 雲上RDS架構
    概述 越來越多的企業選擇上雲，最基礎的雲服務就是IaaS(Infrastructure as a Service)服務，直觀理解就是虛擬主機，用戶不用再自建機房，自己購買伺服器，而是直接向雲廠商購買虛擬主機服務ECS(Elastic Compute Service)，按時按量付費。對於資料庫而言，將 ...
  • MySQL安裝與連接
    1.安裝 下載地址：https://dev.mysql.com/downloads/mysql/ 常見問題及解決辦法：https://blog.csdn.net/chen97_08/article/details/81484286 1.1.添加環境變數 將解壓後的mysql 5.7.21 winx6 ...
  • navicat for mysql 12 的破解安裝和基本操作
    需要安裝Navicat軟體 可以複製百度雲鏈接，若失效，請聯繫我，我會儘快回覆 將鏈接中的破解文件複製到軟體安裝的位置即完成破解 鏈接：https://pan.baidu.com/s/1sIkjsd3TXyNZF9vdhOAnUQ 提取碼：kq7t 複製這段內容後打開百度網盤手機App，操作更方便哦 ...
  • Flutter學習筆記（18）--Drawer抽屜組件
    Drawer（抽屜組件）可以實現類似抽屜拉出和推入的效果，可以從側邊欄拉出導航面板。通常Drawer是和ListView組件組合使用的。 Drawer組件可以添加頭部效果，用DrawerHeader和UserAccountsDrawerHeader這兩個組件可以實現。 DrawerHeade... ...
一周排行
    -Advertisement-
    Play Games
  • Dapr Outbox 執行流程
    Dapr Outbox 是1.12中的功能。 本文只介紹Dapr Outbox 執行流程，Dapr Outbox基本用法請閱讀官方文檔 。本文中appID=order-processor，topic=orders 本文前提知識：熟悉Dapr狀態管理、Dapr發佈訂閱和Outbox 模式。 Outbo ...
  • Advanced .Net Debugging 7：托管堆與垃圾收集
    引言 在前幾章我們深度講解了單元測試和集成測試的基礎知識，這一章我們來講解一下代碼覆蓋率,代碼覆蓋率是單元測試運行的度量值,覆蓋率通常以百分比表示，用於衡量代碼被測試覆蓋的程度，幫助開發人員評估測試用例的質量和代碼的健壯性。常見的覆蓋率包括語句覆蓋率（Line Coverage）、分支覆蓋率（Bra ...
  • C#S7.NET實現西門子PLCDB塊數據採集的完整步驟
    前言 本文介紹瞭如何使用S7.NET庫實現對西門子PLC DB塊數據的讀寫，記錄了使用電腦模擬，模擬PLC，自至完成測試的詳細流程，並重點介紹了在這個過程中的易錯點，供參考。 用到的軟體： 1.Windows環境下鏈路層網路訪問的行業標準工具（WinPcap_4_1_3.exe）下載鏈接：http ...
  • WPF控制項：密碼框綁定MVVM
    從依賴倒置原則（Dependency Inversion Principle, DIP）到控制反轉（Inversion of Control, IoC）再到依賴註入（Dependency Injection, DI）的演進過程，我們可以理解為一種逐步抽象和解耦的設計思想。這種思想在C#等面向對象的編 ...
  • Python中的私有屬性與私有方法
    關於Python中的私有屬性和私有方法 Python對於類的成員沒有嚴格的訪問控制限制，這與其他面相對對象語言有區別。關於私有屬性和私有方法，有如下要點： 1、通常我們約定，兩個下劃線開頭的屬性是私有的（private）。其他為公共的（public）； 2、類內部可以訪問私有屬性（方法）； 3、類外 ...
  • C++ 訪問說明符詳解：封裝數據，控制訪問，提升安全性
    C++ 訪問說明符 訪問說明符是 C++ 中控制類成員（屬性和方法）可訪問性的關鍵字。它們用於封裝類數據並保護其免受意外修改或濫用。 三種訪問說明符： public：允許從類外部的任何地方訪問成員。 private：僅允許在類內部訪問成員。 protected：允許在類內部及其派生類中訪問成員。 示 ...
  • static_cast與dynamic_cast到底是什麼？
    寫這個隨筆說一下C++的static_cast和dynamic_cast用在子類與父類的指針轉換時的一些事宜。首先，【static_cast，dynamic_cast】【父類指針，子類指針】，兩兩一組，共有4種組合：用 static_cast 父類轉子類、用 static_cast 子類轉父類、使用 ...
  • C語言數據結構：雙向鏈表的增刪操作
    /******************************************************************************************************** * * * 設計雙向鏈表的介面 * * * * Copyright (c) 2023-2 ...
  • @ComponentScan註解的實現，Spring掃描包的過程
    相信接觸過spring做開發的小伙伴們一定使用過@ComponentScan註解 @ComponentScan("com.wangm.lifecycle") public class AppConfig { } @ComponentScan指定basePackage，將包下的類按照一定規則註冊成Be ...
  • opensips開啟python支持
    操作系統 ：CentOS 7.6_x64 opensips版本： 2.4.9 python版本：2.7.5 python作為腳本語言，使用起來很方便，查了下opensips的文檔，支持使用python腳本寫邏輯代碼。今天整理下CentOS7環境下opensips2.4.9的python模塊筆記及使用 ...
所有分類