JAVA语言学习笔记（一）

1 一切都是对象

JAVA中所有代码都必须写在类里面。

方法名和参数列表（它们合起来被称为"方法签名"）唯一地标识出某个方法。联想多态。

基本数据类型的"局部变量"相对于类的数据成员不会自动初始化，但会在编译时报错误。

面向对象的程序设计通常可简单的归为"向对象发送消息"。

JAVA中，除了基本数据类型，其它对象传递的是引用。

static域或方法，有特定的存储空间和可以直接用类直接调用（static字段对每个类来说都只有一份存储空间，而非static字段则是对每个对象有一个存储空间）。

2 操作符

观察一下代码，猜测输出的结果。

 1 class Tank {
 2     int level;
 3 }
 4 
 5 public class Think {
 6     public static void main(String[] args) {
 7         Tank t1 = new Tank();
 8         Tank t2 = new Tank();
 9         t1.level = 9;
10         t2.level = 47;
11         System.out
12                 .println("1: t1.level:" + t1.level + ", t2.level:" + t2.level);
13         t1 = t2;
14         System.out
15                 .println("2: t1.level:" + t1.level + ", t2.level:" + t2.level);
16         t1.level = 27;
17         System.out
18                 .println("3: t1.level:" + t1.level + ", t2.level:" + t2.level);
19     }
20 }

重点在13行，内部做了什么？

结果如下所示：

JAVA语言学习笔记（一）

equals和==号的运用，特别注意String类的特点

 1 class Value{
 2     
 3     String i;
 4 }
 5 public class EqualsMethods {
 6    public static void main(String[] args){
 7        Value v1 = new Value();
 8        Value v2 = new Value();
 9        v1.i = v2.i = "10"; //"10"是一个字符串常量，存储在常量区
10        
11        System.out.println(v1.equals(v2)); //false
12        System.out.println(v1.i.equals(v2.i)); //true
13        System.out.println(v1.i == v2.i); //true
14        
15    }
16 }

String类打印。观察下面代码的第9行程序和注释的内容。也可以是（观察下面代码，判断是否发生错误？编译错误还是运行时错误？那类错误？）

 1 package thinkJava;
 2 
 3 import java.util.ArrayList;
 4 import java.util.List;
 5 
 6 public class InfiniteRecursion {
 7    
 8     public String toString(){
 9         return "InfiniteRecursion address: " + super.toString() + "\n"; //this ---> super.toString()
10     }
11     public static void main(String[] args){
12         List<InfiniteRecursion> v = new ArrayList<InfiniteRecursion>();
13         for(int i = 0; i < 10; i++){
14             v.add(new InfiniteRecursion());
15         }
16         System.out.println(v);
17     }
18 }
19 //如果你真的想打印出对象的内存地址，而是应该调用Object.toString()方法。
20 //这才是负责此任务的方法。所以。你不该用this，而是应该调用super.toString()方法。

如果用this方法，则发生递归死循环，很快给出运行时错误-- JAVA语言学习笔记（一）

正确的做法是用父类的super.toString()方法。

JAVA语言学习笔记（一）

3 接口

抽象类，枚举、继承、类型、多态、循环、import方式

 1 package thinkJava;
 2 
 3 import testzd.Note; //testzd package中的Note.java文件
 4 
 5 abstract class Instrument {
 6     private int i;
 7 
 8     public abstract void play(Note n);
 9 
10     public String what() {
11         return "Instrument";
12     }
13 
14     public abstract void adjust();
15 
16 }
17 
18    // 继承抽象类，抽象方法一定要实现。如果不实现父类中的抽象方法，则子类必须也是抽象类，否则编译通不过。
19 class Wind extends Instrument {
20     public void play(Note n) {
21         System.out.println("Wind.pay() " + n);
22     }
23 
24     public String what() {
25         return "wind";
26     }
27 
28     public void adjust() {
29     };
30 }
31 
32 class Percussion extends Instrument {
33     public void play(Note n) {
34         System.out.println("Percussion.pay() " + n);
35     }
36 
37     public String what() {
38         return "Percussion";
39     }
40 
41     public void adjust() {
42     }
43 }
44 
45 class Stringed extends Instrument {
46     public void play(Note n) {
47         System.out.println("Stringed.play() " + n);
48     }
49 
50     public String what() {
51         return "Stringed";
52     }
53 
54     public void adjust() {
55     }
56 }
57 
58 class Brass extends Wind {
59     public void play(Note n) {
60         System.out.println("Brass.play() " + n);
61     }
62 
63     public void adjust() {
64         System.out.println("Brass.adjust()");
65     }
66 }
67 
68 class Woodwind extends Wind {
69     public void play(Note n) {
70         System.out.println("Woodwind.play() " + n);
71     }
72 
73     public String what() {
74         return "Woodwind";
75     }
76 }
77 
78 public class Music4 {
79 
80     static void tune(Instrument i) {
81         i.play(Note.MIDDLE_C);
82         i.play(Note.C_SHARP);
83         i.play(Note.B_FLAT);
84     }
85 
86     static void tuneAll(Instrument[] e) {
87         for (Instrument i : e) {      //遍历的方式
88             tune(i);
89         }
90     }
91 
92     public static void main(String[] args) {
93         Instrument[] orchestra = { new Wind(), new Percussion(),
94                 new Stringed(), new Brass(), new Woodwind() };  //Instrument 类型的，但是放进了好多子类型的。父类是抽象的，不能实例化。保证安全。
95         tuneAll(orchestra);
96     }
97 
98 }
99 //猜测下输出的结果，以及为什么这么繁琐的搞这么多的类？

View Code