Java知识点

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 }
复制代码

局部变量

  • 声明局部变量时一定要初始化。
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 }
复制代码

 

作者:xiazdong
出处:http://www.cnblogs.com/xiazdong
本文版权归作者和博客园共有,欢迎转载,但未经作者同意必须保留此段声明,且在文章页面明显位置给出原文连接,否则保留追究法律责任的权利。

你可能感兴趣的:(java)