初识Java及其数据类型与变量

       1.Java简单介绍

        Java语言是一种优秀的计算机语言，相较于c++，其语义相对较为容易理解，并且没有头文件，指针运算，结构，联合，操作符重载等等。

        Java语言因为有独立的运行环境。因此，只要设备中安装了相应的运行环境即可在任何系统中运行，具有很高的可移植性。

用Java写出  Hello World.

public class HelloWorld{

        public static void main(String[] arges){

                System.out println("Hello World");

    }

}

        2.Java中的数据类型与变量

1.字面常量

        System.out println("Hello World");

在上述语句中Hello World就是所谓字面常量。

        常量就是指在程序运行期间固定不变的量。

字面常量分类：

        （1）字符串常量：由 "" 符号括起来的元素，如 "hello" , "12345" 等。

        （2）整形常量：程序中直接写的数字（没有小数点）如，100 ，20 等。

        （3）浮点数常量：程序中直接写的小数，如，3.14 ，5.56等。

        （4）字符常量：程序中由 '' 括起来的元素，如，'1' , 'A'等。、

        （5）布尔常量：只有true和false。

2.数据类型

        Java中数据类型分为两种：基本数据类型和引用数据类型

        基本数据类型（四类八种）：

                四类：整形，浮点型，字符型，布尔型。

                八种：

         注：根据我们在之前c语言中所学的知识我们知道char类型为1字节，但在Java中为2字节

                （一个字节8个bit位） 

3.变量

        （3.1）变量的概念：对于经常改变的量，在Java程序中叫做变量。而数据类型就是来定义变量的。

        （3.2）语法格式

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

例（虽然定义时可以将变量定义在一行中，但不建议这样）：

int a=100；

double b=3.14；

char c='A'；

boolean b=true； 

System.Out.println(a);  //这是Java中的打印函数。

        （3.3）整型变量

                （3.3.1）整型变量（int）

//方式一：在定义时给出初始值

int a=10；

System.Out.println(a);

//方式二：先定义在赋值

int b;

b=10;

System.Out.println(b);                             

                注意：1.在给整形赋值时要注意不能超过int所能定义的范围。

                            2.int在任何系统下都是4个字节。    

                如下：计算int所能定义的数字的大小

public static void main4(String[] args) {

//局部变量 4个字节

int a = 10;

System.out.println(a);  //目前将Integer当做 "一个int 的plus版本"用于理解

System.out.println (Integer.MAX_VALUE);  //Integer.MAX_VALUE 这样可以输出int的最大值

System.out.println (Integer.MIN_VALUE);  //会输出 int的最小值

int c = 2147483647;

System.out.println(c);

}

                （3.3.2）长整型变量（long）

                                注意：Java中长整型在任何系统下都占8个字节

                                同理：

public static void main(String[] args) {

/**

* 8个字节 -> 64比特位 ->63bit -> -2^63 ~（2^63）-1

*/

long a = 10;

System.out.println(a);

System.out.println(Long.MAX_VALUE);

System.out.println(Long.MIN_VALUE);

long b = 10L;        //此处必须加L

System.out.println(b);

}

注：不加L默认是int，int转为long是安全的，所以会自动转，能编译通过

        如果超过int的取值范围还不加L，那么也会直接报错了

由上述例子可知，同样的，短整型（short）、字节型（byte）都可以用上述方法证明。

注：同样的，short短整型在任何系统下都占2个字节，byte在任何系统下都占1个字节

   （3.4）浮点型变量 

                （3.4.1）双精度浮点型（double）

//先进行一组代码的比较

int a=1；

int b=2；

System.out.println(a/b);

double a=1.0；

double b=2.0；

System.out.println(a/b);                                

                显然，想要输出0.5这个小数只有第二段代码可以做到。

                在Java中 int 除以 int 类型的数据会直接舍弃小数（仍为 int 类型的数）。

注：double在任何系统下都占8个字节。

               （3.4.2）单精度浮点型（float）

float a=1.0f；//必须加f

System.out.println(a); 

  注：float在Java中占4个字节，与double相比所能表示的小数范围相对较小，在工程上一double为主。

浮点数不加F默认是double类型，double转float可能损失精度，因为不会自动转，编译是通不过的

         （3.5）字符型变量（char）

char c1 = 'A';  //大写字母

char c2 = '1'   //数字字符

 // Java中可以存储汉字字符

char c3 = '汉字'；//错误，只能一个字符

         注：       在 C 语言中使用 ASCII 表示字符 , 而 Java 中使用 Unicode 表示字符. 因此，一个字符占用 两个字节 （char类型在Java中正好两个字节）, 表示的字符种类更多, 包括中文.

        （3.6）布尔类型（boolean）

注：

1. boolean 类型的变量只有两种取值 , true 表示真 , false 表示假 .

2. Java 的 boolean 类型和 int 不能相互转换 , 不存在 1 表示 true, 0 表示 false 这样的用法

        （3.7）类型转换

                    

        如图所示，当参与数据类型不一致时，就会进行类型转换。

        Java中类型转换分为两类：        自动类型转换        强制类型转换。

                        （3.7.1）自动类型转换

        即：代码不需要任何处理，在编译时，编译器自动进行类型的转化。

                注：自动转化时是将范围小的数向范围大的数转化

int a = 100;

long b = 10L;

b = a     // a 和 b 都是整形，a 所表示的范围小，b 所表示的范围大，编译器会将 a 提升为              long 类型后赋值给 b 。

a = b     // 编译报错 b 的类型大于 a 的类型，由大转小会出现数据丢失，不安全

同理：float 与 double 类项之间的强制转换同样会有以上问题。

byte c = 100;  // 没有超过byte的大小范围可以赋值。

byte d = 257;  // 超过byte的最大限制编译失败，有数据丢失。

                        （3.7.2）强制类型转换

        即：在进行操作时，代码要进行程序员自行处理，无法由编译器自动完成

                

                注：由人工对数据进行取舍，将范围大的数据向范围小的数据进行转化。

int a = 10；

long b = 100L；

b = a;   //  int -->long , 数据范围由小到大，自动类型转换

a = (int)b；//long -->int , 数据范围由大到小，需要强转，否则编译失败。  

float f = 3.14F;

double d = 5.12;

d = f;        //float -->double , 数据范围由小到大，自动类型转换。

f = d;        //double -->float , 数据范围由大到小，需要强转，否则编译失败。

a = d;        //double -->int ,类型不兼容，编译错误。

a = (int)d;        //将double强制类型转换为int，小数点后的数据全丢。

boolean flag = true;

a = flag;        //编译失败，类型不兼容

flag = a;        //编译失败，类型不兼容

        （3.8）类型提升

                1.int 与 long 之间进行运算 int 会自动转换为long

int a = 10;

long b = 20;

int c = a + b;         // 编译出错: a + b==》int + long--> long + long 赋值给int时会丢失数据

long d = a + b;         // 编译成功：a + b==>int + long--->long + long 赋值给long

                2.byte 与 byte 之间的运算

byte a = 10;

byte b = 20;

byte c = a + b;

System.out.println(c);

// 编译报错

Test.java:5: 错误: 不兼容的类型: 从int转换到byte可能会有损失

        原因：byte 与 byte 相加时，会先将 a 和 b 分别提升为 int 类型，然后计算时得到的结果也为 int 类型，但是 c 被定义为 byte 类型，因此出现报错。

        改正方法:

byte a = 10;

byte b = 20;

byte c= (byte)( a + b);

System.out.println(c);

 注：

        1. 不同类型的数据混合运算 , 范围小的会提升成范围大的 .

        2. 对于 short, byte 这种比 4 个字节小的类型 , 会先提升成 4 个字节的 int , 再运算 .