java中定义变量有哪两种方式

1、实例变量 (非静态字段) 从技术上来说, 对象保存它们各自的状态在 "非静态字段", 也即, 没有使用static 关键字定义的字段. 非静态字段也称为 实例变量 因为它们的值对每个 类 实例 (对每个对象, 换句话说); 一个自行车的currentSpeed 与另外一个自行车的currentSpeed 是独立的.

天全网站建设公司成都创新互联公司,天全网站设计制作，有大型网站制作公司丰富经验。已为天全上千家提供企业网站建设服务。企业网站搭建\外贸营销网站建设要多少钱，请找那个售后服务好的天全做网站的公司定做！

2、类变量 (静态字段)类变量是使用static 修饰符声明的变量;这告诉编译器仅有一份该变量存在, 无论该类被实例化多少个对象。为 某种类型的自行车定义gear数量的字段可以标记为static 因为所有实例有相同数. 代码static int numGears = 6; 将创建一个这样的静态字段. 此外, 可以添加关键字final 来表明转动装置个数永远不发生改变 .

java声明变量

类型 变量名[=初值] [,变量名[=初值]......。

string s="",b=""; 中间，表示连续申明变量，都是最前面的类型。

java 如何定义字符串变量

一、定义字符串

直接定义字符串是指使用双引号表示字符串中的内容，例如"Hello Java"、"Java 编程"等。具体方

法是用字符串常量直接初始化一个 String 对象，示例如下：

String str="Hello Java";     String str;     str="Heilo Java";

二、用 String 类定义

1. String() 初始化一个新创建的 String 对象，表示一个空字符序列。

2. String(String original)

初始化一个新创建的 String 对象，使其表示一个与参数相同的字符序列。换句话说，新创建的字符串是该参数字符串的副本。

例如：

String str1=new String("Hello Java");

String str2=new String(str1);

3、String(char[ ]value)

分配一个新的字符串，将参数中的字符数组元素全部变为字符串。该字符数组的内容已被复制，后

续对字符数组的修改不会影响新创建的字符串。

例如：

char a[]={'H','e','l','l','0'};

String sChar=new String(a);a[1]='s';

4、String(char[] value,int offset,int count)

分配一个新的 String，它包含来自该字符数组参数一个子数组的字符。offset 参数是子数组第一个字符的索引，count 参数指定子数组的长度。

该子数组的内容已被赋值，后续对字符数组的修改不会影响新创建的字符串。

例如：

char a[]={'H','e','l','l','o'};

String sChar=new String(a,1,4);

a[1]='s';

扩展资料：

编程工具：

Eclipse：一个开放源代码的、基于Java的可扩展开发平台 。

NetBeans：开放源码的Java集成开发环境，适用于各种客户机和Web应用。

IntelliJ IDEA：在代码自动提示、代码分析等方面的具有很好的功能。

MyEclipse：由Genuitec公司开发的一款商业化软件，是应用比较广泛的Java应用程序集成开发环境   。

EditPlus：如果正确配置Java的编译器“Javac”以及解释器“Java”后，可直接使用EditPlus编译执行Java程序   。

参考资料：百度百科-java

Java怎么使用synchronized声明一个变量？

首先要说明的是，java里不能直接使用synchronized声明一个变量，而是使用synchronized去修饰一个代码块或一个方法。\x0d\x0a\x0d\x0a详细说明如下：\x0d\x0a\x0d\x0a synchronized用来修饰一个方法或者一个代码块，它用来保证在同一时刻最多只有一个线程执行该段代码。\x0d\x0a 一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。\x0d\x0a 二、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。\x0d\x0a 三、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。\x0d\x0a 四、第三个例子同样适用其它同步代码块。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。\x0d\x0a 五、以上规则对其它对象锁同样适用。\x0d\x0a\x0d\x0a示例代码：\x0d\x0apublic class Thread1 implements Runnable { \x0d\x0a public void run() { \x0d\x0a synchronized(this) { \x0d\x0a for (int i = 0; i

回答于 2022-11-16

java 循环内声明变量

这个String只是个局部变量，本次循环结束后就会失去引用，占用的空间一段时间后会被自动回收

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声明变量代码,java变量声明的基本语法
文章转载：http://hbruida.cn/article/heejph.html