把JAVA的知识点在回顾回顾，要不然都忘掉了。


  基本数据类型:4类8种

       整数型

            byte    1      -128~127

            short   2       

            int     4  

            long    8        

       浮点型

            float   4 

            double  8

       字符型

            char    2

       布尔型

            boolean 1

内存空间不同 取值范围不同


byte 内存空间8

short  内存空间16

int     内存空间32

long     内存空间64

float    内存空间32

double    内存空间64

1:在定义Long或者Float类型变量的时候，要加L或者f。

  整数默认是int类型，浮点数默认是double。

  

  byte，short在定义的时候，他们接收的其实是一个int类型的值。

  这个是自己做了一个数据检测的，如果不再它们的范围内，就报错。

  

2:byte值的问题  -128~127


        一个字节  01111111  127

         

byte b1 = 127;

        byte b2 = (byte)128; //-128

byte b3 = (byte)129; //-127

byte b4 = (byte)130; //-126

byte的范围：-128 ~ 127           

127 01111111 

            

 

        -127: 11111111

                    +1

------------------------

              10000000


-128：10000000 (最高位即是符号位，也是数值位)只有在临界的时候

3:数据类型转换之默认转换  小的数据类型到大的数据类型

byte,short,char -- int -- long -- float -- double

long: 8个字节

float：4个字节

A:它们底层的存储结构不同。

B:float表示的数据范围比long的范围要大

long： 2^63-1

float：3.4*10^38 > 2*10^38 > 2*8^38 = 2*(2^3)^38 = 2*2^114 > 2^63-1


4:Java语言中的字符char可以存储一个中文汉字吗?为什么呢?

可以。因为java语言中的字符占用两个字节。

Java语言采用的是Unicode编码。



常量： 在程序执行过程中其值不发生改变的量

       分类：

           字面值常量

              字符串常量

              整数常量

              小数常量

              字符常量    里面只能是单个字符

              布尔常量    true和false

              空常量      数组

           自定义常量

       进制：x进制就是 逢x进一

          二进制   由0,1组成  0b

          八进制   由0-7组成 0

          十进制   整数默认都是十进制

         十六进制  由0-9,a-f(可以是大写)     0x

       进制转换 

          任意进制转换十进制 

             位权展开法

          十进制转换成任意进制 

             除基取余，直到商为零，余数反转


         快速转换 

             8421码  二进制与十进制的转换

             二进制快速转换八进制   分组法

             二进制快速转换十六进制   分组法


         原码，反码，补码

         存在计算机底层  是二进制的运算

         数据运算的时候用的是该数据的二进制的补码进行计算的

         展示用的是该数据的二进制原码


         正数的原反补都一样，最高位是符号位0  其余位是数值位

         负数 原码 最高位符号位1，其余位是数值位

              反码 最高位不变，其余位按位取反

              补码  反码+1


       变量：

          在程序执行过程中，在一定范围内其值可以发生改变的量


             相当于数学中的未知数


           定义格式 ：

             数据类型 变量名 = 初始值；

                               同类型的常量


java中存在 隐式转换(默认转换)

(1): boolean类型不能转换为其他的数据类型

(2): byte,short,char—int—long—float—double

 (从小的范围往大的范围转)

 如果遇到int类型参与运算 得到的结果肯定是int类型

      如果有long参与运算,得到的结果肯定是long类型

 如果有float参与运算,得到结果肯定是float类型

 如果有double参与运算,得到结果肯定是double 类型

(3): byte,short,char之间不转换,他们参与运算首先转换为int类型

注意：大类型 转 小类型 可能会损失精度。


public class DataTyepDemo {
public static void main(String[] args) {
byte a = 3;
int b = 4;
int c = a+b;
System.out.println(c);
}
}


还有强制类型转换

public class DataTyepDemo1 {
public static void main(String[] args) {
byte a =3;
int b = 4;
byte c = (byte) (a+b);
System.out.println(c);
}
}

 你发现 字符 对应 int类型  应该有 一一对应的关系

  在一个表内

    ASCII

   '0'      48 

'a'      97

'A'      65


public class DataTypeDemo2 {
public static void main(String[] args) {
System.out.println("hello" + 'a' +1 );
System.out.println('a' + 1 + "hello");
System.out.println("-------------");
System.out.println("5+5="+5+5);
System.out.println(5+5+"=5+5");
}
}

结果：

helloa1

98hello

-------------

5+5=55

10=5+5


     变量使用的注意事项

        a:作用域问题

变量定义在哪一级大括号中，哪个大括号的范围就是这个变量的作用域。

            相同的作用域中不能定义两个同名变量。

b:初始化值问题

没有初始化值不能直接使用

c:在一行上建议只定义一个变量

可以定义多个，但是不建议



变量定义格式

 数据类型  变量名 = 初始化值;

 数据类型 变量名;

 变量名 = 初始值;

public class DateTypeNoticeDemo {
public static void main(String[] args) {
int a = 10;
int b = 10;
System.out.println(a);
System.out.println(b);
}
}
public class DataTypeTest {
public static void main(String[] args) {
byte b = (byte) 130;
System.out.println(b);
}
}
/*
  分析:
      130  int  类型  4个字节  32bit
       原码 00000000 000000000 00000000 10000010
   强制转换就是一种运算
     对补码 进行强制转换 
补码 00000000 000000000 00000000 10000010 
强制转换之后得到
                    10000010  --------补码
10000001  --------反码
11111110  ---------原码
-126
*/
public class DataTypeTest2 {
public static void main(String[] args) {
float f1 = (float)12.345;  //这里面 12.345常量是double类型 8个字节 
              //做了强转之后 再赋值给float类型变量
System.out.println(f1);
float f2 = 12.345f;      //这里 12.345常量就是float类型的 直接做赋值
System.out.println(f2);
}
}

  放在操作数前面

       先自加(减)  然后再参与运算

  放在操作数后面 

       先参与运算  然后自加(减)

public class DataTypeTest3 {
public static void main(String[] args) {
int a = 10;
int b = 10;
int c = 10;
a = b++;  //a 10 b 11 c 10
c = --a;  //a 9  b 11 c 9
b = ++a;  //a 10 b 10 c 9
a = c--;  //a 9  b 10 c 8
System.out.println("a:"+a);
System.out.println("b:"+b);
System.out.println("c:"+c);
}
}

比较运算符

public class OperatorDemo {
public static void main(String[] args) {
int a = 32;
int b =23;
System.out.println(a==b);
System.out.println(a>b);
System.out.println(a!=b);
System.out.println(b>=a);
}
}