Java 历史
1995年5月23日，Java语言诞生
**1996年1月，第一个JDK(JDK1.0)诞生
**1996年4月，10个最主要的操作系统供应商申明将在其产品中嵌入JAVA技术
1996年9月，约8.3万个网页应用了JAVA技术来制作
1997年2月18日，JDK1.1发布
1997年4月2日，JavaOne会议召开，参与者逾一万人，创当时全球同类会议规模之纪录
1997年9月，JavaDeveloperConnection社区成员超过十万
1998年2月，JDK1.1被下载超过2,000,000次
1998年12月8日，JAVA2企业平台---J2EE发布
**1999年6月，SUN公司发布Java的三个版本：标准版（J2SE）、企业版（J2EE）和微型版（J2ME）
****2000年5月8日，JDK1.3发布
****2000年5月29日，JDK1.4发布
**2001年6月5日，NOKIA宣布，到2003年将出售1亿部支持Java的手机
2001年9月24日，J2EE1.3发布
2002年2月26日，J2SE1.4发布，自此Java的计算能力有了大幅提升
**2004年9月30日18:00PM，J2SE1.5发布，成为Java语言发展史上的又一里程碑。为了表示该版本的重要性，J2SE1.5更名为Java SE 5.0
**2005年6月，JavaOne大会召开，SUN公司公开Java SE 6。此时，Java的各种版本已经更名，以取消其中的数字“2”：J2EE更名为Java EE，J2SE更名为Java SE，J2ME更名为Java ME
*2006年12月，SUN公司发布JRE6.0
2009年04月20日，甲骨文74亿美元收购Sun，取得java的版权。
2010年9月，JDK7.0已经发布，增加了*简单闭包功能。
2011年7月，甲骨文公司发布java7的正式版。
操作系统按如下顺序寻找JRE环境:
命令:
1)编译
javac Hello.java
2)运行
java Hello.class
标识符
可以由中文字符、英文字符、下划线，$，和数字构成,
但不能以数字打头.
Java大小写敏感.
避开Java的关键字（例如 abstract，case，for等）.
标识符没有长度限制.
标识符命名习惯:
类名:每个单词首字母大写,其他小写;
接口名:与类名一致;
方法名:第一个单词首字母小写,其他单词首字母大写;
变量名:与方法一致;
常量名:全部大写,单词间以"_"连接;
包名:全部小写
Java常用关键字
**关键字 strictfp (**strict float point)
strictfp 关键字可修饰类、接口或方法。
使浮点计算严格执行IEEE-754规范。
关键字 transient (短暂的)
当持久化对象时，可能有一些成员变量，我们不想用serialization机制来保存它。
这时可以在这些域前加上关键字transient。
public class Test implements Serializable{ private static final long serialVersionUID = 5614914871710914541L; private String a; private transient int b; public String getA() { return a; } public void setA(String a) { this.a = a; } public int getB() { return b; } public void setB(int b) { this.b = b; } public String toString(){ return String.format("a:%s,b:%d", this.a,this.b); } public static void main(String[] args)throws IOException, ClassNotFoundException{ ObjectOutputStream out=new ObjectOutputStream(new FileOutputStream("test")); Test test=new Test(); test.setA("测试"); test.setB(30); System.out.println(test);//a:测试,b:30 out.writeObject(test); out.close(); // ObjectInputStream in=new ObjectInputStream(new FileInputStream("test")); Object obj=in.readObject(); if(obj instanceof Test){ test=(Test)obj; System.out.println(test);//a:测试,b:0 } in.close(); }}
访问修饰符
private,default,protected,public
对类，类的属性以及类的方法进行访问权限的控制
访问控制的限制程度由高到低:
private->default->protected->public
this关键字
this（当前类的实例）关键字经常出现在方法中，
用途：
1.返回调用当前方法的对象的引用
2.在构造方法中调用当前类中的其他构造方法
3.当方法参数名和成员变量名相同时，进行区分
super关键字
super（父类的实例）：
1.调用父类的构造方法
2.调用父类中的方法或属性
static关键字
在static修饰的方法中，不能调用没有static修饰的方法和属性，也不能使用this和super关键字
一个对象修改静态属性值后，会影响其他对象
public class A(){
public static int p=0;
}
A.p
或者
A a=new A();
a.p;
都可以.
static修饰自由块
static{
...
}
静态自由块，通常用于初始化静态变量.
静态自由块与类相关,只要类被加载,即时没有创建对象,也将被执行.
并且,无论创建几个对象,仅执行一次.
final关键字
final修饰类，表示该类不能再被继承；
public final class Person{
}
修饰成员变量，表示该变量是一个常量；
final int FEMALE=0;
final int MALE=1;
修饰方法，表示该方法不能在子类中重写.
public final void m1(){
}
instanceof关键字
instanceof是运算符,二元.
o instanceof A:对象o是A的实例,或A的子类的实例返回true,否则返回false.
通常这么写:
if(o instanceof A){
A a=(A)o;//类型转换
}
数据类型
简单数据类型和引用数据类型
简单类型变量直接存储变量的值;而引用类型变量存储的是对象的地址.
浮点数经度问题
float和double只能用来做科学计算或是工程计算,
商业计算中,用java.math.BigDecimal
基本类型和封装类型
int a=Integer.valueOf("123");
//
Integer i=new Integer(123);
System.out.println(i.toString);
int a=i.intValue();
Integer.MAX_VALUE<Float.MAX_VALUE
float f=3.4 错
float f=3.4f 对
字面值,整数默认为int,小数默认为double
int i=3;
long l=3L;//或3l
double d=3.14;
float f=3.14f;//或3.14F
局部变量和成员变量
局部变量必须先初始化（如果后面的代码有访问到它）,而成员变量有默认初始值，
传参：简单类型-值传递，引用类型-引用传递
运算符:
通常都是用短路与和短路或
if(表达式1&&表达式2){
}
if(表达式1||表达式2){
}
Java中不存在“运算符重载”
&逻辑与，&&短路与
如果f1()&f2()&f3()
如果f1()&&f2()&&f3()
&&效率高.
||与|类似.
x++和++x
int a=10;
int b=10;
int j=10+(a++);//j=20
int z=10+(++b);//z=21
x?y:z
反汇编可知:if...else...比三目运算符效率更高一些.
public static void main(String[] args){ boolean flag=true; long beginTime=System.nanoTime(); int a=flag?3:4; System.out.println("使用三目运算符?:,耗时"+(System.nanoTime()-beginTime)+"纳秒"); //使用三目运算符?:,耗时72356纳秒 beginTime=System.nanoTime(); if(flag){ a=3; }else{ a=4; } System.out.println("使用if..else...,耗时"+(System.nanoTime()-beginTime)+"纳秒"); //使用if..else...,耗时10057纳秒 }
short s=0;
s=s+1;(错，表达式s+1的计算结果是int,int赋给short变量,错误,需进行强制类型转换)
s+=1;（对,Java对**+=运算符,会自动进行类型转换**,相当于s=(short)(s+1)）
+=,-=,/=,*=与+=类似
字符串的+操作，底层实现是靠StringBuilder类的实例方法append
String的valueOf静态方法
==和equals（）是不同的
比较两个字符串是否相等,建议用equals()方法
String s="abc" //采用的是字符串缓冲池机制，效率高
String s=new String("abc")//会新建一个对象
int[]a和int a[]都是可以的.
建议用int[]a
public class Test { public void fun(int[]a){ } public static void main(String[] args){ Test test=new Test(); test.fun({1,2,3});//错误 test.fun(new int[]{1,2,3});//正确 }}
for :不能赋值
public static void print(int[]arr){ String str=""; for(int a:arr){ str+=a+" "; } System.out.println(str); } public static void main(String[] args){ int[]arr={1,2,3,4}; print(arr);//1 2 3 4 for(int a:arr){ a=0; } print(arr);//1 2 3 4 }
数组的复制
System类的静态方法
static void arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
数组的排序
public static void java.util.Arrays.sort(int[]a)，经过调优的快速排序算法,升序.
public static void java.util.Arrays.sort(byte[]a)
public static void java.util.Arrays.sort(char[]a)
public static void java.util.Arrays.sort(short[]a)
public static void java.util.Arrays.sort(long[]a)
public static void java.util.Arrays.sort(float[]a)
public static void java.util.Arrays.sort(double[]a)
public static void java.util.Arrays.sort(Object[] a)
根据元素的 自然顺序对指定对象数组按升序进行排序。数组中的所有元素都必须 实现 **Comparable** 接口。此外，数组中的所有元素都必须是 _可相互比较的_（也就是说，对于数组中的任何 e1 和 e2 元素而言， e1.compareTo(e2) 不得抛出 ClassCastException）。
保证此排序是_稳定的_：不会因调用 sort 方法而对相等的元素进行重新排序。
该排序算法是一个经过修改的合并排序算法（其中，如果低子列表中的最高元素小于高子列表中的最低元素，则忽略合并）。此算法提供可保证的 n*log(n) 性能。
compareTo
int compareTo(T o)
比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数。
public class Student implements Comparable<Student> { private String name; private int age; public Student(){ this.name=""; this.age=0; } public Student(String name,int age){ this.name=name; this.age=age; } public String toString(){ return String.format("name:%s,age:%d", this.name,this.age); } public int compareTo(Student student) { // 比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数。 if(this.age<student.age){ return -1; }else if(this.age==student.age){ return 0; }else{ return 1; } };}
public static void main(String[] args) { Student[] arr = { new Student("s1", 50), new Student("s2", 30), new Student("s3", 30), new Student("s4", 10) }; Arrays.sort(arr); for (Student s : arr) { System.out.println(s); } /* * name:s4,age:10 * name:s2,age:30 * name:s3,age:30 * name:s1,age:50 */ }
数组索引从0开始
