Java 编程基础

最新推荐文章于 2024-09-15 19:46:31 发布

weixin_34227447

最新推荐文章于 2024-09-15 19:46:31 发布

阅读量73

点赞数

文章标签： java 操作系统数据结构与算法

原文链接：https://my.oschina.net/smilethat/blog/49187

版权

2019独角兽企业重金招聘Python工程师标准>>>

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
         */
    }