Head First Java, 2nd Edition

这一章可能是我感觉最难的一章了吧，可也是最贴近现实的一章，感觉之前的东西都是纯理论，现在一下子上升到实践还真有点不太习惯。 接下来的两章讲的是GUI，也就是图形用户接口。 。。为什么感觉心里有但是不好说呐。这一章代码敲得很多，知识都融到代码里了吧。OuterClass & InnerClass 是一个亮点吧，InnerClass的目的是想多次实现一个接口。paintComponent()这玩意让我费解了老半天，直到现在也不是完全搞懂。嗯~总之，在学习这一章的过程中我敲了很多代码，也看了很多视频，算是很有收获的吧。 PS:P365 那个加载图片的程序调不通啊，估计是路径的问题吧，等几天看看小翼的视频应该会有收获吧。嗯~ Fight!!!

趁着最近时间多一点，就抓紧多看些书啊。虽然因为一些事情心情不好，但是吃饭的时候吃饭，看书的时候看书嘛。啊哈哈！ 这一章开头由一个音乐播放器引出我们接下来几章要学习的内容，终于接触到一些实际的东西了，好开心啊。 第一个讲的API是JavaSound，还有MIDI(Musical Instrument Digital Interface)。 JavaSound分为两部分：MIDI & Sampled。我们这里只讲MIDI。MIDI呐，就好比是很多张张“乐谱”，里面存放着弹奏各种乐器的指令，就像是浏览器的HTML文件。 我们首先需要一个sequencer（javax.sound.midi），相当于MIDI data和instruments的一个桥梁，好比是CD Player吧。

Sequencer player=MidiSystem.getSequencer();

但是直接这么写会有错误，由此引出了exception-handling机制。 关键字：throws & try & catch throws呐，一个有危险的代码，会throw new exception()（事先要声明throws exception）；调用这个危险代码的函数呐，要用try-catch来wrap它。 一个exception是属于Exception类的一个对象。 Exception的父类是Throwable，继承了两个特别重要的methods，getMessage()&printStackTrace()。（具体的功能我还不是很清楚） 其中RunTimeException是一个例外，我们可以throw,try,catch,但是不做也没关系，因为编译器不会检查它。 如果try里面有代码出现异常，try里面剩余的代码将不再执行。 而finally则是不管出没出现异常，你都要执行的部分。

catch (Exception e) {
	// TODO Auto-generated catch block
	e.printStackTrace();
}        

e就是exception类的一个对象。 当然啦，一个method可以throw很多的exception。你需要把它可能throw的异常都声明才可以，如果它们来自同一个父类，也可以只声明它们的父类。 当然啦，对应的catch也可以是很多个，但是它的顺序可是有讲究的。 Multiple catch blocks must be ordered from smallest to biggest. 就是从具体到一般，因为编译器是从上到下执行的。 如果你不想解决throw出来的问题，你也可以duck it.(我理解就是逃避它吧) 就是在调用throws exception的method的函数里，不用try-catch，而是继续throws exception。就好比推卸责任一样，层层上移，直到main()。 Handle or Declare 这是规矩。 如果你们都不管，最后让main()函数throw exception的话，JVM可能会崩溃哦！ 刚才通过调试发现，如果执行try到最后有return语句的话，他会先去执行finally(),再回到return执行。没有的话，就直接返回了。 最后终于讲到了实际的例子。 我们需要四样东西： Sequencer（CD机） & Sequence（CD） & Track（音轨MIDI Data） & MidiEvents（具体信息） API Document里面的两句话： sequencers play sequences, which contain tracks, which contain MIDI events. A sequencer may provide controls that mute or solo individual tracks.

package chap06;
import javax.sound.midi.*;

public class MiniMiniMusicApp {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
        //sequencers play sequences, which contain tracks, which contain MIDI events. 
		//A sequencer may provide controls that mute or solo individual tracks. 
		MiniMiniMusicApp mini=new MiniMiniMusicApp();
		if(args.length<2){
			System.out.println("Don't forget the instrument and note args");
		}
		else{
			int instrument=Integer.parseInt(args[0]);
			int note=Integer.parseInt(args[1]);
			int result=mini.play(instrument,note);
			System.out.println(result);
		}
	}
	
	public int play(int instrument,int note){
        try {
			Sequencer player=MidiSystem.getSequencer();
			player.open();
			
			Sequence seq=new Sequence(Sequence.PPQ,4);
			
			Track track=seq.createTrack();
			
			ShortMessage first=new ShortMessage();
			first.setMessage(192,1,instrument,0);
			MidiEvent notefirst=new MidiEvent(first,1);
			track.add(notefirst);
			
			ShortMessage a=new ShortMessage();
			a.setMessage(144,1,note,100);
			MidiEvent noteon=new MidiEvent(a,1);
			track.add(noteon);
			
			ShortMessage b=new ShortMessage();
			b.setMessage(128,1,note,100);
			MidiEvent noteoff=new MidiEvent(b,16);
			track.add(noteoff);
			
			player.setSequence(seq);			
			player.start();			
		    return 1;	  
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally{
			System.out.println("finally");
		}        
        return 2;		    	
    }
}

看看这个有趣的例子，我真的很喜欢呐。 MidiEvent里面的ShortMessage的作用是说我们弹奏什么音符，用什么乐器，用多大力。 而MidiEvent是说什么时候去弹。 当然啦，具体的细节我还不是很明白啦。。。 接下来还有很多事情要做呐，让我们荡起双桨吧。2333！

说实话，我是不太擅长读这种知识点相对比较散的章节的。原因一呐，不够专心。原因二呐，不够专心。原因三呐，不够专心。 重要的事情说三遍。 好了，进入正题。 这一章呐，讲的就是对“数字”进行各种操作，这些"操作"中有一些是静态的，由此引出static的概念。 首先由Math类的各种methods引出，Math类没有instance variables，只有static methods，所以无需对象，只需用Math类名来调用各种方法。（具体内容我们后面再说~） 普通的方法和static methods有什么区别呐？最大的区别就是一个是用class name来调用，一个用reference variable name来调用。对于一个虚类来说，它没法初始化；对于“非”虚类，你也可以通过将它的constructor定义为private来限制类外的访问。（Math类定义为public final，构造函数私有化，方法全部是static） Static methods can't use non-static (instance) variables!

public class Duck{
   private int size;
   public static void main(){
       System.out.println("Size of duck is "+size);
  }
}

这个是错的有木有啊！！！“size”是谁的size？ 因为main函数也是static method啊！它定义在Duck类中啊！ 还记不记得这句话：Static methods can't use non-static (instance) variables! 我已哭晕在厕所。。。 同样的： Static methods can't use non-static methods!

public class Duck{
   private int size;
   public static void main(){
       System.out.println("Size of duck is "+getSize() );
  }
   public int getSize()
  {
      return size;
  }
}

这个也是错的啊啊啊！！！返回的“size”是谁的size？ 还是这句话：Static methods can't use non-static methods! 别理我，我想静静。。。 而且通过我的亲身实践，好像即使non-static methods没有使用instance variables，compiler也是不让通过滴。 插一句话，用对象当然也能引用static methods，不过，这样真的好挫啊。 Static variables呐，一句话：one value per class,instead of one value peer instance. 而static variables只会在“类”第一次“载入”时初始化，它“住在”class中。 All instances of the same class share a single copy of the “static variables”. 那么问题来了，“类”什么时候载入呐？ JVM会在某人第一次试图建立一个属于该类的对象，或者使用该类的静态method或variable时“载入”这个“类”。 其中有两个关于静态初始化的保证： 1.static variables在属于该类的任何对象建立前初始化。 2.static variables在属于该类的任何静态方法运行前初始化。 —————————————————————————————————————— 接下来，我们讲到了关键字final Static final variables are constants. 例： public static final double PI=3.1415926... 其中： public: any code can access it. static: you don't need an instance of class Math. final: PI doesn't change. 有个规则要记住：常量的变量名要大写。(static final variables are constants) 这里static & final 缺一不可。（因为non-static variables也可以是final） 那final static variable怎么初始化呐？ 这里有两种方法： 1.At the time you declare it.

public class Foo{
     public static final int FOO_X=25;//注意命名规则
}

2.In a static initializer.

public class Foo{
     public static final int FOO_X;//注意命名规则
     
     static{
        FOO_X=(double)Math.random();
    }
}

记住哦，前面加上final就一定要用这两种方法初始化哦，不像单一个static有default。 static initializer里面的代码是在任何static method调用之前，甚至在任何static instance使用之前，就在“类载入”时运行。（before any other code can use the class） final还可以用在non-static variables & methods & classes等等，分别是不能改变、不能重写（override）、不能继承。 final类中的方法无需声明为final methods. 然后就讲到了Math类的静态方法（其实都是静态的），感觉真的挺简单的。 接下来讲了wrapping a primitive 包装类 就相当于巧克力(primitive)外面包了一层锡箔纸(wrap)。 wrapping a value:

int i=1;
Integer iWrap=new Integer(i);

unwrapping a value:

Boolean unWrapped=iWrap.booleanValue;

现在Java可以自动装包、拆包啦。 注：

ArrayList<Integer>

反正就是随时随地发生啦。 包装类的各种方法也是很简单的，什么parseInt()，toString()，balabala的。 注：“+”是作为String的粘连剂重载的。 后面又讲了String类的一个重要的static方法，format()。其实就是C语言里的那一套，什么 “%d” & “%.2f”之类的。 大部分都是一些记忆的内容，就是里面的“%,d”还是每三位加一个“,”让我很惊讶的。 然后又讲了关于时间的两个类Date() & Calendar()。其实没多大意思，用的时候看看就好了。 最后书上有一个判断输出顺序的习题，看了答案并且通过调试我明白了确确实实是先执行static initializer，有父类的话那就优先执行父类的static initializer；接着就是执行main()，然后开始执行构造函数。 嗯，就这样。

很久没更了啊，总是被乱七八糟的事情耽搁下来（这只是借口）。还好现在又重新开始了呐。这一章主要讲的是对象的生命周期吧，一开始先提出了两个概念：栈（stack）&堆（heap）。堆和栈的区别先放一放，相关知识也还不是我们现在掌握的重点。概括起来就是一句话：对象存放在堆中，函数调用和局部变量（local variables）存放在栈中（main函数也是函数）。实例变量呐（instance variables）存放在对象里，也就是在堆中。 注意：形参也是局部变量 例

public void foo(int x)
{
    int i=x+3;
    boolean b=true;
}

这里x,i,b都是local variables哦！ 函数在栈里也是先进后出，在栈顶的函数正在执行。这也让我明白了，如果在一个函数a中调用其他的函数b，那么b就会进入栈，此时b在栈顶，a在b得下面，b执行完过后，弹出栈，a继续执行，直到a结束（遇到" } "）。 如果局部变量是引用变量的话，那么这个“遥控器”还是在stack中，而它指向的Object就会在heap中。 —————————————————————————————————————— 接下来讲了对象生成的秘密，其实就是构造函数啦。

Duck myDuck = new Duck();

这一步到底是怎么搞的呐？ 其实就是我们在调用构造函数啊！ 构造函数没有返回类型，老生常谈了。再次强调了一点：父类的构造函数不可继承！ 构造函数可以overload，但是一旦overload就要自己再定义一个不带参数的构造函数，因为此时编译器就不会在为你定义一个了。（参数的顺序不同也视为不同的构造函数） 只是不太明白如果想在构造函数中传递float型变量，但是只有接受int型变量的构造函数会出现什么样的情况，还有not all是全部不还是不全部啊。啊啊啊，都忘光了啊！！！ 构造函数可以是public,protected,private,or default.如果是private那还怎么调用啊？笨蛋，可以在类其他构造函数中调用嘛。 如果你想要构造一个新的对象，那么继承树中所有的构造函数都要运行，这是一整个构造链条，如果你的父母没有被“构造”，那哪来的你呐？（虚类也有构造函数，虽然没法用）。 构造树中所有的实例变量都要被声明&初始化，即使是父类中的私有变量，因为他的子类可能还会依靠父类的方法来调用这些私有变量。（嗯~再好好理解） 你在构造子类的同时，父类的部分也在构造，也遵循栈的原理。 子类在栈底，父类在栈顶。父类先弹出，子类后弹出。 那如何调用父类的构造函数呐？ 可以这样嘛？

public Dog()
{
    Animal();
}

其实是不行的！super()是调用父类构造函数的唯一方法。 这又让我想到super关键字的用法，直接上图。

super关键字是一个指向对象内核（继承的父类部分）的引用

前几章讲super关键字的精髓就是调用父类中已被子类override的方法的父类版本。 1.如果我们不自己提供构造函数，编译器就会这么写。

public Dog()
{
   super();
}

2.如果我们自己提供构造函数，但是没有写super()，编译器就会把

super();

放入每一个重载的构造函数中。 注意：是super()!!!意味着如果父类有多个重载的构造函数，只有不含参数的那个构造函数被调用。 当然啦，我们也可以在super中传递参数去调用父类对应的重载构造函数。 天啦噜，父类构造函数一定要在子类构造函数前面完成，所以super()一定要写在第一行。 这时候，this关键字出现啦，this指的就是当前的对象。this只能出现在构造函数中，是当前对象的引用。this的作用呐就是在一个构造函数中去调用另一个重载的构造函数。因为this()也要出现在第一行，所以this()和super()一次只能出现一个啦。 也不能在构造函数里面用this()调用自己啦，那不就成递归了吗？ 到目前为止，我们知道一个Object是怎么出生的了，那它的寿命呐？ 请记住一句话： An Object's life depends entirely on the life of references referring to it. 那么问题来了，引用变量的寿命怎么算？ 这个决定于它是an instance variable or a local variable.（而不管它是primitive还是reference variable） 至于scope（作用域），哥哥都明白了呐~~~ 还有三种情况使一个对象进入GC，只需记住： An Object becomes eligible for GC when its last live reference disappers. 其他的就没有什么啦~只不过后面的五分钟小故事人家就看不懂了。。。 英语要加油了！！！