1. 程式人生 > >Go與Java中package的理解與區別

Go與Java中package的理解與區別

一.GO中package的使用

  1.  package是go程式中最基本的分發單位和工程管理中依賴關係的體現,一個"xx.go"原始檔必須屬於某個package,一個package可以拆成多個".go"原始檔;
  2. 每個".go"原始碼檔案開頭都擁有一個package宣告,表示該原始碼所屬的package;
  3. 要生成golang可執行程式(bin目錄下),必須建立一個名為main的package,並且在該package中必須包含一個名為main()的函式;
  4. 在go工程中,同一個路徑下只能存在一個package
  5. 一個package中可以有一個main()函式,該main()函式可以放在package中的任一".go"原始檔中

 需要注意的是

  • 在go中使用關鍵字"import"匯入的只是是某個package所在的路徑,而並不是實際的package.由於同一個路徑下只能存在一個package,而由於慣例經常將目錄名與該目錄下的package名設為一致,所以會給人造成"improt"後的是package名,而實際上目錄名與該目錄下的package名是可以不同的,"import"後跟的是目錄名;
  • 在程式中正真使用時,才要用到package名
  • 總之,"import"後跟的是目錄名,而程式中使用的是package名,兩者可以不同,而習慣上我們把目錄名和該目錄下的包名設為一樣;另外,不得匯入原始碼檔案中沒有用到的package路徑,否則go編譯器會報編譯錯誤
package main

import (
    "fmt"  //-------->這裡的"fmt"是fmt包所在的目錄名
)


func mian() {
    fmt.println("hello") //-------> 這裡的"fmt"是fmt包
}

二.go的"import"原理

       如果編譯時main包匯入了其他的包,那麼這些包將被依次匯入。

       當一個包被匯入時,如果該包還匯入了其它的包,那麼先將其他的包匯入進來,然後再對該包的包級常量和變數進行初始化,最後執行init函式(如果存在)。包的匯入如上圖所示,是一個遞迴地過程,等所有被匯入的包載入完畢,就會對main包中的包級常量和變數進行初始化,然後執行main包中的init函式(如果存在),最後執行main函式。

       如果一個包被多個包同時匯入,那麼它只會被匯入一次。

三.Go的"import"語法

風格一

import "package1"
import "package2"
import "package3"
...

風格二

import (
    "package1"
    "package2"
    "package3"
    ...
)
  • 點(.)操作

  點(.)操作的含義是:點(.)標識的包匯入後,呼叫該包中函式時可以省略字首包名。點(.)操作的語法為:

import . "package1"
import . "package2"
import . "package3"
...
import (
    . "package1"
    . "package2"
    . "package3"
    ...
)

   下面的示例中,fmt包將使用點操作省略字首包名,os包用法保持不變:

package main

import (
    . "fmt"
    "os"
)

func main() {
    for _, value := range os.Args {
        Println(value)
    }
}
  • 別名操作

  別名操作的含義是:將匯入的包命名為另一個容易記憶的別名。別名操作的語法為:

import p1 "package1"
import p2 "package2"
import p3 "package3"
...
import (
    p1 "package1"
    p2 "package2"
    p3 "package3"
    ...
)

       下面的示例中,fmt包將使用別名操作重新命名為f,os包用法保持不變:

package main

import (
    f "fmt"
    "os"
)

func main() {
    for _, value := range os.Args {
        f.Println(value)
    }
}

• 下劃線(_)操作

       下劃線(_)操作的含義是:匯入該包,但不匯入整個包,而是執行該包中的init函式,因此無法通過包名來呼叫包中的其他函式。使用下劃線(_)操作往往是為了註冊包裡的引擎,讓外部可以方便地使用。下劃線(_)操作的語法為:

import _ "package1"
import _ "package2"
import _ "package3"
...
import (
    _ "package1"
    _ "package2"
    _ "package3"
    ...
)

四.Java中的package與"import"

  1. Java中的package是組織和管理類檔案(xx.java)的一個層級,最終實際上會轉換為檔案系統中的一個目錄檔案,可以理解為Java中的package就是個目錄檔案
  2. 一個package中可以管理多個".java"原始檔
  3. Java中的"import"匯入的不是包而是某個包中的某個類或所有類

 總之,Java中的package實際上就可以理解為檔名,"import"匯入的是包中(檔案中)的某個類(.java檔案);而go總的package不是指檔案,但一個檔案中只能有一個package,一個package組織多個".go"原始檔,"import"匯入的是檔案而不是包,而程式中實際使用的是包

相關推薦

GoJavapackage理解區別

一.GO中package的使用  package是go程式中最基本的分發單位和工程管理中依賴關係的體現,一個"xx.go"原始檔必須屬於某個package,一個package可以拆成多個".go"原始檔; 每個".go"原始碼檔案開頭都擁有一個package宣告,表示該原

c#javabyte位元組的區別及轉換方法

在java中  byte的範圍在 [-128,127] 在C#中  byte的範圍在 [0,255] 所以 java程式與C#程式 進行資料傳輸的時候 要先把java的byte陣列轉換成在[0,255]範圍內的int型陣列a[];再把a[]進行加密得到字串str, 把字串

C#的名稱空間namespaceJava的包package之間的區別

Java 包被用來組織檔案或公共型別以避免型別衝突。包結構可以對映到檔案系統。 System.Security.Cryptography.AsymmetricAlgorithm aa; 可能被替換: import System.Security.Crypography; class xxx { .

java枚舉.net的枚舉區別

java .net 通過一段時間的項目實踐,發現java中的枚舉與.net中的枚舉有很大的差別,初期造成了我對java中的枚舉一些錯誤理解及部分有缺陷的應用,其實追其原因還是因為我會習慣性的認為java的枚舉在作用以及定義上與.net應該是差不多的,畢竟兩者都是高級語言,語言上也有很多相似之處。這就

javapublic voidpublic static void區別

sta erro ati 對象 方法 這樣的 調用 必須 靜態方法 static 方法可以被main方法直接調用,而非static方法不可以。因為static方法是屬於類的,是類方法。可以通過類名.方法名直接調用。而非static方法必須等對象被new出來以後才能使用,因而

Java重載重寫的區別

ref 類對象 就是 不同 3.4 做出 同方 相同 默認 簡單的個人記憶,重寫是子類中的方法與父類的方法參數、返回值一模一樣,重載是對於同一個類中的方法,方法名相同,參數類型、個數不同。當父類的引用指向子類對象的時候,子類中如果有對於父類方法的重寫,則調用的是子類重寫過的

java類方法物件方法區別

public class Test { /** * 下面這個方法就是靜態方法,應該就是樓主所說的類方法~~ * 靜態方法必須定義成static的,在類Test被例項化以前就已經存在於記憶體中 * 靜態方法使所有該類的例項也就是物件共有的方法 */ public static void f1() {

Java"" null 的區別

String name; String nickName = “”; 區別一 null :代表的是空物件。 解釋:它還沒有目標,不知道要指向誰?等同於 String name = null。除了可以操作判斷或賦值語句(== || = )外,不可以對其進行其他任何操作。例如 name.trim

java靜態變數非靜態變數的區別

靜態變數與非靜態變數的區別如下: 1.記憶體分配 靜態變數在應用程式初始化時,就存在於記憶體當中,直到它所在的類的程式執行結束時才消亡; 而非靜態變數需要被例項化後才會分配記憶體。 2.生存週期 靜態變數生存週期為應用程式的存在週期; 非靜態變數的存在週期取決於

Java 的 ==, equals hashCode 的區別聯絡

一、概述 1、概念 == : 該操作符生成的是一個boolean結果,它計算的是運算元的值之間的關係 equals  : Object 的 例項方法,比較兩個物件的content是否相同 hashCode : Object 的 native方法 , 獲取物件的雜湊值,用

java的i++++i有什麼區別

剛開始接觸時,做了一些小測試,還以為這兩個沒有什麼區別。 public class OperatorDemo { public static void main(String[] args){ int a = 10; a++; System.o

java的equals==的區別

這兩個東西初學java的時候就瞭解了,但那時只是大概的知道判斷數字相等就用==,String字串相等就用equals,後來也有去網上看了一下具體區別,但是,每隔一段時間理解就會變得模糊,所以在這裡記錄一下:1,對於==1)、作用於基本資料型別(也就是8大基本資料型別)變數:比

c++java關於訪問修飾符的區別

#include <iostream> #include <math.h> using namespace std; class A { protected:void fun(){cout<<"hello"<<endl;} }; int main(){A a;a

java 標準輸出標準錯誤 out err 區別 用法 聯絡 java的outerr區別 System.out和System.err的區別 System.out.println和System.err.println的區別 Java重定向S

/** * The "standard" output stream. This stream is already * open and ready to accept output data. Typically this stream * corresponds

Java抽象類介面區別

抽象類:抽象類是無法例項化的特殊類。所以問題是為什麼我們需要一個不能被例項化的類,抽象類只能是子類(繼承自)。換句話說,它只允許其他類繼承它,但不能例項化。優點是它為所有子類執行特定的層次結構。簡

【本人禿頂程式設計師】淺析JAVA堆記憶體棧記憶體的區別

←←←←←←←←←←←← 快!點關注!!! Java把記憶體劃分成兩種:一種是棧記憶體,一種是堆記憶體。 一、棧記憶體 存放基本型別的變數,物件的引用和方法呼叫,遵循先入後出的原則。 棧記憶體在函式中定義的“一些基本型別的變數和物件的引用變數”都在函式的棧記憶體中分配。當在一

java的hasCodeequals理解(轉載)

1. 首先equals()和hashcode()這兩個方法都是從object類中繼承過來的。  equals()方法在object類中定義如下:    public boolean equals(Object obj) {  return (this == obj); 

[引用區別] c++引用java引用區別

綜述:     在Java中,類例項宣告和構造是分開。"T a;"是宣告,而"a=new T();"才是構造。引用宣告和C++相同。但是Java的機制與C++不同,Java中的引用也叫控制代碼,或者說控制代碼才是其真實名稱。類宣告的都是一個控制代碼,呼叫建構函式才會使得控制

JavaArrayList和LinkedList區別以及時間複雜度空間複雜度

Java中ArrayList和LinkedList區別以及時間複雜度與空間複雜度? 一.時間複雜度 二.空間複雜度 三.總結    一般大家都知道ArrayList和LinkedList的大致區別: 1.ArrayList是實現了基於動態陣

java氣泡排序選擇排序的區別

初學java語言,排序演算法絕對是我們拿來實踐的好例子。而在排序中有兩種簡單的演算法是繞不開的,就是氣泡排序與選擇排序。下面來分別講解: 冒泡演算法:假設陣列長度為lenght,冒泡演算法的外迴圈為l