JavaSE-2-数据类型与运算符

2017年11月3日
JavaSE-1-语言与开发环境
2017年11月2日
2.新建servlet-dopost_request_乱码_filter
2017年11月17日

Javase的数据类型与运算符

  –by Xrzhang

1.关键字

定义:关键字是SUN公司事先定义的,有特别意义的单词

特点:在 Java 中关键字都是小写的

组成:

 

2.标识符

定义:标识符可以标识类名,接口名,变量名,方法名

命名规则:

a) 标识符是由,数字,字母,下划线和美元符号,¥构成,其他符号不可以

b)必须以字母、下划线或美元符号,¥开头,不能以数字开头

特点:

a)关键字不能作为标识符

b)标识符区分大小写

c)标识符理论上没有长度限制

示例:

 

命名 Java 标标识识符符,,最最好好见见名名知知意意

3.变量(Var

变量是内存中用来存放特定数据类型数据的一块空间,它的值是可以改变的。Java 中的变量有四个基本属性:变量

名,数据类型,存储单元和变量值

变量名:合法的标识符,以字母,$_开头(见名知意)

变量的数据类型:可以是基本类型和引用类型(必须包含类型)

存储单元:存储单元大小是由数据类型决定的,如:int 为 个字节 32 

变量值: 在存储单元中存放的值

变量的声明格式:

【数据类型 变量名(标识符) *字面值】  

4.数据类型

Java 总共有两种数据类型, 主要有基本类型和引用类型, 基本类型有 种, 引用数据类型有

<1> 基基本本数数据据类类型型

数值类型

整数型(byte,short,int,long)

浮点型(float,double)

字符类型(char)

布尔类型(boolean,只能取值 true 和 false)

<2> 引引用用数数据据类类型型

数组


接口

八种数据类型的取值范围

 

在计算机内部,所有信息都采用二进制表示,每个二进制由 0 和 两种状态,一个字节有 8位,也就是由 个 或 

成,如果 short 类型的 在计算机中是如何存储的,short 是两个字节,那么

short 6 的二进制为:00000000 00000110;

int 类型的 在计算机中存储为 32 位:00000000 00000000 00000000 00000110

十十进进制制到到二二进进制制的的换换算算

规则:除 2 取余,逆序输出

如 10 进制 二进制换算方式为:

6/2=3 余 0

3/2=1 余 1

1/2=0 余 1

将余数逆序输出就是 6 的二进制表示:110 ,位数不够补零

二二进进制制到到十十进进制制的的换换算算

规则:取出最后一位,从 2 的 次方开始乘,将得到的结果相加即可

如:二进制的 110 的十进制换算:

0*2 的 次方=0

1*2 的 次方=2

1*2 的 次方=4

110 的十进制为:0+2+4=6

*数据类型其实就是决定在jvm中开辟多大的内存空间,来存储你的字面值。字面值最终转换为二进制编码,进行存储。因为不管任何语言只要是在计算机中进行操作,都会转换成机器代码,只不过这些操作都是语言帮我们自动处理。

*数据类型运算的时候都是使用int接受,或者比int更大范围的数据去接受。

*整型和浮点型类型大小比较的过程,和自动转换,强制类型转换。

Byte < short <int <long < float < double(float用科学记数法接受long)

*定义过程中,float一定要在结尾加f或者FLong一定要加l或者L,最好用L Double可加可不加。

*小数的前置0可以省略。

5.字符编码

 

6. 运算符


7.字符集

字符集:通常意义就是单个字符,字符必须以单引号引起来,(),java语言是16Unicode编码方式。早期是

  1. public
    class
    BiaoShiFu
  2. {
  3.     public
    static
    void
    main(String[] args){
  4.         /*
  5.             变量:数据类型 变量名 = 字面值;
  6.             变量名:$,_ 开头,其他随便(除了java的关键词),
  7.             中间不能包含特殊字符串(#,@)和空格等其他字符.
    1.         */
    2.         int age = 30;
    3.         float cc = 30f;
    4.         int $$$=100;
    5.         int $_26 = 100;
    6.         int $我爱你=13300;
    7.         //boolean $@ = true; 错误的|
    8.         //boolean $ @ = true; 错误的
    9.         //boolean 2$@ = true; 错误的
    10.  
    11.         print(age);
    12.         print(cc);
    13.         print($$$);
    14.         print($_26);
    15.         print($我爱你);
    16.     }
    17.     public
      static
      void
      print(Object message){
    18.         System.out.println(“打印的结果是:”+message);
    19.     }
    20. }
    1. public
      class
      BiaoShiFu02{
    2.     private
      static
      int age = 30 ;
    3.     public
      static
      void
      main(String[] args){
    4.         /*
    5.             变量:数据类型 变量名 = 字面值;
    6.             变量名:$,_ 开头,其他随便(除了java的关键词),
    7.             中间不能包含特殊字符串(#,@)和空格等其他字符.
    8.             同样用于:方法和类的名称
    1.             {
    2.         
    3.             }//就是一个作用域
    4.         */
    5.         //int age = 30;
    6.         //age = 20;//修改变量在内存中的值.=赋值
    7.  
    8.         print(age);
    9.  
    10.     }
    11.     public
      static
      void
      print(Object message){
    12.         System.out.println(“打印的结果是:”+message);
    13.     }
    14. }
    15. public
      class
      JavaInteger{
    16.     private
      static
      int age = 30 ;
    17.     public
      static
      void
      main(String[] args){
    18.         /*
    19.             为什么在开发中都推荐使用int类型,而不是long也不是short呢.
    20.             在业务的开发过程,我们难免会遇到算术运算。+,- * /    
    21.         */
    22.         byte a = 100;
    23.         byte b = 110;
    24.         int c = a * b;
    25.         short d = 470;
    26.         short e = 10;
    27.         int ff = d + e;
    28.         long fff = d + e;
    29.         float fff2 = d + e;
    30.         float fff3 = d + e;
    31.  
    32.         print(c);
    33.         print(ff);
    34.         print(fff);
    35.         print(fff2);
    36.         print(fff3);
    37.  
    38.     }
    39.     public
      static
      void
      print(Object message){
    40.         System.out.println(“打印的结果是:”+message);
    41.     }
    42. }
    1. public
      class
      JavaInteger02{
    2.     private
      static
      int age = 30 ;
    3.     public
      static
      void
      main(String[] args){
    4.         byte a = 100;
    5.         int b = a ;
    6.         b = 200;
    7.         int c = b;
    8.         float e = c;
    9.         e = 110;
    10.         double f = a;
    11.  
    12.         console(a);//100
    13.         console(b);//200
    14.         console(c);//200
    15.         console(e);//110.0
    16.         console(f);//100.0
    17.  
    18.     }
    19.     public
      static
      void
      console(Object message){
    20.         System.out.println(“打印的结果是:”+message);
    21.     }
    22. }
    1. public
      class
      JavaInteger03{
    2.     public
      static
      void
      main(String[] args){
    3.         /*
    4.             float类型:如果接受整型,
    5.             定义是比较特殊:
    6.             如果float接受的是一个整数.不需要加f或者F
    7.             但是如果是小数一定要加f或者F
    1.             因为java一个小数的默认数据类型是:double
    2.         */
    3.         float c = 100f;
    4.         float d = 36.5f;//JavaInteger03.java:12: 错误: 不兼容的类型: 从double转换到float可能会有损失
    5.         console(c);
    6.         console(d);
    7.         console(“==============================”);
    8.         double cc = 100d;
    9.         double dd = 36.5d;//默认省去尾巴d或者D
    10.         double f = 36.589d;
    11.         double g = 236.589D;
    12.         double h = d;
    13.         console(cc);
    14.         console(dd);
    15.         console(f);
    16.         console(g);
    17.     }
    18.     //打印方法
    19.     public
      static
      void
      console(Object message){
    20.         System.out.println(“打印的结果是:”+message);
    21.     }
    22. }
    1. public
      class
      JavaInteger05{
    2.     public
      static
      void
      main(String[] args){
    3.  
    4.         //opacity:0-0.5-1
    5.         //opacity:.5等价于opacity:0.5
    6.         float a = .35f;//0.35f
    7.         console(a);
    8.         double b = .0004548d;
    9.         console(b);
    10.     }
    11.     //打印方法
    12.     public
      static
      void
      console(Object message){
    13.         System.out.println(“打印的结果是:”+message);
    14.     }
    15. }
    1. public
      class
      JavaInteger06{
    2.     public
      static
      void
      main(String[] args){
    3.  
    4.         double c = 59.8998;
    5.         int money = (int)c; //直接丢掉小数,留下整数部分,不会四舍五入。
    6.         //在开发过程,命令进制在万不得已的情况下,不允许使用强制数据类型转换。
    7.         console(money);
    8.     }
    9.     //打印方法
    10.     public
      static
      void
      console(Object message){
    11.         System.out.println(“打印的结果是:”+message);
    12.     }
    13. }
    1. public
      class
      JavaInteger07{
    2.     public
      static
      void
      main(String[] args){
    3.         //十进制:0 1 2 3 4 5 6 7 8 9====二进制 1010
    4.         int a = –10;
    5.         a = 100;
    6.         //八进制 0 1 2 3 4 5 7 ,必须以0开头—-
    7.         int b = 013;
    8.         console(a);
    9.         console(b);
    10.  
    11.         //二进制转十进制,2位次幂除以每个进制对应的数字相加等到结构
    12.         //十进制转二进制,用十进制除以2的余数,从下往上拼接得到
    13.  
    14.         //十进制转八进制:用10除以8的余数从下往上拼接
    15.         //二进制转八进制: 用分组法,每三个一组:从右往左 1 2 4排列。如
    16.         //1 0 ===> 1 1 0 ===> 1 0 1
    17.         //2    1 ===> 4 2 1 ===> 4 2 1

    18. // 2 =====>6 =====>5 == 265
    19.         //10110101===八进制===
    20.         //2 6 5
    21.         //010    110 101
    22.         //十六进制,必须以0x或者0X开头,0-9 a-f,一组数字
    23.         int cc = 0x89aed;
    24.         //0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
    25.         //0 1 2 3 4 5 6 7 8 9 a b c d e f
    26.         //1 ==== 0 1 1 1 ==== 0 1 1 0
    27.         //1====== 8 4 2 1 ==== 8 4 2 1
    28.         //1===7====6====0x176
    29.         console(cc);
    30.         //八进制,十进制,十六进制都是数字.
    31.     }
    32.     //打印方法
    33.     public
      static
      void
      console(Object message){
    34.         System.out.println(“打印的结果是:”+message);
    35.     }
    36. }
    1. public
      class
      Test {
    2.     public
      static
      void
      main(String[] args) {
    3.         //都是什么进制转成十进制
    4. //        System.out.println(Integer.parseInt(“013”, 8));
    5. //        System.out.println(Integer.parseInt(“ff”, 16));
    6. //        System.out.println(Integer.parseInt(“ffff”, 16));
    7. //        System.out.println(Integer.parseInt(“1010”, 2));
    8. //        
    9. //        System.out.println(“====十进制转其他进制”);
    10. //        String c = Integer.toString(110, 2);//十进制转二进制
    11. //        String c2 = Integer.toString(120, 8);//十进制转八进制
    12. //        String c3 = Integer.toString(130, 16);//十进制转十六进制
    13. //        String c4 = Integer.toString(140, 10);
    14. //        System.out.println(c);
    15. //        System.out.println(c2);
    16. //        System.out.println(c3);
    17. //        System.out.println(c4);
    18.  
    19.  
    20. //        int b = Integer.parseInt(“013”,8);//十进制
    21. //        String c = Integer.toString(b, 16);
    22. //        System.out.println(c);
    23.  
    24. //        System.out.println(eto16(“013”));
    25. //        System.out.println(eto162(“0xab897”));
    26.  
    27.         int ccc = 0B101010110;
    28.         float c = 3.14_787_878_787f;
    29.         System.out.println(ccc);
    30.  
    31.         String b = “1010111”;
    32.         System.out.println(“二进制转十六进制===”+eto165(b));
    33.         System.out.println(“十六进制转二进制===”+eto163(eto165(b)));
    34.         System.out.println(“二进制转八进制===”+eto166(b));
    35.         System.out.println(“八进制转二进制===”+eto162(eto166(b)));
    36.         System.out.println(“八进制转十六进制===”+eto16(eto166(b)));
    37.  
    38.     }
    39.  
    40.     //二进制转十六进制
    41.     public
      static String eto165(String b){
    42.         int bc = Integer.parseInt(b,2);
    43.         //十进制—-parseInt(进制数字,radix);//radix告诉进制数字是进制—-转成,十进制
    44.         //Integer.parseInt(进制数字,radix)===将某一种进制转换成十进制
    45.         String c = Integer.toString(bc, 16);
    46.         return c;
    47.     }
    48.  
    49.     //二进制转八进制
    50.     public
      static String eto166(String b){
    51.         int bc = Integer.parseInt(b,2);
    52.         //十进制—-parseInt(进制数字,radix);//radix告诉进制数字是进制—-转成,十进制
    53.         //Integer.parseInt(进制数字,radix)===将某一种进制转换成十进制
    54.         String c = Integer.toString(bc, 8);
    55.         return c;
    56.     }
    57.  
    58.     //八进制转十六进制
    59.     public
      static String eto16(String b){
    60.         int bc = Integer.parseInt(b,8);//十进制
    61.         String c = Integer.toString(bc, 16);
    62.         return c;
    63.     }
    64.  
    65.     //八进制转二进制
    66.     public
      static String eto162(String b){
    67.         int bc = Integer.parseInt(b,8);//十进制
    68.         String c = Integer.toString(bc, 2);
    69.         return c;
    70.     }
    71.  
    72.     //十六进制转二进制
    73.     public
      static String eto163(String b){
    74.         int bc = Integer.parseInt(b,16);
    75.         //十进制—-parseInt(进制数字,radix);//radix告诉进制数字是进制—-转成,十进制
    76.         //Integer.parseInt(进制数字,radix)===将某一种进制转换成十进制
    77.         String c = Integer.toString(bc, 2);
    78.         return c;
    79.     }
    80.  
    81.     //十六进制转10进制
    82.     public
      static String eto164(String b){
    83.         int bc = Integer.parseInt(b,16);//十进制
    84.         return bc+“”;
    85.     }
    86. }

发表评论

电子邮件地址不会被公开。 必填项已用*标注