首页 > > 程序设计 > Java技术 >

Java基础（二）

2018-06-18 03:31:46来源：未知 阅读 ()

新老客户大回馈,云服务器低至5折

一、Java数据类型

1、基础数据类型（8种）

1、整数类型 （4种）

　　byte 1个字节8位，-2^8--2^8-1范围是-128到127

　　short 2个字节16位，-32768—32767

　　int  4个字节32位，-2147483648—2147483647  常用

　　long  8个字节64位，-9223372036854775808—9223372036854775807 

　　注意：给long赋值时，因为整数默认是int类型，要转换为long类型的值，后面加上l或L，一般用L，l容易与1混淆。

2、浮点类型（2种）

　　float 单精度 4个字节32位，直接赋值时必须在数字后加上f 或F

　　double 双精度 8个字节64位  常用

　　注意：浮点运算很少是精确的，只要是超过精度能表示的范围就会产生误差。往往产生误差不是 因为数的大小，而是因为数的精度。因此，产生的结果接近但不等于想要的结果。尤其在使用 float 和 double 作精确运算的时候要特别小心。

　　商业中精准计算使用java.math包中提供的API类BigDecimal。

3、字符类型（1种）

　　char 2个字节16位，字符常量使用单引号 ‘ ’包裹起来。char c = 65;//表示 ’A’ 这个字符，使用一个数字表示，对应有一个ASCII码表。

4、布尔类型（1种）

　　boolean 两个值 true 和 false

2、引用数据类型

　　类、数组、接口、枚举。。。

3、数据类型转换

　　下面这7种数据类型，它们之间都可以进行转换，但是可能会存在精度损失或者其他一些变化：

　　byte --》 short ，char --》  int  --》 long  --》  float  --》  double

　　如果从小转换到大，（除了byte不能自动转换char ，以及char不能自动转换short）可以自动完成转换。而从大到小，必须强制转换(强制转换前必须知道被转换的值在要转换的类型范围内)。

　　规律：有包含关系的可以由低精度赋值给高精度。高转低会导致精度丢失,不同类型的强制转换，可能会导致精度的下降.

　　问：为什么float 在long 后面？ 因为小数(浮点数) 的存储方式，结构和整数不一样。

 1 public class TypeCast {
 2     @Test
 3     public void testIntToDouble(){
 4         int num = 10;
 5         double d = 10.1;
 6         double c = d + num;
 7         System.out.println(c);
 8     }
 9 
10     @Test
11     public void testShortToInt(){
12         short s = 10;
13         int num = 20;
14         int n = num + s;
15         System.out.println(n);
16     }
17 
18     /**
19      * 从大到小，必须强制转换
20      */
21     @Test
22     public void testByteToInt(){
23         byte b=3;
24         b=(byte)(b*3);//必须声明byte。
25         System.out.println(b);
26     }
27 
28     /**
29      * char类型向更高长度类型（例如整型）转换时，会转换为对应的ASCII码值，再做其他类型的自动转换
30      */
31     @Test
32     public void testCharToInt(){
33         char c = 'A';
34         int num = 10;
35         int a = c + num;
36         System.out.println(a);
37     }
38 }

　　注意：char型具有两个字节，其数值范围是0 ~ 2^16-1，这直接导致byte型不能自动类型提升到char，char和short直接也不会发生自动类型提升（因为值范围问题），同时，byte当然可以直接提升到short型。所以，char 不能和byte short 相互自动转换

　　小结：在 Java 的领域里，基本数据类型变量存的是数据本身，而引用类型变量存的是保存数据的内存空间地址。基本数据类型变量里存储的是直接放在抽屉里的东西，而引用数据类型变量里存储的是 这个抽屉的钥匙，钥匙和抽屉一一对应。

二、常量

1. 常量介绍

　　Java中的常量，常量就是一个固定不变的量（或者值）。例如 123,45,1.2，false等。

常见的分类

① 整数常量     例如：123 ，250,666

② 小数常量    例如：1.2,3.14

③ 字符串常量   例如：”12345”

④ 字符常量      例如： ‘2’,‘B’

⑤ 布尔常量     例如：true  ,false

上面的 5种表示形式的常量都可以直接放在打印语句中打印。

2. 常见转义字符

①\n表示换行；

②\t表示制表符，相当于Table键；

③\b表示退格键，相当于Back Space键；

④\'表示单引号；

⑤\''表示双引号；

⑥\\表示一个斜杠\

三、变量

1、变量的语法

1、先声明再赋值

　　int a;

　　a = 1;

2、声明时同时赋值

　　int a = 1;

2、变量的分类

1、成员变量

　　1、直接声明在类中的变量。（类中成员）

　　2、如果成员变量没有赋值，系统会分配默认值

　　3、作用域范围，整个类的范围

2、局部变量

　　1、直接声明在方法内部,比如main方法的形参 或者 大括号中

　　2、作用域范围，只能在方法内使用，局部变量，必须放在使用的功能语句前面

3、变量分类的详解

成员变量(也叫字段) ： 静态的（类变量）和非静态的（实例变量）

局部变量：不能使用static修饰

分类详解：

  位置 是否有static 
 生命周期（开始） 生命周期（结束）
类变量 类中 √ 类被加载的时候 类被卸载的时候
实例变量 类中   创建对象的时候 对象被销毁
局部变量 方法内部（形参，代码块）   方法被调用的时候 方法调用完毕

 

 

            

 

 

 

 

理解：

类被加载的时候 ：把类的字节码文件加载到JVM中；

局部变量的作用 ：一般都是方法中，为了辅助方法完成功能而临时定义的变量；

类变量  ： 有static修饰的成员变量（字段）；

实例变量： 没有static修饰的成员变量（字段）；

3、表达式

　　由一系列的 常量、 变量 、运算符，括号()组成的一个算式，为了按照一定的运算规则计算出结果值。

四、运算符

1、算数运算符

　　加（+）减（-）乘（*）除（/）取模（%）

 1 public class Modulo {
 2     /**
 3      * 取模，对整数取余2,结果为0是偶数，为1是奇数
 4      */
 5     @Test
 6     public void modulo() {
 7         System.out.println(6 % 2); //余数是0
 8         System.out.println(7 % 2); //余数是1
 9     }
10 }

　　一些常量表示符：NaN、Infinity 表示无穷大

2、自增自减

++（自增）    --（自减）

自增自减只能够用于变量，不能用于常量，自增自减运算的优先级，比算术运算符高

 1 public class AutoAdding {
 2     /**
 3      * 自增
 4      */
 5     @Test
 6     public void autoAdding1() {
 7         int i = 3;  // 表示把3赋值给变量i
 8         i++;      //表示变量i的值加1，i的值变成4
 9         System.out.println(i);
10         ++i;      //表示变量i的值加 1，i的值变成5
11         System.out.println(i);
12     }
13 
14     /**
15      * 变量名在前 i++,先赋值再自增
16      */
17     @Test
18     public void autoAdding2() {
19         int i = 3;
20         int j = i++;
21         System.out.println(j); //3
22         System.out.println(i); //4
23     }
24 
25     /**
26      * 变量名在前 ++i，先自增再赋值
27      */
28     @Test
29     public void autoAdding3() {
30         int i = 3;
31         int j = ++i;
32         System.out.println(j); //4
33         System.out.println(i); //4
34     }
35 
36     @Test
37     public void autoAdding4() {
38         int i = 3;
39         int a = i++ + i++ + i++; //3(4) 4(5) 5(6)
40         int b = ++i + ++i + ++i; //7 8 9
41         System.out.println(a); //12
42         System.out.println(b); //24
43         System.out.println(i); //9
44     }
45 
46     @Test
47     public void autoAdding5() {
48         int i = 5;
49         i++;
50         System.out.println("i=" + i);//6
51         ++i;
52         System.out.println("i=" + i);//7
53         int a = ++i;
54         System.out.println("a=" + a);//8 i=8
55         a = a++;
56         System.out.println("a=" + a);//8
57         a = ++a;
58         System.out.println("a=" + a);//9
59     }
60 }

3、赋值运算

=    +=     -=     *=     /=    %=

从右到左，把符号右边的值赋值到左边的变量中

 1 public class AssignmentOperator {
 2     /**
 3      * 赋值运算
 4      */
 5     @Test
 6     public void test1() {
 7         int i = 3;
 8         i += 2;// 表示把2 累加到变量 i 中
 9         System.out.println(i); //5
10         i -= 1;
11         System.out.println(i); //4
12         i *= 3;
13         System.out.println(i); //12
14         i /= 3;
15         System.out.println(i); //4
16         i %= 3;
17         System.out.println(i); //1
18     }
19 }

4、比较运算符

==    !=     >    <    >=    <=    instanceof

1、比较运算的结果是一个布尔类型的值（true 或false）

2、instanceof 是判断一个对象是否属于某种类型

 1 public class ComparisonOperator {
 2     @Test
 3     public void test(){
 4         int a = 3;
 5         System.out.println(1 == 1); //true
 6         System.out.println(a != 2); //true
 7         System.out.println(a > 2); //true
 8         System.out.println(a < 5); //true
 9         int b = 5;
10         System.out.println(a >= b); //false
11         System.out.println(b <= 6); //true
12         System.out.println("hello" instanceof String); //true
13     }
14 }

5、逻辑运算符

&    |     &&     ||   ^    ！

1、应用于多个条件的组合判断。

2、逻辑运算符两边结果值的都必须是布尔类型。

&   ：两边都为true ，结果为true

|    ：只要有一边为true，结果为true

&& ：两边都为true ，结果为true

||   ：只要有一边为true，结果为true

^   ：两边不一样，结果为true ，否则为false

！ ：逻辑非

3、&&  ||   和   & |    区别？

1)  & | 既可以充当逻辑运算，也可以是位运算符。

　　根据表达式的结果是否为布尔类型来判断

2) 双与 、双或具有短路行为

如果逻辑运算左边的值能够确定整个逻辑运算表达式的值，那么右边就不执行了，短路了。

　　&& 短路，左边表达式结果为false

　　 ||  短路 ，左边表达式结果为true

 1 public class Demo {
 2     /**
 3      * 要判断1 / 0 == 0 出现异常
 4      */
 5     @Test
 6     public void test1() {
 7         System.out.println(1 < 0 & 1 / 0 == 0);  //java.lang.ArithmeticException: / by zero
 8     }
 9 
10     /**
11      * 短路，不判断1 / 0 == 0，返回false
12      */
13     @Test
14     public void test2() {
15         System.out.println(1 < 0 && 1 / 0 == 0);  //false
16     }
17 
18     /**
19      * 要判断1 / 0 == 0 出现异常
20      */
21     @Test
22     public void test3() {
23         System.out.println(1 > 0 | 1 / 0 == 0);  //java.lang.ArithmeticException: / by zero
24     }
25 
26     /**
27      * 短路，不判断1 / 0 == 0，返回true
28      */
29     @Test
30     public void test4() {
31         System.out.println(1 > 0 || 1 / 0 == 0);  //true
32     }
33 }

4、常见错误：

  例如：判断一个整数的变量 a里面的数据  在0-100之间

  正确写法： a>0   &&  a<100

  错误写法:   0<  a < 100  (java没有这种语法，不支持)

6、位运算

&    |    ^     ~    <<      >>     >>>

1、可以把1看成是true,把0看成是false

2、位运算就是二进制的位进行运算

&  :与 位运算，两边为1，结果为1

|   :或 位运算，有一个为1，结果为1

^  :  异或，两边不一样，就为1，否则为0

~  :  取反，1变成0  ,0 变成1

<< :  向左位移动，例如1<<3                      

>> :   向右位移动，例如8>>2        

>>>:  无符号向右移动

 1 public class BitOperation {
 2     @Test
 3     public void test() {
 4         /*与
 5         *   00000011
 6         *   00000100
 7         *   00000000
 8         * */
 9         System.out.println(3 & 4); //0
10 
11         /*或
12         *   00000011
13         *   00000100
14         *   00000111
15         * */
16         System.out.println(3 | 4); //7
17 
18         /*向左位移动
19         *   00000001
20         *   00001000
21         */
22         System.out.println(1 << 3); //8
23 
24         /*~ 取反
25         *   原码：1000 0000 0000 0101
26         *   反码：1111 1111 1111 1010 符号位不变，其他位取反
27         *   补码：1111 1111 1111 1011 反码+1
28         *   补码再取反
29         *        0000 0000 0000 0100 --》 4
30         */
31         System.out.println(~(-5)); //4
32     }
33 }

注意：正数的补码，反码，原码都一样；

          负数的反码：符号为不变，其他位取反；

          负数的补码：它的反码+1；

7、三目运算符

　　语法格式：X ? Y : Z

1)上面的三目运算整体看成是一个表达式，应该有一个结果值

2) X  布尔类型的值或者结果为布尔类型的表达式

3) Y  Z  一般来说数据类型相同的值或者表达式

4) 运算的规则

　　X 为true，就是 Y 的结果值 ( 冒号前面的表达式的值)

　　X为false，就是Z的结果值 ( 冒号后面的表达式的值)

　　注意： 不要受  ？ 和    :  的干扰，它们只是一个固定语法格式

 1 public class TernaryOperator {
 2     /**
 3      * 三目运算
 4      */
 5     @Test
 6     public void test() {
 7         int num = 5;
 8         System.out.println(num % 2 == 0 ? "偶数" : "奇数");  //输出奇数
 9     }
10 }

 

标签：

版权申明：本站文章部分自网络，如有侵权，请联系：west999com@outlook.com
特别注意：本站所有转载文章言论不代表本站观点，本站所提供的摄影照片，插画，设计作品，如需使用，请与原作者联系，版权归原作者所有

上一篇：java开发常用技术

下一篇：Hibernate从入门到上手（纯java project、Maven版本hibernate）

相关文章

IDC资讯： 主机资讯 注册资讯 托管资讯 vps资讯 网站建设

网站运营： 建站经验 策划盈利 搜索优化 网站推广 免费资源

网站联盟： 联盟新闻 联盟介绍 联盟点评 网赚技巧

行业资讯： 搜索引擎 网络游戏 电子商务 广告传媒

网络编程： Asp.Net编程 Asp编程 Php编程 Xml编程 Access Mssql Mysql 其它

服务器技术： Web服务器 Ftp服务器 Mail服务器 Dns服务器 安全防护

软件技巧： 其它软件 Word Excel Powerpoint Ghost Vista QQ空间 QQ FlashGet 迅雷

网页制作： FrontPages Dreamweaver Javascript css photoshop fireworks Flash

程序设计： Java技术 C/C++ VB delphi

网络知识： 网络协议 网络安全 网络管理 组网方案 Cisco技术

操作系统： Win2000 WinXP Win2003 Mac OS Linux FreeBSD

热门词条
最新资讯
热门关注
热门标签