黑马程序员技术交流社区

标题: 【厦门JavaEE基础6期-每日总结】String类、static、Arrays类、Math类 [打印本页]

作者: 厦门校区 时间: 2019-3-8 17:23
标题: 【厦门JavaEE基础6期-每日总结】String类、static、Arrays类、Math类
1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？

2.什么情况下会用到Static关键字？

3.静态代码块会在什么时候执行？

4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？

作者: 陈伟彬 时间: 2019-3-8 19:52
本帖最后由陈伟彬于 2019-3-8 21:25 编辑

1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？
答：
      引用数据类型；
   原因：字符串底层是char数组，而数组在创建之初长度就是固定的，因此字符串的长度是不可变；
2.什么情况下会用到Static关键字？
答
      当某一类下的每个对象都有一个相同变量时，则可以使用Static将其从属于对象变成属于类使其成为同一类下所有对象的共享；
3.静态代码块会在什么时候执行？
答：
      在首次使用含代码块的类时，代码块会执行唯一一次
4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？
答：
   如果两个不是在同一个类中：
            String s = new String("abc")：创建两个对象；
                  “abc”放在方法区常量池中；new String 放在堆中；
            String s = "abc"：创建一个对象；
                     "abc"放在方法区常量池中；
      如果两个在同一个类中：
            String s = new String("abc")  先写的话：
                     String s = new String("abc")：创建两个对象；
                     String s = "abc"：没有创建对象；
            String s = "abc"  先写的话：
                     String s = new String("abc")：创建一个对象；
                     String s = "abc"：创建一个对象；

作者: 王冠琦 时间: 2019-3-8 20:10
1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？
引用数据类型。
字符串池在方法区（Method Area）中是一种特殊的存储区域。
当创建一个字符串时，如果字符串已经存在于池中，现有字符串的引用将被退回，而不是创建一个新的对象并返回其引用。
如果字符串可变，那么在这些模块中，将会引发严重的安全性问题。
不可变的对象不能被改变，他们可以在多个线程中共享，就不需要使用线程的同步操作。

2.什么情况下会用到Static关键字？
static 关键字，它可以用来修饰的成员变量和成员方法，被修饰的成员是属于类的，而不是单单是属
于某个对象的，这种情况下就可以用到static。

3.静态代码块会在什么时候执行？
随着类的加载而执行且执行一次，优先于main方法和构造方法的执行。

4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？
String s = new String("abc");
在运行 new String()时，把文字池即pool中的字符串"abc"复制到堆中，并把这个对象的应用交给s，所以创建了两个String对象，一个在pool 中，一个在堆中。

String s = "abc"
会保存在方法区的字符串常量池中，首先检查字符串常量池中是否存在"abc"对象，
如果存在，直接返回指向"abc"对象的指针，不存在就会在字符串常量池中创建一个"abc"，然后返回指针。

作者: 郑海波 时间: 2019-3-8 20:42
1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？
String是引用数据类型；对一个String变量重新赋值或者添加字符，相当于生成了一个新的字符串，原本的字符串还在常量池，不会发生变化（此时这个字符串是一个常量），因此字符串的长度是不变的。
2.什么情况下会用到Static关键字？
当一个类的对象存在同一种变量时，就可以用static关键字去修饰，当这个类一运行就会生成这个变量，应用于所有对象。

3.静态代码块会在什么时候执行？
静态代码块会在第一次用到该类时执行，并且只会执行这一次，后面重新用到这个类也不会重复执行。

4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？
String s = new String("abc");这句代码创建了3个对象，在栈内存中建立了一个String s，在堆内存中新建了一个new String，在堆内存的常量池生成一个abc；
String s = "abc";这句代码创建了2个对象，在栈内存中建立了一个String s，在堆内存的常量池生成一个abc。

作者: 王冠琦 时间: 2019-3-8 20:47
1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？
引用数据类型。
字符串池在方法区（Method Area）中是一种特殊的存储区域。
当创建一个字符串时，如果字符串已经存在于池中，现有字符串的引用将被退回，而不是创建一个新的对象并返回其引用。
下面的代码将在堆中只会创建一个字符串对象。
如果字符串可变，那么在这些模块中，将会引发严重的安全性问题。
不可变的对象不能被改变，他们可以在多个线程中共享，就不需要使用线程的同步操作。

2.什么情况下会用到Static关键字？
static 关键字，它可以用来修饰的成员变量和成员方法，被修饰的成员是属于类的，而不是单单是属
于某个对象的，这种情况下就可以用到static

3.静态代码块会在什么时候执行？
随着类的加载而执行且执行一次，优先于main方法和构造方法的执行。

4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？
String s = new String("abc");
在运行 new String()时，把文字池即pool中的字符串"abc"复制到堆中，并把这个对象的应用交给s，所以创建了两个String对象，一个在pool 中，一个在堆中。

String s = "abc"
会保存在方法区的字符串常量池中，首先检查字符串常量池中是否存在"abc"对象，
如果存在，直接返回指向"abc"对象的指针，不存在就会在字符串常量池中创建一个"abc"，然后返回指针。

作者: 黑马6期陈华 时间: 2019-3-8 20:59
本帖最后由黑马6期陈华于 2019-3-8 21:01 编辑

1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？
（1）String类是引用数据类型。
（2）因为String类的对象是字符串常量，常量一旦被创建，其内容在程序运行期间就永不可变。
2.什么情况下会用到Static关键字？
（1）用来修饰成员变量：使所有本类的对象都共享同一份静态变量的数据。
（2）用来修饰成员方法：使方法可以通过类名直接调用而不需要创建对象。
（3）静态代码块：当需要初始化某个类，给静态变量赋值的时候。
3.静态代码块会在什么时候执行？
当第一次用到本类时，会【唯一一次地】执行静态代码块。
4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？
（1）String s = new String("abc");这句代码创建了3个对象，String s在栈内存中被创建，在堆内存中创建了new String对象，在堆中的字符串常量池中创建了“abc”。
（2）String s = "abc";这句代码创建了2个对象，String s在栈内存中被创建，在堆中的字符串常量池中创建了“abc”。

作者: 高坂火龙果 时间: 2019-3-8 21:01

1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？
String是引用数据类型；对一个String变量重新赋值或者添加字符，相当于生成了一个新的字符串，原本的字符串还在常量池，不会发生变化（此时这个字符串是一个常量），因此字符串的长度是不变的。

2.什么情况下会用到Static关键字？
当一个类的对象存在同一种变量时，就可以用static关键字去修饰，当这个类一运行就会生成这个变量，应用于所有对象。

3.静态代码块会在什么时候执行？
静态代码块会在第一次用到该类时执行，并且只会执行这一次，后面重新用到这个类也不会重复执行。

4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？
String s = new String("abc");创建了3个对象，在栈内存中建立了一个String s，在堆内存中新建了一个new String，在堆内存的常量池生成一个abc；
String s = "abc";创建了2个对象，在栈内存中建立了一个String s，在堆内存的常量池生成一个abc。

作者: 龚荣章 时间: 2019-3-8 21:09
1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？
String是引用数据类型；对一个String变量重新赋值或者添加字符，相当于生成了一个新的字符串，原本的字符串还在常量池，不会发生变化（此时这个字符串是一个常量），因此字符串的长度是不变的。
2.什么情况下会用到Static关键字？
当一个类的对象存在同一种变量时，就可以用static关键字去修饰，当这个类一运行就会生成这个变量，应用于所有对象。

3.静态代码块会在什么时候执行？
静态代码块会在第一次用到该类时执行，并且只会执行这一次，后面重新用到这个类也不会重复执行。

4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？
String s = new String("abc");这句代码创建了3个对象，在栈内存中建立了一个String s，在堆内存中新建了一个new String，在堆内存的常量池生成一个abc；
String s = "abc";这句代码创建了2个对象，在栈内存中建立了一个String s，在堆内存的常量池生成一个abc。

作者: 陈志铖 时间: 2019-3-8 21:12
1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？
引用数据类型
字符串是常量,运行期间不会改变
2.什么情况下会用到Static关键字？
当某一类下的每个对象都有一个相同变量时，则可以使用Static将其从属于对象变成属于类使其成为同一类下所有对象的共享；
3.静态代码块会在什么时候执行？
当某一类下的每个对象都有一个相同变量时，则可以使用Static将其从属于对象变成属于类使其成为同一类下所有对象的共享；
4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？
String s = new String("abc");这句代码创建了3个对象，在栈内存中建立了一个String s，在堆内存中新建了一个new String()，在堆内存的常量池生成一个abc；
String s = "abc"创建了两个,在栈内存中建立了一个String s,在堆内存的常量池生成一个abc；

作者: 李伟艺 时间: 2019-3-8 21:13
1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？
是引用类型。
因为String类的底层是一个char类型数组，数组在创建后，长度不可变

2.什么情况下会用到Static关键字？
创建静态变量和静态方法的时候

3.静态代码块会在什么时候执行？
会再第一次使用类的时候，并且只会执行一次

4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？

.String s = new String("abc");创建的两个对象再一个在堆中，一个在字符串常量池中
String s = "abc"；创建了一个对象，实在字符串常量区中。

作者: 叶彬彬 时间: 2019-3-8 21:16
1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？
引用数据类型；因为字符串是常量，常量在程序运行期间不可改变

2.什么情况下会用到Static关键字？
当每一个对象都共享一个属性时，这个属性可以用Static关键字修饰。被Static修饰的属性就不仅仅属于对象，而属于类

3.静态代码块会在什么时候执行？
在第一次使用到本类时，会执行一次，而且只执行一次，执行优先度比其他的构造方法高

4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？
String s = new String("abc")：
创建2个对象；
在栈中创建了一个变量名为s的字符串对象；
在堆里创建了内容为“abc”的对象，不在常量池中
String s = "abc"：
创建2个对象；
在栈中创建了一个变量名为s的字符串对象；
在堆中的字符串常量池里创建一个字符串对象内容为“abc”

作者: 厦门第六期刘鹏 时间: 2019-3-8 21:27
1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？引用数据类型字符串是常量常量在运行期间不可改变

2.什么情况下会用到Static关键字？当每一个对象都共享一个属性时，这个属性可以用Static关键字修饰。

3.静态代码块会在什么时候执行？第一次使用类的时候

4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？两个对象字符串常量池跟堆中

作者: 王冠琦 时间: 2019-3-8 21:28
1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？
引用数据类型。
字符串池在方法区（Method Area）中是一种特殊的存储区域。
当创建一个字符串时，如果字符串已经存在于池中，现有字符串的引用将被退回，
而不是创建一个新的对象并返回其引用。
下面的代码将在堆中只会创建一个字符串对象。
如果字符串可变，那么在这些模块中，将会引发严重的安全性问题。
不可变的对象不能被改变，他们可以在多个线程中共享，就不需要使用线程的同步操作。

2.什么情况下会用到Static关键字？
static 关键字，它可以用来修饰的成员变量和成员方法，被修饰的成员是属于类的，而不是单单是属
于某个对象的，这种情况下就可以用到static

3.静态代码块会在什么时候执行？
随着类的加载而执行且执行一次，优先于main方法和构造方法的执行。

4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？
String s = new String("abc");
在运行 new String()时，把文字池即pool中的字符串"abc"复制到堆中，并把这个对象的应用交给s，
所以创建了两个String对象，一个在pool 中，一个在堆中。

String s = "abc"
会保存在方法区的字符串常量池中，首先检查字符串常量池中是否存在"abc"对象，
如果存在，直接返回指向"abc"对象的指针，不存在就会在字符串常量池中创建一个"abc"，然后返回指针。

作者: LPY 时间: 2019-3-8 21:28

1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？
引用数据类型；因为字符串是常量，常量在程序运行期间不可改变

2.什么情况下会用到Static关键字？
当每一个对象都共享一个属性时，这个属性可以用Static关键字修饰。被Static修饰的属性就不仅仅属于对象，而属于类

3.静态代码块会在什么时候执行？
在第一次使用到本类时，会执行一次，而且只执行一次，执行优先度比其他的构造方法高

4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？
String s = new String("abc")：
创建2个对象；
在栈中创建了一个变量名为s的字符串对象；
在堆里创建了内容为“abc”的对象，不在常量池中
String s = "abc"：
创建2个对象；
在栈中创建了一个变量名为s的字符串对象；
在堆中的字符串常量池里创建一个字符串对象内容为“abc”

作者: 廖艺铭 时间: 2019-3-8 21:29
1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？
引用数据类型；
因为字符串的值在创建后不能被更改
2.什么情况下会用到Static关键字？
static可以用来修饰的成员变量和成员方法，被修饰的成员是属于类的；
当该类的每个对象需要共享同一个成员属性的值时，可以用static修饰
3.静态代码块会在什么时候执行？
在该类及其子类第一次加载时执行且执行一次
4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？
String s = new String("abc");创建一个对象
栈中为s开辟空间，大小为一个句柄大小或者说地址大小，指向堆中对象
堆中而不在常量池中，开一个句柄大小的空间，指向堆中一个字节数组
堆中开辟一个字节数组空间

String s = "abc";创建一个对象
栈中为s开辟空间，大小为一个句柄大小或者说地址大小，指向堆中的常量池中对象
堆中的常量池中，开一个句柄大小的空间，指向堆中一个字节数组
堆中开辟一个字节数组空间

作者: 陈鉴 时间: 2019-3-8 21:34
1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？
引用数据类型；因为字符串是常量，常量在程序运行期间不可改变

2.什么情况下会用到Static关键字？
当每一个对象都共享一个属性时，这个属性可以用Static关键字修饰。被Static修饰的属性就不仅仅属于对象，而属于类

3.静态代码块会在什么时候执行？
在第一次使用到本类时，会执行一次，而且只执行一次，执行优先度比其他的构造方法高

4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？
String s = new String("abc")：
创建2个对象；
在栈中创建了一个变量名为s的字符串对象；
在堆里创建了内容为“abc”的对象，不在常量池中
String s = "abc"：
创建2个对象；
在栈中创建了一个变量名为s的字符串对象；
在堆中的字符串常量池里创建一个字符串对象内容为“abc”

作者: 黑马六期-董安平 时间: 2019-3-8 21:36
1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？
答：String类是引用数据类型。
因为字符串是常量，内容永不可不变。

2.什么情况下会用到Static关键字？
答：
（1）用来修饰成员变量：使所有本类的对象都共享同一份静态变量的数据。
（2）用来修饰成员方法：使方法可以通过类名直接调用而不需要创建对象。
（3）静态代码块：当需要初始化某个类，给静态变量赋值的时候。

3.静态代码块会在什么时候执行？
答：当第一次用到本类时，静态代码块执行唯一的一次。

4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？
答：
（1）创建了三个对象，分别存在于：String s 在栈内存中创建，new String在堆内存中被创建，
堆中的字符串常量池中创建了"abc"
（2）创建了两个对象，String s 在栈内存中创建，堆中的字符串常量池中创建了"abc"

作者: 李智梁 时间: 2019-3-8 21:38
1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？
（1）String类是引用类型数据。
（2）字符串底层是char数组，而数组在创建之初长度就是固定的，因此字符串的长度是不可变得。
2.什么情况下会用到Static关键字？
（1）用来修饰成员变量：使所有本类的对象都共享同一份静态变量的数据。
（2）用来修饰成员方法：使方法可以通过类名直接调用而不需要创建对象。
（3）静态代码块：当需要初始化某个类，给静态变量赋值的时候。
3.静态代码块会在什么时候执行？
答：静态代码块会在第一次用到静态代码块所在类的时候，执行唯一的一次。
4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
   String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？
(1)String s = new String("abc");这句代码创建了3个对象，
   a.在栈内存中建立了一个String s，
   b.在堆内存中新建了一个new String，
   c.在堆内存的常量池生成一个abc；
(2)String s = "abc";这句代码创建了2个对象，
   a.在栈内存中建立了一个String s，
   b.在堆内存的常量池生成一个abc。

作者: 王旭艺 时间: 2019-3-8 21:40
1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？
String类是引用数据类型。字符串的内容创建后是不可变，所以长度也不可变。

2.什么情况下会用到Static关键字？

static 关键字的使用，它可以用来修饰的成员变量和成员方法，被修饰的成员是属于

类的，而不是单单是属于某个对象的。也就是说，既然属于类，就可以不靠创建对象来调用

了。
3.静态代码块会在什么时候执行？
当第一次用到本类时，静态代码块执行唯一的一次

4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创

建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？
String s = new String("abc");创建了3个对象，在栈内存中建立了一个String s，在

堆内存中新建了一个new String，在堆内存的常量池生成一个abc；
String s = "abc";创建了2个对象，在栈内存中建立了一个String s，在堆内存的常量池生

成一个abc。

作者: javawjs 时间: 2019-3-8 21:40
王佳盛

1. String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？
答：String类是引用数据类型；字符串是一个常量，常量在程序运行中不可被改变，所以字符串长度不可改变。

2. 什么情况下会用到Static关键字？
答：当一个属性属于类而不属于对象时，就可以用到Static关键字。例如一个学生类中的班级属性，它应该是属于类的，而不属于对象。这样班级的属性就可以用Static关键字修饰；
3. 静态代码块会在什么时候执行？
答：当第一次用到类时，静态代码块会执行唯一一次；并且会先于构造方法执行

4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？
答：
（1） String s = new String("abc");创建了两个对象，一个是对象时s，存在于堆内存中；还有一个对象是“abc”存在于方法区中的字符串常量池中。
（2） String s = "abc";只创建了一个对象，存在于字符串常量池中

作者: 余建强 时间: 2019-3-8 21:41
1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？
String是引用数据类型,因为字符串是一个常量,所以字符串的长度不可改变
2.什么情况下会用到Static关键字？
需要共享方法共享变量,代码块只需要创建一次的时候
3.静态代码块会在什么时候执行？
类被调用的时候
4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？
String s = new String("abc");创建了两次,堆内存和方法区域,
String s = "abc";创建了一次,在栈内存创建

作者: 李煜霖 时间: 2019-3-8 21:41
1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？
答：
      引用数据类型；
   原因：字符串底层是char数组，而数组在创建之初长度就是固定的，因此字符串的长度是不可变；
2.什么情况下会用到Static关键字？
答
      当某一类下的每个对象都有一个相同变量时，则可以使用Static将其从属于对象变成属于类使其成为同一类下所有对象的共享；
3.静态代码块会在什么时候执行？
答：
      在首次使用含代码块的类时，代码块会执行唯一一次
4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？
答：
   如果两个不是在同一个类中：
            String s = new String("abc")：创建两个对象；
                  “abc”放在方法区常量池中；new String 放在堆中；
            String s = "abc"：创建一个对象；
                     "abc"放在方法区常量池中；
      如果两个在同一个类中：
            String s = new String("abc")  先写的话：
                     String s = new String("abc")：创建两个对象；
                     String s = "abc"：没有创建对象；
            String s = "abc"  先写的话：
                     String s = new String("abc")：创建一个对象；
                     String s = "abc"：创建一个对象；

作者: java基础6期刘伟 时间: 2019-3-8 21:42
1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？
引用数据类型，字符串是一个常量，字符串底层是char数组，而数组在创建之初长度就是固定的，因此字符串的长度是不可变；
2.什么情况下会用到Static关键字？
当 static 修饰成员变量时，该变量称为类变量。该类的每个对象都共享同一个类变量的值。任何对象都可以更改该类变量的值，但也可以在不创建该类的对象的情况下对类变量进行操作。

3.静态代码块会在什么时候执行？
静态代码块会在第一次用到该类时执行，并且只会执行这一次，后面重新用到这个类也不会重复执行。

4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？
String s = new String("abc");这句代码创建了3个对象，在栈内存中建立了一个String s，在堆内存中新建了一个new String，在堆内存的常量池生成一个abc；
String s = "abc";这句代码创建了2个对象，在栈内存中建立了一个String s，在堆内存的常量池生成一个abc。

作者: 罗加铭 时间: 2019-3-8 21:44
1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？
答：String是引用数据类型；字符串池在方法区）中是一种特殊的存储区域。当创建一个字符串时，如果字符串已经存在于池中，现有字符串的引用将被退回，而不是创建一个新的对象并返回其引用
2.什么情况下会用到Static关键字？
答：在没有创建对象的情况下来进行调用
3.静态代码块会在什么时候执行？
答：随着类的加载而执行且执行一次，优先于main方法和构造方法的执行
4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？
答：String s = new String("abc")创建两个对象，分别存在栈和符串常量池中；String s = "abc"创建一个对象，存在字符串常量池中

作者: 6期江岳 时间: 2019-3-8 21:45
1、String是引用类型，因为String类型一旦被创建就在堆内存内开辟了一个空间，程序运行期间不可改变。
2、当创建的对象里在对应的类里都有一个共同的属性就可以用static进行修饰。
3、静态代码块会在第一次用到该类时执行，并且只会执行这一次。后面再次使用该类就不会出现。
4、2个对象，new String（）在堆内存内被创建，“abc”在堆内存被创建。

作者: zhaizhile 时间: 2019-3-8 21:46
1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？
引用数据类型
字符串是常量，常量在程序运行期间不可改变

2.什么情况下会用到Static关键字？
当每一个对象都共享一个属性时，这个属性可以用Static关键字修饰。被Static修饰的属性就不仅仅属于对象，而属于类

3.静态代码块会在什么时候执行？
在第一次使用到本类时，会执行一次，而且只执行一次，执行优先度比其他的构造方法高
4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？

String s = new String("abc");创建的两个对象一个在堆中，一个在字符串常量池中
String s = "abc"；创建了一个对象，在字符串常量区中。

作者: 开心的小孩 时间: 2019-3-8 21:46
陈鹏涛
1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？
   是引用数据类型，字符串是常量
2.什么情况下会用到Static关键字？
修饰成员变量的情况
修饰成员方法的情况
3.静态代码块会在什么时候执行？
定义在成员位置，使用static修饰的代码块{ }。
位置：类中方法外。执行：随着类的加载而执行且执行一次，
优先于main方法和构造方法的执行。

4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建两个对象；
                     String s = new String("abc")放在栈中；
                     new String("abc")放在堆中；
      String s = "abc"：
            一个对象；
                     放在栈中；

作者: 陈前凌 时间: 2019-3-8 21:48
1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？
String是引用数据类型
因为字符串的底层构造是byte[]数组，不能改变长度

2.什么情况下会用到Static关键字？
当信息不是某个对象特有的，而是属于类的，用Static

3.静态代码块会在什么时候执行？
当第一次用到代码块中的类的时候，代码块执行唯一的一次

4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？
1.创建了两个对象，分别在堆中的字符串常量池和堆中创建对象
2.一个对象，在字符串常量池中创建。

作者: 陈驰煜 时间: 2019-3-8 21:48
1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？
是引用数据类型, 因为字符串底层是一个char数组, 数组长度不可变

2.什么情况下会用到Static关键字？
当需要一个可以共享与所有对象的变量或方法时

3.静态代码块会在什么时候执行？
在使用类时, 在构造方法执行之前

4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？
a.创建了2个对象, 分别在方法区和堆内存中创建,
b.创建了1个对象,在方法区中创建

作者: 卢勇炜 时间: 2019-3-8 21:49

1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？
答：String类是引用数据类型，字符串是一个常量，字符串底层是char数组，而数组在创建之初长度就是固定的，因此字符串的长度是不可变
2.什么情况下会用到Static关键字？
答：当一个属性属于类而不属于对象时，就可以用到Static关键字。例如一个学生类中的班级属性，它应该是属于类的，而不属于对象。这样班级的属性就可以用Static关键字修饰。
3.静态代码块会在什么时候执行？
答：当第一次用到本类时，静态代码块执行唯一的一次。
4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？
答：String s = new String("abc");这句代码创建了3个对象，在栈内存中建立了一个String s，然后在堆内存中新建了一个new String，以及在堆内存的常量池生成一个abc；
String s = "abc";这句代码创建了2个对象，第一是在栈内存中建立了一个String s，第二个对象是在堆内存的常量池生成一个abc。

作者: 曾伟清 时间: 2019-3-8 21:49
1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？
答：String类是引用数据类型。字符串最底层是byte数组，而数组在创建的时候长度就是固定的，因此字符串的长度不可变；
2.什么情况下会用到Static关键字？
答：static 关键字，可以修饰变量、方法和代码块。当每个对象都共享同一个变量的值，就可以修饰变量；当想让代码块优先于main方法和构造方法的执行，也可以用static修饰；在使用的过程中，其主要目的还是想在不创建对象的情况
下，去调用方法；
3.静态代码块会在什么时候执行？
答：静态代码块随着类的加载而执行且执行一次，优先于main方法和构造方法的执行。
4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？
String s = new String("abc")：创建了两个；new String("abc")创建在堆中，"abc"创建在堆中的常量池。
String s = "abc";创建了一个：在堆中的常量池。

作者: 刘曾铭 时间: 2019-3-8 21:50
1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？
（1）String类是引用数据类型。
（2）因为字符串是一个常量，一旦创建完成，常量是不可改变的，所以字符串的长度不可变。

2.什么情况下会用到Static关键字？
当用Static关键字修饰时候，可以用来修饰成员变量或者成员方法。而这个时候这个变量或者方法就不单单
属于创建对象而是属于这个类。所有与这类有关可以共享这个变量或者方法。可以通过直接类名称点上修饰的
变量或者方法。

3.静态代码块会在什么时候执行？
当我们在调用静态代码块的这个类时，静态代码块有且仅仅执行一次。

4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？
（1）创建了两个个对象，分别存在于：，new String在堆内存中被创建，
堆中的字符串常量池中创建了"abc"
（2）创建了两个对象，String s 在栈内存中创建，堆中的字符串常量池中创建了"abc"

作者: 林艺彬 时间: 2019-3-8 21:53
1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？
String类是引用数据类型。因为对一个String变量重新赋值或者添加字符，相当于生成了一个新的字符串，原本的字符串还在常量池，不会发生变化。
2.什么情况下会用到Static关键字？
当某一类下的每个对象都有一个相同变量时，则可以使用Static将其从属于对象变成属于类使其成为同一类下所有对象的共享；
3.静态代码块会在什么时候执行？

当第一次用到本类时，静态代码块执行唯一的一次。
4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？
String s = new String("abc")：创建2个对象；在栈中创建了一个变量名为s的字符串对象；在堆里创建了内容为“abc”的对象，不在常量池中，
String s = "abc"：创建2个对象；在栈中创建了一个变量名为s的字符串对象；在堆中的字符串常量池里创建一个字符串对象内容为“abc”。

作者: 陈弘帅 时间: 2019-3-8 21:53

1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？
      引用数据类型；
      因为字符串的值在创建后不能被更改
2.什么情况下会用到Static关键字？
      static可以用来修饰的成员变量和成员方法，被修饰的成员是属于类的；
      当该类的每个对象需要共享同一个成员属性的值时，可以用static修饰
3.静态代码块会在什么时候执行？
      在该类及其子类第一次加载时执行且执行一次
4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？
      String s = new String("abc");创建一个对象
      栈中为s开辟空间，大小为一个句柄大小或者说地址大小，指向堆中对象
      堆中而不在常量池中，开一个句柄大小的空间，指向堆中一个字节数组
      堆中开辟一个字节数组空间

      String s = "abc";创建一个对象
      栈中为s开辟空间，大小为一个句柄大小或者说地址大小，指向堆中的常量池中对象
      堆中的常量池中，开一个句柄大小的空间，指向堆中一个字节数组
      堆中开辟一个字节数组空间。

作者: 林志鹏 时间: 2019-3-8 21:54
1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？
String类是引用数据类型，因为字符串是常量；字符串的内容永不可变，字符串效果上相当于是char[]字符数组，数组的长度是不可变的。

2.什么情况下会用到Static关键字？
当想用的静态方法不属于对象而是属于类的时候会用到。需要共享变量或者共享方法的时候会用到

3.静态代码块会在什么时候执行？
静态代码块会在调用本类的时候执行，也只能执行唯一的一次。而且静态代码块会比构造更早执行

4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？
（1）String s = new String("abc");这句代码创建了2个对象，一个对象String s存在栈内存中，
一个字符常量"abc"存在字符串常量方法中在堆中。
（2） String s = "abc";创建了1个对象，存在堆内存中的字符串常量方法中。

作者: 魏政 时间: 2019-3-8 21:55
1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？
String类是引用数据类型；
因为字符串的长度在创建后不能被更改。
2.什么情况下会用到Static关键字？
static可以用来修饰成员变量和成员方法，被修饰的成员是属于类的，而不是单单是属于某个对象的。也就是说，既然属于类，就可以不用创建对象来。

3.静态代码块会在什么时候执行？
静态代码随着类的加载而执行且执行一次，优先于main方法和构造方法的执行。

4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？

String s = new String("abc");这句代码创建了3个对象，在栈内存中建立了一个String s，在堆内存中新建了一个new String，在堆内存的常量池生成一个abc；
String s = "abc";这句代码创建了2个对象，在栈内存中建立了一个String s，在堆内存的常量池生成一个abc。

作者: 蓝建华 时间: 2019-3-8 21:57

1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？

答：是引用数据类型，字符串的底层是byte类型的数组，因此其长度不可变。

2.什么情况下会用到Static关键字？

答：在不创建对象的情况下想去调用方法，可以直接用类名.方法名或者变量名，或者需要对对类中的数据进行初始化的时候可以用到

3.静态代码块会在什么时候执行？

答：随着类的加载而执行且执行一次，优先于main方法和构造方法的执行。

4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？

答：(1)String s = new String("abc");这句代码创建了3个对象，
         1.在栈内存中建立了一个String s，
         2.在堆内存中新建了一个new String，
         3.在堆内存的常量池生成一个abc；
   (2)String s = "abc";这句代码创建了2个对象，
         1.在栈内存中建立了一个String s，
         3.在堆内存的常量池生成一个abc。

作者: 黄成龙 时间: 2019-3-8 21:58
1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？

String类是引用数据类型，字符串封装的源码底层是采用byte数组去存储每个字符，根据字符串的长度创建对应的byte数组去存储，所以它的长度是不可变。

2.什么情况下会用到Static关键字？

当多个对象的成员属性统一时，可以用Static修饰去共享同一个成员属性，避免创建对象时要多次的进行属性设置。在main方法的类中，由于main方法是用Static修饰， main方法中调用的方法也都必须是用Static修饰才可以访问或调用。

3.静态代码块会在什么时候执行？

静态代码会随着静态代码块所属的类加载而执行，优先于对象的创建，但只执行唯一一次。

4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？

String s = new String("abc")创建了两个字符串，双引号是在堆内存中字符串常量池创建，new是在堆内存中创建。
String s = "abc"创建了一个，在堆内存中的字符串的常量池中。

作者: 黄振明 时间: 2019-3-8 21:59
1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？
是引用数据类型。
因为字符串是常数

2.什么情况下会用到Static关键字？
当一个类的对象存在同一种变量时，可以用static关键字修饰

3.静态代码块会在什么时候执行？
会在第一次用到该类执行，且只执行一次，并优先于构造方法执行

4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？
String s = new String("abc")这句话创建了三个对象
一个在栈内存中生成、一个在内存的堆中创建、一个在常量池中。
创建了两个对象，在栈内存建立了String s ，在方法区的常量池生成一个“abc”

作者: chenopen 时间: 2019-3-8 21:59
1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？
String是引用数据类型。因为String类型的底层实现原理是字符数组，数组一旦创建就长度就固定了。
2.什么情况下会用到Static关键字？
当一个变量或方法不依赖于具体对象，而是共享时候，会用到static关键字。
3.静态代码块会在什么时候执行？
在第一次加载代码块所在的类时候会执行。
优先于main方法和构造方法执行。
4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？
String s=new String("abc"):创建了2个对象。"abc"在内存中的字符串常量池中创建。
new在堆内存中创建。String s = "abc"：创建了1个对象。在堆内存中创建。

作者: 黄杰南 时间: 2019-3-8 22:00
1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？
String类是引用数据类型,因为字符串是个常量

2.什么情况下会用到Static关键字？
共享一个类的属性，又不用再创建一个对象传递参数
3.静态代码块会在什么时候执行？
当第一次用到本类时，静态代码块执行唯一的一次；静态内容总是优先于非静态，所以静态代码块比构造方法先执行

4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？
String s = new String("abc");创建了1个对象，String s 在栈内创建，new String("abc")在堆内存中创建；
String s = "abc";创建了1个对象，String s 在栈内创建，"abc"在堆中字符串常量池中创建

作者: JavaEE06蒋才东 时间: 2019-3-8 22:02
1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？
String类是引用数据类型
字符串本身是一个常量，常量在程序运行期间不能发生改变，因此字符串的长度不可发生改变
2.什么情况下会用到Static关键字？
a.类变量：使用static关键字修饰成员变量
b.类方法：使用static关键字修饰成员方法
c.静态代码块：使用static修饰代码块
3.静态代码块会在什么时候执行？
静态代码块会随着类的加载而执行，优先于main方法和构造方法的执行
4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？
String s = new String("abc");这句代码创建了3个对象，在栈内存中建立了一个String s，在堆内存中新建了一个new String，在堆内存的常量池生成一个abc；
String s = "abc";这句代码创建了2个对象，在栈内存中建立了一个String s，在堆内存的常量池生成一个abc。

作者: 叶振鹏 时间: 2019-3-8 23:16
1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？
String类是引用数据类型
字符串相当于是一个一个单独的字符拼接起来，其显示效果相当于是char[]字符数组，字符串的底层是用byte[]字节数组来储存而数组最主要的特性就是其在程序运行期间长度是不可以改变的，

2.什么情况下会用到Static关键字？
（1）用来修饰成员变量：使所有本类的对象都共享同一份静态变量的数据。
（2）用来修饰成员方法：使方法可以通过类名直接调用而不需要创建对象。
（3）静态代码块：当需要初始化某个类，给静态变量赋值的时候。
3.静态代码块会在什么时候执行？
在首次使用含代码块的类时，代码块会执行唯一一次
后面不管使用到这个含有代码块的类都不会在执行
4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？
String s = new String("abc");创建了两个对象，new String在堆内存中，“abc”在堆内存中的字符串常量池中
String s = "abc"要考虑两种情况1是与String s = new String("abc");在同一个类中，那么String s = "abc"就没有创造对象而是与String s = new String("abc")共用同一个字符串“abc”，
2是不在一个类中那么它创建了一个对象“abc”存放在堆内存中的字符串常量池中

作者: 徐代成 时间: 2019-3-9 09:06
1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？
（1）String类是引用数据类型。
（2）因为String类的对象是字符串常量，常量一旦被创建，其内容在程序运行期间就永不可变。
2.什么情况下会用到Static关键字？
（1）用来修饰成员变量：使所有本类的对象都共享同一份静态变量的数据。
（2）用来修饰成员方法：使方法可以通过类名直接调用而不需要创建对象。
（3）静态代码块：当需要初始化某个类，给静态变量赋值的时候。
3.静态代码块会在什么时候执行？
当第一次用到本类时，静态代码块会执行唯一的一次。
4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？
（1）String s = new String("abc");这句代码创建了3个对象，String s在栈内存中被创建，在堆内存中创建了new String对象，在堆中的字符串常量池中创建了“abc”。
（2）String s = "abc";这句代码创建了2个对象，String s在栈内存中被创建，在堆中的字符串常量池中创建了“abc”。

作者: 唐彬桂 时间: 2019-3-9 09:20
1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？
引用类型。
因为String类的对象是字符串常量，常量一旦被创建，其内容在程序运行期间就永不可变
2.什么情况下会用到Static关键字？
用来修饰成员变量：使所有本类的对象都共享同一份静态变量的数据。
用来修饰成员方法：使方法可以通过类名直接调用而不需要创建对象。
静态代码块：当需要初始化某个类，给静态变量赋值的时候。
3.静态代码块会在什么时候执行？
随着类的加载而执行且执行一次，优先于main方法和构造方法的执行。
4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？
创建了三个对象，分别存在于：String s 在栈内存中创建，new String在堆内存中被创建，
堆中的字符串常量池中创建了"abc"
创建了两个对象，String s 在栈内存中创建，堆中的字符串常量池中创建了"abc"

作者: omasoo 时间: 2019-3-9 11:42
李伟斌

1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？
答:String是引用数据类型,因为字符串的值在创建后不可变,所以长度也不可变.
2.什么情况下会用到Static关键字？
答:要访问静态使用静态方法或静态成员的时候.
3.静态代码块会在什么时候执行？
答:静态代码块内的成员被实现或调用.
4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？
答:a.创建了一个对象,存在堆中.
b.创建了一个对象,存在常量池中.

作者: 吴越 时间: 2019-3-9 19:36
1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？
String类是引用数据类型，因为String对象是一个字符串常量，创建之后常量的长度用不可变。

2.什么情况下会用到Static关键字？
（1）类变量：一个类的成员变量数据需要给该类所有成员共享时，用static修饰。
（2）类方法：一个方法需要通过类名直接调用，不想要创建对象时，用static修饰。
（3）静态代码块：在初始化代码块的时候，需要给静态变量赋值，用static修饰。

3.静态代码块会在什么时候执行？
静态代码块：当第一次用到本类时，静态代码块执行唯一的一次。

4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？
String s = new String("abc")这句代码创建了两个对象，一个是堆内存中的new String对象，一个是堆内存中字符串常量池里的“abc”字符串对象。
String s = "abc"创建了一个对象，在堆内存中字符串常量池里创建了的“abc”字符串对象。

作者: 沈松宏 时间: 2019-3-9 19:44
1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？
String类是引用数据类型；字符串底层是靠字符数组实现的
2.什么情况下会用到Static关键字？
成员变量和成员方法使用static修饰的时候，通过类名直接访问

3.静态代码块会在什么时候执行？
随着类的加载而执行且执行一次，优先于main方法和构造方法的执行。
格式
4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
创建了一个对象；在内存中的方法区创建

作者: LIUXIAOMING 时间: 2019-3-10 16:37
1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？
引用数据类型。
字符串池在方法区（Method Area）中是一种特殊的存储区域。
当创建一个字符串时，如果字符串已经存在于池中，现有字符串的引用将被退回，而不是创建一个新的对象并返回其引用。
下面的代码将在堆中只会创建一个字符串对象。
如果字符串可变，那么在这些模块中，将会引发严重的安全性问题。
不可变的对象不能被改变，他们可以在多个线程中共享，就不需要使用线程的同步操作。

2.什么情况下会用到Static关键字？
static 关键字，它可以用来修饰的成员变量和成员方法，被修饰的成员是属于类的，而不是单单是属
于某个对象的，这种情况下就可以用到static

3.静态代码块会在什么时候执行？
随着类的加载而执行且执行一次，优先于main方法和构造方法的执行。

4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？
String s = new String("abc");
在运行 new String()时，把文字池即pool中的字符串"abc"复制到堆中，并把这个对象的应用交给s，所以创建了两个String对象，一个在pool 中，一个在堆中。

String s = "abc"
会保存在方法区的字符串常量池中，首先检查字符串常量池中是否存在"abc"对象，
如果存在，直接返回指向"abc"对象的指针，不存在就会在字符串常量池中创建一个"abc"，然后返回指针

作者: omasoo 时间: 2019-3-10 21:25
李伟斌

1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？
答:String是引用数据类型,因为字符串的值在创建后不可变,所以长度也不可变.
2.什么情况下会用到Static关键字？
答:要访问静态使用静态方法或静态成员的时候.
3.静态代码块会在什么时候执行？
答:静态代码块内的成员被实现或调用.
4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？
答:a.创建了一个对象,存在堆中.
b.创建了一个对象,存在常量池中.

作者: 龙舟 时间: 2019-3-10 21:26
1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？
是引用类型。
因为String类的底层是一个char类型数组，数组在创建后，长度不可变

2.什么情况下会用到Static关键字？
创建静态变量和静态方法的时候

3.静态代码块会在什么时候执行？
会再第一次使用类的时候，并且只会执行一次

4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？

.String s = new String("abc");创建的两个对象再一个在堆中，一个在字符串常量池中
String s = "abc"；创建了一个对象，实在字符串常量区中。

作者: Wyt1935 时间: 2019-3-10 21:27
吴元陶：

1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？
引用数据类型。
字符串池在方法区（Method Area）中是一种特殊的存储区域。
当创建一个字符串时，如果字符串已经存在于池中，现有字符串的引用将被退回，而不是创建一个新的对象并返回其引用。
下面的代码将在堆中只会创建一个字符串对象。
如果字符串可变，那么在这些模块中，将会引发严重的安全性问题。
不可变的对象不能被改变，他们可以在多个线程中共享，就不需要使用线程的同步操作。

2.什么情况下会用到Static关键字？
static 关键字，它可以用来修饰的成员变量和成员方法，被修饰的成员是属于类的，而不是单单是属
于某个对象的，这种情况下就可以用到static

3.静态代码块会在什么时候执行？
随着类的加载而执行且执行一次，优先于main方法和构造方法的执行。

4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？
String s = new String("abc");
在运行 new String()时，把文字池即pool中的字符串"abc"复制到堆中，并把这个对象的应用交给s，所以创建了两个String对象，一个在pool 中，一个在堆中。

String s = "abc"
会保存在方法区的字符串常量池中，首先检查字符串常量池中是否存在"abc"对象，
如果存在，直接返回指向"abc"对象的指针，不存在就会在字符串常量池中创建一个"abc"，然后返回指针。

作者: 小翔vvvv 时间: 2019-3-10 21:33
叶凌青

1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？
答：String类是引用数据类型。字符串最底层是byte数组，而数组在创建的时候长度就是固定的，因此字符串的长度不可变；
2.什么情况下会用到Static关键字？
答：static 关键字，可以修饰变量、方法和代码块。当每个对象都共享同一个变量的值，就可以修饰变量；当想让代码块优先于main方法和构造方法的执行，也可以用static修饰；在使用的过程中，其主要目的还是想在不创建对象的情况
下，去调用方法；
3.静态代码块会在什么时候执行？
答：静态代码块随着类的加载而执行且执行一次，优先于main方法和构造方法的执行。
4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？
String s = new String("abc")：创建了两个；new String("abc")创建在堆中，"abc"创建在堆中的常量池。
String s = "abc";创建了一个：在堆中的常量池。

作者: 庄家琦 时间: 2019-3-10 21:34
1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？
String是引用数据类型他是基于char数组之上的一个类型改变了字符串那地址也相应的改变了
2.什么情况下会用到Static关键字？
可以不用新建类直接导出类
3.静态代码块会在什么时候执行？
会在导出的时候仅执行一次
4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？

String s = new String("abc");创建了三个对象

栈内存:String s
堆内存:new String
堆内存的常量池生成"abc"

栈内存:String s
堆内存常量池:"abc"

作者: 卢春旭 时间: 2019-3-10 21:34
1.String类是引用数据类型，因为String对象是一个字符串常量，创建之后常量的长度用不可变。
2.（1）类变量：一个类的成员变量数据需要给该类所有成员共享时，用static修饰。
（2）类方法：一个方法需要通过类名直接调用，不想要创建对象时，用static修饰。
（3）静态代码块：在初始化代码块的时候，需要给静态变量赋值，用static修饰。
3.静态代码块：当第一次用到本类时，静态代码块执行唯一的一次。
4.String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？
String s = new String("abc")这句代码创建了两个对象，一个是堆内存中的new String对象，一个是堆内存中字符串常量池里的“abc”字符串对象。
String s = "abc"创建了一个对象，在堆内存中字符串常量池里创建了的“abc”字符串对象。

作者: 陈鉴 时间: 2019-3-10 21:37
1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？
答：
      引用数据类型；
   原因：字符串底层是char数组，而数组在创建之初长度就是固定的，因此字符串的长度是不可变；
2.什么情况下会用到Static关键字？
答
      当某一类下的每个对象都有一个相同变量时，则可以使用Static将其从属于对象变成属于类使其成为同一类下所有对象的共享；
3.静态代码块会在什么时候执行？
答：
      在首次使用含代码块的类时，代码块会执行唯一一次
4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？
答：
   如果两个不是在同一个类中：
            String s = new String("abc")：创建两个对象；
                  “abc”放在方法区常量池中；new String 放在堆中；
            String s = "abc"：创建一个对象；
                     "abc"放在方法区常量池中；
      如果两个在同一个类中：
            String s = new String("abc")  先写的话：
                     String s = new String("abc")：创建两个对象；
                     String s = "abc"：没有创建对象；
            String s = "abc"  先写的话：
                     String s = new String("abc")：创建一个对象；
                     String s = "abc"：创建一个对象；

作者: 钟扬辉 时间: 2019-3-10 21:37
1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？引用数据类型字符串是常量常量在运行期间不可改变

2.什么情况下会用到Static关键字？当每一个对象都共享一个属性时，这个属性可以用Static关键字修饰。

3.静态代码块会在什么时候执行？第一次使用类的时候

4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？两个对象字符串常量池跟堆中

作者: 张广发 时间: 2019-3-10 21:39
1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？
引用数据类型。
字符串池在方法区（Method Area）中是一种特殊的存储区域。
当创建一个字符串时，如果字符串已经存在于池中，现有字符串的引用将被退回，而不是创建一个新的对象并返回其引用。
如果字符串可变，那么在这些模块中，将会引发严重的安全性问题。
不可变的对象不能被改变，他们可以在多个线程中共享，就不需要使用线程的同步操作。

2.什么情况下会用到Static关键字？
static 关键字，它可以用来修饰的成员变量和成员方法，被修饰的成员是属于类的，而不是单单是属
于某个对象的，这种情况下就可以用到static。

3.静态代码块会在什么时候执行？
随着类的加载而执行且执行一次，优先于main方法和构造方法的执行。

4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？
String s = new String("abc");
在运行 new String()时，把文字池即pool中的字符串"abc"复制到堆中，并把这个对象的应用交给s，所以创建了两个String对象，一个在pool 中，一个在堆中。

String s = "abc"
会保存在方法区的字符串常量池中，首先检查字符串常量池中是否存在"abc"对象，
如果存在，直接返回指向"abc"对象的指针，不存在就会在字符串常量池中创建一个"abc"，然后返回指针。

作者: 苏森鹏 时间: 2019-3-10 21:44
1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？
String是引用数据类型；对一个String变量重新赋值或者添加字符，相当于生成了一个新的字符串，原本的字符串还在常量池，不会发生变化（此时这个字符串是一个常量），因此字符串的长度是不变的。
2.什么情况下会用到Static关键字？
当一个类的对象存在同一种变量时，就可以用static关键字去修饰，当这个类一运行就会生成这个变量，应用于所有对象。

3.静态代码块会在什么时候执行？
静态代码块会在第一次用到该类时执行，并且只会执行这一次，后面重新用到这个类也不会重复执行。

4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？
String s = new String("abc");这句代码创建了3个对象，在栈内存中建立了一个String s，在堆内存中新建了一个new String，在堆内存的常量池生成一个abc；
String s = "abc";这句代码创建了2个对象，在栈内存中建立了一个String s，在堆内存的常量池生成一个abc。

作者: 林奕全 时间: 2019-3-10 21:46
1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？

String是引用数据类型，因为String定义的是一个常量字符串，常量在程序运行期间不可改变。

2.什么情况下会用到Static关键字？
static关键字可以用来修饰成员变量和成员方法，被修饰的成员是属于类的，而不是仅仅属
于某个对象的，这种情况下用到static关键字。

3.静态代码块会在什么时候执行？
在第一次使用到本类时，会执行一次，而且只执行一次，优先于main方法和构造方法的执行。

4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？
1.String s = new String("abc")创建了2个对象；String s在栈当中创建；new String("abc")在堆内存的常量池生成一个abc，凡是new 出来的东西都在堆当中；
2.String s = "abc"创建了2个对象；String s在栈内存中创建，而在堆内存的常量池生成一个abc。

作者: 管文祥 时间: 2019-3-12 19:17
1.String类是基本数据类型还是引用数据类型？为什么字符串的长度不可变？
答：String类是引用数据类型，因为字符串的底层数据是char类型的数组，而数组一旦被创建，长度就无法被改变
2.什么情况下会用到Static关键字？
答：用来修饰成员变量：使所有本类的对象都共享同一份静态变量的数据。
用来修饰成员方法：使方法可以通过类名直接调用而不需要创建对象。
静态代码块：当需要初始化某个类，给静态变量赋值的时候。
3.静态代码块会在什么时候执行？
答：静态代码块会随着类的加载而优先执行，而且只执行一次
4.String s = new String("abc");这句代码创建了几个对象？分别在内存中的哪个区域创建？
String s = "abc";创建了几个对象，分别在内存中的哪个区域创建？
答：String s = new String("abc");这句代码创建3个对象，首先在栈内存中创建了String s，在堆内存中创建了一个new String，然后在堆内存的字符串常量池中生成了一个abc
String s = "abc";创建了2个对象，首先在栈内存中创建了String s，然后在堆内存的字符串常量池中生成了一个abc

欢迎光临黑马程序员技术交流社区 (http://bbs.itheima.com/)

黑马程序员IT技术论坛 X3.2