java中怎麼聲明

Ⅰ java中函數的聲明和定義

Java中，我們應該知道最基本的就是定義變數和聲明變數了，那麼定義與聲明這兩者有沒有區別呢?具體的區別又是哪些呢?下面學習啦小編來告訴你定義與聲明的區別。

定義和聲明的定義區別

1、一種是需要建立存儲空間的。例如：int a 在聲明的時候就已經建立了存儲空間。

2、另一種是不需要建立存儲空間的。 例如：extern int a 其中變數a是在別的文件中定義的。

聲明是向編譯器介紹名字--標識符。它告訴編譯器「這個函數或變數在某處可找到，它的模樣象什麼」。

而定義是說：「在這里建立變數」或「在這里建立函數」。它為名字分配存儲空間。無論定義的是函數還是變數，編譯器都要為它們在定義點分配存儲空間。

對於變數，編譯器確定變數的大小，然後在內存中開辟空間來保存其數據，對於函數，編譯器會生成代碼，這些代碼最終也要佔用一定的內存。

總之就是：把建立空間的聲明成為「定義」，把不需要建立存儲空間的成為「聲明」。

基本類型變數的聲明和定義(初始化)是同時產生的;而對於對象來說，聲明和定義是分開的。

下面小編給大家舉個例子說明一下。

例如：類A

如果A a;就是一個聲明，告訴編譯器a是A類的一個對象變數，但是不進行初始化;

如果以後a=new A();這就是初始化，分配了空間。

需要注意的是我們聲明的最終目的是為了提前使用，即在定義之前使用，如果不需要提前使用就沒有單獨聲明的必要，變數是如此，函數也是如此，所以聲明不會分配存儲空間，只有定義時才會分配存儲空間。

用static來聲明一個變數的作用有二：

(1)對於局部變數用static聲明，則是為該變數分配的空間在整個程序的執行期內都始終存在。

(2)外部變數用static來聲明，則該變數的作用只限於本文件模塊。

定義和聲明的具體區別

所謂定義就是(編譯器)創建一個對象，為這個對象分配一塊內存，並給它取上一個名字，這個名字就是就是我們經常所說的變數名或對象名。

聲明有2重含義：

(1) 告訴編譯器，這個名字已經匹配到一塊內存上，下面的代碼用到變數或者對象是在別的地方定義的。聲明可以出現多次。

(2) 告訴編譯器，這個名字已經被預定了，別的地方再也不能用它來作為變數名或對象名。

定義和聲明最重要區別

定義創建對象並為這個對象分配了內存，聲明沒有分配內存。

Ⅱ java中要聲明一個int型的二維動態數組，如何聲明

public class Demo12 {
public static void main(String[] args) {
int[][] a = new int[3][5];//聲明一個3行5列的二維數組
//第一個括弧里代錶行數，第二個括弧里代表列數
}
}
我這個好像只是一個二維數組，至於你所說的動態二維數組我也不懂

Ⅲ java靜態變數怎麼聲明

個人的總結
1 靜態變數只有一份被類的所有實例共享
2 靜態變數的聲明在編譯時已經明確了內存的位置
3 延遲初始化是改變靜態變數的值
引用

Java靜態變數的初始化（static塊的本質）

在網上看到了下面的一段代碼：

1. public class Test {
2. static {
3. _i = 20;
4. }
5. public static int _i = 10;
6.
7. public static void main(String[] args) {
8. System.out.println(_i);
9. }
10. }

public class Test { static { _i = 20; } public static int _i = 10; public static void main(String[] args) { System.out.println(_i); } }

上述代碼會列印出什麼結果來呢？10還是20？本文將以此代碼為引子，著重討論一下靜態變數的初始化問題。 樓主可以找組織先記下175再來記下161最後填寫984就會出現扣裙問題1：靜態變數如何初始化

Java類中可以定義一個static塊，用於靜態變數的初始化。如：

1. public class Test {
2. public static int _i;
3. static {
4. _i = 10;
5. }
6. }

public class Test { public static int _i; static { _i = 10; } }

當然最常用的初始化靜態變數的操作是在聲明變數時直接進行賦值操作。如：

1. public class Test {
2. public static int _i = 10;
3. }

public class Test { public static int _i = 10; }

那麼上述兩例在本質上有什麼區別嗎？回答是沒有區別。兩例代碼編譯之後的位元組碼完全一致，通過 「javap -c」查看到的位元組碼如下：

public class Test extends java.lang.Object{
public static int _i;

public Test();
Code:
0: aload_0
1: invokespecial #1; //Method java/lang/Object."<init>":()V
4: return

static {};
Code:
0: bipush 10
2: putstatic #2; //Field _i:I
5: return

}

通過位元組碼還可以看出，當類的定義中不含有static塊時，編譯器會為該類提供一個默認的static塊。當然這是在含有靜態變數初始化操作的前 提下。如果靜態變數沒有初始化操作，則編譯器不會為之提供默認的static塊。如：

1. public class Test {
2. public static int _i;
3. }

public class Test { public static int _i; }

其位元組碼的表現形式為：

public class Test extends java.lang.Object{
public static int _i;

public Test();
Code:
0: aload_0
1: invokespecial #1; //Method java/lang/Object."<init>":()V
4: return

}

由於靜態變數是通過賦值操作進行初始化的，因此可以通過靜態函數返回值的方式為其初始化。如：

1. public class Test {
2. public static int _i = init();
3.
4. private static int init() {
5. return 10;
6. }
7. }

public class Test { public static int _i = init(); private static int init() { return 10; } }

其本質與下面的代碼相同：

1. public class Test {
2. public static int _i;
3. static {
4. _i = init();
5. }
6.
7. private static int init() {
8. return 10;
9. }
10. }

public class Test { public static int _i; static { _i = init(); } private static int init() { return 10; } }

問題2：JDK如何處理static塊

類定義中可以存在多個static塊嗎？回答是可以。如：

1. public class Test {
2. public static int _i;
3. static {
4. _i = 10;
5. }
6.
7. public static void main(String[] args) {
8. }
9.
10. static {
11. _i = 20;
12. }
13. }

public class Test { public static int _i; static { _i = 10; } public static void main(String[] args) { } static { _i = 20; } }

此類編譯之後的位元組碼為：

public class Test extends java.lang.Object{
public static int _i;

public Test();
Code:
0: aload_0
1: invokespecial #1; //Method java/lang/Object."<init>":()V
4: return

public static void main(java.lang.String[]);
Code:
0: return

static {};
Code:
0: bipush 10
2: putstatic #2; //Field _i:I
5: bipush 20
7: putstatic #2; //Field _i:I
10: return

}

觀察static{}部分可以看出，上例的代碼與下面的代碼效果一致：

1. public class Test {
2. public static int _i;
3.
4. public static void main(String[] args) {
5. }
6.
7. static {
8. _i = 10;
9. _i = 20;
10. }
11. }

public class Test { public static int _i; public static void main(String[] args) { } static { _i = 10; _i = 20; } }

此例可以證明，不僅類定義中可以有多個static塊，而且在編譯時編譯器會將多個static塊按照代碼的前後位置重新組合成一個static 塊。
問題3：如何看待靜態變數的聲明

靜態變數存放在常量池之中。如何證明呢？如：

1. public class Test {
2. public static int _i = 10;
3. }

public class Test { public static int _i = 10; }

使用「javap -c -verbose」查看其位元組碼的內容如下：

public class Test extends java.lang.Object
SourceFile: "Test.java"
minor version: 0
major version: 49
Constant pool:
const #1 = Method #4.#14; // java/lang/Object."<init>":()V
const #2 = Field #3.#15; // Test._i:I
const #3 = class #16; // Test
const #4 = class #17; // java/lang/Object
const #5 = Asciz _i;
const #6 = Asciz I;
const #7 = Asciz <init>;
const #8 = Asciz ()V;
const #9 = Asciz Code;
const #10 = Asciz LineNumberTable;
const #11 = Asciz <clinit>;
const #12 = Asciz SourceFile;
const #13 = Asciz Test.java;
const #14 = NameAndType #7:#8;// "<init>":()V
const #15 = NameAndType #5:#6;// _i:I
const #16 = Asciz Test;
const #17 = Asciz java/lang/Object;

{
public static int _i;

public Test();
Code:
Stack=1, Locals=1, Args_size=1
0: aload_0
1: invokespecial #1; //Method java/lang/Object."<init>":()V
4: return
LineNumberTable:
line 2: 0

static {};
Code:
Stack=1, Locals=0, Args_size=0
0: bipush 10
2: putstatic #2; //Field _i:I
5: return
LineNumberTable:
line 3: 0

}

我們看到，常量池中const #2指向的就是Test._i，也就是靜態變數。靜態變數被保存到常量池中的工作原理這里不深入討論。在此需要注意的是：

* 靜態變數的聲明與初始化是兩個不同的操作；
* 靜態變數的聲明在編譯時已經明確了內存的位置。

如：

1. public class Test {
2. public static int _i = 10;
3. }

public class Test { public static int _i = 10; }

上述代碼的本質可以視為：

1. public class Test {
2. // 靜態變數的聲明
3. public static int _i;
4.
5. // 靜態變數的初始化
6. static {
7. _i = 10;
8. }
9. }

public class Test { // 靜態變數的聲明 public static int _i; // 靜態變數的初始化 static { _i = 10; } }

由於靜態變數的聲明在編譯時已經明確，所以靜態變數的聲明與初始化在編碼順序上可以顛倒。也就是說可以先編寫初始化的代碼，再編寫聲明代碼。如：

1. public class Test {
2. // 靜態變數的初始化
3. static {
4. _i = 10;
5. }
6.
7. // 靜態變數的聲明
8. public static int _i;
9. }

public class Test { // 靜態變數的初始化 static { _i = 10; } // 靜態變數的聲明 public static int _i; }

對初始問題的解答

解答了上述三個問題，讓我們再來看看開篇提到的問題。代碼如下：

1. public class Test {
2. static {
3. _i = 20;
4. }
5. public static int _i = 10;
6.
7. public static void main(String[] args) {
8. System.out.println(_i);
9. }
10. }

public class Test { static { _i = 20; } public static int _i = 10; public static void main(String[] args) { System.out.println(_i); } }

其本質可以用下面的代碼表示：

1. public class Test {
2. static {
3. _i = 20;
4. }
5. public static int _i;
6. static {
7. _i = 10;
8. }
9.
10. public static void main(String[] args) {
11. System.out.println(_i);
12. }
13. }

public class Test { static { _i = 20; } public static int _i; static { _i = 10; } public static void main(String[] args) { System.out.println(_i); } }

再簡化一下，可以表示為：

1. public class Test {
2. public static int _i;
3.
4. static {
5. _i = 20;
6. _i = 10;
7. }
8.
9. public static void main(String[] args) {
10. System.out.println(_i);
11. }
12. }

public class Test { public static int _i; static { _i = 20; _i = 10; } public static void main(String[] args) { System.out.println(_i); } }

至此，代碼已經明確告訴我們列印結果是什麼了！

Ⅳ java如何聲明字元串類型

使用「String」可以聲明字元串類型
如：String str = "你好嗎";

Ⅳ java數組怎麼聲明

1. java中定義一個字元串數組方式如下，string類型和其他基本類型相似，創建數組有兩種方式：
String[] str={"AAA","BBB","CCC"};
String str[]={"AAA","BBB","CCC"};

2.推薦用ArrayList<String> strArray = new ArrayList<String> (); 比較靈活。

3.也可以寫為如下格式：class[] array; array = new class[number];其中前半句為聲明，後半句空宏廳為初始化，初始化必須要讓編譯器知道大小，聲明的斗隱時候java是不分配內存的，只有創建的時候也就是new的時候才會分配內存。

(5)java中怎麼聲明擴展閱讀：

1.數組是相同數據類型的元素的集合。

2.數組中的各元素的存儲是有先後順序的，它們在內存中按照這絕扮個先後順序連續存放在一起。

3.數組元素用整個數組的名字和它自己在數組中的順序位置來表示。例如，a[0]表示名字為a的數組中的第一個元素，a[1]代表數組a的第二個元素，以此類推。

4.對於VB的數組，表示數組元素時應注意：下標要緊跟在數組名後，而且用圓括弧括起來（不能用其他括弧）。下標可以是常量，變數，或表達式，但其值必須是整數。下標必須為一段連續的整數，其最小值成為下界，其最大值成為上界。不加說明時下界值默認為1。

Ⅵ JAVA怎麼聲明一個數組

聲明一個字元串數組，其中初始化了4個字元串
String[] strs = new String[]{"abc","sss","sdd","dsf"};
聲明一個整形數組，數組長度為3
int[] nums = new int[3];