Java开发环境、数据类型和运算符介绍

这篇文章的知识点包括：Java的开发环境使用介绍、Java数据类型的使用介绍以及运算符的使用介绍，阅读完整文相信大家对java的有更深学习。

Java集成开发环境

eclipse的使用方法

之前我们在体验java编程或者写小的demo的时候，都是命名一个.java的源文件，在dos界面中编译和运行，但是这样给人的感觉并不友好，为了解决这一问题，一些大佬便开发了与各种语言对应的集成开发环境，其中包含文本编辑处理，自动编译，简化运行，随时进行代码调试。

目前来说，比较流行开源的集成开发环境：eclipse、IDEA、NetBeans

对于初学者而言，eclipse推荐使用，而且用的也比较多。

注意：安装的eclipse须与之前安装的jdk位数一致（我的是64位的）这里具体的安装步骤比较简单，就不赘述了，大家可以在网上查找视频更加方便直接。

eclipse用法：安装后打开eclipse软件，使用前通过以下方法设置。

1、选择工具栏的窗口——首选项——弹出对话框选择常规下拉菜单中的启动和关闭如下图设置:

2、选择菜单栏中的文件——重新启动；就会弹出如下对话框

3、如何使用其来编写、编译和执行java程序？

菜单栏选择文件——新建——其他——Java项目，谈出如下对话框

之后软件右侧会生成一个你自己命名的项目名称的文件夹；点开选择src——右键选择新建——class（类），弹出如下对话框，进行设置；

字体设置可以在窗口——首选项——外观——颜色和字体上设置——文本字体设置，如下图所示：

我们通过上面介绍的集成开发环境来回顾之前的学习内容。编写如下代码：

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

}

那么我们如何编译运行呢？

eclipse集成开发环境中我们只要使用菜单栏中的运行按钮就可以自动编译运行了，是不是非常方便。如下图所示：

以上就是关于eclipse的具体设置方法和运行java程序的步骤了。

变量和数据类型

我们继续在方才的代码案例中回顾变量和几种数据类型吧。

1、基本数据类型

public class Test {
    public static void main(String[] args) {
        //System.out.println("hello world");

        int i = 0;
        i = 1;
        int j = 2;
        i = j;
        System.out.println(i);
    }

}

输出的结果为 2，这说明变量是会随着赋值改变而改变，同一类型的变量之间也可以互相赋值。但如果是不同类型的呢？比如将上面的i赋值给byte k 就会报错了。但是赋值给long就可以。

public class Test {
    public static void main(String[] args) {
        //System.out.println("hello world");

        /*int i = 0;
        i = 1;
        int j = 2;
        i = j;
        System.out.println(i);*/

        int i = 2;
        byte a = i;
        long b = i;
        System.out.println(b);
    }

}
//结果如下图所示

我们可以给出下面的包含转换关系：

char、byte、short（此三者不可以互相转换）——》int——》long——》float——》double

我们称这种转换为系统的自动转换，那么可想而知，假设有多种类型的数据混合运算时，系统首先会将所有的数据自动转换为容量（表数范围）最大的那种数据类型，然后进行运算。

2、字符类型运算

public class Test {
    public static void main(String[] args) {
        /*int i = 1;
        short a = 2;
        byte b = 3;
        int value = i + a + b;
        System.out.println(value);*/

        char c = 'a';
        int d = 1;
        int e = c + d;
        System.out.println(e);
    }

}

结果为98，表示这个c字符为97，原因是由于ASCII码，大家可以百度查询一下；这个结果表明char类型的 数据在与数字进行数学运算时，是转为对应的ASCII码进行计算。

3、字符串混合运算

注意！！！

当把任何基本类型的值和字符串值进行连接运算时（+），基本类型的值将自动转换为字符串类型。例如：

public class Test {
    public static void main(String[] args) {
        String s = "hello";
        int a = 1;
        String str = s + a;
        System.out.println(str);
        //上面两行代码可以简化为：System.out.println(s+a);
    }
}

运行结果：hello1

体会下图代码运行的结果：

小结：在进行包含字符串的混合运算时，字符串前面的运算为正常运算，后面的所有类型都转换为字符串类型的计算。

4、强制类型转换

概念——自动类型转换的逆过程，将表数范围大的数据类型转换为小的数据类型。

1、使用是要加上强制转换符（（）），即英文括号，但这可能造成精度降低或溢出，要特别注意。

例如：

public class Test {
    public static void main(String[] args) {

        int c = 9;
        byte b = (byte)c;//数据类型使用英文括号括起来

        System.out.println(b);
    }

}

运行结果：9

2、通常，字符串不能直接转换为基本类型，但通过基本类型对应的包装类型可以实现将字符串转换成基本类型。例如：

public class Test {
    public static void main(String[] args) {

        String  a = "43";

        int i =  Integer.parseInt(a);
        System.out.println(i);
    }

}

运行结果：43

3、注意！！！

Boolean类型不可以转换为其他的数据类型

运算符

下面我们来谈谈在java编程语言中运算符的相关知识。

简单而言，运算符是一种特殊的符号，用以表示数据的运算、赋值和比较等。分为以下几类：

算术运算符、赋值运算符、比较（关系）运算符、逻辑运算符、位运算符、三元运算符。下面逐一介绍。

4.1算数运算符

算数运算符的种类如下图所示

加减乘除就不用解释了，正常的数学运算。大家自己可以实践去敲代码验证。举几个例子给大家去自己验证：

public class Test {
    public static void main(String[] args) {

        System.out.println(- 2);
        System.out.println(- -2);
        System.out.println(6 / 2);
        System.out.println(6 / 5);
        System.out.println(6.0 / 5.0);
        System.out.println(6.44 / 3.0);
    }

}

结果如下图所示：

表明整数之间的除法是取整的，小数则不是如此。

上面的%表示取模就是去余数，好比7%5就是2；

++表示自增--表示自减；上面的解释还是比较理论了，还是通过实际demo来体会验证一波吧：

public class Test {
    public static void main(String[] args) {

        int i = 0;
        int j = 0;
        int m = i++;
        int n = ++j;

        System.out.println(i);
        System.out.println(j);
        System.out.println(m);
        System.out.println(n);

    }

运行结果如下：

从以上结果可以看出，i++给变量赋值时是想将自己的值赋值给变量，而++i则是将自己增加之后的值赋值给变量，但是最终的结果都会使自身（上例中的i和j）增加1，同理--也是一样。

当然+号也可以用于字符串的拼接，前面我们已经举过例程，不再赘述了。

4.1.1算数运算符需要注意的一些问题

1、取余（取模）——%

如果对负数取模，可以把模数负号忽略不计，如：5%-2=1.但是被模数是负数则不可忽略。此外，取模运算的结果不一定总是整数。例：

public class Test {
    public static void main(String[] args) {

        System.out.println(5 % -2);
        System.out.println(-5 % 2);
        System.out.println(5 % -2.1);

    }

}

运行结果如下：

1
-1
0.7999999999999998

2、整数之间的除法只保留整数部分，例：

int x = 3512;
x = x/1000*1000;

结果是3000；

3、“+”除字符串相加以外，也可以将非字符串转换为字符串，例：

System.out.println("5+5="+5+5);

结果是：5+5=55，这里是字符串拼接前面讲述过的。

4、单引号和双引号的区别

看下面实例：

public class Test {
    public static void main(String[] args) {

        System.out.println('*' + '\t' + '*');
        System.out.println("*" + "\t" + "*");
    }

}

结果如下：

单引号表示单个字符，计算时会转换为ASCII码运算，而双引号则是正常输出，\t表示的是一个Tab键的间距。

4.2赋值运算符

符号“=”；当“=”两侧数据类型不一致时，可以使用自动类型转换或使用强制类型转换原则进行处理；

支持连续赋值

扩展赋值运算符：+=；-=；*=；/=；%=；下面通过实际案列代码进行剖析：

public class Test {
    public static void main(String[] args) {

        int i = 1;
        short s = 2;

        i = s;//自动类型转换
        s = (short)i;//强制类型转换

        int j=2;
        int k=2;
        j=k=2;//运行连续赋值
        System.out.println(j + "," + k);//输出结果应为：2,2

        //扩展赋值运算举例
        i = i + 2;//可以换成以下写法（这里i初始值为2了）
        i += 2;//i变为6
        System.out.println(i);//输出结果应为6

        //s = s + 2;错误写法因为s会被自动转换为int类型的变量，改为s = (short)(s + 2);
        s += 2;//这种写法是不是更加方便？自动强制类型转换了。
        System.out.println(s);//输出结果应为4
    }

}

结果如下：

2,2
6
4

使用扩展运算符时，变量在参与运算时会把结果强制转换为当前变量的类型。

那么思考下面的一个问题：

public class Test {
    public static void main(String[] args) {

        int i = 1;
        i *= 0.1;
        System.out.println(i);
    }

}

结果为0

原因：扩展运算自动强制转换为int类型

4.3比较运算符

比较运算符就是用于比较的，诸如比较是否相等，大于小于等等。

比较运算符如下：

比较运算符的结果是boolean型，即结果为true 或者 false；在后面我们讲解控制流程语句中会使用的非常多，下面举简单的例子体会一下：

public class Test {
    public static void main(String[] args) {

        System.out.println(4>5);
        System.out.println(4<5);
    }

}

结果为：

false
true

4.4逻辑运算符

逻辑运算符——用于逻辑判断，学习过数字电路的应该非常熟悉了。下面直接罗列出来：

&——逻辑与  |——逻辑或  ！——逻辑非

&&——短路与 ||——短路或 ^——逻辑异或

第一行可能不少人都比较熟悉，而第二行有些就不太清楚了；我们先看下面一张表：

逻辑与——表示a和b都为true才成立；逻辑或——表示a或b有一个成立就可以；逻辑非——表示去反逻辑；逻辑异或——表示a和b有一个成立且一个不成立才为true；短路与——和逻辑与判断的结论是一致的；短路或——和逻辑或判断的结论是一致的。

下面给出例程：

public class Test1 {
    public static void main(String[] args) {
        System.out.println(4 == 4 & 1 == 1);
        System.out.println(4 == 4 && 2 == 1);
        System.out.println(4 == 4 || 1 != 1);
    }
}

运行结果：

true
false
true

4.4.1逻辑运算符实际使用是需要注意的地方

1、逻辑运算符用于连接布尔型表达式，在Java中不可以写成3<x<6，应该写成x>3 & x<6 。

2、“&”和“&&”的区别：

• 单&时，左边无论真假，右边都进行运算；
• 双&时，如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。

举个例子验证一下：

public class Test1 {
    public static void main(String[] args) {

        int i = 0;
        int j = 1;
        System.out.println(i != 0 & j++ == 2);
        System.out.println(j);//单&左边为真或假右边都执行运算，此时j=2

        System.out.println(j == 2 && i++ == 1);
        System.out.println(i);//双&左边为真，右边参与运算，此时i=1

        System.out.println(j != 2 && i++ == 2);
        System.out.println(i);//双&&左边为假，右边不运算，此时i仍为1
        //以上输出判断语句的结果都为false
    }
}

结果：

false
2
false
1
false
1

3、“|”和“||”的区别同理，||表示：当左边为真，右边不参与运算。

public class Test1 {
    public static void main(String[] args) {

        int i = 0;
        int j = 1;
        System.out.println(i != 0 | j++ == 1);//注意和++j的区别，看最下面的++i
        System.out.println(j);//单|左边为真或假右边都执行运算，此时j=2

        System.out.println(j == 2 || i++ == 0);
        System.out.println(i);//双|左边为真，右边不参与运算，此时i=0

        System.out.println(j != 2 || ++i == 1);
        System.out.println(i);//双|左边为假，右边参与运算，此时i=1
        //以上判断的结果都为true
    }

结果如下：

true
2
true
0
true
1

小结：在不需要逻辑运算两边都参与运算的时候，尽量使用&&和||

4、异或( ^ )与或( | )的不同之处是：当左右都为true时，结果为false。

理解方法口诀：异或，追求的是“异”!

4.5位运算符

位运算是直接对二进制进行运算，请看下面表格：

编程的时候一般比较少但是面试笔试的时候比较多，因此还是需要了解的。可能有些朋友对二进制还不太了解，可以百度一下，不算难的哈！

4.5.1移位运算符

下面举例说明为运算符使用时左移右移和无符号右移。

public class Test1 {
    public static void main(String[] args) {

    int x = 8,y = -16;
    System.out.println(x<<2);//相当于8*2*2
    //二进制中8:表示为1000，左移两位即0010 0000
    System.out.println(x>>2);//相当于8/（2*2）
    //右移两位即0010
    System.out.println(y>>2);
    //负数二进制-16：表示为1111 0000（验证其实很简单加上16的二进制看看是否为0即可）；
    //右移两位即：0011 1100（-4），4的二进制为：0000 0100
    //以上两个例子都是有符号的右移，下面举例讲一下无符号的右移（表示为>>>）
    System.out.println(x>>>2);//无符号（正数）右移>>>等同于>>

    System.out.println(y>>>2);//负整数右移>>>则不等同，表示无符号的右移忽略符号
    //>>>无符号的右移对于负数而言是不考虑符号位的，所以输出的结果数据比较大。
    }
}

输出结果：

32
2
-4
2
1073741820

规律小结：

1、有符号的右移是看右移之后的首位是0还是1，是0前面空位补0,1则补1；

2、无符号的右移，移动之后不管首位是0还是1，空位都是直接补0

4.5.2与运算符、或运算符和异或运算符

这三者看了前面的内容可能对此有疑问，这不是逻辑运算符吗？其实并不是，这里的&、|和^有另外的意义和用处，这也离不开二进制计算的，下面举例逐一解释。

public class Test1 {
    public static void main(String[] args) {

        int a = 12 , b = 5;
        //对比一下位运算符和逻辑运算符的区别，再回顾一下逻辑运算符中&和&&区别和联系
        System.out.println(a & b); //&与运算符
        //计算方法：12的二进制(省略前面的28个0):1100，5的二进制为：0101 与运算其实就是做每一个二进制位的逻辑加法：都为1才为1
        // 1100
        //&0101
        //=0100，结果为4
        //具体解释：&符号在逻辑运算符中表示且，而计算机中1表示true ，0表示false
        //那么只有都为真的时候才为真，所以12 & 5 的结果为4
        System.out.println(a == 12 & b == 5);
        //表示逻辑判断，其实就是下面的写法：（后面学到控制流程语句就会明白的）
        if(a == 12 & b == 5) {
            System.out.println(true);
        }

        //=====================================
        //下面介绍一些或运算和异或运算
        System.out.println(a | b);// |表示或运算符
        //计算方法：不都为0则为1
        // 1100
        //|0101
        //=1101，结果为13其含义是两个数之间的每个二进制位之间不都为0则或运算的结果为1
        //异或运算
        System.out.println(a ^ b);// ^ 这里表示异或运算符
        //计算方法：二者不同则为1
        // 1100
        //^0101
        //=1001，结果为9
    }
}

结果如下：

4
true
true
13
9

规律小结：

&、|、^三者作为位运算符进行数字运算时，需要将其转换为二进制，然后对每一位二进制数进行对应的逻辑运算即可。理解上面说的方法自己，然后敲一下代码理解消化一下！

4.5.3反码运算符

~，这就是反码运算符；看代码案例：

public class Test1 {
    public static void main(String[] args) {
        //反码演示举例
        System.out.println(~5);
        //计算方法：
        //12 的二进制：0000 1100，按位取反为1111 0011，结果为-13可以通过源码验证
        //其实简单计算的话12去反码之后的值与自身相加为-1，原因大家可以自行了解计算机二进制中原码、反码和补码的联系
        //简述规律：补码=原码的反码加1，补码就是负数在二进制中表示的方法
    }
}

结果为：-13

规律小结：反码比较简单，就是将源码按位取反，

4.5.4位运算符总结

1、首先在编程使用的过程中一般用的不如逻辑运算符，但我们需要知道其核心原理；

2、其次要了解位运算过程，知道运算的核心方法；

3、最后需要自己了解和理解计算机二进制数的表示方法以及原码、反码和补码的换算方法；

规律总结请看下图表：

4.6三元运算符

概念：三元运算符，或为三目运算符。

格式：(条件表达式)? 表达式1：表达式2；

我们举例来理解：

public class Test1 {
    public static void main(String[] args) {

        int a = 1;

        int k = a > 0 ? 1 : 0;
        System.out.println(k);
    }
}

结果为：1

其表示的含义为，判断a的值是否大于0，若a大于0则将1赋值给看，反之将0赋值给k。

那么三目运算符在编程中究竟有什么用呢？可以方便书写简化代码。

例如这样的一个问题：如何获取两个中较大的数？

public class Test1 {
    public static void main(String[] args) {

        int a = 1 ,b = 4;

        int k = a > b ? a : b;
        System.out.println(k);
    }
}

如果不使用三目运算符则需要进行条件控制语句判断，下一篇文章将着重讲述关于流程控制语句。

那么再考虑一个问题：如何获取三个数中最大的数？看代码

public class Test1 {
    public static void main(String[] args) {

        int a = 1 ,b = 4,c = 6;

        int k = (a > b ? a : b) > c ? (a > b ? a : b) : c ;
        //先判断a和b的大小，选出其中大的再与c比较大小，最后输出最大的。也可以写成下面的方法
        //int k = (a > b ? ( a > c ? a : c) : (b > c ? b : c));
        //假设方法进行判断，a大于b则让a再与c比较，否则让b与c比较，输出最大的；
        System.out.println(k);
    }
}

结果为：

6

6

这就是三目运算符的嵌套使用。

运算符的优先级

运算符上面已经讲述完了，但是我们考虑一个问题，当各种运算符混合使用的时候该先执行谁呢？这就涉及到优先级了。

运算符的优先级排列顺序请看下图：

优先级数字越小则优先级越高，结合性上看就是按照上述声明，从左到右就是左边的优先级高，从右到左就是右边的优先级更高。

关于优先级，其实我们不需要刻意去记忆，因为当我们在编写程序的时候为了方便自己和他人理解都会避免使用过于复杂的运算符，或者加上英文括号来更好地解释自己的代码。

总结

以上就是Java开发环境、数据类型和运算符的介绍，看完之后是否有所收获呢？如果想了解更多相关内容，欢迎关注亿速云行业资讯！