Java知识点：琐碎知识点(1)

Java基本介绍

SUN:Stanford University Network
Java之父：James Gosling
Java的跨平台性因为有Java虚拟机，运行class文件。
Java吉祥物：Duke
JDK是用来开发的（编译Java程序），而如果只运行Java程序，则只需要JRE即可。
而JDK也是用Java写的，因此如果要编译Java程序，也要JRE，因此在JDK目录中也会有一个JRE目录。
第三方的JAR包（dom4j.jar）都是由class文件组成的，Eclipse的“add to build path”就是将jar包加入环境变量classpath中。

标识符命名规范

关键字必须是小写

1. 不能用Java的关键字作为标识符名称。
2. 以“字母、$、下划线”作为开始。
3. 允许“字母、$、下划线、数字”。

花括号的对齐方式

void fun()        //建议使用                                                     void fun(){　　　　//不建议使用
{　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

}　　　　　　　　　　　　　　　　　　　　　　　　　　　　　}

类、接口、方法、变量命名规范

• 类： 名词，比如 Apple
• 接口：形容词，比如Serializable（可序列化）
• 方法：动词+名词，比如 doCalculation()
• 变量：名词

JavaBeans 命名规范

• JavaBeans是一个带有属性的Java类。
• 如果属性是Boolean类型，则getter方法可以是isXxx()或getXxx()； 如果属性是非Boolean类型，则getter方法可以是getXxx()。
• setter方法的命名是：setXxx()。
• 对于监听器方法，命名规范为：addXxxListener() 和 removeXxxListener()。

Strictfp

• strictfp: strict floating-point calculation(严格浮点运算)
• 介绍：strictfp 是 Java 的关键字(keyword)，自从 Java 1.2 以来被引入，使得浮点运算遵循 IEEE 754 标准。
• 目的：portable（可移植性）。
• 需求：在每个平台（机器）上（32位、64位）的浮点运算精度相同，比如，使用 strictfp 规定浮点运算的精度是32位，而在64位的机器上浮点运算可以精确到64位，但是使用strictfp后，就算在64位的机器上运行程序，浮点运算精度仍为32位。

 1 public class Strictfp

 2 {

 3     public static void main(String args[])

 4     {

 5         A a = new A();

 6         System.out.println(a.subtract1(2.00,1.10));

 7         System.out.println(a.subtract2(2.00,1.10));

 8     }

 9 }

10 

11 class A

12 {

13     public double subtract1(double left,double right)

14     {

15         return left - right;

16     }

17     public strictfp double subtract2(double left,double right)

18     {

19         return left - right;

20     }

21 }

局部变量

• 声明局部变量时建议要初始化，虽然不初始化本身不会编译错误，但是你使用了未初始化的变量时会Compile Error。

int a;

System.out.println(a);    //Compile Error:"可能尚未初始化变量 a"

a+=b 与 a=a+b的区别

　（假设a的类型是A，b的类型是B）

• a+=b  等价于  a=(A)(a+b)

异常分类

• RuntimeException：不用捕获或声明抛出的异常，如NullPointerException。
• 检验异常：需要捕获或声明抛出的异常。
• Error：机器内部错误。

进制转换

 1 public class Wrapper01

 2 {

 3     public static void main(String[] args) {

 4         System.out.println(Integer.parseInt("111100",2));                                    //二进制 -> 十进制

 5         System.out.println(Integer.toHexString(Integer.parseInt("111100",2)));    //二进制 -> 十六进制

 6         System.out.println(Integer.toOctalString(Integer.parseInt("111100",2)));    //二进制 -> 八进制

 7 

 8         System.out.println(Integer.parseInt("74",8));                                            //八进制 -> 十进制

 9         System.out.println(Integer.toBinaryString(Integer.parseInt("74",8)));        //八进制 -> 二进制

10         System.out.println(Integer.toHexString(Integer.parseInt("74",8)));        //八进制 -> 十六进制

11 

12         System.out.println(Integer.toHexString(60));                                            //十进制 -> 十六进制

13         System.out.println(Integer.toOctalString(60));                                            //十进制 -> 八进制

14         System.out.println(Integer.toBinaryString(60));                                            //十进制 -> 二进制

15 

16         System.out.println(Integer.toBinaryString(Integer.parseInt("3C",16)));    //十六进制 -> 二进制

17         System.out.println(Integer.toBinaryString(Integer.parseInt("3C",16)));    //十六进制 -> 二进制

18         System.out.println(Integer.parseInt("3C",16));                                        //十六进制 -> 十进制

19     }

20 }

不用第三方变量交换整数

a = a ^ b;

b = a ^ b;    //(a^b)^b=a ,现在b=a

a = a ^ b;    //(a^b)^a = b,现在a=b

临时环境变量设置

• set PATH    //显示PATH
• set PATH=XXXXX   //设置PATH

方法重写

　　假设原方法为A，重写的方法为B

• 方法B的返回类型可以是方法A的返回类型的子类型。
• 方法B不能抛出比方法A更多的异常。
• 方法B的访问控制不能比方法A的更限制。

 重写与重载的区别

	重载	重写
参数	必须改变	一定不能改变
返回类型	可以改变	一般不改变
异常	可以改变	只能抛更小的异常
访问级别	可以改变	一定更广
调用	编译时决定调用哪个重载版本	运行时决定调用哪个重写方法

 1 public class Polymorphism02

 2 {

 3     public static void fun(Student student)

 4     {

 5         System.out.println("调用了以Student为参数的函数");

 6         student.print();

 7     }

 8     public static void fun(Person person)

 9     {

10         System.out.println("调用了以Person为参数的函数");

11         person.print();

12     }

13     public static void main(String[] args) {

14         Person person = new Student();

15         fun(person);        //调用了fun(Person person)，但是因为多态性，所以函数中的person.print()调用了Student的print方法

16     }

17 }

18 

19 class Person

20 {

21     public void print()

22     {

23         System.out.println("Person");

24     }

25 }

26 class Student extends Person

27 {

28     public void print()

29     {

30         System.out.println("Student");

31     }

32 }

初始化块

• 静态代码块：加载类时被执行，即使创建了多个类对象，但是只在第一次创建前执行静态代码块。
• 一般初始块：调用构造函数的super语句（第一句）后执行。

 1 public class InitializationBlock01

 2 {

 3     public static void main(String[] args) {

 4         //output: a b z c d e f c d e f

 5         System.out.println("z");

 6         B b = new B();    

 7         B c = new B();

 8     }

 9 }

10 class A

11 {

12     {

13         System.out.print("c ");

14     }

15     public A()

16     {

17         System.out.print("d ");

18     }

19 }

20 class B extends A

21 {

22     static

23     {

24         System.out.print("a ");

25     }

26     public B()

27     {

28         System.out.print("f ");

29     }

30     {

31         System.out.print("e ");

32     }

33     static

34     {

35         System.out.print("b ");

36     }

37 }

位运算

• a >> b ：a是int，则有32位，这个运算是将a有符号右移(b%32)位；a是long，则有64位，这个运算是将a有符号右移(b%64)位.
• a >>> b: a是int，则有32位，这个运算是将a无符号右移(b%32)位；a是long，则有64位，这个运算是将a无符号右移(b%64)位.
• a << b : a是int，则有32位，这个运算是将a左移(b%32)位；a是long，则有64位，这个运算是将a左移(b%64)位.