数据类型

      Java中的数据是分类型的,可以分为以下几种类型:

l  基本数据类型:整数类型、小数(浮点型)类型、字符类型、布尔类型

l  引用数据类型:数组、类、接口

常量

    固定不变的值,就是常量。与它相对应的就是变量了,顾名思义就是可以变化的量(值)。

     下面用一个小程序输出一下常量

/*
定义一个Demo_1类,输出一下常量的值。
输出以下常量的值:
        1、整数常量
        2、小数常量
        3、布尔常量
        4、字符常量
        5、字符串常量
*/
 
public class Demo_1{
        public static void main(String[] args){
                  //整数常量    十进制    0——9
                  System.out.println(22);
                  //整数常量    二进制    以ob(OB)开头       0、1
                  System.out.println(0b10);
                  //整数常量    八进制    以0开头                  0——7
                  System.out.println(017);
                  //整数常量    十六进制        以ox(OX)开头       0——9    A--F
                  System.out.println(0xe);
                  //小数常量   
                  System.out.println(1.0);
                  //布尔常量    只有两个值   true false
                  System.out.println(true);
                  System.out.println(false);
                  //字符常量    用单引号''括起来只能有一个字符
                  System.out.println('a');
                  //字符串常量        用双引号""括起来可以由无数字符组成
                  System.out.println("HelloWorld");
                  }
}

变量

     变量可以理解为内存中的一块临时空间,里面的值可以随时进行改变。

     定义变量时要有与它对应的数据类型,且数据类型确定后,就不能在该类型中放入其他类型的值。

     数据类型有以下几种类型:

l  整型数据:

1.         byte

2.         short

3.         int

4.         long

l  浮点型数据

1.         Double

2.         float

l  字符数据

1.         Char

l  布尔类型

2.         Boolean

Java中默认的整数类型是int类型。如果这个数是12345678901,不加修饰可能会认为它是long型的数,它的范围已经超过了int的范围,这样写是错误的,如果这样的数超过int的范围,必须在数字的后面加上字母f(F),表示这个数值为long型数据。

Java中默认的小数(浮点型)类型是double类型,如果写了一个小数如1.23,后面不加任何修饰,会默认为double类型的小数,如果想要表示float类型的数据,需要在小数后面加上Ff)。

如何去定义一个变量呢?

l  定义一个变量需要有三个要素:数据类型、变量名、值。定义格式如下

数据类型 变量名  =  ;

数据类型有八种,具体类型为上面八种类型。变量名的定义遵循标识符的定义规则即可。值就是定义了什么类型的数据类型就赋什么类型的值。

         下面将各类型变量进行代码中的定义:

  /*
    定义出所有数据类型的变量
    */
    public class Variable{
                   public static void main(String[] args){
                            //整数变量    字节型变量   byte类型
                            byte b = 127;
                            System.out.println(b);
                            //整型变量    短整型变量   short类型
                            short s = 12345;
                            System.out.println(s);
                            //整数变量    整数变量        int类型
                            int i = 123456;
                            System.out.println(i);
                            //整型变量    长整型变量   long类型
                            long l = 123456789L;
                            System.out.println(l);
                            //浮点型变量        单精度    float类型
                            float f = 1.0F;
                            System.out.println(f);
                            //浮点型变量        双精度    double类型
                            double d = 1.02;
                            System.out.println(d);
                            //字符类型    char类型
                            char c = '王';
                            System.out.println(c);
                            //布尔类型    boolean类型
                            boolean bool = true;
                            System.out.println(bool);
                   }
}

    还有一种数据类型不属于基本数据类型,而是属于引用数据类型,该类型为String类型,字符串类型,下面定义了一个字符串数据类型的变量的代码:

/*
字符串数据类型变量的定义
*/
public class Variable_1{
             public static void main(String[] args){
                       //定义一个字符串数据类型的变量 String类型
                       String s = "字符串数据类型变量";
                       System.out.println(s);
             }
}

定义变量的注意事项:

l  定义一个变量必须要进行赋值,不赋值不能使用

public static void main(String[] args){
   int i;
   System.out.println(i);
}

这种情况定义了一个变量i,没有对i进行赋值,这种写法是错误的,不需要对i进行赋值,改正如下:

public static void main(String[] args){
   int i;
   i = 1;
   System.out.println(i);
}

l  变量有自己的作用范围,在一对大括号内有效。

public static void main(String[] args){
   {
            int i = 1;
   }
   System.out.println(i);
}

i在它自己的一个大括号内,有效作用只在大括号里面,输出语句在大括号外面,所以输出语句里面的i找不到。改正如下:

public static void main(String[] args){
   {
            int i = 1;
System.out.println(i);
   }
}

l  变量不能重复定义

public static void main(String[] args){
   int i = 1;
   double i = 1.0;
   System.out.println(i);
System.out.println(i);
}

变量重复进行定义,这种情况是绝对不允许的,改正如下:

public static void main(String[] args){
   int i = 1;
   double j = 1.0;
   System.out.println(i);
System.out.println(j);
}

数据类型的转换

    数据之间的转换需要遵行两个原则:

1.         范围小的数据可以直接转换为范围大数据类型

2.         范围大的数据不可以直接转为范围小的数据类型。

数据类型范围大小的排序:

   Byte->short->int->long->float->double

需要注意的布尔类型的数据不能进行数据转换

         下面的代码演示了数据类型之间的转换:

/*
数据类型的转换:自动类型提升(转换)
*/
public class DateChange{
                  public static void main(String[] args){
                           double d = 100;//100默认数据类型是int类型,它自动进行了数据类型的转换转成了double类型,100.0
                            System.out.println(d);
                           
                            byte b = 100;
                            int i = b;//b为byte类型,在赋值的这时候自动提升(转换)为int类型
                            System.out.println(i);
         }
}

    数据的强制转换

         这种情况是在数据范围大的数要转换为范围小的数值时需要进行强制类型的转化。

         需要注意的是这种转换方式会丢失数据的精度。

数据的强制转换可以套用下面的格式:

   范围小的数据类型 变量名 = (范围小的数据类型)需要被强制转换的数据;

下面的代码演示了数据类型的强制转换:

/*
数据类型的转换:强制类型转换
*/
public class DateChange_1{
                  public static void main(String[] args){
                           double d = 3.14;
                            int i = (int)d;//本来d为double类型,不能直接转换为int类型,所以需要手动进行数据的强转
                            System.out.println(i);
                           
                            byte b = (byte)200;//200默认类型是int。需要手动转换为byte类型,注意这种转换方式会丢失数据的精度
                            System.out.println(b);
                  }
}

运算符——算术运算符

        算数运算符有:

                  +(加)

                  -(减)

                  *(乘)

                  /(除)

                  %(取模)也就是取余数

                  ++(自增1

                  --(自减1

      注意:+可以用作连接符,如:System.out.println(“5+5=”+5+5);它的打印结果就是5+5=55,当字符串和其他数据用加号连接是,打印的还是一个连接起来的字符串。

      注意:++aa++的区别

            ++a  对自己进行自增,与其他值参与运算int a = 1;int b = ++a + 13;自增之后参与运算+13后赋值给ba的值为2b的值为15

            a++  对自己进行自增,与其他值参与运算int a = 1;int b = ++a + 13;先把值赋给b之后在参与运算,a的值为2b的值14

a++++a的具体体现代码如下:

/*
a++      ++a的区别
*/
public class Operator{
    public static void main(String[] args){
              int a = 5;
              int b = a++;
              System.out.println(a);//a的值为6
              System.out.println(b);//,b的值为5,a++先将a的值赋值给b,在对自己进行自增
             
              int a1 = 6;
              int b1 = ++a1;
              System.out.println(a1);//a的值为7
              System.out.println(b1);//b的值为7,++a1先对自己进行自增操作。然后把值赋值给b1
             
              int a2 = 1;
              int b2 = ++a2 + 13;
              System.out.println(a2);//a2的值为2
              System.out.println(b2);//b2的值为15
             
              int a3 = 1;
              int b3 = a3++ + 13;
              System.out.println(a3);//a3的值为2
              System.out.println(b3);//b3的值为14
         }
}