Java基础_变量

已于 2022-08-24 16:41:46 修改
阅读量745 收藏 3
点赞数
分类专栏： 后端开发_Java学习 后端开发_韩顺平Java系列 文章标签： java
于 2022-08-24 16:27:34 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/skrloinking/article/details/126507394
版权

第三章 变量

3.1 认识变量

​ 变量本质上就是代表一个”可操作的存储空间”，空间位置是确定的，但是里面放置什么值不确定。我们可通过变量名来访问“对应的存储空间”，从而操纵这个“存储空间”存储的值。 变量作为程序中最基本的存储单元，其要素包括变量名，变量类型和作用域。变量在使用前必须对其声明, 只有在变量声明以后，才能为其分配相应长度的存储空间。

3.1.1 什么是变量

  • 变量是程序的基本组成单位

  • 变量是由 数据类型+变量名+值 组成的

  • 变量的基本原理：

    在计算机中的内存 数据类型会声明出 一个空间，然后赋值进去，最后通过变量名（即在内存中的一个地址），查询或者更改。

/*
 * 变量是程序的基本组成单位
 * 不论是使用哪种高级程序语言编写，变量都是其程序的基本组成单位
 * 
 * 变量有三个基本要素：
 * 类型  名称  值
 */
public class Variable{

    //编写一个main方法
    public static void main(String[] args){

        //定义了一个变量，类型是 int （整型）。名称为：a，值为：1
        int a = 1 ;
        //定义了一个变量，类型是 int （整型）。名称为：b，值为：3
        int b = 3 ;

        //在控制台输出 a 和 b 变量的值
        System.out.println(a);
        System.out.println(b);

        //给 变量b 重新赋值 
        b = 5 ;
        //在控制台输出 b 变量的值
        System.out.println(b);

    }
}

3.1.3 变量的类型

变量用于操作系统中，实体之间的传递，把变量看作一个在内存空间中声明的存储位置，在调用变量的时候，系统会自动的调用内存中的存储位置。

在Java中，变量又称为字段，故字段在Java中又有分类。

基本数据类型：

  • 整型：

    byte（-128~127） \ short（2字节） \ int（4字节）\long（8字节）

    int - 存储整数（整数），不带小数，例如 123 或 -123

    long - 类型数据必须以l或者L结尾（整型数据默认是int类型）

  • 浮点型：

    float（4字节）\double（8字节）

    double - 存储带小数的浮点数，例如 19.99 或 -19.99

    float - 类型数据要加F或者f结尾（默认浮点数类型是double）

  • 字符型：

    char[2]- 存储单个字符，例如 ‘a’ 或 ‘B’。Char 值用单引号括起来

  • 布尔型：

    boolean[1] - 存储具有两种状态的值：真或假

引用数据类型：

  • 类（class）- 字符串类型属于类类型的数据。

    String- 存储文本，例如“hello”。字符串值用双引号括起来

  • 接口（interface）

  • 数组（array）

3.2 变量的介绍

3.2.1 变量的概念

变量相当于内存中一个数据存储空间的表示，可以通过变量名可以访问到变量(值)。在现实生活中，变量相当于一个房间，房间可以通过房间号来找到。

3.2.2 变量使用的基本步骤

  1. 声明变量

//初始化声明一个变量

int var01;

  1. 赋值

//把 100 赋值给 var01

var01 = 100;

  1. 打印变量

//在控制台打印 var01

System.out.println(var01);

  • 往往可以一步 声明变量的同时完成初始化赋值

    //声明变量 var02 并把 100 赋给它

    int var02 = 100;

    //在控制台打印 var02

    System.out.println(var02);

3.3 变量快速入门

变量使用入门案

/*
 * 变量使用入门案例
 * 1、在控制台打印个人信息
 * 2、个人信息包括-名称 性别 年龄 成绩
 */
public class Variable01{
    //编写一个main方法
    public static void main(String[] args){

        //个人名称
        String name = "小原同学";
        //性别
        char gender = '男';
        //年龄
        int age = 21;
        //成绩
        double score = 99.99;

        //在控制台打印个人信息
        System.out.println("个人基本信息如下:");

        System.out.println("名称为："+ name);

        System.out.println("性别为："+ gender);

        System.out.println("年龄为："+ age);

        System.out.println("成绩为："+ score);

    }
}

3.4 变量使用注意事项

  1. 变量表示内存中的一个存储区域
  • 不同的变量，不同的类型，占用的空间大小不同。

  1. 变量必须先声明，后使用。程序是有序执行。

  2. 变量 = 数据类型 + 数据名 + 值

  3. 变量在同一个作用域内，名称不能相同

  4. 该区域的 数据 可以在 同一类型 范围内 任意变化

// 变量使用注意事项
public class VarDetail{
    //编写一个main方法
    public static void main(String[] args){

        //1、变量 = 数据类型 + 数据名 + 值
        //2、变量必须先声明，后使用。
        int firstInt = 99;
        //在控制台打印 int类型的firstInt
        System.out.println(firstInt);

        //3、该区域的数据可以在 同一类型 范围内任意变化
        //        firstInt = '变';  × 不能类型变化会出错
        firstInt = 999;
        //在控制台打印 int类型的firstInt
        System.out.println(firstInt);

        //4、变量在同一个作用域内，名称不能相同
        //        int firstInt = 88; (×)
    }
}
class CommonVar{
    public static void main(String[] args){
        int firstInt = 88;
        //在控制台打印 int类型的firstInt
        System.out.println(firstInt);
    }
}

3.5 程序中 +号的使用

  1. 当左右两边都是数值类型时，则做加法运算

  2. 当左右两边有一方为字符串类型时，则做拼接运算

  3. 程序的运算顺序，是从左到右，从上到下的

// 程序中 +号的使用
// 1、当左右两边都是数值类型时，则做加法运算
// 2、当左右两边有一方为字符串类型时，则做拼接运算
// 3、程序的运算顺序，是从左到右，从上到下的
public class SystemPlus{
    //编写一个main方法
    public static void main(String[] args){

        //在控制台打印
        System.out.println(900+99); //999
        System.out.println(900+99+"9"); //9999
        System.out.println("9"+900+99); //990099

    }
}

3.6 数据类型详细

  1. java 数据类型分为两大类 基本数据类型， 引用类型
  2. 基本数据类型有 8 中 数值型 [byte , short , int , long , float ,double] char , boolean
  3. 引用类型 [类，接口， 数组]

![](file:///C:/Users/Yuan/AppData/Roaming/marktext/images/2022-07-31-16-54-59-image.png?msec=1661307037124)

3.6.1 整数类型

类型占用存储空间表数范围
byte   [字节]1字节-27 ~ 27-1（-128~127）
short [短整型]2字节-215 ~ 215-1 （-32768~32767）
int      [整型]4字节-231 ~ 231-1 (-2147483648~2147483647) 约21亿
long   [长整型]8字节-263 ~ 263-1
整型的使用细节:
  1. Java各整数类型有固定的范围和字段长度，不受具体 OS[操作系统] 的影响，以 保证java程序的可移植性。
  2. Java的整型常量(具体值)默认为int型，声明long型常量须后加T'或L'
  3. java程序中变量常声明为int型， 除非不足以表示大数，才使用long
  4. bit: 计算机中的最小存储单位。byte:计算机中基本存储单元,1byte = 8 bit。
通过二进制存储入系统：

![](file://C:\Users\Yuan\AppData\Roaming\marktext\images\2022-07-31-18-40-22-image.png?msec=1661307037083)

代码实现：
//整型的使用细节
public class IntDetail{
        //编写一个main方法
    public static void main(String[] args){

        //Java 的整型常量（具体值）默认为 int 型，声明 long 型常量须后加‘l’或‘L’

        // long 类型不能转换 int 类型
        // int num2 = 1L;
        int num1 = 1;//4 个字节

        // int 类型可以转换 long 类型
        long num3 = 1L;//8 个字节
        long num4 = 2;

        //在控制台打印
        System.out.println(num1);
        // System.out.println(num2);
        System.out.println(num3);
        System.out.println(num4);

    }
}

3.6.2 浮点类型

Java 的浮点类型可以表示一个小数，比如 123.4，7.8 ，0.12 等等。

浮点型的分类:
类型占用存储空间范围
float   单精度4字节-3.403E38 ~ 3.403E38
double 双精度8字节-1.798E308 ~ 1.798E308
面试细节：
  1. 关于浮点数在机器中存放形式的简单说明, 浮点数=符号位+指数位+尾数位
  2. 尾数部分可能丢失，造成精度损失(小数都是近似值)。
浮点类型的使用细节：

  1. 与整数类型类似，Java浮点类型也有固定的范围和字段长度，不受具体OS的 影响。[float 4个字节 double是8个字节]

  2. Java 的浮点型常量默认为double型，声明float型常量， 须后加 'f' 或 'F'

  3. 浮点型常量有两种表示形式:

十进制数形式: 5.12 512.0f .512 (必须有小数点)

科学计数法形式: 5.12e2 [5.12*10的2次方] 5.12E-2 [5.12/10的2次方]

  1. 通常情况下，应该使用double型，因为它比float型更精确。 [举例说明]

double d1 = 3.1415926535 ; (更精确)

float f1 = 3.1415926535F ;(丢失部分精度)

  1. 浮点数使用出现的问题：2.7 和 8.1/3 比较 
double num01 = 2.7;
double num02 = 8.1 / 3 ;
if(Math.abc(num01 - num02) < 0.00001 ){
    System.out.println("这俩值基本相同了！");
}
代码实现：
//浮点数细节及使用细节
public class FloatDetail{

    //编写一个main方法
    public static void main(String[] args){

        //浮点型常量 默认为 double 类型，声明为float类型常量，需要在后面加 'f' 或 'F'

        double db01 = 3.1415926; //8 个字节
        float ft01 = 2.713156F; //4 个字节

        // double 类型不能转换 float 类型
        // float db02 = 3.14;

        // float 类型可以转换 double 类型
        double db02 = 3.1415926F; //8 个字节

        double db03 = 2.713156; //8 个字节

        System.out.println("第一次数据为");
        System.out.println(db01);
        System.out.println(ft01);
        System.out.println(db02);
        System.out.println(db03);

        //十进制数形式：如：5.12 512.0f .512 (必须有小数点）
        double db04 = .512;
        double db05 = 0.512;
        double db06 = 512.0f;

        System.out.println("第二次数据为");
        System.out.println(db04);
        System.out.println(db05);
        System.out.println(db06);
        System.out.println(db04 == db05); //判断 db04 和 db05 是否相同

        //科学计数法形式：如：9.99e2 =》[9.99 * 10^2]       999E-2 =》[999 / 10^2]
        double db07 = 9.99e2;
        double db08 = 9.99E2;
        double db09 = 999E-2;
        double db10 = 999e-2;

        System.out.println("第三次数据为");
        System.out.println(db07);
        System.out.println(db08);
        System.out.println(db09);
        System.out.println(db10);
        System.out.println(db07 == db08); //判断 db07 和 db08 是否相同
        System.out.println(db09 == db10); //判断 db09 和 db10 是否相同

        //通用情况，应该使用 double 型，因为它比 float 型更精确
        //位数多的话会出现精度丢失
        double db11 = 0.12345678901;
        float ft02 = 0.12345678901F;
        System.out.println(db11);
        System.out.println(ft02);

        //浮点数使用出现的问题：2.7 和 8.1/3 比较
        double db12 = 2.7 ;
        double db13 = 8.1/3 ;
        double db14 = 2.7 ;

        System.out.println("----------------------------------");
        System.out.println(db12); // 2.7
        System.out.println(db13); //接近 2.7的一个小数。

        //对比两个小数时 要对数据进行处理 然后再进行比较判断
        //例题则需要 以两个数的差值的绝对值，在某个精度范围内判断
        if(db12 == db14){
            //细节:如果是直接查询得的的小数或者直接赋值，是可以判断相等
            System.out.println( "db12 == db14 相等");
        }

        if(Math.abs(db12-db13) < 0.00001 ){
            System.out.println("差值非常小，约等于他们相同!");
        }
        System.out.println(Math.abs(db12 - db13));
    }

}

3.6.3 字符类型(char)

基本介绍：

字符类型可以表示单个字符,字符类型是 char，char 是两个字节(可以存放汉字)，多个字符我们用字符串String(我们后面详细讲解 String)

案例演示： Char01.java
//字符类型的基本使用
public class Char01{
    //编写一个main方法
    public static void main(String[] args){
        char cr1 = '原';
        char cr2 = 'y';
        char cr3 = '\t';
        //字符类型可以直接存放一个数字，因为在底层编码对应的是数字
        //每个数字都会对应一个字母 比如 97 =》'a' 
        char cr4 = 97;
        System.out.println(cr1);
        System.out.println(cr2);
        System.out.println(cr3);
        System.out.println(cr4);        
    }
}   
字符类型使用细节：
  1. 因为char是16位的，采取的Unicode的编码方式，所以char就有以下的初始化方式: 
//字符，可以是汉字，因为是Unicode编码

char c = 'c'; 

//可以用整数赋值
//可以用整数赋值【整数范围：0~65535】。输出字符编码表中对应的字符。

char c = 十进制数，八进制数，十六进制数等等;

//用字符的编码值来初始化，如：char='\0',表示结束符，
//它的ascll码是0，这句话的意思和 char c=0 是一个意思。

char c = '\u数字';
  1. 字符常量是用单引号 '' 括起来的字符。

例如：char c01 = 'a'; char c02 = '我'; char c03 = '9';

  1. char 类型的变量 允许使用转义字符 '\' 来将其后的字符转变为特殊字符型常量。

例如：char c04 = '\n'; --> '\n'表示换行符 '\t'表示对齐符

  1. 在 java 中，char 的本质是一个整数，在输出时，默认是 unicode 码对应的字符

在线Unicode编码转换-Unicode和ASCII在线互转-中文转Unicode工具

  1. 可一直接给 char 赋一个整数，然后输出时，会按照对应的unicode字符的输出。

ASSIC -------> Unicode --------> 对应的字符 97 -------> 'a'

  1. char类型是可以进行运算的，相当于一个整数，因为它都有对应的 Unicode码。

  2. ASCII 字符编码表

Ascii码对照表-在线Ascii码对照表-在线ASCII转换

  1. char类型是可以运算的因为char在ASCII等字符编码表中有对应的数值。

在Java中，对char类型字符运行时，直接当做ASCII表对应的整数来对待。

  1. char + char，char + int——类型均提升为int，

附值char变量后，输出字符编码表中对应的字符。

代码实现：
//字符类型的使用细节
public class CharDetail{
    //编写一个main方法
    public static void main(String[] args){

        // 在 java 中，char 的本质是一个整数，在输出时，默认是 unicode 码对应的字符
        // 因为char是16位的，采取的Unicode的编码方式，所以char就有以下的初始化方式:
        // ASCII 是包含在 Unicode 的
        char cr0 = 21407; // 通过 Unicode 转换为对应的字符 -----> '原'
        //控制台输出：原
        System.out.println(cr0);

        //要输出对应的数字，可以(int)字符 强制转换
        char cr1 = '原'; //不做处理的话 会直接输出 ---> 原
        //控制台输出：'原' 对应的 字符编码
        System.out.println((int)cr1);

        char cr2 = 23567; //通过 Unicode 转换为对应的字符 -----> '小'
        //控制台输出：'小' 对应的 字符编码
        System.out.println((int)cr2);

        //char 类型是可以进行运算的，相当于一个整数，因为它都对应有 Unicode 码.
        // '原' 对应的Unicode码 21407 + int 类型 8593 =30000
        //char类型相加，提升为int类型
        System.out.println('原'+ 8593 );

        //想法：char类型的 加减会出现什么情况？
        //char + char，char + int——类型均提升为int，附值char变量后，输出字符编码表中对应的字符。
        char cr3 = 'a' + 1; //97 + 1 ==> 98 
        char cr4 = 'b' + 1; //98 + 1 ==> 99 
        int i1 = 10;
        //常量无需转换，cr3 + 1 是一个 int类型 的变量
        //故 cr9 = cr3 + 1；会报错 需要强制转换
        char cr9 = (char)(cr3+1);
        char cr10 = (char)(cr3+i1);
        char cr11 = (char)(cr3+cr4);

        System.out.println((int)cr3); //98
        System.out.println(cr3); // b

        System.out.println((int)cr4); //99 
        System.out.println(cr4); // c

        System.out.println(cr9); // b
        System.out.println((int)cr9); //99 
        System.out.println(cr10); // L
        System.out.println((int)cr10); //108
        System.out.println(cr11); // ?
        System.out.println((int)cr11); //197 

        // 99 -> 通过 编码表 ASCII 找到对应的字符 -> c

        char cr5 = 43; //目前 ASCII 默认支持十进制
        System.out.println(cr5);

    }
}

3.6.4 字符类型本质

ansi编码_Java 字符编码_weixin_39835792的博客-CSDN博客

https://www.cnblogs.com/LCABC/articles/16463252.html

常见的字符编码表

  • ASCII码 —ASCII编码表由一个字节表示，128个字符，实际上一个字节可以表示256个字符，但是老外的英文只有那么24个字母，用不了那么多的字符。但是随着计算机的普及，全球都在使用计算机，原本的编码不能够满足全球各国语言，所以出现了Unicode

  • Unicode — Unicode编码表是固定大小的编码，使用两个字节来表示字符，字母和汉字统一都是占用两个字节，容易造成空间浪费。

  • utf-8 — 大小可变的编码，字母使用一个字节，汉字使用3个字节。

  • gbk — gbk编码可以表示汉字，而且范围广，字母使用一个字节，汉字2个字节。

  • gb2312 — 可以表示汉字，gb2312<gbk

  • big5 码 — 繁体中文，台湾，香港

字符集

字符(Character)是各种文字和符号的总称，包括各国家文字、标点符号、图形符号、数字等。字符集(Character set)是多个字符的集合，字符集种类较多，每个字符集包含的字符个数不同，常见字符集名称：ASCII 字符集、GB2312 字符集、BIG5 字符集、 GB18030 字符集、Unicode 字符集等。计算机要准确的处理各种字符集文字，就需要进行字符编码，以便计算机能够识别和存储各种文字。

字符编码

字符编码(英语：Character encoding)也称字集码，是把字符集中的字符编码为指定集合中某一对象(例如：比特模式、自然数序列、8 位组或者电脉冲)，以便文本在计算机中存储和通过通信网络的传递。

为了理解字符集和字符编码的关系，这里举个简单的例子，我们可以把字符集当成接口，把字符编码当成接口的实现。Unicode是接口(字符集)， UTF-8 / UTF-16 / UTF-32则是不同的实现(字符编码)。

ANSI

ANSI 全称(American National Standard Institite)美国国家标准学会(美国的一个非营利组织)，首先 ANSI 不是指的一种特定的编码，而是不同地区扩展编码方式的统称，各个国家和地区所独立制定的兼容 ASCII 但互相不兼容的字符编码，微软统称为 ANSI 编码。

ASCII码介绍:

  • 一个字节表示具体的字符，只用了后七位（2 ^ 7 = 128）最前面的一位统一为0，能够表示128个字符，其中包括了英文字符、阿拉伯数字、西文字符以及32个控制字符。

  • 用来表示更多的欧洲文字，不同国家有不同的字符编码，即使都是256个字符编码，但后128个字符的编码方式不一样，代表的字母也不一样

  • ASCII 字符编码表

    Ascii码对照表-在线Ascii码对照表-在线ASCII转换

Unicode 字符集:

  • 包含了世界上所有的字符，并且每一个符号都是独一无二的；

  • 中文需要两个字节进行存储，而用两个存储字节英文字符时，前面一个字节都为0，造成存储的浪费；出现了 Unicode 的多种的存储方式；

UTF-8 :

  • UTF-8是互联网上使用最广的一种Unicode的实现方式，是一种可变长的编码方式。

  • 对于单字节的符号，字节的第一位设为0，后面7位为这个符号的Unicode码。因此对于英文的字母，UTF-8编码和ASCII码是相同的；

  • 对于n（n>1）字节的符号，第一个字节的前n位都设为1，第n+1位设为0，后面字节的前两位一律设为10，剩下没有提及的二进制位，全部为这个符号的Unicode；

3.6.5 布尔类型（boolean）

基本介绍：

  1. 布尔类型（Boolean 类型），Boolean类型数据只允许取值 true false ，为空则为Null。

  2. boolean 类型 占一个字节

  3. boolean 类型适用于 逻辑运算，一般用于流程控制

  • if 条件控制语句

  • for 循环控制语句

  • while 循环控制语句

  • do-while 循环控制语句

boolean 案例了解：
// if循环语句判断案例
public class Boolean01{
    //编写一个main方法
    public static void main(String[] args){

        //条件 判断成绩是否通过 案例

        //定义一个布尔变量 通过状态
        boolean isPass = true;

        //判断 isPass 是否 等于 true
        if(isPass == true){
            //如果 isPass 为 true 则打印成绩合格
            System.out.println("恭喜你，成绩为合格");
        } else {
            //如果 isPass 为 flase 则打印成绩不合格
            System.out.println("对不起，成绩不合格");
        }
    }
}

3.7 数据类型转换

3.7.0 基本数据类型转换

介绍：

当 Java 程序在进行赋值或者运算时，精度小的类型自动转换为精度大的数据类型，这个就是自动类型转换。

数据类型按精度大小排序:

char ---> int ---> long ---> float ---> double

byte ---> short ---> int ---> long ---> float ---> double

自动转换 演示案例：
//自动类型转换 基本案例
public class AutoConvert{
    //编写一个main方法
    public static void main(String[] args){

        //java程序在进行赋值的时候，精度小的可以自动转换为精度大的数据类型

        // char 类型 自动转换为 int
        int it1 = 'd';
        //输出打印 it1 显示 char类型’d‘对应的编码
        System.out.println(it1);

        // int 类型 自动转换为 double
        double db1 = 99;
        //输出打印 db1 显示 double 类型的 100
        System.out.println(db1);

    }
}
3.7.1 自动类型转换注意和细节

  1. 有多种类型的数据混合运算时，系统首先 自动 将所有数据转换成运算里精度高的那种数据类型，然后再进行运算。

  2. 当我们把精度低的数据类型赋给精度高的数据类型时，会进行自动类型转换，

当我们把精度大的数据类型赋给精度小的数据类型时，就会报错。 高精度->低精度

  1. （byte，short）和 char 之间不会相互自动转换。

  2. byte，short，char 他们之间可以进行计算，但是要首先要转换为 int 类型。

  3. Boolean 不参与 类型转换。

  4. 自动提升原则：表达式结果的类型自动提升为 操作数中最大的类型

代码实现:
//自动类型转换 注意事项及使用细节
public class AutoConvertDetail{
    //编写一个main方法
    public static void main(String[] args){

        //1、有多种类型的数据混合运算时，系统首先自动 将所有数据转换成运算里精度高的那种数据类型，然后再进行运算。

        // 定义一个 int 类型的常量 99
        int it1 = 99;

        // 定义一个 float 类型的变量 it1 + 0.99F =》结果为 double类型  XXXXX
        // float ft1 = it1 + 0.99;

        // 定义一个 float 类型的变量  it1 + 0.99F =》结果为 99.99 float类型
        float ft1 = it1 + 0.99F;
        // 定义一个 double 类型的变量  it1 + 0.99999 =》结果为 99.99999 double类型
        double db1 = it1 + 0.99999;
        // 定义一个 double 类型的变量  it1 + 0.999F =》结果为 99.999xxxxx double类型
        double db2 = it1 + 0.999F;

        System.out.println(ft1); // 99.99
        System.out.println(db1); // 99.99999
        System.out.println(db2); // 99.999xxxxx

        //2、当我们把精度大的数据类型赋给精度小的数据类型时，就会报错。高精度->低精度

        // 定义一个 float 类型的变量 --> 将 常量100 赋给float类型
        float ft2 = 100;  //100.0
        // 定义一个 int 类型的变量 --> 将 100.00 赋给int类型
        // int it2 = 100.00; //报错 double类型 -> int类型

        System.out.println(ft2); // 100.0


        //3、（byte，short）和 char 之间不会相互自动转换。
        byte be1 = 'a';
        System.out.println(be1); // 97
        short st1 = 'b';
        System.out.println(st1); // 98

        //当把具体数赋给 byte 或者 short 时，(1)先判断该数是否在 byte short 范围内
        byte be2 = 99 ;
        short st2 = 100;
        char cr1 = 'a';

        /* 错误原因：byte 不能自动转成 char类型 、short 不能自动转成 char类型
        char cr2 = be2;
        char cr3 = st2;
        */

        //当把变量赋值时候，会先判断类型 
        // byte be3 = cr2;  cr2是char类型的
        // short st3 = cr3;    cr3是char类型的
        /* 错误：类型转换错误
        System.out.println(cr2); // c
        System.out.println(cr3); // d
        System.out.println(be3);
        System.out.println(st3);
        */

        //4、byte，short，char 他们之间可以进行计算，但是要首先要转换为 int 类型。

        byte be4 = 9;
        short st4 = 10;
        int st5 = be4 + st4; //这三者进行运算 会将精度提到int类型 be4 + st4 => int类型
        System.out.println(st5); //int类型 ==》 19 

        //只要这三者进行运算，哪怕是同类型也会提升至 int类型
        byte be5 = 100;
        int be6 = be4 + be5;
        short st6 = 100;
        int st7 = st4 + st6;
        System.out.println(be6); //int类型 ==》109
        System.out.println(st7); //int类型 ==》110

        char cr4 = 97;
        int it6 = be4 + cr4;
        System.out.println(it6); //int类型 ==》106

        //5、Boolean 不参与 类型转换。
        boolean bn1 = true;
        // int it7 = true; //报错：不兼容的类型，直接无法转换

        //6、自动提升原则：表达式结果的类型自动提升为 操作数中最大的类型

        //练习代码需求：判断 类型混合运算的结果是什么类型的；

        byte num1 = 10;
        short num2 = 100;
        int num3 = 1000;
        double num4 = 888.88;

        double num10 = num1 + num2 + num3 + num4; //自动提升为精度最高的类型 double num4;
        System.out.println(num10); //double类型 ==》1998.88
    }
}
3.7.2 强制类型转换

介绍: 自动类型转换的逆过程，将容量大的数据类型转换为容量小的数据类型。使用时要加上强制转换符( )，但可能造成精度降低或溢出,格外要注意。

强制类型转换 演示案例：
//强制类型转换 基本案例
public class ForceConvert{

    //编写一个main方法
    public static void main(String[] args){

        //精度高的强制转换为 精度低的类型 会造成精度丢失
        double num1 = 99.99;
        int num2 = (int)num1;
        System.out.println("int类型的数值为：" + num2);

        //精度高的强制转换为 精度低的类型 超过了精度低的容量 会造成精度溢出
        int num3 = 999;
        byte num4 = (byte)num3;
        System.out.println("byte类型的数值为：" + num4);

    }
}
强制类型转换 细节说明:
  1. 当进行数据转换时， 从 精度大 ====》 精度小，就需要使用到强制转换.

double ==> int int ==> byte

  1. 强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级.

int = (int) 2.7; int = (int) (10 * 2.7)------>先运算括号里面的。

  1. char类型可以保存int的常量值 但不能保存 int的变量值，需要强转.

char char1 = 10; char char2 = (char) int2 ;

  1. byte、short、char类型再进行运算时，当作int类型处理。

只要出现三者运算，自动提升为int类型

 //强制类型转换 使用细节
public class ForceConvertDetail{

    //编写一个main方法
    public static void main(String[] args){

        //1、当进行数据转换时， 从 精度大 ====》 精度小，就需要使用到强制转换.
        double db1 =  (double) 100;
        byte be1 = (byte) 100;
        System.out.println(db1);//输入结果：double ==> 100.0
        System.out.println(be1);//输入结果：byte ==> 100

        //2、强转符号只针对于最近的操作数有效，往往会使用小括号提升优先级.
        int ride = (int) (99.9*33.33 + 22.22 * 10);
        System.out.println(ride); //输入结果：int ==> 3551
        // 错误示范 int ride = (int) 99.9*33.33 + 22.22 * 10; 只会强转临近 常量
        int ride1 = (int) 90.9*10 + 10 * 10;
        System.out.println(ride1); //输入结果：int ==> 1000

        //3、char类型可以保存int的常量值 但不能保存 int的变量值，需要强转.
        char char1 = 10;
        System.out.println(char1); //输入结果：char ==> 10
        int it1 = 100;
        char char2 = (char)it1;    // 是一个100的字符 '100'--> d
        System.out.println(char2); //输入结果：char ==> '100' --> d

        //4、byte、short、char类型再进行运算时，当作int类型处理。
        byte be2 = 10;
        short st1 = 10;
        char c1 = 'd';
        int it2 = be2 + st1 + c1;
        System.out.println(it2); //输入结果：int ==> 120

    }
}

3.8 基本数据类型和 String 类型的转换

3.8.1 介绍和使用

在程序开发中，我们经常需要将基本数据类型转换成String类型，

或者将String类型转成基本数据类型。

基本类型转String类型

  • 实现：

    定义基本数据类型后，String = 基本数据类型 + "";

    // 基本数据类型 --> String 类型的转换
    public class StringToBasic{

        //编写一个main方法
        public static void main(String[] args){

            //基本数据类型
            byte byte1 = 11;
            short short1 = 22;
            int int1 = 33;
            long long1 = 44L;

            float float1 = 55.55F;
            double double1 = 66.66;

            char char1 = 100;
            boolean boolean1 = true;

            //转换为 String 类型
            String byte2 = byte1 + "";
            String short2 = short1 + "";
            String int2 = int1 + "";
            String long2 = long1 + "";
            String float2 = float1 + "";
            String double2 = double1 + "";
            String boolean2 = boolean1 + "";
            String char2 = char1 + "";

            System.out.println(byte2); //String --> "11" ;
            System.out.println(short2); //String --> "22" ;
            System.out.println(int2); //String --> "33" ;
            System.out.println(long2); //String --> "44" ;
            System.out.println(float2); //String --> "55.55" ;
            System.out.println(double2); //String --> "66.66" ;
            System.out.println(boolean2); //String --> "true" ;
            System.out.println(char2); //String --> "d" ;

        }
    }
String类型转基本数据类型

  • 实现:

    通过使用基本类型的包装类，调用 parseXxxx方法实现

    Integer.parseInt("int"); or Boolean.parseBoolean("true")

     // String 类型 --> 基本数据类型的转换
    public class BasicToString{

        //编写一个main方法
        public static void main(String[] args){

            //声明一个 String类型的变量
            String str1 = "119";
            String str2 = "true";

            //使用 基本数据类型对应的包装类，的相应方法，得到基本数据类型
            byte b1 = Byte.parseByte(str1);
            short s1 = Short.parseShort(str1);
            int i1 = Integer.parseInt(str1);
            long l1 = Long.parseLong(str1);
            float f1 = Float.parseFloat(str1);
            double d1 = Double.parseDouble(str1);
            boolean bn1 = Boolean.parseBoolean(str2);

            System.out.println(b1); //byte --> 119
            System.out.println(s1); //short --> 119
            System.out.println(i1); //int --> 119
            System.out.println(l1); //long --> 119
            System.out.println(f1); //float --> 119.0
            System.out.println(d1); //double --> 119.0
            System.out.println(bn1); //boolean -->true

            //怎么把字符串转成字符 char -> 含义是指 把字符串的第一个字符得到
            //s5.charAt(0) 得到 s5 字符串的第一个字符 '1'
            char cr1 = str1.charAt(0);
            char cr2 = str1.charAt(1);
            char cr3 = str1.charAt(2);

            System.out.println(cr1);
            System.out.println(cr2);
            System.out.print(cr3);
        }
    }
3.8.2 注意事项

  1. 在将 String 类型转成 基本数据类型时，要确保 String 类型能够转成有效的数据，比如我们可以把"123" , 转成一个整数，但是不能把 "hello" 转成一个整数

  2. 如果格式不正确，就会抛出异常，程序就会终止。

代码实现：
//演示字符串转基本数据类型的细节
public class StringToBasicDetail{
    //编写一个main方法
    public static void main(String[] args){

        //定义 String 类型的变量
        String str1 = "110";
        String str2 = "hello";
        //转换为 int 类型
        int it1 = Integer.parseInt(str1);
        int it2 = Integer.parseInt(str2);//编译报错 因为系统无法识别类型

        System.out.println(it1);
        System.out.println(it2);
    }
}

3.9 本章练习

1、判断程序会输出什么结果

[Homework01.java]

// 1、判断程序会输出什么结果
public class Homework01{

    //编写一个main方法
    public static void main(String[] args){
        int num1;
        int num2;
        int num3;
        num1 = 99;
        num2 = 357;
        num3 = num1 + num2; // int类型 -----> 456

        System.out.println("num3的值为：" + num3);

        int num4 = 159;
        int num5;
        num5 = num3 - num4;  // int类型 -----> 297
        System.out.println("num5的值为：" + num5);
    }
}
2、使用char类型 打印 特殊字符

[Homework02.java]

使用 char 类型，分别保存 \n \t \r \ 123 等字符，并打印输出

代码实现：

//2、使用 char 类型，分别保存 \n \t \r \\ 123 等字符，并打印输出
public class Homework02{

    //编写一个main方法
    public static void main(String[] args){
        char num1 = '\n';
        char num2 = '\t';
        char num3 = '\r';
        char num4 = '\\';

        char num5 = '1';
        char num6 = '2';
        char num7 = '3';

        System.out.println(num1); // 换行
        System.out.println(num2); // 制表位
        System.out.println(num3); // 回车
        System.out.println(num4); // 输出 \ 
        System.out.println(num5); // 1
        System.out.println(num6); // 2
        System.out.println(num7); // 3
    }
}
3、编程，保存 两本书名 书的价格 两个性别

[Homework03.java]

编程，保存两本书名，用 + 拼接，看效果。保存两个性别，用加号拼接，看效果。

保存两本书的价格，用加号拼接，看效果

代码实现：

//3、编程，保存两本书名，用 + 拼接，看效果。保存两个性别，用加号拼接，看效果。保存两本书的价格，用加号拼接，看效果
public class Homework03{

    //编写一个main方法
    public static void main(String[] args){

        //声明 两本书 String类型 并且保存书名
        String book1 = "《末世英雄传》";
        String book2 = "《天域苍穹》";
        //打印输出 用+拼接的结果  《末世英雄传》《天域苍穹》
        System.out.println(book1+book2); // 只是将两个字符串类型拼接到了一起

        //声明 两个性别 使用char类型保存
        char sex1 = '男';
        char sex2 = '女';
        //打印的会是 字符对应的字符编码值 加法运算
        System.out.println(sex1+sex2); // 常量 ===> 52906;

        //声明 两本书的价格 使用 double 类型保存
        double price1 = 33.33;
        double price2 = 66.66;
        //打印输出 两个 double 类型 加法运算
        System.out.println(price1+price2); // double ===> 99.99
    }
}
4、编程实现以下需求

[Homework04.java]

姓名性别年龄成绩爱好
小原男2199.99乒乓球

  1. 声明姓名、性别、年龄、成绩、爱好这些变量

  2. 使用 + 拼接，添加转义字符，使用一条语句输出

  3. 添加适当的注释

代码实现：

//4、在控制台输出个人信息 -- 姓名、性别、年龄、成绩、爱好
public class Homework04{

    //编写一个main方法
    public static void main(String[] args){

        //声明一个 String 类型的变量 name;
        String name = "小原";
        //声明一个 char 类型的变量 sex;
        char sex = '男';
        //声明一个 int 类型的变量 age;
        int age = 21;
        //声明一个 double 类型的变量 garden;
        double garden = 99.99;
        //声明一个 String 类型的变量 habbit;
        String habbit = "篮球、乒乓球";

        //输出打印
        System.out.println("姓名\t性别\t年龄\t成绩\t爱好\n"+ name +"\t"+ sex +"\t"+ age +"\t"+ garden +"\t"+ habbit);
    }
}

本文由 mdnice 多平台发布

一个程序原
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java基础;14_变量的介绍.avi
01-10
java基础;14_变量的介绍.avi
java基础;17_变量的注意事项.avi
01-10
java基础;17_变量的注意事项.avi
Java基础---变量(三)
weixin_33754913的博客
09-02 186
简单的说，我们可以把变量看作是个盒子，可以将钥匙、手机、饮料等物品存放在这个盒子中，也可以在需要的时候换成我们想存放的新物品。在 Java 中，我们通过三个元素描述变量：变量类型、变量名以及变量值。如果我们把变量比作是酒店的房间，要存储的数据就好比要住宿的客人，我们可以根据客人的要求安排其入住“标准间”或者是“总统套房”，并且可以根据房间名字快速查找到入住客人的信息。同理，在...
java中的变量基本概念
xiaotai1234的博客
07-15 2367
java中的变量基本概念 1.变量的概念 内存中的一个存储区域 该区域的数据可以在同一类型范围内不断变化 变量是程序中最基本的存储单元。包含变量类型、变量名和存储的值 2.变量的作用 用于在内存中保存数据 3.变量的声明和赋值 4.使用变量注意 Java中每个变量必须先声明，后使用 使用变量名来访问这块区域的数据 变量的作用域：其定义所在的一对{ }内 变量只有在其作用域内才有效 同一个作用域内，不能定义重名的变量 /* 变量的使用 1. java定义变量的格式：数据类型 变量名 = 变量值; 2. 说
Java变量基础概念
晨曦的博客
07-31 373
变量的定义及使用
JAVA中什么是变量?
m0_68862982的博客
01-09 661
数据值:存储的要使用的数据(这个值可以是常量,也可以是其他变量保存的)变量本质上就是代表一个可操作的存储空间，空间位置是确定的，但是里面放置什么值不确定。我们可通过变量名来访问对应的存储空间”，从而操纵这个存储空间存储的值。变量是程序中最基本的存储单元, 有变量类型, 变量名 存储的值组成。内存中一块存储区域,该区域的数据可以在同一类型的范围内不断的变化。变量名:内存中一块存储空间的名字(自己起的名字)数据(变量)类型 变量名 = 数据值;用于在内存中保存数据。1 变量的概念是什么。
Java中的变量你了解吗？
编程火箭车（Coding Rocket）专注编程领域
04-23 1189
在Java中，变量是一种用于存储数据值的占位符。
02_Java基础_（变量、运算符）_讲义cxf
02-15
02_Java基础_（变量、运算符）_讲义cxf
java基础;16_变量的定义和使用.avi
01-10
java基础;16_变量的定义和使用.avi
01_Java基础_第1天（Java概述、环境变量、注释、关键字、标识符、常量）_讲义
02-15
【Java基础概述】 Java是一种广泛使用的面向对象的编程语言，主要应用于后端开发，与Apache等服务器技术结合，构建各种互联网应用和企业级系统。Java以其跨平台的特性，能够编写从桌面应用到大型分布式系统的各种...
java基础之变量
weixin_45847691的博客
06-14 3274
java变量是程序中最基本的存储单元，其包括变量名、变量类型、作用域。java程序中每一个变量都属于特定的数据类型，在使用前必须对其进行声明。 如：int a = 100; float f =23.3f; String 是=“hello”; —1、概念：本质上来说变量是内存中的一小块区域，通过变量名来访问这块区域。因此，使用每一个变量前必须要先申请（声明）然后必须对其进行赋值，才能使用 这块区域的大小取决于 声明的数据类型为哪一类 2、分类： java中没有无符号的数 按照所属的数据类型分：基本数据类型（
Java变量
Runing_IT_Man的博客
09-02 408
Java变量 关键字 要学习变量的概念，首先要了解什么是关键字，关键字是指Java中具有特殊功能的词，变量、类和方法等在命名时应该避免去使用这些关键字。常用的关键字：Abstract、break、case、catch、char、continue、do、double、else、final、finally、float、for、if、import、instanceof、int、class、long、
java基本组成第2篇、变量和常量、运算符
qq_41944612的博客
03-12 212
变量和常量、运算符 1.变量： 我们可以简单的理解为在程序运行过程中可以发生改变的数据。 java变量是程序中最基本的存储单元,java是一种强类型语言,每一个变量必须声明其类型。 声明变量： 声明一个变量其要素分为三个 数据类型 变量名 = 变量初始值 如：btye a=100； int b=1000； c...
Java基础：变量
weixin_48622654的博客
06-21 274
1.3简单的原理示意图 变量相当于内存中一个数据存储空间的表示，你可以把变量看做是一个房间的门牌号，通过门牌号我们可以找到房间，而通过变量名可以访问到变量(值)。 2)赋值 3.变量快速入门 变量使用入门案例 看演示并对代码进行说明，演示记录人的信息的代码 4.变量使用注意事项 5.程序中 +号的使用 6.数据类型 每一种数据都定义了明确的数据类型，在内存中分配了不同大小的内存空间(字节)。 Java的整数类型就是用于存放整数值的，比如12,30,3456等等 7.3整数的类型 8.浮点类型 8
变量的含义（转载）
CH_sir的博客
08-19 1621
一、基本定义： 是计算机语言中能储存计算结果或能表示值的抽象概念。 理解： 我们在程序中会经常定义一些变量来保存和处理数据。从本质上看，变量代表了一段可操作的内存，也可以认为变量是内存的符号化表示。 当程序需要使用内存时，可以定义某种类型的变量。此时编译器根据变量类型分配一定大小的内存空间。程序可以通过变量名来访问对应的内存； 二、数据类型与变量的关系 变量的数据类型决定了对应内存的大小，那么存储类型则影响着对内存的使用方式，使用方式具体就是说字啊什么时间、程序的什么地方可以使用变量，即变量的生命周
JAVA的数据类型与变量
最新发布
WHabc2002的博客
07-26 380
字面常量的分类：1.字符串常量：由""括起来的，比如“12345678”你好。2.整形常量：程序中直接写的数字注意没有小数点，比如：1231003.浮点数常量：程序中直接写的小数，比如：3.140.494.字符常量：由 单引号 括起来的当个字符，比如：‘a’、‘1’5.布尔常量：只有两种true和false6.空常量：null注意：字符串、整形、浮点型、字符型以及布尔型，在Java中都称为数据类型。在Java和。
Java系列之：var关键字
zhengzaifeidelushang的博客
08-01 6947
Java系列之：var关键字
C语言基础——变量
qq_41536160的博客
03-19 9058
二、变量 2.1 变量基本概述 变量是程序的基本组成单位，变量相当于内存中一个数据存储空间的表示，你可以把变量看做是一个房间的门牌号，通过门牌号我们可以找到房间，从而通过变量名可以访问到变量(值)。 变量应该有名字，并在内存中占据一定的存储单元；变量名和变量值有不同的含义；变量名实为一个符号地址 2.1.1 变量的使用步骤： //（1）声明变量： int num; //（2）赋值： num = 60; // (3)使用： printf("num=%d", num); // (4) 变量声明与赋值一步到位：
Java基础 - 变量的定义和使用
张聪的博客
11-05 731
Java基础 - 变量的定义和使用 变量定义 1 public class Main { 2 3 public static void main(String[] args) { 4 5 // 定义byte类型的变量 6 byte b = 10; 7 System.out.println(b); 8 9 ...
JAVA变量在线命名软件_java基础之Java变量命名规范
05-16
Java变量命名规范如下： 1. 变量名只能由字母、数字、下划线和美元符号组成，不能以数字开头。 2. 变量名应该具有描述性，能够清楚地表达出变量的含义。 3. 变量名应该只使用小写字母，不同的单词之间使用下划线进行分隔。 4. 在类变量和实例变量中，变量名应该以小写字母开头。如果变量名由多个单词组成，第一个单词的首字母应该小写，后面的单词的首字母应该大写，例如：myVariableName。 5. 在局部变量中，变量名可以以任何字母开头，但通常使用小写字母。如果变量名由多个单词组成，可以使用驼峰命名法，例如：myLocalVariableName。 6. 对于常量，在命名时应该全部使用大写字母，并用下划线分隔单词，例如：MY_CONSTANT_NAME。 对于Java变量在线命名软件，可以参考以下网站： 1. https://www.codota.com/code/java/methods/com.google.common.base.CaseFormat/toLowerCamel 2. https://www.npmjs.com/package/java-variable-naming 3. https://www.npmjs.com/package/java-naming-conventions 这些软件可以帮助您快速命名变量，并遵守Java变量命名规范。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值