JAVA开发讲义(二)-Java程序设计之数据之谜一

JAVA开发讲义(二)-Java程序设计之数据之谜一

程序之美

创建第一个java程序，hello world;

public class test{
public static void main(String[] args){
System.out.println("hello,worid");
}
}

看到寥寥数笔，一个简单的JAVA程序就写好了，下面我们进行编译和运行

编译命令：javac test.java
运行命令：java test

Java之所以支持跨平台，其最大的功劳者主要是Java虚拟机（Java Virtual Machine，简称 JVM），也就是我们经常所说的JVM，JVM是一个”桥梁“，是一个”中间件“，是实现跨平台的关键，Java代码首先被编译成字节码文件，再由JVM将字节码文件翻译成机器语言，从而达到运行Java程序的目的。

数据类型

java 是一种强类型语言。也就是说，每一变量必须声明一种类型。Java中，共有8中基本的数据类型，其中4种整型，2中浮点型，一种字符型char和一种真值的boolean类型。

整型

整型是一种数值，没有小数部分，允许为负数。在Java中整型分为四种类型：int, short, long, byte.

类型 存储需求 取值范围
int   4个字节  -2147483648 ~ 2147483647 
short 2个字节  -32768 ~ 32767
long  8个字节  -9223372036854775808 ~ 9223372036854775807
byte  1个字节  -128 ~ 127

这里重点说下int/long类型, 熟知C/C++的小伙伴应该知道，C/C++的int/long型随着操作系统的不同而不同，比如32为操作系统C/C++的int/long型为32位4个字节，而64位操作系统的C/C++的int/long型为64位即为8个字节。而在Java中，int/long型的取值范围和存储和操作系统无关，int型永远为4个字节，long永远为8个字节。这样就大大提高了Java程序的可移植性。
下面说下这几种类型的转换：

public class DataTransferHelper
{
/**
     * 将一个单字节的byte转换成32位的int
     * 
     * @param b
     *            byte
     * @return convert result
     */
    public static int unsignedByteToInt(byte b) {
        return (int) b & 0xFF;
    }

    /**
     * 将一个单字节的Byte转换成十六进制的数
     * 
     * @param b
     *            byte
     * @return convert result
     */
    public static String byteToHex(byte b) {
        int i = b & 0xFF;
        return Integer.toHexString(i);
    }

    /**
     * 将一个4byte的数组转换成32位的int
     * 
     * @param buf
     *            bytes buffer
     * @param byte[]中开始转换的位置
     * @return convert result
     */
    public static long unsigned4BytesToInt(byte[] buf, int pos) {
        int firstByte = 0;
        int secondByte = 0;
        int thirdByte = 0;
        int fourthByte = 0;
        int index = pos;
        firstByte = (0x000000FF & ((int) buf[index]));
        secondByte = (0x000000FF & ((int) buf[index + 1]));
        thirdByte = (0x000000FF & ((int) buf[index + 2]));
        fourthByte = (0x000000FF & ((int) buf[index + 3]));
        index = index + 4;
        return ((long) (firstByte << 24 | secondByte << 16 | thirdByte << 8 | fourthByte)) & 0xFFFFFFFFL;
    }

    /**
     * 将16位的short转换成byte数组
     * 
     * @param s
     *            short
     * @return byte[] 长度为2
     * */
    public static byte[] shortToByteArray(short s) {
        byte[] targets = new byte[2];
        for (int i = 0; i < 2; i++) {
            int offset = (targets.length - 1 - i) * 8;
            targets[i] = (byte) ((s >>> offset) & 0xff);
        }
        return targets;
    }

    /**
     * 将32位整数转换成长度为4的byte数组
     * 
     * @param s
     *            int
     * @return byte[]
     * */
    public static byte[] intToByteArray(int s) {
        byte[] targets = new byte[2];
        for (int i = 0; i < 4; i++) {
            int offset = (targets.length - 1 - i) * 8;
            targets[i] = (byte) ((s >>> offset) & 0xff);
        }
        return targets;
    }

    /**
     * long to byte[]
     * 
     * @param s
     *            long
     * @return byte[]
     * */
    public static byte[] longToByteArray(long s) {
        byte[] targets = new byte[2];
        for (int i = 0; i < 8; i++) {
            int offset = (targets.length - 1 - i) * 8;
            targets[i] = (byte) ((s >>> offset) & 0xff);
        }
        return targets;
    }

    /**32位int转byte[]*/
    public static byte[] int2byte(int res) {
        byte[] targets = new byte[4];
        targets[0] = (byte) (res & 0xff);// 最低位
        targets[1] = (byte) ((res >> 8) & 0xff);// 次低位
        targets[2] = (byte) ((res >> 16) & 0xff);// 次高位
        targets[3] = (byte) (res >>> 24);// 最高位,无符号右移。
        return targets;
    }

    /**
     * 将长度为2的byte数组转换为16位int
     * 
     * @param res
     *            byte[]
     * @return int
     * */
    public static int byte2int(byte[] res) {
        // res = InversionByte(res);
        // 一个byte数据左移24位变成0x??000000，再右移8位变成0x00??0000
        int targets = (res[0] & 0xff) | ((res[1] << 8) & 0xff00); // | 表示安位或
        return targets;
    }
}

下面说下数值的表达
长整型数值有一个后缀L或l，例如4000000000L。
十六进制数值有一个前缀0x, 例如0xFF
八进制数值有一个前缀0, 例如010,对应十进制中的8.
二进制数值有一个前缀0b或0B， 例如0b1001对应十进制就是9.

浮点类型

浮点类型用于表示小数部分的数值。Java中包含两种浮点类型：
类型 存储需求 取值范围
float 4字节 大约

double 8字节 大约

double表示这种类型的数值精度是float类型的两倍，故而称之为双精度数值。其实在实际应用中，float大部分情况很难满足需求，大家都采用的是double类型，只有需要单精度数据的库或者需要储存大量数据等采用到float类型。
float类型的表示有一个后缀F或f,如3.1415F,如果没有后缀，如3.14,这种浮点数值默认为double类型。当然也可在浮点数值添加后缀D或d,如3.14D等。
表示溢出或出错情况的三种特殊的浮点数值：
正无穷大
负无穷大
NaN(不是一个数字)
例如，一个正整数除以0的结果为无穷大，计算0/0或者负数的平方根结果为NaN.

浮点数值非的检测：

if(x == Double.NaN){//错误的
}

应该这样：

if(Double.isNaN(x)){//正确的
}

如果在数值计算中不允许有任何舍入伍差，需使用BigDecimal类，以后有机会我会和大家详细讲解。

char类型

char类型表示单个字符。说到char,小伙伴很容易想到Unicode字符，Unicode字符有些字符可以用一个Char描述，有的字符需要用两个Char值来描述。
char类型的表示
char 类型值要用单引号括起来。如‘B’表示编码值为66,char类型也可以表示一个十六进制的值，范围从\u0000到\Uffff.例如\u03C0表示希腊字母兀.
表示特殊字符的转义序列，参见如下表。

例如：public static void main(String\u005B\u005D args)就完全符合语法规则，\u005B和\u005D是[和]的编码。

关于Unicode和char类型，我们需要讲解的太多，后面有机会我会详细给小伙伴们叙述，这里就不过多讲述。

boolean类型

boolean(布尔)类型有两个值，分别为false和true,用于逻辑判断。整型值和布尔值之间不能进行相互转换。
但是在实际应用中我们可以用整型值参与boolean值判断，如下

int x = 1;
if(x == 1){
}

变量

在Java中，每一个变量都有一个类型。变量就相当于值得一个载体，可以装在值。例如：

double pi;
int day;
long length;
boolean done;

另外说几种定义变量赋值的方式：

int i,j;
i = 0;
j = 0;

int i = 0, j = 0;

int i = 0, j;
j = 0;

都可以，也就是说变量可以在定义的时候初始化，也可以使用的时候初始化。
不过不建议一次声明多个变量，因为逐一声明每一个变量可以提高程序的可读性。

变量的初始化
声明一个变量后，必须使用赋值语句对其进行显示的初始化，不能使用未初始化的变量，否则会产生意想不到的后果。如下

int days;
System.out.println(days);

编译器就会提示编译错误。ERROR–variable not initialized

对一个声明过的变量赋值，需要使用等号=，将变量放在等号的左侧，值放到等号的右侧。如下：

int days;
days = 100;

当然也可以合二为一。

int days = 100;

声明变量可以放到代码的任何地方。
下面再说下：
C语言中：

int i = 0;是一个定义

extern int i;是一个声明

而在Java中，不区分变量的声明与定义。

常量

在java中，常量是用关键字final指示的值。如：

public class test{
public static void main(String[] args){
final int MAX_DAY = 100;
System.out.println("最大天数为：" + MAX_DAY);
}
}

final int MAX_DAY = 100;中MAX_DAY就是一个常量，他只能被赋值一次，一旦被赋值，就不能被修改。一般我们定义常量都是用大写的方式。

如果想定义一个全局常量，希望它在很多地方都能用，可以定义为类常量。如下：

public class test{
public final int MAX_DAY = 100;
public static void main(String[] args){

System.out.println("最大天数为：" + MAX_DAY);
}
}

在其他类中使用时应该加上类标志：test.MAX_DAY.

运算符

Java中同样有算术运算符，如+、-、*、/等表示加、减、乘、除等运算。%表示整数的求余操作(有时称为取模)，例如5%2 = 1等。
JAVA的可移植性是大家一致公认的，同样的一个运算无论在哪个虚拟机上运行，结果都应该一样。为了保证结果的一致性。java采用了截断机制，这个机制遭到了数值计算团体的反对。截断不但可能导致溢出，而且截断需要消耗时间，单只计算速度变慢。java程序设计语言承认了最优性能与理想结果之间存在冲突，并给予改进。虚拟机设计者对于中间计算结果采用扩展的精度。对于使用strictfp标记的函数中的所有指令都将采用严格的浮点计算。实际的计算方式将取决Intel处理器的行为。使用默认的方式不会产生溢出，而使用严格的计算有可能产生溢出。

数学函数与常量
在Math类中，包含了各种各样的数学函数。在编写程序是，我们可以直接使用，这样就能够事半功倍。
如下计算平方根

public class test{
public static void main(String[] args){
double x = 4;
double y = Math.sqrt(x);
System.out.println(y);
}
}

结果为:2.0

另外着重说下pow这个函数， 这个函数是求x的y次方。如下：

public class test{
public static void main(String[] args){
double x = 4;
double y = Math.pow(x, 3);
System.out.println(y);
}
}

结果为：64.0
当然Math类中也提供了一些常用的三角函数：

Math.sin
Math.cos
Math.tan
Math.atan
Math.atan2

指数函数以及它的反函数：

Math.exp
Math.log
Math.log10

兀和e常量的近似值：

Math.PI
Math.E

完整使用过程：

import static java.lang.Math.*;
public class test{
public static void main(String[] args){
double x = 4;
double y = Math.pow(x, 3);
System.out.println(y);
}
}

数值类型转换和强制转换

在使用过程中，我们经常会用到将一种数据类型转换为另外一种数据类型。说到数值类型转换，人们主要关心的是是否转换有无信息丢失，例如123456789是一个大数，所包含的位数比float类型位数多，当将这个整形数值转换为float类型时，将会得到同样大小的结果。
例如:

int n = 123456789;
float f = n;//f is 1.23456792E8

当将上述两个数值进行二元操作时(例如 n + f, n 是整数，f是浮点数)，操作数转换为同一种类型，然后进行计算。
1、如果两个操作数中有一个是double类型，另一个操作数就会转换为double类型。
2、否则，如果其中一个操作数是float类型，另一个操作数将会转换为float类型。
3、否则，如果其中一个操作数是long类型， 另一个操作数将会转换为long类型。
4、否则，两个操作数都将被转换为int类型。

强制数值转换有可能丢失一部分信息，需要强制类型转换(cast)实现这个操作。强制类型转换的语法格式是在圆括号中给出想要转换的目标类型，后面紧跟待转换的变量名。例如：
double x = 9.997;
int nx = (int)x;
这样，变量值为9.强制类型转换通过截断小数部分将浮点值转换为整型。
如果想对浮点数进行舍入运算，以便得到最接近的整数，那就需要使用Math.round方法：

double x = 9.997;
int nx  = (int)Math.round(x);

这时变量nx的值为10。当调用round的时候，仍然需要使用强制类型转换
(int)。其原因是round方法返回的结果为long类型，由于存在信息丢失的可能性，所以只有使用显式的强制类型转换才能够将long类型转换成int类型。当进行强制类型转换，而有超出了目标类型的表示范围，结果会截然不同。例如，(byte)300的实际值为44。

结合赋值和运算符

可以在赋值中使用二元运算符，是一种方便简洁的书写形式。如

x += 6;

实质上相当于 x = x + 6;
(一般的，要把运算符放在等号左边，如*=或%=)

自增自减运算符

自增运算符 ++ 会把操作数加 1，自减运算符 – 会把操作数减 1，如下：
x = x + 1;
等价于：
x ++;

同样的：
x = x - 1;
等同于：
x --;

由上可知，无论增减，都可以放在操作数的前面（前缀）或后面（后缀）。例如：

x = x+1;

可以写成：

++x; // 前缀形式
或者：

x++; // 后缀形式
但是当我们进行赋值的时候要注意：
a = x ++;
x是先赋值，然后进行++,等于++并未合并到赋值语句。同样：
a = ++x;
x是先进行++，然后进行赋值这个时候a = x + 1;

关系和boolean运算符

在Java中，使用&&表示逻辑“与”运算符，使用||表示逻辑“或”运算符。而且Java支持三元操作符?:。如果条件为true,表达式为：条件？操作1：操作2，则执行操作1。
处理整型类型时，可以直接对组成整型数各个位完成操作。这意味这可以使用掩码技术得到各个位。位运算符如下
& （“and”） |(“or”) ^(“xor”) ~(“not”)

import java.util.*; // 导入Scanner类

public class BooleanValue {
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        boolean flag;// 声明一个boolean类型的变量，注意没有初始化
        double dScore;
        double pScore;// 声明一个double类型的变量，保存lisi的成绩
        System.out.println("请输d的成绩：");
        dScore= input.nextInt();   // 输入d的成绩
        System.out.println("请输入p的成绩：");
        pScore= input.nextInt();        // 输入p的成绩
        flag = dScore== pScore; // 将比较结果保存在flag中
        System.out.println("d的成绩和p的成绩相同吗?" + flag); // 结果
    }
}

位运算符

位运算符用来对二进制位进行操作，Java中提供了如下表所示的位运算符：位运算符中，除～ 以外，其余均为二元运算符。 操作数只能为整型和字符型数据。
下面简单说下按位与：
00000010(2)
&00000101(2)
00000000(2)
由此可知2&5=0
C语言代码为：

# include <stdio.h>
int main(int argc, int[] args){
int a = 2;
int b = 5;
printf("%d", a & b);
getchar();
return 0;
}

括号和运算符级别

括号和运算符级别参见下表：

枚举类型

枚举类型(enumeration)是 C++ 中的一种派生数据类型，它是由用户定义的若干枚举常量的集合。

定义格式为：
enum <类型名> {<枚举常量表>};

enum 定义其后的标识符是一个枚举类型的名字。
由枚举常量构成枚举常量表，以标识符形式表示的整型量，各枚举常量之间以“，”间隔，各不相同，取值类型与条件表达式相同。例如：
enum week{sun, mon, tue, wed, thu, fri, sat};
注意序号是从0开始，依次之后的枚举常量值加1，各枚举常量的值可以重复。例如：
enum week {sun = 7, mon = 1, tue, wed, thu, fri, sat};

好了，今天就讲到这里吧，之后的下次在讲吧，希望我讲解的能够帮助徘徊在Java边缘的初学者们，感谢你们阅读我的文章。