J2SE学习历程

2014/12/09

1、+两边有字符串的话，则另外的先转换为字符串再连接。

int c = 12;

System.out.println(“c=” + c);

2、如果a=2，b=a++，先赋值再运算，b为2，a为3；b=++a，先运算再赋值，b为3，a为3.

2014/12/10

1、  if、else、else if、for后需要执行的如果只有一句，可省略大括号。（不过最好不要省了，危险）

2、  switch后面的括号中只能放int的变量，byte short之类可以转换成int的可以放；

switch不加break会穿透。case相当于一个入口，进入之后则下面的语句都会执行，除非加了break。

2014/12/13

1、  成员变量（即对象的数据）默认有初始值(数组也有)，局部变量没有初始值，必须对其赋值后才能用。

2014/12/15

1、方法重载（overload）只能是方法的参数不同（参数类型不同或个数不同），返回值情况要相同。

void max(int a, int b){}与void max(double a,double b){}是，

void max(int a, int b){}与int max(int a,int b){}不是，且会出错。

2014/12/17

1、  import是后面接类，不是包。

2、  *只能代替类，不能代替包，比如import com.*，只能指代com中的类，不能指代com.io中的类，import com.io中的类只能用com.io.*。

3、  关于包，只有绝对包（绝对路径），没有相对包（相对路径）的说法。

4、  子类的构造过程中必须调用基类的构造方法；

子类的构造方法中用super(argument_list)调用基类构造方法，且必须在构造方法中的第一行，this(argument_list)可调用子类自己的构造方法。

如果没写super(argument_list)，则默认调用无参数的基类构造方法。

2014/12/19

1、  Object中的equals方法只有当两个引用指向同一对象时才返回true。

c1

c2

第一个对象

第二个对象

上面的c1.equals(c2)将返回false，c1c2指向一个对象才返回true。

通常要重写toString()和equals()方法。字符串类(String)的equals()方法已经重写，即两个字符串一样即返回true。

2、  对象转型。

Person a =
new Person(); Student b = new Student();（学生extends人）

可以a = new
Student()，但a不可访问学生独有的数据及方法；

Student c =
(Student)a；这时a强制转换为学生后，可访问学生独有的数据及方法。

栈中的引用和堆中new的对象，二者的类型是独立的，基类引用可以指向子类对象，反之不行。但基类只能访问此对象地址中继承自基类的数据。

instanceof前面其实是引用所指对象，探测此对象的类型，而不是此引用的类型。

当需要使用子类数据时，就需要将引用强制转换为子类引用。

2014/12/20

1、  动态绑定，接上一条。当基类引用a指向子类对象时，a.方法 可调取子类重写的方法。（只有重写的方法才能动态绑定）。

2、  基类中的抽象(abstract)方法是专门用来给子类重写的。类中有抽象方法，则此类必须为抽象类。抽象类不能new出来（不能实例化），不过可以创建这种类型的引用，指向其非抽象的子类。

3、  final关键字。变量不能改变其值，方法不能被重写，类不能被继承。

4、   接口（interface）。其中数据必须是public static
final的（写不写都行，不写也默认是这个），方法都是抽象的，不写abstract。

5、  接口可以像基类一样进行对象转型和引用指向子类。规则相同。接口互相之间可以继承（extends）。

6、  方法抛出异常需要两个操作：a、方法名后面写throws
exception；b、方法里写throw
new exception()（即将对应类型的异常抛出）。

a、  throw new exception()——throws exception——catch相当于一个通道；

b、  throw new exception()抛出的异常必须在throws中有，否则会说此异常未处理；

c、  throws exception可以写任意类型异常，只要包含方法里throw的异常就ok，写了throws，必须写catch(不一定在本层catch)，不管方法里有没有throw；

d、  写了throws的异常类型，必须要配套写catch，如果方法后面没有立即catch，他的上层总有一块要catch。

e、  throw的类 < throws的类 = catch(包含上层的catch)的类；

7、  重写方法需要抛出与原方法一致的异常类型或不抛异常。

2014/12/22

1、  java的数组也是引用类型（只有8种基础数据类型不是引用类型），数组的值存在堆中，引用存在栈中。也要new。

2、  数组的值会初始化，按成员变量的规则进行初始化。

3、  对引用类型（即对象）构成的数组，为下面的形式。数组的值中保存引用，而不是对象，数组的值作为引用再指向实际的对象：

Date[] days; days
= new Date[2]; 循环：days[i] = new Date(2004,4,i +1);

Date[] days;在栈中生成数组的引用；

days = new
Date[2];将堆中数组的值赋值为Date类的引用；

days[i] = new
Date(2004,4,i +1);在堆中生成对象，并用数组中保存的引用指向他们。

4、  引用类型构成的数组，初始化的值为null；

2014/12/31

1、  比较字符串时。equals方法比较值是否相等，“==”比较两个对象地址是否相同，即是否指向同一对象。

String a="1234";

String b="1234";

String c = new String("1234");

System.out.println(a==b);

System.out.println(a==c);

System.out.println(a.equals(c));

输出为true false true。

说明不用new的时候，字符串是共用的。

2015/1/21

1、  二维数组在java中是“数组的数组”。声明方法：

int a[][] =
{{1,2};{2,3};{3,4,5}};

或：

int a[][] =
new int[3][5];

或：

int a[][] =
new int[3][];

a[0] = new
int[2];

a[1] = new
int[3];

a[2] = new
int[5];

只有前一个中括号要先声明出来（或者同时声明），后一个才能再声明。

int a[][] = new int[][]是不行的。

2015/1/24

1、  valueOf(String s)方法，各基础类型包装类有，返回字符串的该类型数据。（例如int a = Integer.valueOf(“123”),如果没法转成对应数据的话，比如“zcx”不能转成int，则throws NumberFormatException）；反过来也有各基础类型到字符串的valueOf()

toString()方法，各类均有，返回对象对应的字符串。一般要将其重写。

2、  向数组中填值，必须先指定数组的长度，或者直接用{a,b,c}的方法一次全部指定；不能一个一个的填。

2015/1/25

1、  定义文件的路径时，建议采用两种方式：String directory = “mydir1” + separator + “mydir2”;或String directory = “mydir1/mydir2”;

2015/3/10

1、  容器。在
容器.remove(something) 时，something会与容器中所有对象进行equals，

equals为true的被remove。所以加入容器的对象，有必要将equals重写，且有必要使equals的两个对象的hashCode相等（将hashCode也重写）。

2015/3/15

1、  I/O流。输出时，先flush再关闭。否则可能数据还未写完输出管道就被关了（在用内存缓冲区的时候）。

2015/3/25

1、  io的类，Reader,Writer,InputStream,Outputstream。这是最基本的四类。他们不能直接用，要用他们的子类。子类中，OutputStreamWriter和InputStreamReader可以将字节流转换为字符流，剩下的方法，不能在字节流和字符流间转换。（看相关类的构造方法）

2015/7/10

1、  synchronized(this)以及synchronized属性的方法，锁定的是不同线程中运行此方法时的当前对象。仅当有两个线程同时运行相同对象的此方法时，出现互斥。此对象的其他方法不受影响，可以与其同时执行（访问此方法中正在处理的值）。

这样就会出错，所以加了synchronized(this)以及synchronized属性的方法中，处理的值，此值出现的方法都应该加synchronized。也就是，多个方法中都对某个值有操作时（rwx看情况），这些方法都应该加synchronized。

其实，加锁并不是一定在方法的层面上，synchronized(this)括住的内容才是真正互斥的，此方法中没被括住的语句执行时并不加锁。

2、  某一线程新开另一个线程时（以及放锁时），此线程的下一语句和另一线程的第一句不一定谁先执行

（不同机器差异）。所以有时要用到sleep。

2015/7/16

1、  布局管理器起作用时，组件大小和位置由布局管理器安排，setLocation(),setSize(),setBounds()都将不起作用；若想起作用，需setLayout(null)

2、  事件监听：继承ActionListener接口的类中重写actionPerformed方法；main中new出其对象a，然后b.addActionListener(a)（b为按钮之类的对象）。

main中：Button b = new Button(“Press me”);

Monitor a = new Monitor();

b.addActionListener(a);

新类：class Monitor implements
ActionListener{

public void actionPerformed(ActionEvent
e){

System.out.println("a
button has been pressed!");

}

2015/7/24

1、  持有引用：一个类A中需要另一个类B中的某个成员变量；可以在这个类A的构造方法中传入类B，在构造方法中将类B作为A的一个成员变量，即可访问B中的成员变量。

class B …

class A{

B b = null;                                    #将类B作为A的成员变量

public A(B someone){               #在构造方法中将某个B类对象传入A的成员变量b中

this.b =
someone;

}

}

想要new A时，A a = new A(someone); someone为某个B类对象。（其实把A类写成内部类结构更好）

2015/8/16

1、java类在编译时，会直接初始化静态变量；在实例化时，才会按先后顺序初始化非静态变量，然后调用构造方法。