2020.10.10Java变量、数据类型、运算符

于 2020-10-10 17:48:25 发布
阅读量261 收藏
点赞数 3
分类专栏： 笔记 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45649686/article/details/108994909
版权

1.变量

程序中基本存储单元，在运行过程中值可变。
本质上变量就是内存中的一块区域，通过变量名访问，在使用前变量必须赋值才能使用。

public class VarDemo {
    public static void main(String[] args){
        //基本类型变量
        int a;//声明
            a=10;//赋值
        System.out.println(a);//使用前必须赋值  10

        int b=10;//声明，赋值
        System.out.println(b);//10

        int x,y,z;
        x=10;
        y=5;
        z=20;

        int m=10,n=20;
        double c=1.2222;
        System.out.println(c);//1.2222
        float d= 1.1f;
        System.out.println(d);//1.1
        char ch='段';
        System.out.println(ch);//段
        /*
          字符串
          用另一个类作为类型的变量，称为引用类型变量
         */
        String str="abc";
        System.out.println(str);//abc
    }
}

变量分类：
（1）从数据类型角度分类：
基本类型变量
引用类型变量
（2）从位置分类：
成员变量 类的属性（定义在类中）
局部变量（定义在方法中）

2.数据类型

（1）java语言是一种强数据类型语言，每个数据必须指定类型，指导JVM分配内存空间。
（2）数据类型

  1. 基本类型：

    只有8种 便于使用
    byte、short、int、long、float、double、boolean、char

  2. 引用类型：

    除了8种基本类型，其余都是引用类型
    （用类作为类型的是引用类型 数组（[]）、类（class））

3.基本数据类型

（1）整数类型
byte：长度1字节 -128~127
short：长度2字节 -32768~32767
int：长度4字节
long：长度8字节
注意：java中的整数值还可以用其他进制表示
二进制：0b/0B
八进制：0
十六进制：0x/0X
注意：使用的类型，在赋值时需要注意值与类型相匹配。

/**
 * 整数类型
 */
public class IntDemo {
    public static void main(String[] args){
        //长度为1字节  -128~127
        byte b=127;
        System.out.println(b); //127

        //长度2字节   -32768~32767
        short s=32767;
        System.out.println(s); //32767

        //长度4字节
        int i=100000;
        System.out.println(i); //100000

        //长度8字节   后加l/L
        long a=10000000L;
        System.out.println(a); //1000000

        /*
        注意：使用的类型，在赋值时需要注意值与类型相匹配
        注意：Java中的整数类型还可以用其他进制表示
            二进制：0b/0B开头
            八进制：0开头
            十六进制：0x/0X开头
         */
        int c=0b01; //二进制
        int d=010;  //八进制
        int e=0x11;  //十进制
        System.out.println(c); //1
        System.out.println(d); //8
        System.out.println(e); //17
    }
}

（2）浮点类型
float：长度4字节 由于在计算机中的计算方式不同，4字节的浮点大于4字节、8字节的整数。浮点数默认值为double类型，声明float值需要加f/F。
double：长度8字节
计算机中小数是以近似值方式存储的

/**
 * 浮点类型
 */
public class DoubleDemo {
    public static void main(String[] args) {
        //长度4字节   由于在计算机中中的计算方式不同，4字节的浮点大于4字节、8字节的整数
        float f=10.4f;  //浮点数默认值为double类型，声明float值需要加f/F
        System.out.println(f);  //10.4

        //长度8字节
        double b=10.5;
        System.out.println(b);  //10.5

        //计算机中小数是以近似值方式存储的
        System.out.println(b-f==0.1); //false
    }
}

（3）布尔类型
boolean：逻辑值 只能使用true/false关键字表示

/**
 * boolean 逻辑值
 * 只能使用true/false 关键字表示
 */
public class BooleanDemo {
    public static void main(String[] args){
        boolean b1=true;
        boolean b2=false;

        //使用其他值报错
//        boolean b3=1;
        if(2<1){
            System.out.println("1");
        }else {
            System.out.println("0");//0
        }

        System.out.println(b1);//true
        System.out.println(b2);//false
    }
}

（4）字符型
表示一个字符
char：长度2字符
编码问题 计算机表示字符
计算机底层都是二进制 计算机如何表示字符

  • 编码表 人为定义的
  • 字符在不同的编码表中有一个对应的十进制数，最终在计算机上使用这个数存储，最早的编码表 ASCII a~z:97 ~ 122
    A~Z：65 ~ 90 只能表示英文。
  • 不同国家就定义自己国家的编码 例如：中国 GBK GB2312。
  • 后来就诞生了unicode编码表，里面包含了全球各个国家的文字字符。 utf-8是一种可变长度的编码表。
  • char类型数据可以参与算术运算。
  • 使用字符对应的码表中的整数值来计算。
/**
 1. 字符型
 2. 表示一个字符
 3. char a='a';一个字符
 */
public class CharDemo {
    public static void main(String[] args) {
        //长度2字节
        char c='a';
        char c1='中';
        //编码问题   计算机表示字符
        /**
         * 计算机底层都是二进制
         * 计算机如何表示字符
         * 编码表 认为定义的
         * 字符在不同的编码表中有一个对应的进制数，最终在计算机上使用这个数存储
         * 最早的编码表ACSII  只能表示英文  a~z:97~122 A~Z:65~90
         * 不同的国家就定义自己国家的编码 例如中国：GBK  GB2312
         * 后来就诞生了unicode编码表，里面包含了全球各个国家的文字字符
         * utf-8是一种可变长度的编码表
         */
        //char类型数据可以参与算术运算
        //使用字符对应的码表中的整数值来进行运算
        System.out.println(c+0); //97
        System.out.println(c1+0); //20013
    }
}

4.基本数据类型转换

8种基本类型之间除了布尔值，其余7种之间都可以转换。
转换分为默认转换和强制转换。
数据类型容量大小排序：
char,byte,short->int->long->float->double
char,byte,short之间不会互相转换，他们三个计算前都会转为int类型。
（1）默认转换
容量小的可以自动转换为容量大的。
原因：容量大的可以包含容量小的。
参与混合运算时小容量的会自动转为大容量。
（2）强制类型转换
容量大的转为容量小的
会有问题：

  1. 溢出：小的装不下大的
  2. 精度降低
/**
 * 基本数据类型转换
 * 8种基本类型转换之间除了布尔值，其余7种都可以转换
 * 转换分为默认转换和强制转换
 */
public class DataType {
    public static void main(String[] args) {
        /*
        默认转换
        容量小的可以自动向容量大的转换
        原因：容量大的可以包含容量小的
        参与混合运算时小容量会自动转换为大容量
         */
        int a=10;
        long b=a;
        float f=b;
        double d=f;
        System.out.println(d);//10.012

        /*
        强制类型转换
        容量大的转为容量小的
        会有问题
        溢出：小的装不下大的
        精度降低
         */
        int x=258;
        byte y=(byte) x;
        System.out.println(y);//2

        float m=10.5f;
        int n=(int)m;
        System.out.println(n);//10

    }
}

5.运算符

（1）算术运算符
+ 正数 加法 字符串连接 数值+字符串=字符串
- 负数 减法 数值与数值（char）
* 乘法 数值与数值（char）
/ 除法 数值与数值（char）
% 取余 数值与数值（char）
++ 自增
– 自减
注意：++在混合运算中，++在后先运算后自增，++在前先自增后运算

/**
 * 算术运算符
 * +  正数  加法  字符串连接
 * —  负号  减法
 * *  乘法
 * /  除法
 * %  取余
 * ++ 自增
 * -- 自减
 */
public class OperDemo1 {
    public static void main(String[] args) {
        //+
        int a=10;
        int b=5;
        char c='a';
        String str="20";
        System.out.println(a+b);//15  数值+数值=数值
        System.out.println(b+c);//102  数值+char=数值
        System.out.println(b+str);//520  数值+字符串=字符串
        System.out.println(c+str);//a20  char+字符串=字符串

        //-
        int d=-5;
        System.out.println(a+d);//5  数值-数值=数值
        System.out.println(c-b);//92  char-数值=数值

        //%
        System.out.println(a%b);//0


        //++ --
        int x=5;
        int y = x++ +1;
        System.out.println(y);//6 ++在混合运算中，++在后先运算后自增  ++在前先自增后运算
        System.out.println(x);//6
        int z = --x -1;
        System.out.println(z);//4  --在混合运算中，--在后先运算后自增  --在前先自增后运算
        System.out.println(x);//5
    }
}

（2）比较运算符
==、！= 基本类型值之间的比较，引用类型与引用类型比较
>、<、>=、<= 数值与数值（char）

/**
 * 比较运算符
 * ==、！=  基本类型数值之间的比较    引用类型与引用类型比较
 * <、>、<=、>=  数值与数值（char）
 */
public class OperDemo2 {
    public static void main(String[] args) {

        int a=10;
        int b=5;
        char c='a';
        System.out.println(a==b);//false
        System.out.println(a!=b);//true
        System.out.println(a+b==c);//false
        System.out.println(a+b!=c);//true

        System.out.println(a>b);//true
        System.out.println(a<b);//false
        System.out.println(a>=b);//true
        System.out.println(a<=b);//false
    }
}

（3）赋值运算符
= 注意：=两边类型与值相匹配
+=、*=、/=、%=、-=

/**
 * 赋值运算符
 * = 注意：两边类型与值相匹配
 * += -= *= /= %=
 *   int a=10;
 *   基本数据类型转换：默认转换，强制类型转换
 *   long b=a;
 *   byte c=(byte)b;
 */
public class OperDemo4 {
    public static void main(String[] args) {
        short s=3;
        //s=s+2；  不支持  s为short型  2为int型
        s+=2; //隐式转换  5
        System.out.println(s);
    }
}

（4）逻辑运算符
&-逻辑与 |-逻辑或 ^-逻辑异或
&、|、^ 左右操作数为逻辑值（true/false） 否则为位运算
&&-短路与 ||-短路或 ！-逻辑非

/**
 * 逻辑运算符
 * &-逻辑与  |-逻辑或  ^-逻辑异或    左右操作数为逻辑值(true/false)  否则是位运算
 * &&-短路与  ||-短路或  ！-逻辑非
 */
public class OperDemo3 {
    public static void main(String[] args) {

        int a=5;
        int b=10;
        int c=15;
        System.out.println(a>b&a>c);//false  左边无论真假，右边都进行运算
        System.out.println(a<b&a<c);//true
        System.out.println(a>b&&a>c);//false    如果左边为真，右边参与运算，如果左边为假，那么右边不参与运算。
        System.out.println(a<b&&a<c);//true
        System.out.println(a>b|a>c);//false  左边无论真假，右边都进行运算
        System.out.println(a<b|a>c);//true
        System.out.println(a>b||a>c);//false  如果左边为真，右边不参与运算，如果左边为假，那么右边参与运算。
        System.out.println(a<b||a>c);//true
        System.out.println(a>b^a<c);//true
        System.out.println(a<b^a>c);//true
        System.out.println(a>b^a>c);//false
        System.out.println(a<b^a<c);//false

        System.out.println(a+b==c & a++>c);//false
        System.out.println(a);//6
        System.out.println(a+b==c && a++>c);//false
        System.out.println(a);//6
    }
}

（5）条件运算符
（条件运算符）？表达式1：表达式2
条件表达式结果为true执行表达式1 否则执行表达式2

/**
 * 条件运算符
 * （条件表达式）？表达式1：表达式2
 * 条件表达式结果为true执行表达式1  否则执行表达式2
 */
public class OperDemo5 {
    public static void main(String[] args) {
        int a=10;
        int b=5;
        int c=(a>b)?a:b; //需要一个返回值
        System.out.println(c); //10
    }
}

（6）位运算
是二进制位（bit位）上的运算，执行效率高
<< 左移 左移一位相当于*2
>> 右移 右移一位相当于/2
>>> 无符号右移 不需要关心高位上的符号（如果影响到了符号位，只需要在符号位补0）
& 与
| 或
^ 异或
~ 非

/**
 * 位运算
 * 是二进制位（bit位）上的运算，执行效率高
 * << 左移   左移一位相当于*2
 * >> 右移   右移一位相当于/2
 * >>> 无符号位右移  不需要关心高位上的符号（如果影响到了符号位，只需要在符号位补0）
 * & 与
 * | 或
 * ^ 异或
 * ~ 非
 */
public class OperDemo6 {
    public static void main(String[] args) {
        int a=2;
        System.out.println(a<<1);//4   0010->(<<1)0100  0010->(<<2)1000
        int b=8;
        System.out.println(b>>1);//4   1000->(>>1)0100
        System.out.println(3&4);//0
        /*
              0011
              0100   都为1结果为1
              0000
         */
        System.out.println(3|4);//7
        /*
              0011
              0100   都为0结果为0
              0111
         */
        System.out.println(3^4);//7
        /*
             0011
             0100   相同为0，不同为1
             0111
         */
        System.out.println(~3);//-4
        /*
             0011
             1100    -4  取反
         */

        int x=10;
        int y=5;
        x=x^y;// 1010^0101=1111
        y=x^y;// 1111^0101=1010
        x=x^y;// 1111^1010=0101
        System.out.println(x);//5
        System.out.println(y);//10
    }
}
段茜琳
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值