JavaSE 变量和数据类型

柒柒要开心

已于 2023-07-26 10:08:42 修改

阅读量171

点赞数

分类专栏： Java的学习之路文章标签： java 开发语言

于 2023-04-05 15:00:10 首次发布

本文链接：https://blog.csdn.net/WR1207/article/details/129970186

版权

Java的学习之路专栏收录该内容

15 篇文章 0 订阅

订阅专栏

一、变量的基本概念

1、概念

变量：可以变化的量

Java是一种强制性语言，每个便令必须声明其类型

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

强类型的编程语言，它对变量的数据类型有严格的限定。

强类型语言：要求变量要严格符合规定，所有变量变量先定义后使用

 如Java c语言

 优点：更加安全 不过速度慢

弱类型语言：要求变量符合规定

  如VB JS

  可以随便编写 速度快 //数据类型：整数类型，浮点数类型，字符类型

// 数据类型变量名 = 值；可以使用逗号隔开来声明多个同类型变量

public static void main(String[] args) {
     String a="hello";
     int mun = 10;
          System.out.println(a);
          System.out.println(10);

 }

// An highlighted block
var foo = 'bar';

2、变量的命名规则

1.所有变量、方法、类名:见字如已

2.类成员变量：首字母小写和驼峰原则（除了第一个单词以外，后面的单词首字母大写）lastName

3.局部变量：首字母小写和驼峰原则

4.常量：大写字母和下划线：

5.类名：首字母大写和驼峰原则

6.方法名：首字母小写和驼峰原则

注意！！！

1.每个变量必须有类型，类型可以基本类型，也可以是引用类型
2.变量名必须是合法的标识符
3.变量声明是一条完整的语句，因此每一个声明都必须以分号结束
4.在Java中局部变量必须初始化

public class  Demo06 {
    public static void main(String[] args) {
        //int a=1;b=2;c=3;//错误的方法，程序可读性差
        int a = 1;
        int b = 2;
        String name = "yizu";
        char x = 'X';
        double pi = 3.14;
    }

public class Demo07 {

    //com.R.base.变量的作用域
    //类变量
    //实例变量
    //局部变量

       //类变量 static
    static double salary = 2500;

    //属性：com.R.base.变量

    //实例变量：从属于对象（类）,如果不自行初始化，这个类型的默认值 数字为：0，0.0
     //布尔值：默认是false
     //除了基本类型，其余的默认值都是null
    String name;
    int age;

    //main方法
    public static void main(String[] args) {
        //局部变量：周期在main方法后的大括号之中     必须声明和初始化值
        int i = 10;
        System.out.println(i);

        //变量类型 变量名字  new demo07+alt 回车
        Demo07 demo07 = new Demo07();
        System.out.println(demo07.age);
        System.out.println(demo07.name);

        //类变量  static
        System.out.println(salary);


    }

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

    }

在这里插入图片描述

public class Demo08 {
    //常量是一种特殊的变量
    //常量被设定后不能再改变
    //final 常量名=值；
    //常量名一般使用大写字母

    //修饰符（static final）不存在先后顺序
    static final double PI = 3.14;
    public static void main(String[] args) {
        System.out.println(PI);

    }

在这里插入图片描述

public static void main(String[] args) {
        int a = 10;
        int b;//在Java当中局部变量必须初始化
        System.out.println(b);
    }

在这里插入图片描述

二、数据的基本类型

数据的基本类型有数值类（整数型，浮点型）、字符类、布尔类
在这里插入图片描述

1、整数类型

整数类型有四种不同的类型：字节类（byte）、短整型（short）、整型（int）、长整型（long）

1.整型变量

public static void mainint(String[] args) {
        int a = 10;
        int b = 10;//在Java当中局部变量必须初始化
        //int d = 12345678901234; // 编译时报错，初值超过了int的范围
        //System.out.println(d);
        System.out.println(Integer.MAX_VALUE);//int的包装类型为 Integer  暂时认为是int的plus版本
        System.out.println(Integer.MIN_VALUE);
    }

注意！！！

int不论在何种系统下都是4个字节
在给变量设置初始值时，值不能超过int的表示范围，否则会导致溢出
int的包装类型为 Integer

2.长整型变量

public static void mainLong(String[] args) {
        int a = 10;
        long b = 10; // long定义的长整型变量
        long c = 10L; // 为了区分int和long类型，一般建议：long类型变量的初始值之后加L或者l
        long d = 10l; // 一般更加以加大写L，因为小写l与1不好区分

        System.out.println(Long.MIN_VALUE);
        System.out.println(Long.MAX_VALUE);
    }

注意！！！

长整型变量的初始值后加L或者l，推荐加L
长整型不论在那个系统下都占8个字节
long的包装类型为Long

3.短整型变量

public static void mainShort(String[] args) {
        short a = 10;
        System.out.println(a);
        System.out.println(Short.MAX_VALUE);
        System.out.println(Short.MIN_VALUE)；
    }

注意！！！

short在任何系统下都占2个字节
short的表示范围为：-32768 ~ 32767
使用时注意不要超过范围(一般使用比较少)
short的包装类型为Short

4.字节型变量

byte b = 10;
System.Out.println(b);
// byte型变量所能表示的范围：
System.Out.println(Byte.MIN_VALUE);
System.Out.println(Byte.MAX_VALUE);

注意！！！

byte在任何系统下都占1个字节
byte的范围是：-128 ~ 127
字节的包装类型为Byte

整数类型拓展``

在整数中有多种进制，如二进制、八进制、十进制、十六进制

在Java中二进制后用0b；

          八进制后用0；

          十六进制用0x；

public static void main(String[] args) {
        //整数拓展  进制  二进制0b  八进制0  十进制  十六进制0x
        int i = 10;
        int i2 = 010;
        int i3 = 0x10;
        System.out.println(i);
        System.out.println(i2);
        System.out.println(i3);

2、浮点类型

1.双精度浮点型

public static void main(String[] args) {
        double d = 12.5;
        System.out.println(d);
        double a = 1.0;
        double b = 2.0;
        System.out.println(a / b);

        int c = 1;
        int e = 2;
        System.out.println(c*1.0/e);

        double num = 1.1;
        System.out.println(num * num);//1.21
}

注意！！！

double在任何系统下都占8个字节
浮点数与整数在内存中的存储方式不同，不能单纯使用的形式来计算
double的包装类型为Double
double 类型的内存布局遵守 IEEE 754 标准(和C语言一样), 尝试使用有限的内存空间表示可能无限的小数, 势必会存在一定的精度误差，因此浮点数是个近似值，并不是精确值。

2.单精度浮点数

 		float f = 12.5f;//4个字节
        System.out.println(f);

注意！！！

float 类型在 Java 中占四个字节, 同样遵守 IEEE 754 标准. 由于表示的数据精度范围较小, 一般在工程上用到浮点数
都优先考虑 double, 不太推荐使用 float. float的包装类型为Float。

浮点数拓展

在面试中有一个题，问你银行业务如何算

很多人会用float和double，其实是错误的

因为浮点数表达的字长有限离散含入误差大约接近但不等于

 float f = 0.1F; //0.1
        double d = 1.0/10; //0.1
        System.out.println(f==d);//false 表示不相同
        System.out.println(f);
        System.out.println(d);

注意！！！

double在任何系统下都占8个字节
浮点数与整数在内存中的存储方式不同，不能单纯使用的形式来计算
double的包装类型为Double
double 类型的内存布局遵守 IEEE 754 标准(和C语言一样),
尝试使用有限的内存空间表示可能无限的小数,
势必会存在一定的精度误差，
因此浮点数是个近似值，并不是精确值。
float 类型在 Java 中占四个字节, 同样遵守 IEEE 754 标准.
由于表示的数据精度范围较小,
一般在工程上用到浮点数都优先考虑 double,
不太推荐使用 float. float的包装类型为Float。

3、字符类型

字符类型用char表示

 //字符类型
        char name = 'A';
        //字符串，string不是关键字，是一个类
        String namea = "爱你";

注意！！！

Java 中使用单引号 + 单个字母的形式表示字符字面值.
计算机中的字符本质上是一个整数. 在 C 语言中使用 ASCII 表示字符, 而 Java 中使用 Unicode 表示字符. 因此
一个字符占用两个字节, 表示的字符种类更多, 包括中文
char的包装类型为Character

字符类型拓展

字符在本质上是数字，强制转换可以把字符变成数字

//转义字符
        //\t  制表符
        //\n  换行
        System.out.println("hello\tworld");
        System.out.println("==================================");
        String sa = new String("hello world");
        String sb = new String("hello world");
        System.out.println(sa==sb);//不相等

        String sc = "hello world";
        String sd = "hello world";
        System.out.println(sc==sd);//相同
        //对象   从内存分析

  //字符拓展
        char c1 = 'a';
        char c2 = '中';
        System.out.println(c1);
        System.out.println((int)c1);//强制转换
        System.out.println(c2);
        System.out.println((int)c2);
        //强制转换可以把字符变成数字
        //所有的字符本质还是数字
        //编码  Unicode 表：（97=a）  2字节 1-65536
        //U0000  UFFFF
        char c3 = '\u0061';//\u表示转义
        System.out.println(c3);//a

注意！！！

4、布尔类

在Java中使用booleam定义布尔类型变量，布尔类型变量只有true和false两个值

//布尔值：是非
        boolean flag = true;
        //boolean flag = false;

注意！！！

boolean 类型的变量只有两种取值, true 表示真, false 表示假.
Java 的 boolean 类型和 int 不能相互转换, 不存在 1 表示 true, 0 表示 false 这样的用法
Java虚拟机规范中，并没有明确规定boolean占几个字节，也没有专门用来处理boolean的字节码指令，在Oracle公司的虚拟机实现中，boolean占1个字节。
boolean的包装类型为Boolean

布尔类型拓展

//布尔值扩展
        boolean flag = true;

        if (flag==true){}//新手
        if (flag){}//老手
        //Less is More!  代码要精简易读

三、数据的类型转换

1、基本概念

由于java是一种强类型语言，所以进行有些运算的时候，需要用到类型转换
运算中，不同类型的数据先转化为同一类型，然后进行运算
数据的类型转换一般分为两类：
自动类型转换(隐式) 和强制类型转换(显式)

2、基本代码

public class Demo04 {
    //不同类型的数据类型先转换为同一类型，然后进行运算
    //低----------------->高
    //byte,short,char -> int -> long -> float -> double
    public static void main(String[] args) {
        int i = 128;
        //byte b = (byte)i;  //错误，内存溢出
        double b = i;

        //强制转换  （类型）变量名 高--低
        //自动转换   低--高
        System.out.println(i);
        System.out.println(b);
        /*
        * 注意点
        * 1.不能对布尔值进行转换
        * 2.不能把对象类型转换为不相干的类型
        * 3.在吧高容量转换到低容量的时候，强制转换
        * 4.转换的时候可能存在内存溢出，或者精度问题！
        * */
        System.out.println("=============================");
        System.out.println((int)23.7);//23
        System.out.println((int)-45.09f);//45

        System.out.println("=============================");
        char c = 'a';
        int d = c+1;//自动转换  98
        System.out.println(d);
        System.out.println((char)d);//b


    }
}

在这里插入图片描述

public static void main6(String[] args) {
        int a = 1000;
        long b = 10L;
        b = a;
        //a = b;//编译出错，因为long的范围比int范围大，会有数据丢失，不安全
        //a = (int) l;//强制类型转换

        boolean flg = true;
        //a = flag; // 编译失败：类型不兼容
        //flag = a; // 编译失败：类型不兼容

        byte f = 10;
        byte f2 = 20;

        //byte f3 = f + f2;
        int f3 = f + f2;
        byte f4 = (byte)(f + f2);

    }

 public static void main(String[] args) {
        //操作比较大的数的时候，注意溢出问题
        //JDK7新特性，数字之间可以用下划线分割
        int money = 10_0000_0000;
        int years = 20;
        int total = money*years;//-147....,计算的时候溢出了
        System.out.println(total);
        long total2 = money*years;//默认是int，转换之前就已经出现问题了
        long total3 = money*((long)years);//先把一个数转换为long
        System.out.println(total3);

在这里插入图片描述

注意！！！

不同类型的数据混合运算, 范围小的会提升成范围大的.
对于 short, byte 这种比 4 个字节小的类型, 会先提升成 4 个字节的 int , 再运算.

四、字符串类型

在Java中使用String类定义字符串类型
在有些情况下，需要将字符串和整形数字之间进行转换

 public static void main7(String[] args) {
        String str = "hello";
        System.out.println(str);
        System.out.println(str.length());

        String str2 = "345";
        //int val = Integer.valueOf(str2);
        int val = Integer.parseInt(str2);
        System.out.println(val+1);

        int p = 100;
        String str3 = String.valueOf(p);
        System.out.println(str3);
        System.out.println("=======================");
        int a = 10;
        int b = 20;
        //System.out.println("a = "+a +" b = " + b);
        System.out.println("a + b = "+a+b);// a+b=1020
        System.out.println(a+b + "a + b  ");//30a+b

    }

柒柒要开心

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
JavaSE 变量和数据类型

2.类成员变量：首字母小写和驼峰原则（除了第一个单词以外，后面的单词首字母大写）lastName。Java变量是程序中最基本的储蓄单位，其要素包括变量名，变量类型和作用域。由于java是一种强类型语言，所以进行有些运算的时候，需要用到类型转换。.变量声明是一条完整的语句，因此每一个声明都必须以分号结束。.每个变量必须有类型，类型可以基本类型，也可以是引用类型。运算中，不同类型的数据先转化为同一类型，然后进行运算。Java是一种强制性语言，每个便令必须声明其类型。6.方法名：首字母小写和驼峰原则。
复制链接

扫一扫