Java 编程基础
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规范。
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开始
