Thinking in Java chapter6 笔记和习题

Size: px

Start display at page:

Download "Thinking in Java chapter6 笔记和习题"

鲁吭云
4 years ago
Views:

1 Thinking in Java chapter6 笔记和习题 emacsun 目录 1 简介 1 2 默认的 constructor 和带参数的 constructor 2 3 从 constructor 的定义引入函数重载 4 4 默认的 constructor 7 5 this 的作用 9 6 理解 static 10 7 class 成员初始化 10 8 初始化顺序 11 9 static 类型的初始化显示初始化非静态实例初始化数组初始化 20 1 简介 Initialization and Cleanup 这一章首先讲述类初始化的一些操作, 顺带初始化操作阐述了方法重载然后讲述了轊轡轶轡的轇轡轲轢轡轧轥轃软转转轥轣轴软轲机制其中輱

2 輲默认的 CONSTRUCTOR 和带参数的 CONSTRUCTOR 关于 static 初始化的例子最为令人印象深刻, 我把那个橱柜的代码做了逐行解析, 学完之后感觉非常顺畅 2 默认的 constructor 和带参数的 constructor 首先默认的 constructor, 看代码 : import java.util.*; import static net.mindview.util.print.*; class Rock{ Rock(){ System.out.println("Rock"); public class SimpleConstructor { public static void main(string args[]) { for (int i=0; i < 10 ;i++) { new Rock(); 注意輺 constructor 是一个函数, 其名称和 class 的名称必须相同輨没有为什么, 这是规定輩但是没有说明这个函数可不可以携带参数, 实际上是可以的, 继续看代码 : import java.util.*; import static net.mindview.util.print.*; class Rock{ Rock(int i){ System.out.print("Rock" + i); 輲輯輲輵

3 輲默认的 CONSTRUCTOR 和带参数的 CONSTRUCTOR public class SimpleConstructor2 { public static void main(string args[]) { for (int i=0; i < 10 ;i++) { new Rock(i); 这段代码的输出是輺 Rock 0 Rock 1 Rock 2 Rock 3 Rock 4 Rock 5 Rock 6 Rock 7 Rock 8 Rock 9 注意在这段代码中使用了 print 而不是 println 輮 print 输出默认不带回车 ; println 输出默认带回车 constructor 函数没有返回值, 注意这里的没有返回值和 void 函数是两回事 String 对象初始化值是 null 輬看代码 : import java.util.*; import static net.mindview.util.print.*; class Rock{ String str; public class Exercise0601 { public static void main(string args[]) { Rock rcok = new Rock(); print("" + rcok.str); 其输出为 null 輳輯輲輵

4 3 从 constructor 的定义引入函数重载輳从 CONSTRUCTOR 的定义引入函数重载作者从 constructor 过度到另一个知识点 overload 輬平滑自然对于重载, 值得注意的是 primitive 类型的重载看代码 : import static net.mindview.util.print.*; public class PrimitiveOverloading{ void f1(char x){printnb("f1(char) "); void f1(byte x){printnb("f1(byte) "); void f1(short x){printnb("f1(short) "); void f1(int x){printnb("f1(int) "); void f1(long x){printnb("f1(long) "); void f1(float x){printnb("f1(float) "); void f1(double x){printnb("f1(double) "); void f2(byte x){printnb("f2(byte) "); void f2(short x){printnb("f2(short) "); void f2(int x){printnb("f2(int) "); void f2(long x){printnb("f2(long) "); void f2(float x){printnb("f2(float) "); void f2(double x){printnb("f2(double) "); void f3(short x){printnb("f3(short) "); void f3(int x){printnb("f3(int) "); void f3(long x){printnb("f3(long) "); void f3(float x){printnb("f3(float) "); void f3(double x){printnb("f3(double) "); void f4(int x){printnb("f4(int) "); void f4(long x){printnb("f4(long) "); void f4(float x){printnb("f4(float) "); void f4(double x){printnb("f4(double) "); void f5(long x){printnb("f5(long) "); 輴輯輲輵

5 輳从 CONSTRUCTOR 的定义引入函数重载 void f5(float x){printnb("f5(float) "); void f5(double x){printnb("f5(double) "); void f6(float x){printnb("f6(float) "); void f6(double x){printnb("f6(double) "); void f7(double x){printnb("f7(double) "); void testconstval(){ printnb("5: "); f1(5);f2(5);f3(5);f4(5);f5(5);f6(5);f7(5);print(); void testchar(){ char x = x ; printnb("char: "); f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x);print(); void testbyte(){ byte x = 0; printnb("byte: "); f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x);print(); void testshort(){ short x = 0; printnb("short: "); f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x);print(); void testint(){ int x = 0; 輵輯輲輵

6 輳从 CONSTRUCTOR 的定义引入函数重载 printnb("int: "); f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x);print(); void testlong(){ long x = 0; printnb("long: "); f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x);print(); void testfloat(){ float x = 0; printnb("float: "); f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x);print(); void testdouble(){ double x = 0; printnb("double: "); f1(x);f2(x);f3(x);f4(x);f5(x);f6(x);f7(x);print(); public static void main(string[] args){ PrimitiveOverloading p = new PrimitiveOverloading(); p.testconstval(); p.testchar(); p.testbyte(); p.testshort(); p.testint(); p.testlong(); p.testfloat(); p.testdouble(); 輶輯輲輵

7 这段代码的输出是輺輴默认的 CONSTRUCTOR 5: f1(int) f2(int) f3(int) f4(int) f5(long) f6(float) f7(double) char: f1(char) f2(int) f3(int) f4(int) f5(long) f6(float) f7(double) byte: f1(byte) f2(byte) f3(short) f4(int) f5(long) f6(float) f7(double) short: f1(short) f2(short) f3(short) f4(int) f5(long) f6(float) f7(double) int: f1(int) f2(int) f3(int) f4(int) f5(long) f6(float) f7(double) long: f1(long) f2(long) f3(long) f4(long) f5(long) f6(float) f7(double) float: f1(float) f2(float) f3(float) f4(float) f5(float) f6(float) f7(double) double: f1(double) f2(double) f3(double) f4(double) f5(double) f6(double) f7(double) 4 默认的 constructor 默认的 constructor 是没有参数的如果定义类时没有指定构造函数, 那么编译器会生成一个默认的构造函数如果在定义类时指定了构造函数, 那么在创建该类的对象时就需要指定该对象实用的构造函数, 而不能使用默认构造函数, 否则就会报错看代码 : 輱 class Bird { 輲 Bird ( int i ){ 輳 Bird ( double d ){ 輴輵 public class NoSynthesis { 輶 public static void main ( String [] args ){ 輷 Bird b2 = new Bird (1); 輸 Bird b3 = new Bird (1.0); 輹 Bird b4 = new Bird (); 輱輰輱輱这个代码会报错 : error: no suitable constructor found for Bird(no arguments) Bird b4 = new Bird(); ^ constructor Bird.Bird(int) is not applicable (actual and formal argument lists differ in length) constructor Bird.Bird(double) is not applicable (actual and formal argument lists differ in length) 輷輯輲輵

8 1 error 輴默认的 CONSTRUCTOR 编译器会认为没有无参数的构造函数定义对代码进行修改 : 輱 class Bird { 輲 Bird ( int i ){ 輳 Bird ( double d ){ 輴輵 public class NoSynthesis { 輶 public static void main ( String [] args ){ 輷 Bird b2 = new Bird (1); 輸 Bird b3 = new Bird (1.0); 輹輱輰就没有报错但是, 看代码 : 輱 class Bird { 輲 Bird ( int i ){ 輳 Bird ( double d ){ 輴輵 public class NoSynthesis { 輶 public static void main ( String [] args ){ 輷 Bird b2 = new Bird (1); 輸 Bird b3 = new Bird (1.0); 輹 Bird b4; 輱輰輱輱这个代码也没有报错, 但是我不知道 b4 调用了那个构造函数为了确认一下, 对代码做如下修改 : 輱 class Bird { 輲 Bird ( int i){ 輳 System. out. println (" with int i"); 輴輵 Bird ( double d){ 輶 System. out. println (" with double d"); 輷輸輹 public class NoSynthesis { 輱輰 public static void main ( String [] args ){ 輱輱 Bird b2 = new Bird (1); 輱輲 Bird b3 = new Bird (1.0); 輱輳 Bird b4; 輱輴輱輵输出为輺 with int i with double d 輸輯輲輵

9 輵 THIS 的作用可见 Bird b4 没有调用给出的两个构造函数, 而是用的默认的构造函数 5 this 的作用简而言之, this 用来代表当前的对象在使用的过程中, 你完全可以用 this 来替代当前的对象但是 this 的实用也会有一些限制, 比如只能在 non-static 的方法中使用但是在一个类的多个方法中不需要显示的使用 this 来指示当前类 this 的一个经常用到的地方是 return 语句返回一个对象看代码 : 輱 public class Leaf { 輲 int i =0; 輳 Leaf increament (){ 輴 i ++; 輵 return this ; 輶輷 void print (){ 輸 System. out. println (" i = " + i); 輹輱輰 public static void main ( String [] args ){ 輱輱 Leaf x = new Leaf (); 輱輲 x. increament (). increament (). print (); 輱輳輱輴结果输出为 : i = 2 this 也可以用来把当前的对象传递给另外的方法, 看代码 : 輱 class Person { 輲 public void eat ( Apple apple ){ 輳 Apple peeled = apple. getpeeled (); 輴 System. out. println (" Yummy "); 輵輶輷輸 class Peeler { 輹 static Apple peel ( Apple apple ){ 輱輰 //... remove peel 輱輱 return apple ; 輱輲輱輳輱輴輱輵 class Apple { 輱輶 Apple getpeeled (){ return Peeler. peel ( this ); 輱輷輱輸輹輯輲輵

10 輱輹 public class PassingThis { 輲輰 public static void main ( String [] args ){ 輲輱 new Person (). eat ( new Apple ()); 輲輲輲輳輷 CLASS 成员初始化 this 还可以用来从一个 constructor 中调用另一个 constructor 这一用途有两点需要注意 : 輱輮你不能在一个 constructor 中调用两次 this 初始化函数輲輮在一个 constructor 中, 如果要使用 this, 第一行有效代码就应该是使用 this 的代码 6 理解 static 有了 this 我们现在可以更深刻的理解 static 我们可以从 non-static 函数里调用 static 函数, 但是不能从 static 函数里调用 non-static 函数为什么輿因为在 static 函数里没有对象的概念 static 函数依赖于 class 的定义存在, 而不依赖于对象的存在所以 static 看起来就像是一个全局方法, 不依赖于对象存在但是 Java 中是没有全局函数的, 所以通过 static 可以实现类似的效果正是因为 static 的这个特性, 人们诟病 Java 的 static 方法不是面向对象的因为在 static 方法中, 无法像一个对象发消息, 因为根本没有 this 因此当你的代码中有很多 static 的时候, 你要重新审视一下你的代码结构但是在很多时候 static 又是一个不得不存在的特性, 在以后的章节中就会看到 7 class 成员初始化 Java 中对于 class 的基础类型成员都做了默认初始化这说明, 每一个基础类成员都有一个默认的构造函数, 为其赋初值看代码 : 輱 import static net. mindview. util. Print.*; 輲輳 public class InitialValues { 輴 boolean t; 輵 char c; 輶 byte b; 輷 short s; 輱輰輯輲輵

11 輸初始化顺序輸 int i; 輹 long l; 輱輰 float f; 輱輱 double d; 輱輲 InitialValues reference ; 輱輳 void printinitiavalues (){ 輱輴 print (" Data type initial values "); 輱輵 print (" boolean "+t); 輱輶 print (" char "+c); 輱輷 print (" int "+i); 輱輸 print (" long "+l); 輱輹 print (" float "+f); 輲輰 print (" double "+d); 輲輱 print (" InitialValues "+ reference ); 輲輲輲輳 public static void main ( String [] args ){ 輲輴 InitialValues iv = new InitialValues (); 輲輵 iv. printinitiavalues (); 輲輶輲輷輲輸其输出为 : Data type initial values boolean false char [ ] int 0 long 0 float 0.0 double 0.0 InitialValues null char 的初始值是輰, 打印出来是一个空格另外需要注意的是 : 如果在 class 中定义了一个对象而没有为其赋初值, 则这个对象的 reference 会被赋值 null 8 初始化顺序在 Java 中, 类变量的初始化先于类方法调用什么意思? 就是说 : 在写代码的时候, 即便你把类变量的定义放在了构造函数的后面, Java 依然会先初始化这些变量, 然后再去调用函数 ( 这个函数通常是构造函数 ) 看代码 : 輱 import static net. mindview. util. Print.*; 輲 class Window { 輳 Window ( int marker ){ 輱輱輯輲輵

12 輴 print (" Window number : " + marker ); 輵輶輷 class House { 輸 Window w1 = new Window (1); 輹 House (){ 輱輰 print (" House ()"); 輱輱 w3 = new Window (33); 輱輲輱輳 Window w2 = new Window (2); 輱輴 void f (){ 輱輵 print ("f()"); 輱輶輱輷 Window w3 = new Window (3); 輱輸輱輹 public class OrderOfInitialization 輲輰 { 輲輱 public static void main ( String args []) 輲輲 { 輲輳 House h = new House (); 輲輴 h.f (); 輲輵輲輶输出为 : Window number: 1 Window number: 2 Window number: 3 House() Window number: 33 f() 輹 STATIC 类型的初始化从代码中我们可以看到, House 的构造函数在 w1 和 w2 之间但是我们执行 House h = new House() 这一行代码时, 初始化的执行顺序是 : 輱輮初始化 w1 輲輮初始化 w2 輳輮初始化 w3 輴輮调用 House() 对 w3 再次初始化 9 static 类型的初始化无论创建了多少个对象, static 类型的数据都只占用一份存储只有輱輲輯輲輵

13 輹 STATIC 类型的初始化 class 的域可以是 static, 一个本地变量不能是 static 类型的接下来我们通过一个例子来查看 static 是如何初始化的輬看代码輺輱 // specifying initial values in a class definition 輲 import static net. mindview. util. Print.*; 輳輴 class Bowl { 輵 Bowl ( int marker ){ 輶 print (" Bowl (" + marker + ")"); 輷輸 void f1(int marker ){ 輹 print ("f1(" + marker + ")"); 輱輰輱輱輱輲輱輳 class Table { 輱輴 static Bowl bowl = new Bowl (1); 輱輵 Table (){ 輱輶 print (" Table ()"); 輱輷 bowl2.f1 (1); 輱輸輱輹 void f2(int marker ){ 輲輰 print ("f2(" + marker + ")"); 輲輱輲輲 static Bowl bowl2 = new Bowl (2); 輲輳輲輴輲輵 class Cupboard { 輲輶 Bowl bowl3 = new Bowl (3); 輲輷 static Bowl bowl4 = new Bowl (4); 輲輸 Cupboard (){ 輲輹 print (" Cupboard ()"); 輳輰 bowl4.f1 (2); 輳輱輳輲 void f3(int marker ){ 輳輳 print ("f3(" + marker + ")"); 輳輴輳輵 static Bowl bowl5 = new Bowl (5); 輳輶輳輷 public class StaticInitialization 輳輸 { 輳輹 public static void main ( String args []) 輴輰 { 輴輱 print (" Creating new Cupboard () in main "); 輴輲 new Cupboard (); 輴輳 print (" Creating new Cupboard () in main "); 輴輴 new Cupboard (); 輴輵 table.f2 (1); 輴輶 cupboard.f3 (1); 輴輷輴輸 static Table table = new Table (); 輴輹 static Cupboard cupboard = new Cupboard (); 輵輰这段代码是我目前敲过的最长的轊轡轶轡代码, 其输出也最长, 看输出輺輱輳輯輲輵

14 Bowl(1) Bowl(2) Table() f1(1) Bowl(4) Bowl(5) Bowl(3) Cupboard() f1(2) Creating new Cupboard() in main Bowl(3) Cupboard() f1(2) Creating new Cupboard() in main Bowl(3) Cupboard() f1(2) f2(1) f3(1) 輹 STATIC 类型的初始化让我们来仔细分析一下每一行的输出是怎么来的通过 Bowl 我们可以知道初始化的顺序当我们调用 main() 时, 首先初始化的是 StaticInitialization 中的 static 成员, 然后是 non-static 成员在这个代码中是先初始化最后两行的 table 和 cupboard 在初始化 table 过程中, 生成了前四行输出具体过程是 : 先初始化 Table 的 bowl1 和 bowl(2) 然后调用构造函数 Table() 生成第三行第四行输出在初始化 cupboard 过程中, 生成了接下来的五行输出具体过程是 : 先初始化 bowl(4) 和 bowl(5) 然后初始化 bowl3 最后调用 Cupboard() 构造函数 table 和 cupboard 初始化结束后, 接下来执行第輴輱行打印了一句提示, 然后执行第輴輲行, 这个时候由于 bowl4 和 bowl5 已经被初始化了, 所以只初始化了 bowl3 并调用了 Cupboard() 构造函数然后执行第輴輳行, 同样的只初始化了 bowl3 并调用了 Cupboard() 构造函数輱輴輯輲輵

15 最后调用 table.f2(2) 和 cupboard.f3(1) 生成最后两行输出輱輰显示初始化 10 显示初始化在 Java 中可以使用 static 语句初始化 ( 有时候我们叫之中初始化方式为 static 块 ) 看代码 : 輱 public class Spoon { 輲 static int i; 輳 static { 輴 i = 47; 輵輶看起来像是一个方法, 但是注意这种初始化方法仅仅是一个 static 关键词跟着一个语句块同其他 static 初始化语句一样, 使用 static 块的初始化也仅仅执行一次看代码 : 輱 class Cup { 輲 Cup ( int marker ){ 輳 print (" Cup (" + marker + ")"); 輴輵 void f( int marker ){ 輶 print ("f(" + marker + ")"); 輷輸輹輱輰 class Cups { 輱輱 static Cup cup1 ; 輱輲 static Cup cup2 ; 輱輳 static { 輱輴 cup1 = new Cup (1); 輱輵 cup2 = new Cup (2); 輱輶輱輷 Cups (){ 輱輸 print (" Cups ()"); 輱輹輲輰輲輱輲輲 public class ExplicitStatic { 輲輳 public static void main ( String [] args ){ 輲輴 print (" Inside main ()"); 輲輵 Cups. cup1.f (99); ( cupsrun ) 輲輶輲輷 static Cups cups1 = new Cups (); ( cupsrun1 ) 輲輸输出为 : Inside main() 輱輵輯輲輵

16 Cup(1) Cup(2) f(99) 輱輰显示初始化 static 初始化语句在下列任一情况下初始化 Cups : 輱輮第轣轵轰轳轲轵轮行执行輲輮第轣轵轰轳轲轵轮被注释, 第轣轵轰轳轲轵轮輱行解注 ; 在情况輱, 我们访问了 Cups 的成员变量, 这个时候出发了 Cups 类的初始化 ; 在情况輲, 我们初始化了对象 cups1 当我们把第轣轵轰轳轲轵轮輱行解注, 第轣轵轰轳轲轵轮注释掉之后, 输出为 : Cup(1) Cup(2) Cups() Inside main() 可以看到在类 ExplicitStatic 中, 也是 static 变量先初始化我们看到 Inside main() 最后输出说明程序先完成了静态成员 cups1 的初始化之后再调用的 main 函数如果我把第轣轵轰轳轲轵轮輱行和第轣轵轰轳轲轵轮行都解注, 则输出 : Cup(1) Cup(2) Cups() Inside main() f(99) 可以看出还是 static 变量优先, 通过第轣轵轰轳轲轵轮輱行对 Cups 类的静态变量进行了初始化然后再执行 main 函数问题 Create a class with a static String field that is initialized at the point of definition, and another one that is initialized by the static block. Add a static method that prints both fields and demonstrates that they are both initialized before they are used. 解答 : 首先编写代码, 如下輱輶輯輲輵

17 輱輰显示初始化輱 import static net. mindview. util. Print.*; 輲輳 class String1 { 輴 static String str1 = " string in String1 "; 輵 String1 (){ 輶 print ("" + str1 ); 輷輸輹 class String2 { 輱輰 static String str2 ; 輱輱 static { 輱輲 str2 = " string in string2 "; 輱輳輱輴 String2 (){ 輱輵 print ("" + str2 ); 輱輶輱輷輱輸輱輹 public class Exercise0614 { 輲輰 public static void main ( String [] args ){ 輲輱 print (" Inside main ()"); 輲輲 String1 str1 = new String1 (); 輲輳 String2 str2 = new String2 (); 輲輴輲輵输出为 : Inside main() string in String1 string in string2 之所以按顺序初始化 str1 和 str2, 是因为在 Exercise0614 的类中, 这两个变量不是 static, 把这两个类改成 static 的有 : 輱 import static net. mindview. util. Print.*; 輲輳 class String1 { 輴 static String str1 = " string in String1 "; 輵 String1 (){ 輶 print ("" + str1 ); 輷輸輹 class String2 { 輱輰 static String str2 ; 輱輱 static { 輱輲 str2 = " string in string2 "; 輱輳輱輴 String2 (){ 輱輵 print ("" + str2 ); 輱輶輱輷輱輷輯輲輵

18 輱輸輱輹 public class Exercise0614 { 輲輰 public static void main ( String [] args ){ 輲輱 print (" Inside main ()"); 輲輲輲輳 static String1 str1 = new String1 (); 輲輴 static String2 str2 = new String2 (); 輲輵輲輶輱輰显示初始化输出为 : string in String1 string in string2 Inside main() 然后修改代码, 为其添加静态函数 ( 静态函数可以在不定义对象的时候调用, 而我们调用静态函数的同时, 对这个静态函数所属的类初始化, 主要是初始化其 static 变量 ) 輱 import static net. mindview. util. Print.*; 輲輳 class String1 { 輴 static String str1 = " string in String1 "; 輵 String1 (){ 輶 print (" construct 1" + str1 ); 輷輸 static void f1 (){ 輹 print (" static method " + str1 ); 輱輰輱輱輱輲 class String2 { 輱輳 static String str2 ; 輱輴 static { 輱輵 str2 = " string in string2 "; 輱輶輱輷 String2 (){ 輱輸 print (" constructor 2" + str2 ); 輱輹輲輰 static void f2 (){ 輲輱 print (" static method " + str2 ); 輲輲輲輳輲輴輲輵 public class Exercise0614 { 輲輶 public static void main ( String [] args ){ 輲輷 print (" Inside main ()"); 輲輸 String2.f2 (); 輲輹 String1.f1 (); 輳輰輳輱 static String2 str2 = new String2 (); 輳輲輱輸輯輲輵

19 输出为 : constructor 2string in string2 Inside main() static methodstring in string2 static methodstring in String1 輱輱非静态实例初始化 11 非静态实例初始化对于非静态变量, 轪轡轶轡提供了类似于 static 块的初始化方式看代码 : 輱 import static net. mindview. util. Print.*; 輲輳 class Mug { 輴 Mug ( int marker ){ 輵 print (" Mug (" + marker +")"); 輶輷 void f( int marker ){ 輸 print ("f(" + marker + ")"); 輹輱輰輱輱 public class Mugs { 輱輲 Mug mug1 ; 輱輳 Mug mug2 ; 輱輴 { 輱輵 mug1 = new Mug (1); 輱輶 mug2 = new Mug (2); 輱輷 print (" mug1 & mug2 initialized "); 輱輸輱輹 Mugs (){ 輲輰 print (" Mugs ()"); 輲輱輲輲 Mugs ( int i){ 輲輳 print (" Mugs ( int )"); 輲輴輲輵 public static void main ( String [] args ){ 輲輶 print (" Inside main ()"); 輲輷 new Mugs (); 輲輸 print (" new Mugs () completed "); 輲輹 new Mugs (1); 輳輰 print (" new Mugs (1) completed "); 輳輱輳輲输出为 : Inside main() Mug(1) Mug(2) 輱輹輯輲輵

20 mug1 & mug2 initialized Mugs() new Mugs() completed Mug(1) Mug(2) mug1 & mug2 initialized Mugs(int) new Mugs(1) completed 輱輲数组初始化从这个输出可以看出, 实例可以按照顺序初始化, 没有像 static 一样执行顺序和代码出现顺序不一样的情况 12 数组初始化数组是一些相同类型元素的集合这些元素可以是基础类型也可以是某个类 ( 这么说可能有些不严谨, 基础类型也是类, 在轊轡轶轡中一切都是类 ) 定义一个整型数组可以使用 int[] a1; 也可以用 int a1[] 在 Java 中, 数组的初始化可以通过大括号实现, 也可以不初始化 Java 中, 数组名的赋值, 复制的是引用看代码 : 輱 import static net. mindview. util. Print.*; 輲輳 public class ArrayOfPrimitives { 輴 public static void main ( String [] args ){ 輵 int [] a1 = {1,2,3,4,5; 輶 int [] a2; 輷 a2 = a1; 輸 for ( int i = 0; i < a1. length ; i ++) { 輹 a2[i] = a2[i ]*2; 輱輰輱輱 for ( int i = 0; i < a1. length ; i ++) { 輱輲 print ("a1[" + i + "]= " + a1[i ]); 輱輳輱輴輱輵输出是 : a1[0]= 2 a1[1]= 4 a1[2]= 6 a1[3]= 8 輲輰輯輲輵

21 a1[4]= 10 輱輲数组初始化可以看到执行了 a2=a1 之后, a2 指向的内容和 a1 指向的内容是一样的这时候即使对 a2 进行修改, a1 的内容也同时发生了改变关于数组越界的问题在 C/C++ 和 Java 中有不同的处理方法 : C/C++ 不会对数组越界进行约束, 而 Java 会在 Java 中, 一旦数组越界就会报错虽然适时的检查会不会报错是一件很低效的事情, 但是为了开发效率, Java 的设计者认为这是值得的对于事先不知道长度的数组, 需要用 new 来为其分配空间, 看代码 : 輱 import java. util.*; 輲 import static net. mindview. util. Print.*; 輳輴 public class ArrayNew { 輵 public static void main ( String [] args ){ 輶 int [] a; 輷 Random rand = new Random (47); 輸 a = new int [ rand. nextint (20)]; 輹 print (" length of a = " + a. length ); 輱輰 print ( Arrays. tostring (a )); 輱輱輱輲输出为 : length of a = 18 [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] 之前创建了 primitive 的数组现在创建对象数组, 当创建对象数组时, 数组元素是对象的索引现在考虑创建 Integer 数组 ( 回忆一下 Integer 是类不是轰轲轩轭轩轴轩轶轥类型基础类型和类的区别是, 基础类型保存在栈上, 而对象保存在堆上 ) 輱 import java. util.*; 輲 import static net. mindview. util. Print.*; 輳輴 public class ArrayClassObj { 輵 public static void main ( String [] args ){ 輶 Random rand = new Random (47); 輷 Integer [] a = new Integer [ rand. nextint (10)]; 輸 print ( Arrays. tostring (a )); 輹 print (" length of a = " + a. length ); 輱輰 for ( int i = 0; i < a. length ; i ++) { 輱輱 a[i] = rand. nextint (500); 輱輲輱輳 print ( Arrays. tostring (a )); 輱輴輲輱輯輲輵

22 輱輵輱輲数组初始化输出是 : [null, null, null, null, null, null, null, null] length of a = 8 [55, 193, 361, 461, 429, 368, 200, 22] 从代码可以看出, 没有初始化之前打印输出的都是 null 而不是像基础类型那样初始化为 0, 只有初始化之后才会有数据打印在创建对象数组时, 即使使用 new 也没有初始化这个数组, 必须一个一个来对于对象数组也可以用大括号进行初始化, 看代码 : 輱 import java. util.*; 輲輳 public class ArrayInit { 輴 public static void main ( String [] args ){ 輵 Integer [] a = { 輶 new Integer (1), 輷 new Integer (2), 輸 3, 輹 ; 輱輰 Integer [] b = new Integer []{ 輱輱 new Integer (1), 輱輲 new Integer (2), 輱輳 3, 輱輴 ; 輱輵 System. out. println ( Arrays. tostring (a )); 輱輶 System. out. println ( Arrays. tostring (b )); 輱輷輱輸输出为 : [1, 2, 3] [1, 2, 3] 注意初始化对象数组时, 最后一个元素后面的逗号使用这个逗号写出的代码便于维护, 尤其是维护长数组可以用这种初始化方法传递变长参数看代码 : 輱 class A{ 輲輳 public class VarArgs { 輴 static void printarray ( Object [] args ){ 輵 for ( Object obj : args ) 輶 System. out. print ( obj + " "); 輷 System. out. println (); 輲輲輯輲輵

23 輱輲数组初始化輸輹 public static void main ( String [] args ){ 輱輰 printarray ( new Object []{ 輱輱 new Integer (47), new Float (3.14), new Double (11.11), 輱輲 ); 輱輳 printarray ( new Object []{ " one "," two "," three " ); 輱輴 printarray ( new Object []{ new A(), new A(), new A ()); 輱輵輱輶输出是 : one two three A@15db9742 A@6d06d69c A@7852e922 上面代码的 Object 共有的根类, 关于这个类, 我们后面还会学到更多因为所有类都是从 Object 继承而来, 所以可以把 Object 数组传入一个方法另外我们还可以看到,print 函数接收一个 Object 的数组, 然后用 foreach 的循环语法打印每个 Object 数组中 reference 对应的内容打印标准的 Java 库类输出具有较强的可读性 ( 看输出的前两行 ), 打印自定义的类的输出 ( 输出的第三行 ) 就有点不知所云不过从输出的第三行可以看出打印自定义类, 其输出具有固定的格式, 然后是一串十六进制数 ( 以后我们会了解到, 这串十六进制数是对象地址 ) 上面的这段代码在轊轡轶轡轓轅輵之前比较常见, 但是自从轊轡轶轡轓轅輵之后, 就有更方便的写法了 : 可以像 printarray() 那样打印数组 ( 我现在写这个笔记的时候用的是轓轅輸, 所以浪费了一段时间学习了一个历史技术 ) 看代码 : 輱 public class NewVarArgs { 輲 static void printarray ( Object... args ){ 輳 for ( Object obj : args ) { 輴 System. out. print ( obj + " "); 輵輶 System. out. println (); 輷輸 public static void main ( String [] args ){ 輹 printarray ( new Integer (47), new Float (3.14), new Double (11.11)); 輱輰 printarray (47,3.14F,11.11); 輱輱 printarray (" one "," two "," three "); 輱輲 printarray ( new A(), new A(), new A ()); 輱輳 printarray (( Object []) new Integer []{1,2,3,4); ( NewVarArgsline2 ) 輱輴 printarray (); // Empth list is also OK; 輱輵輱輶輲輳輯輲輵

24 输出为 : 輱輲数组初始化 one two three A@15db9742 A@6d06d69c A@7852e 开心的服下这颗语法糖当你使用 varargs 时, 不在需要写明数组信息, 编译器会自动帮你填写编译器会给 print() 函数一个 array 但是注意这里不仅仅是从一个元素列表到一个数组的转换注意代码中第轎轥轷轖轡轲轁轲轧轳转轩轮轥輲行, 我们可以看到一个 Integer 数组转换成了一个 Object 数组在编译过程中, 编译器看到这是一个数组, 并不会做转换 ( 对这句话我还没有深刻的理解, 需要以后回头看 ) 最后一行代码告诉我们, 可以对一个 vararg 的列表传送零个参数这个语法很有用, 尤其是当函数的尾随参数个数可变时关于尾随参数, 看代码 : 輱 public class OptionalTrailingArguments { 輲 static void f( int required, String... trailing ){ 輳 System. out. print (" required : " + required + " "); 輴輵 for ( String s: trailing ) 輶 System. out. print (s + " "); 輷 System. out. println (); 輸輹 public static void main ( String [] args ){ 輱輰 f(1," one "); 輱輱 f(2," two "," three "); 輱輲 f (0); 輱輳輱輴输出为 : required: 1 one required: 2 two three required: 0 从上面代码还可以看出, 可以使用除了 Object 之外的类型作为 varargs 的类型 ( 在这里例子中, 我们实用的是 String ) 事实上, 可以使用任何类型作为可变参数类型看代码 : 輱 public class VarargType { 輲輴輯輲輵

輱輲数组初始化輲 static void f( Character... args ){ 輳 System. out. print ( args. getclass ()); 輴 System. out. println (" length " + args. length ); 輵輶 static void g( int... args ){ 輷 System. out. print ( args. getclass ()); 輸 System.

25 輱輲数组初始化輲 static void f( Character... args ){ 輳 System. out. print ( args. getclass ()); 輴 System. out. println (" length " + args. length ); 輵輶 static void g( int... args ){ 輷 System. out. print ( args. getclass ()); 輸 System. out. println (" length " + args. length ); 輹輱輰 public static void main ( String [] args ){ 輱輱 f( a ); 輱輲 f (); 輱輳 g (1); 輱輴 g (); 輱輵 System. out. println (" int []: " + new int [0]. getclass ()); 輱輶輱輷输出为 : class [Ljava.lang.Character; length 1 class [Ljava.lang.Character; length 0 class [I length 1 class [I length 0 int []: class [I 从上面的代码可以看出, 可以使用 Character 数组作为可变参数类型, 也可以使用 int 这种基础类型作为可变参数类型 getclass() 函数是 Object 的内置函数輲輵輯輲輵

2015 3 3 4 5 148

1 Q 2 Q Q 147 2015 3 3 4 5 148 6 7 8 Q Q Q Q Q Q Q Q Q / Q 149 2015 3 Q Q Q Q 9 Q 150 10 Q Q Q 輥輯訛 Q 輥輰訛輥輱訛 Q 151 2015 3 輥輲訛 152 Q,,,,, ;,,,,, Q,, 輥輳訛 Q 153 2015 3 輥輴訛輥輵訛輥輶訛 Q Q Q 154