Java语法：变量，数据类型，类型转换，运算符_int b=42889;long a=42889l;system.outprintln(b==a);-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_63531507/article/details/122301324

变量：在程序的执行过程中，其值可以发生改变的量叫变量。
定义变量的格式：
1、数据类型变量名 = 初始化值;
2、数据类型变量名;
变量名 = 初始化值;

必须对其限定数据类型，要有变量名，要给他赋值，初始化值。

定义变量的注意事项

1.作用域：变量在同一个大括号有效，出了大括号无效。

2.相同的作用域不能定义两个同名变量。

3.没有初始化值不能直接使用，在使用时赋值即可

定义变量的格式

1.数据类型变量名 = 初始化值;

2.数据类型变量名

变量名 = 初始化值；

public class Cherries{
    static int a = 10;

    public static void main(String[] args) {
        System.out.println(a);

        int b = 20;
//        int b = 30;

        //仅仅定义了一个int类型的变量c，但是没有给值
        int c;
        c = 200;
        System.out.println(c);

        int a, b1, c1;
        a = 10;
        b1 = 20;
        c1 = 30;
        System.out.println(a);
        System.out.println(b1);
        System.out.println(c1);

数据类型：
A:基本数据类型
byte 1个字节 -2^7~2^7-1
short 2个字节
int 4个字节
long 8个字节
float 4个字节
double 8个字节
char 2个字节
boolean 1个字节

1、 +一般情况下，做加法运算。
2、 boolean类型的变量不能赋值给其他数据类型
3、默认转换
         byte,short,char—int—long—float—double
         byte,short,char相互之间补转换，他们参与运算首先转换为int类型
4、强制类型转换的格式：
     目标数据类型 目标变量名 = (目标数据类型)要进行赋值变量
     不建议大量使用强制类型转换，因为可能会损失精度。

public class Cherries {
    public static void main(String[] args) {
//        int a = 10;
//        int b = 20;
//        int c = a + b;
//        System.out.println(c);
//
//        boolean flag = true;
//        a = flag;

        byte b1 = 3;
        int a = 4;

        //自动类型转换
//        a = b;
//        b = a;

//        int i = 10;
//        long l = i;

        //强制类型转换
//        byte b1 = a;
        byte b1 = (byte) a;
        System.out.println(a);

 面试题
      byte b1=3,b2=4,b;
      b=b1+b2;
      b=3+4;
      哪句是编译失败的呢？为什么呢？

变量相加和常量相加不一样：
  1、变量相加首先会提升数据类型，然后再相加赋值，如果接收的数据类型范围小于计算结果后的数据类型范围，报错，不能赋值
  2、常量相加，会先进行计算，计算完后看看在不在接收的数据类型范围内，如果在，直接赋值，如果不在，报错。

public class Cherries {
    public static void main(String[] args) {
//        int a = 3;
//        byte b = 4;
//        int c1 = a + b;
//
//        byte c2 = (byte)(a + b);
//        System.out.println(c2);

        byte b1=3,b2=4,b;
//        b=b1+b2;
        b=(byte)(b1+b2);
        b=3+4;

    }
}

byte b = 130;有没有问题?如果我想让赋值正确，可以怎么做?结果是多少呢?
    有问题的，因为byte数据类型的范围是在-128~127之间，而130超出了范围。

public class Cherries {
    public static void main(String[] args) {
//        byte b = 130;

        byte b = (byte)130;
        System.out.println(b);  // -126
        b = (byte)131;
        System.out.println(b);

        byte b1 = (byte)300;
        System.out.println(b1); // 44
    }
}

我们知道数据在计算机中运算时是采用补码的方式进行参数运算的，所以要知道130的补码。而想要知道补码，就得知道反码，原码。所以得求出130的二进制表示。

130的二进制：10000010

由于默认是int类型，所以扩大字节

130的源码为00000000 00000000 00000000 10000010

又由于最高位是0，所以原码，反码，补码都一样

130的补码00000000 00000000 00000000 10000010

做截取操作10000010

这是补码：10000010

已知补码，求原码：
       符号位   数值位
补码：    1     0000010
反码：    1     0000001
原码：    1     1111110

最终结果为：11111110
将它换算成十进制就是我们看到的结果：-126

+的运算：

1.当+两边都是字符或者字符串的时候，这时＋号做的是加法运算。

2.当+两边其中是字符串的时候，+做的是字符串的拼接，拼接后组成一个新的字符串。

3.字符串与任何数值做加法，做的是字符串的拼接，拼接完成后组成一个新的字符串。

public class Cherries {
    public static void main(String[] args) {
        System.out.println("hello"+'a'+1); // helloa1
        System.out.println('a'+1+"hello"); // 98hello
        System.out.println("5+5="+5+5); // 5+5=55
        System.out.println(5+5+"=5+5"); // 10=5+5

        //System.out.println("5+5="+5+5); // 5+5=55 我就想先计算后面的5+5怎么办？
        //小括号可以改变运算的顺序优先级
        System.out.println("5+5="+(5+5));
    }
}

++:自加1

当++在前的时候，先自加1，在做赋值操作，当++在后的时候，先做赋值操作，在自加1。

--：自减1

当--在前的时候，先自减1，在做赋值操作，当--在后的时候，先做赋值操作，在自减1。

public class Cherries {
    public static void main(String[] args) {
//        int a = 10;
//        int c = a--;
//        System.out.println(a); //9
//        System.out.println(c); //10
//
//        int a1 = 10;
//        int c1 = --a1;
//        System.out.println(a1); //9
//        System.out.println(c1); //9


        int a = 10;
        int c = a++;
        System.out.println(a); //11
        System.out.println(c); //10

        int a1 = 10;
        int c1 = ++a1;
        System.out.println(a1); //11
        System.out.println(c1); //11

    }
}

运算符：
算术运算符：+，-，，/，%
赋值运算符：=，+=，-=，=，/=，%=
比较运算符：==，>,<,>=,<=,!=
逻辑运算符：&，|，^,!,&&,||
位运算符：&，|，^，~，<<,>>,>>>
三目运算符：(关系表达式)?表达式1:表达式2;

算数运算符

运算：对常量和变量的操作过程称之为运算。

运算符：对常量和变量进行操作的符号称之为运算符。

表达式：用运算符把常量或者变量连接起来的符号，并且符合java语法的式子就可称之为表达式。

操作数：参与运算的数据。

算术运算符：+，-，*，/，%

public class Cherries {
    public static void main(String[] args) {
        //+ 加法运算
        System.out.println(1+1);

        //-减法运算
        System.out.println(5-2);

        //* 乘法运算
        System.out.println(2*2);

        //  / 整除运算,只获取整数部分
        System.out.println(5/2);
        // 我就想获取小数怎么办？将其中的某一个数的数据类型变成double
        System.out.println((5*1.0)/2); // 2.5

        // %  取余运算
        // 5/2=2 .... 1
        System.out.println(5%2);

    }
}

比较运算符:== ,!= ,>, <, >= ,<=

注意事项：

1.关系运算符表达式的结果是一个boolean类型，结果要么是ture,要么是false。

2.等于号不能少写，=是数值运算符，==才是关系运算符。

3.赋值的时候要注意类型问题，关系运算符的表达式是boolean类型，所以结果只能是boolean类型的变量接受。

public class Cherries {
    public static void main(String[] args) {
        int a = 3;
        int b = 9;
        boolean flag = (a == b);
//        int flag2 = (a == b);
        System.out.println(flag);

        //!=
        System.out.println(a != b);

        //>
        System.out.println(a>b);

        //<
        System.out.println(a<b);

        //>=
        a = 4;
        System.out.println(a>=b);

        //<=
        System.out.println(a<=b);

        System.out.println(a==b);
        System.out.println(a=b);
    }
}

逻辑运算符：&，|，^,!,&&,||

逻辑运算符两边是一个boolean值，运算是一个。

&:两边只要有一个为false，结果就为false

|:两边只要有一个为ture，结果就为ture

^：两边一样为ture,两边不一样为false

！:将ture变为false,false变为tture。

public class Cherries {
    public static void main(String[] args) {
//        int a = 3;
//        int b = 4;
//        System.out.println(a&b);

        int a = 3;
        int b = 4;

        // &
//        System.out.println((a++ == 3) & (b++ == 4)); //左边true,右边也是true,结果是true,两边都做运算
//        System.out.println("a:" + a + ",b:" + b);
//        System.out.println((a++ == 4) & (b++ == 4)); //左边是false,右边是true,结果是false,两边都做运算
//        System.out.println("a:" + a + ",b:" + b);
//        System.out.println((a++ == 3) & (b++ == 5)); //左边是true,右边是false,结果是false,两边都做运算
//        System.out.println("a:" + a + ",b:" + b);
//        System.out.println((a++ == 4) & (b++ == 5)); //左边是false,右边是false,结果是false,两边都做运算
//        System.out.println("a:" + a + ",b:" + b);


        // |
//        System.out.println((a++ == 3) | (b++ == 4)); //左边true,右边也是true,结果是true,两边都做运算
//        System.out.println("a:" + a + ",b:" + b);
//        System.out.println((a++ == 4) | (b++ == 4)); //左边是false,右边是true,结果是true,两边都做运算
//        System.out.println("a:" + a + ",b:" + b);
//        System.out.println((a++ == 3) | (b++ == 5)); //左边是true,右边是false,结果是true,两边都做运算
//        System.out.println("a:" + a + ",b:" + b);
//        System.out.println((a++ == 4) | (b++ == 5)); //左边是false,右边是false,结果是false,两边都做运算
//        System.out.println("a:" + a + ",b:" + b);

        // ^
//        System.out.println((a++ == 3) ^ (b++ == 4)); //左边true,右边也是true,结果是false,两边都做运算
//        System.out.println("a:" + a + ",b:" + b);
//        System.out.println((a++ == 4) ^ (b++ == 4)); //左边是false,右边是true,结果是true,两边都做运算
//        System.out.println("a:" + a + ",b:" + b);
//        System.out.println((a++ == 3) ^ (b++ == 5)); //左边是true,右边是false,结果是true,两边都做运算
//        System.out.println("a:" + a + ",b:" + b);
//        System.out.println((a++ == 4) ^ (b++ == 5)); //左边是false,右边是false,结果是false,两边都做运算
//        System.out.println("a:" + a + ",b:" + b);

        // !
        System.out.println(!((a++ == 4) ^ (b++ == 5)));


    }
}

 
&&: 短路与,结果和单个与结果一样，有false则false，但是执行的东西不一样,
    当&&左边的表达式结果为false的时候，结果是false，右边不执行
||: 短路或,结果和单个或结果一样，有true则true,但是执行的东西不一样,
    当||左边是true的时候，右边不执行，结果是true.

逻辑运算符用于连接布尔型表达式，在Java中不可以写成3<x<6，应该写成x>3 & x<6

public class Cherries {
    public static void main(String[] args) {
        int a = 3;
        int b = 4;

        // &
//        System.out.println((a++ == 3) & (b++ == 4)); //左边true,右边也是true,结果是true,两边都做运算
//        System.out.println("a:" + a + ",b:" + b);
//        System.out.println((a++ == 4) & (b++ == 4)); //左边是false,右边是true,结果是false,两边都做运算
//        System.out.println("a:" + a + ",b:" + b);
//        System.out.println((a++ == 3) & (b++ == 5)); //左边是true,右边是false,结果是false,两边都做运算
//        System.out.println("a:" + a + ",b:" + b); // 4，5
//        System.out.println((a++ == 4) & (b++ == 5)); //左边是false,右边是false,结果是false,两边都做运算
//        System.out.println("a:" + a + ",b:" + b); //

        System.out.println("====================================================================");
        a = 3;
        b = 4;
        // &&
//        System.out.println((a++ == 3) && (b++ == 4)); //左边true,右边也是true,结果是true,两边都做运算
//        System.out.println("a:" + a + ",b:" + b);
//        System.out.println((a++ == 4) && (b++ == 4)); //左边是false,右边是true,结果是false,两边都做运算
//        System.out.println("a:" + a + ",b:" + b); //a:4,b:4
//        System.out.println((a++ == 3) && (b++ == 5)); //左边是true,右边是false,结果是false,两边都做运算
//        System.out.println("a:" + a + ",b:" + b);
//        System.out.println((a++ == 4) && (b++ == 5)); //左边是false,右边是false,结果是false,两边都做运算
//        System.out.println("a:" + a + ",b:" + b); //a:4,b:4
        System.out.println("====================================================================");
        a = 3;
        b = 4;
        // |
        System.out.println((a++ == 3) | (b++ == 4)); //左边true,右边也是true,结果是true,两边都做运算
        System.out.println("a:" + a + ",b:" + b);
        System.out.println((a++ == 4) | (b++ == 4)); //左边是false,右边是true,结果是false,两边都做运算
        System.out.println("a:" + a + ",b:" + b); //a:4,b:4
        System.out.println((a++ == 3) | (b++ == 5)); //左边是true,右边是false,结果是false,两边都做运算
        System.out.println("a:" + a + ",b:" + b);
        System.out.println((a++ == 4) | (b++ == 5)); //左边是false,右边是false,结果是false,两边都做运算
        System.out.println("a:" + a + ",b:" + b); //a:4,b:4
        System.out.println("====================================================================");
        a = 3;
        b = 4;
        // ||
//        System.out.println((a++ == 3) || (b++ == 4)); //左边true,右边也是true,结果是true,两边都做运算
//        System.out.println("a:" + a + ",b:" + b); //a:4,b:4
//        System.out.println((a++ == 4) || (b++ == 4)); //左边是false,右边是true,结果是false,两边都做运算
//        System.out.println("a:" + a + ",b:" + b); //a:4,b:5
//        System.out.println((a++ == 3) || (b++ == 5)); //左边是true,右边是false,结果是false,两边都做运算
//        System.out.println("a:" + a + ",b:" + b); //a:4,b:4
//        System.out.println((a++ == 4) || (b++ == 5)); //左边是false,右边是false,结果是false,两边都做运算
//        System.out.println("a:" + a + ",b:" + b); //a:4,b:5

        //java不支持连续比较
//        System.out.println(20>a>10);
        System.out.println((a<20 & a>10));

    }
}

位运算符：&，|，^，~，<<,>>,>>>

public class Cherries {
    public static void main(String[] args) {
        byte a = 3;
        byte b = 4;
        System.out.println(a&b);
        System.out.println(a|b);
        System.out.println(a^b);
        System.out.println(~a); //-4
    }
}
/*
        由于数据在计算机中参与运算的都是补码，而想要知道补码，就得知道反码，原码，就得求出二进制
        3的二进制：00000011
        4的二进制：00000100
        又由于3和4都是正数
        3的补码：00000011
        4的补码：00000100

        & 运算：有0则0
            00000011
         &
            00000100
        ---------------
            00000000

        结果是 ： 0

        ====================================

        | 运算：有1则1
            00000011
         |
            00000100
        --------------
            00000111

        结果是：7

        ====================================

        ^ 运算：相同则0，不同则1
            00000011
         ^
            00000100
        --------------
            00000111

        结果是：7

        ====================================

        ~ 运算：1变成0，0变成1
            00000011
        ~
        -------------
        补码：     11111100
        已知补码求原码：
        反码：     11111011
        原码：     10000100

        结果是：-4

位运算符：
<<: 左移，二进制左移，右边用0补齐,多出来的丢弃
>>: 右移，最左边最高位是0用0补齐，最高位是1就用1补齐，多出来的丢弃。
>>>: 无符号右移，无论左边最高是0还是1，都用0补齐，多出来的丢弃。

public class Cherris {
    public static void main(String[] args) {
        System.out.println(3<<2); //12 = 3*4 = 3*2^2
        System.out.println(24>>2); //6 = 24/(2*2)
        System.out.println(-24>>2);// -6
        System.out.println(-24>>>2);//1073741818

        System.out.println(3<<3); // 3*2^3


        //请用最有效率的方式写出计算2乘以8的结果
//        System.out.println(2*8);
        System.out.println(2<<3);
    }
}

/*
       <<: 左移，二进制左移，右边用0补齐
       3的二进制：00000000 00000000 00000000 00000011
       由于3是正数，所以原码，反码，补码都一样
       3的补码：00000000 00000000 00000000 00000011
       左移：
            00000000 00000000 00000000 00000011
        (00)00000000 00000000 00000000 00001100   （补码）
      由于最高位是0，既是补码也是原码，所以结果是：  12

      ================================================================
      >>: 右移，最左边最高位是0用0补齐，最高位是1就用1补齐，多出来的丢弃。
      24的二进制：00000000 00000000 00000000 00011000
      由于24是正数，所以原码，反码，补码都一样
      24的补码：00000000 00000000 00000000 00011000
      右移：
              00000000 00000000 00000000 00011000
              0000000000 00000000 00000000 000110(00)  (补码)
      由于最高位是0，既是补码也是原码，所以结果是：6

      ================================================================
      >>: 右移，最左边最高位是0用0补齐，最高位是1就用1补齐，多出来的丢弃。
      -24的二进制：10000000 00000000 00000000 00011000
      已知原码求补码：
        原码：10000000 00000000 00000000 00011000
        反码：11111111 11111111 11111111 11100111
        补码：11111111 11111111 11111111 11101000
      右移：
            11111111 11111111 11111111 11101000
            1111111111 11111111 11111111 111010(00)  (补码)
      已知补码求原码：
        补码：11111111 11111111 11111111 11111010
        反码：11111111 11111111 11111111 11111001
        原码：10000000 00000000 00000000 00000110
        最终结果是：-6

        ==============================================================
        >>>: 无符号右移，无论左边最高是0还是1，都用0补齐，多出来的丢弃。
        -24的二进制：10000000 00000000 00000000 00011000
      已知原码求补码：
        原码：10000000 00000000 00000000 00011000
        反码：11111111 11111111 11111111 11100111
        补码：11111111 11111111 11111111 11101000
        无符号右移2位：
             11111111 11111111 11111111 11101000
             0011111111 11111111 11111111 111010(00)   (补码)
        由于最高位是0，所以它的原码，反码，补码都是一样的。
        最终结果位：0011111111 11111111 11111111 111010 = 1073741818

三目运算符：(关系表达式)?表达式1:表达式2;

三目运算符又称之为三元运算符

格式：(关系表达式)？表达式1:表达式2

如果关系表达式的结果为ture,运算后的结果是表达式1

如果关系表达式的结果为false,运算后的结果是表达式2

注意事项：

1.三目运算符表达式的结果数据类型由三目运算符表达式1和表达式2中最大数据类型决定的。

2.关系表达式一定只能是boolean类型

public class Cherries {
    public static void main(String[] args) {
        //求出a,b中的最大值
        int a = 10;
        int b = 30;
        //三目运算符解决
        int c = (a>b)?a:b;

        //面试题：int a = 20;double b = 30.0;(a>b)?a:b
        int a1 = 20;
        double b1 = 30.0;
        double c1 = (a1>b1)?a1:b1;
        System.out.println(c1);


    }
}

public class Cherries {
    public static void main(String[] args) {
//        三个当中提取体重最大的一个，首先定义三个变量

        int weight1 = 180;
        int weight2 = 200;
        int weight3 = 150;
//用三元运算符比较前两个，并用临时变量保存起来
        int tempwight=weight1>weight2?weight1:weight2;
//用三元运算符获取临时变量，再和第三个进行比较，获取最大变量
        int maxweight=tempwight>weight3?tempwight:weight3;
        System.out.println("maxweight"+maxweight);
    }
}