Java基础(二)

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

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

一、Java数据类型

1、基础数据类型(8种)

1、整数类型 (4种)

  byte 1个字节8位,-2^8--2^8-1范围是-128127

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

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

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

  注意:long赋值时,因为整数默认是int类型,要转换为long类型的值,后面加上lL,一般用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型不能自动类型提升到charcharshort直接也不会发生自动类型提升(因为值范围问题),同时,byte当然可以直接提升到short型。所以,char 不能和byte short 相互自动转换

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

二、常量

1. 常量介绍

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

常见的分类

① 整数常量     例如: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 的结果值 ( 冒号前面的表达式的值)

  Xfalse,就是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)