J2SE学习历程

2014/12/09

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

int c = 12;

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

二、若是a=2，b=a++，先赋值再运算，b为2，a为3；b=++a，先运算再赋值，b为3，a为3.

2014/12/10

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

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

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

2014/12/13

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

 

2014/12/15

一、方法重载（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

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

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

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

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

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

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

2014/12/19

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

c1

 

c2

 

第一个对象

 

第二个对象

 

 

 

 

 

 

 

 

 

 

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

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

二、  对象转型。

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

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

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

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

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

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

 

2014/12/20

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

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

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

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

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

六、  方法抛出异常须要两个操做：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)的类；

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

2014/12/22

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

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

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

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);在堆中生成对象，并用数组中保存的引用指向他们。

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

2014/12/31

一、  比较字符串时。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

一、  二维数组在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

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

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

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

2015/1/25

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

2015/3/10

一、  容器。在 容器.remove(something) 时，something会与容器中全部对象进行equals，

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

2015/3/15

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

2015/3/25

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

2015/7/10

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

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

 

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

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

（不一样机器差别）。因此有时要用到sleep。

2015/7/16

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

二、  事件监听：继承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

一、  持有引用：一个类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

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