JAVA类型转换及变量详解

类型转换

由于java是强类型语言，所以要进行有些运算的时候，需要用到类型转换。

byte（1个字节）,short（2个字节）,char（2个字节）----->int（4个字节）---->long（8个字节）---->float（4个字节）---->double（8个字节）（小数的优先级一定大于整数）

低-----------------------------------------------------------------高

运算中，不同类型的数据先转化为同一类型，然后进行运算。

类型转换相关代码如下：

public class D {
    public static void main(String[] args) {
        int i=128;
        byte a=(byte) i;
        /*Byte,按住ctrl,点击Byte,即可进入Byte的详情界面，可知Byte的最大值为127，
        这里赋值的是128，即存在内存溢出的情况。*/
        //强制转换的格式如下所示：类型 变量=（类型）变量名  高--低需要强制转换
        //自动转换什么也不需要写，按正常转换即可  低--高自动转换
        double b=i;//自动转换
        System.out.println(i);
        System.out.println(a);
        System.out.println(b);

        /*注意点：1.不能对布尔值进行转换，布尔值是按位计算的，与按字节运算的不相干。
        2.不能把对象类型转换为不相干的类型。
        3.在把高容量转换到低容量的时候，强制转换*/
       System.out.println((int)23.7);//double型，双精度，比int容量高，强制转换
       System.out.println((int)-45.89f);//float型，单精度，比int优先级高，强制转换
       // 4.转换的时候可能存在内存溢出，或者精度问题
       char c='a';
       int d=c+1;//低转高，自动进行转换。
       System.out.println(d);
       System.out.println((char) d);//int型转变为char类型，高转低，强制转换。
    }
}

运行界面如下：

其中Byte的详请界面如下所示： 

Byte,按住ctrl,点击Byte,即可进入Byte的详情界面，可知Byte的最大值为127，

基本数据类型之间的运算规则：

自动类型提升：

当容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型。

此时的容量大小指的是，表示数的范围的大和小，比如：float容量要大于long的容量

低转高自动转（byte、char、short-->int-->long-->float-->double  

特别的：当byte、char、short三种类型的变量做运算时，结果为int类型。

class Main {
    public static void main(String[] args) {
        int a=12;
        byte b=3;
        int c=a+b;//b为byte,转换为int,低转高，自动转换。
        System.out.println(c);
    }
}

char和short和为int型。 

class Main {
    public static void main(String[] args) {
        short a=12;
        char b='3';
        int c=a+b;
        System.out.println(c);
    }
}

 char和byte和为int型。

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

强制类型提升：自动类型提升运算的逆运算。高转低需要强制转换。

注意点：强制类型转换，可能导致精度损失。

class Main {
    public static void main(String[] args) {
        double d1=12.0;
        int i1=(int)d1;
        System.out.println(i1);
    }
}

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

class Main {
    public static void main(String[] args) {
        double d1=12.9;
        int i1=(int)d1;  //截断操作，损失精度
        System.out.println(i1);
    }
}

 编码情况：

class Main {
    public static void main(String[] args) {
        //整型常量，默认类型h是int型
        //浮点型常量，默认类型是double型。
        long  a=123555554444444l;//数字小的时候可以不加l,数字过大必须加l。
        float b=12.5f;  //必须加1f
        System.out.println(a);
    }
}

 内存溢出相关代码详解：

public class E {
    public static void main(String[] args) {
        //操作比较大的数的时候，注意溢出问题
        //JDK新特性，数字之间可以用下划线分割
        int money=10_0000_0000;
        int years=20;
        int total=money*years;
        long   total1=money*years;//这两个乘积值默认为int，在计算出结果后才去转换已经迟了
        //所以要在乘积之前就进行转换。
        long   total2=money*(long)years;
        long   total3=(long)money*years;
        System.out.println(money);
        System.out.println(total); //-1474836480,计算的时候溢出了。
        System.out.println(total1);//-1474836480,计算的时候溢出了。
        System.out.println(total2);
        System.out.println(total3);
    }
}

运行界面如下：

 变量：

变量的概念：

内存中的一个存储区域

该区域的数据可以在同一类型范围内不断变化

变量是程序中最基本的存储单元。包含变量类型、变量名和存储的值

变量都定义在其作用域内，在作用域内，它是有效的。出了作用域就失效了。

不可以在同一个作用域内定义同名的变量（可以通过反证法进行思考，即不可以为可以）

变量是什么：就是可以变化的量

java是一种强类型语言，每个变量都必须声明其类型

java变量是程序中最基本的存储单元，其要素包括变量名，变量类型和作用域

格式如下所示：

type   varName  [=value]

//数据类型      变量名=值；可以使用逗号隔开来声明多个同类型变量（一般不建议这种使用）

注意事项：

1.每个变量都有类型，类型可以是基本类型，也可以是引用类型

2.变量名必须是合法的标识符（变量命名为开头第一个单词的首字母小写，之后每个单词的首字母大写）。

3.变量声明是一条完整的语句，因此每一个声明都必须以分号结束。

变量的命名规范：

所有变量、方法、类名：见名知意

类成员变量：首字母小写和驼峰原则，即第一个单词首字母小写，后面的单词首字母大写,如lastName

局部变量：首字母小写和驼峰原则，即第一个单词首字母小写，后面的单词首字母大写

常量：大写字母和下划线，即MAX_VALUE

类名：首字母大写和驼峰原则：每个单词首字母大写，其他小写,即GoodMan

方法名：首字母小写和驼峰原则，即第一个单词首字母小写，后面的单词首字母大写。即runRun()

变量的相关代码详解如下：

public class F {
    public static void main(String[] args) {
       // int a,b,c;  //可以使用逗号隔开来声明多个同类型变量（一般不建议这种使用）
        //int a=1,b=2,c=3;  //这种方法也不常用，尽量写成三行,要注重程序的可读性。
        int a=1;
        int b=2;
        int c=3;
        String  name="rgf"; //每一个声明都必须以分号结束,而且是英文的分号。
        char x='X';
        double pi=3.14;
        System.out.println(a);
        System.out.println(x);
        System.out.println(pi);
    }
}

运行界面如下： 

变量作用域：

类变量（static关键字后面的）

实例变量（写在类中间）

局部变量（写在方法里面）

变量实例代码详解：

public class G {
    //属性：变量
    //类变量  static
    static double salary=2500;

    /*实例变量：方法外面，类里面，从属于对象，如果不自行初始化，这个类型的默认值
    一般为0（代表整数）或者0.0（代表小数）,布尔值的默认值是false，
    除了基本类型，其余的默认值都是null。
     */
    String name;//默认值为null
    int age;//默认值为0


    //main方法，在类里面
    public static void main(String[] args) {


        //局部变量；必须声明和初始化值
        int i=10;//只在第二个大括号内有用。
        //================================================
        //调用实例变量的方法。
        G g = new G();//变量类型  变量名字=new G(),其中g就叫对象。
        new G();/*如何在这个的基础上出现以上的效果，可以通过在括号后面加.var即可
        也可以通过alt+enter实现这种功能。*/
        System.out.println(g.age);
        System.out.println(g.name);

        //类变量  static关键字，获得它们的属性，可以直接用
        System.out.println(salary);
        
    }



    //其他方法,add方法
    //public void add(){}
}

运行界面如下：

 常量：

常量：初始化后不能再改变值，不会变动的值

所谓常量可以理解成一种特殊的变量，它的值被设定后，在程序运行过程中不允许被改变。

final 常量名=值；

final double PI=3.14;

常量名一般使用大写字符。

常量的代码详解：

public class H {
    //final为修饰符，不存在先后顺序
    static final double PI=3.14; //static定义为静态的常量
    public static void main(String[] args) {
        System.out.println(PI);
    }
}

运行界面如下：