JAVA数据类型变量和运算符_java整数和小数的总和代号是什么-CSDN博客

本文链接：https://blog.csdn.net/m0_66278959/article/details/126984736

学习内容

关键字
标识符
注释
常量
变量
数据类型和类型转换
运算符

关键字：

被Java语言赋予特定含义的单词就是关键字 public private

特点：组成关键字的字母全部小写

注意事项：

goto和const作为 保留字存在,目前并不使用，

类似myeclipse中,针对关键字有特殊的颜标记（紫色），非常直观。

标识符：就是给包、类,接口,方法,变量等起名字时使用的字符

组成规则：

1. 英文大小写字母、 2. 数字字符、 3. –$和_ 。

注意事项：

1、不能以数字开头(以字母开头)

2、不能是Java中的关键字和保留字

3、严格区分大小写

包含如下几项：

1、包(其实就是文件夹,用于解决相同类名问题)

2、类或者接口

3、方法和变量

4、常量

命名规范：

1、包：全部小写

2、类或者接口：大驼峰，每个单词的首字母都要大写DemoDay2、StudentDao

3、方法和变量：小驼峰，第一个单词首字母小写从第二个单词每个单词的首字母都大写

如：studentAdd、studentAge 、studentName。

4、常量：所有字母都大写内部的值是固定值得，π=3.1415926........

final（最终） double PAI =3.1415926;

注释：

1、单行注释：格式： //注释文字

2、多行注释：格式： /* 注释文字 */

3、文档注释：格式：/** 注释文字 */

常量：fifinal 在程序执行的过程中其值不可以发生改变

变量：在程序执行的过程中，在某个范围内其值可以发生改变的量

使用格式：

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

int myAge = 20 ;
String name="tom";
int i = 10

数据类型和类型转换：Java语言是强类型语言，对于每一种数据都定义了明确的具体数据类型，在内存中分配了不同大小的内存空间。

整数默认：int 小数默认：double

使用变量注意事项：

作用域：

变量定义在哪一级大括号中，那个大括号的范围就是这个变量的作用域。相同的作用域中不能定义两个同名变量。

初始化值：

局部变量没有初始化值的变量不能直接使用

成员变量若没有设置初始值，内存默认的有数据

类型转换

boolean类型不能转换为其他的数据类型

默认转换（小转大）

byte,short,char—int—long—flfloat—double（左---右的数据存放空间是有小到大的）

byte,short,char相互之不转换，他们参与运算首先转换为int类型

强制转换（大转小）

目标类型变量名=(目标类型)(被转换的数据)

编写案例演示使用变量的注意事项。 
变量的第二种定义格式：数据类型 变量名; 
变量名=100。 一行定义多个变量的两种情况： 
方式一： 
int x = 10;int y = 20; 

方式二： int x,y; 
x = 10; y = 20;

byte b = 10; int i = 100;
System.out.println(b+i); 

//下边两行的代码是否有问题？ 
byte bb = b + i; 
System.out.println(bb); 

//下边两行的代码是否有问题 
int j = b + i; 
System.out.println(j);

面试题：

byte b1=3,b2=4,b; b=b1+b2; b=3+4;

哪句是编译失败的呢？为什么呢？

思考题：

byte b = 130;有没有问题?如果想让赋值正确，可以怎么做?

1、先思考分析下边代码的结果

2、然后在执行控制台输出这些值

3、对比结果是否与你思考的一致，

4、考虑结果为什么是这样的

1. System.out.println('a'); 

2. System.out.println('a'+1);

3. System.out.println("hello"+'a'+1);

4. System.out.println('a'+1+"hello"); 

5. System.out.println("5+5="+5+5);

6. System.out.println(5+5+"=5+5");

运算符：（算术运算符）

除法：

1.整数相除，只能得到整数

2.要想得到小数，可以*1.0

3.除数不能为0

1:基本小题目 
int a = 10; 

int b = 10; 

int c = 10; 

a = b++; c = --a; 

b = ++a; a = c--;

请分别计算出a,b,c的值 

2:比较复杂的题目 
int a = 4; 

int b = (a++)+(++a)+(a*10); 

引出运算符的优先级

赋值运算符：= ,+=, -=, *=, /=, %=

赋值时候，注意数据的类型问题

比较运算符的==不能写成=:
 
System.out.println(a==b); 

System.out.println(a=b); 

赋值的时候要注意类型问题 

int x = 10; int y = 10; 

boolean flag = (x == y); 

boolean flag = (x = y); 

boolean b1 = true; 

boolean b2 = false; 

boolean b3 = (b1 == b2); 

boolean b4 = (b1 = b2);

如下操作写出结果

int a,b;a = b = 10; 

System.out.println(a);

System.out.println(b); 

int a = 10; a += 20; 

System.out.println(a);

面试题

下边的两个代码有没有问题，如果有，那里有问题？

1、short s=1； s =s+1; 

2、short s=1; s+=1;//s=s+1;

+= 运算符的特点：有一个隐含的默认转换功能。实际上等价于：

short s = 1; s+=1等价于 s=(s的数据类型) (s+1);

比较运算符：也叫做关系运算符

逻辑运算符：

写出逻辑与与短路与的异同点

写出&与&&的异同点

位运算符（了解）

三目运算符：三元运算符格式：

(判断表达式)?表达式1：表达式2；

如果条件为true，运算后的结果是表达式1；

如果条件为false，运算后的结果是表达式2；

示例：获取两个数中大数

int x=3,y=4,z; 

z = (x>y)?x:y;

//z变量存储的就是两个数的大数。

运算符的优先级 ：

下面是代码的一些相关总结：

package da3;

public class Text1 {
    public static void main(String[] args) {
        /*
        赋值运算符
        += -= *= /= %=
        1,会自动对数字进行数据类型的转换
        2，写法简单
         */
        short n1 = 20 , n2 = 33 , n3 = 55, n4 = 99 , n5 = 89, n6 , n7 , n8 , n9;
        n1 += 1; // = n1 = n1 + 1 = 20+1 = 21
        n1 = (short)(n1+1);//n1=22
        n2-=3;//n2=n2-3=33-3=30
        n3*=2;//n3=n3*2=55*=110
        n4/=3;//n4=n4/3=99/3=33
        n5%=10;//n5=n5%10=89%10=9
        System.out.println("n1，"+n1+",n2，"+n2+",n3，"+n3+",n4，"+n4+",n5，"+n5);
        n6 =(short)(n1+3);//n6=n1+3=20+3=23
        System.out.println(n6);//n6=22+3=25
        //short与数字进行运算的时候 会向上转换为int类型所以要在运算前面加上强制转换


    }
}

package da3;

public class Text2 {
    public static void main(String[] args) {
        /*
        比较运算符/关系运算符
        == 比较前后的数据的值是否相同 若相同 返回true 反之返回false
        != 不等于 前后两个数据是否不同 若不同 得到true 反之 得到false
        > <  满足判断条件就得到true 反之 得到false
        <= >= 满足前后任何一个条件就得到true
         */
        double s1 = 12.5, s2 = 89, s3 = 12.5 , s4 =45;
        System.out.println(s1==s3);//true
        System.out.println(s1!=s2);//true
        System.out.println(s1>s4);//false
        System.out.println(s2<=s3);//false
        System.out.println(s2>=s4);//true
        System.out.println(s3<s4);//true
        System.out.println(s1<=s3);//true
        System.out.println(s1>=s3);//true
        String str1 = "hello", str2 = "China";
        System.out.println(str1+str2);
    }

}

package da3;

public class Text3 {
    public static void main(String[] args) {
        /*
       并且 & 逻辑与 前后两个都是真 最终结果才是true 其余全是false
       或者 | 逻辑或 前后都是false 最终就是false 其余全是true
        ^XOR 异或 只要前后的真假不同 最终结果就是true 反之就是false
        !NOT 非 原来是true 取非后为false 原来是false 取非后为true
      并且  &&AND 短路与 前后两个都是真 最终结果才是true 其余全是false
      或者  ||OR 短路或 前后都是false 最终结果就是false 其余全是true
         */
        System.out.println(1>2&3<4);//false
        System.out.println(1>2|3<4);//true
        System.out.println(1>2^3<4);//true
        System.out.println(!(1>2));//true
        System.out.println(1>2&&3<4);//false
        System.out.println(1>2||3<4);//true
        /*
        &与&&的区别
        &&当前边的结果为false的时候 后边的条件表达式就不在判断了
        &是无论前边结果为什么，后边都需要判断执行
        |与||的区别
        ||若前边为true后边就不在判断了
        |无论前边是什么结果 后边都需要判断
         */
        int n1 = 12, n2 = 23 , n3 = 34, n4 , n5;
        if (n1<10&&n1++<25)
        {
            System.out.println("你执行了");
        }
            System.out.println("n1:"+n1);//12
        if ( n2 < 10 & n2++ <25 )
            {
                System.out.println("执行了");//24
            }
            System.out.println("n2:"+n2);

        if ( n1 > 5 || n1++ < 99 )
        {
            System.out.println("123");
        }
        System.out.println("n1:"+n1);//12
        if ( n2 > 50 | n2 ++ < 100 )
        {
            System.out.println("456");
        }
        System.out.println("n2:"+n2);//25
    }
}

package da3;

import java.sql.SQLOutput;
import java.util.Scanner;

public class Text4 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        /*
        三目运算符
        格式 条件表达式？表达式1 表达式2
        若前边的条件表达式为真 最终结果为表达式1 若前边的表达式结果为假
        则最终结果为表达式二
         */
//        double r3 = x1 < x2 ? x1 : x2;
//        Console.WriteLine("两个数值中最小的值为："+r3);
//        double r4 = (x1 < x2 ? x1 : x2) < x3 ? (x1 < x2 ? x1 : x2) : x3;
//        Console.WriteLine("三个数值中最小的值为："+r4);
        String sex="男";
        String result=(sex=="女")?"西装":"裙子";
        System.out.println(result);
        //得到两个数字中最大的值
        int n1 = 100 , n2 = 23;
        int max = n1>n2?n1:n2;//表达式为真执行n1
        System.out.println("两个数字中较大的值为"+max);
        int m1 = 100, m2 = 23, m3 = 189;
        int max2 = (m1>m2?m1:m2)>m3?(m1>m2?m1:m2):m3;
        System.out.println("三给数字中的最大的值为："+max2);
        System.out.println("*********************");
        System.out.println("请输入第一个数字");
        int a = sc.nextInt();
        System.out.println("请输入第二个数字");
        int b = sc.nextInt();
        System.out.println("请输入第三个数字");
        int c = sc.nextInt();
        int m = ( a > b ? a:b)>c?(a>b?a:b):c;
        System.out.println("三个数字中最大的值为："+m);





    }
}

package da3;

import java.util.Scanner;

public class Text5 {
    public static void main(String[] args) {
        //变量： 内部存储的数据是可以被改变的
        String name="张三";
        System.out.println(name);
        name="李四";
        System.out.println(name);
        name="黄金ak47式";
        System.out.println(name);
        int age;
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入年龄");
        age = sc.nextInt();
        System.out.println(age);

        String tag = "算什么";
        System.out.println(tag);
        tag = "配什么";
        System.out.println(tag);

        /*
        常量 其内部存储的数据是不能更改的
        被final关键字所修饰
        格式final 数据类型 常量名字=数据值
        常量的名字所有英文字母全部大写 若有多个单词 每个单词以
        _链接

         */
        final  double STU_NAME=3.14;
        System.out.println(STU_NAME);
        //PAI=3.1415926

        char sname = '李';//声明变量李
        System.out.println(sname);
        sname ='王';//变量
        System.out.println(sname);
        final float TAG = 9.5F;//声明常量TAG
        System.out.println(TAG);
       // TAG = 5.5;//当去修改常量里存储的数据的时候 程序会报错
        //System.out.println(TAG);



    }
}

最后在附上一些循环的案例

package da4;


public class Text2 {
    public static void main(String[] args) {
        /*
        while 循环
        语法结构
        while（条件表达式）
        {
        代码块；
        }
        执行流程
        每次执行的时候 都会判断while（）内部的表达式
        若结果为true 则就会执行{}内部的代码块 反之就不执行
        循环终止

        int i = 10 ;//变量初始化赋值
        while (1>0)
        {//判断是否为真 为真执行 反之不执行 跳出循环
            System.out.println(i);//10 9 8 …… 1
            i--;//进行变量指定更改
        }
        */
        int  sum = 0 , s = 1 ;
        while ( s <= 100 )
        {
            if ( s % 2 == 1 )
            {
                sum += s ;
            }
            s++;
        }
        System.out.println(""+sum);
        System.out.println("**************");
         /*
        首次运行的时候先执行do后边的代码块
        然后在判断while后边的条件 若为真 再次执行do后边
        的代码块 若为假 循环终止
         */
        int m = 10 ;
        do {
            System.out.println(m);//10 9 8 7 ..... 1
            m-=2;//m=m-2
        }while (m>0);
        //while 循环是先判断条件在执行 所以有可能while循环一次都执行不了
        // do while 循环时先执行在判断条件 所以do-while是至少会执行一次的循环




    }
}

package da4;

public class Text5 {
    public static void main(String[] args) {
        /*
        当循环嵌套的时候 会先将内层循环完整的执行结束终止后 在执行
        外层循环的下一轮
         */
        for ( int i = 1 ; i <= 9 ; i++   )
        {//外层第一轮 i ： 1 第二轮 i 2 第三轮 i 3
            for ( int j = 1 ; j <= 3 ; j++ )
            {//j:1 j:2 j:3
                if ( j == 2 )
                {
                    break;//跳出与其紧挨着的外层循环
                }
                System.out.println("i"+i+"j:"+j);//i:1 j:1 i:1 j:2 i:j:3
                //i:2 j:1 i:2 j:2 i:2 j:3
            }
            System.out.println( "******************" );
        }

    }
}

package da4;

import java.util.Scanner;

public class Text7 {
    public static void main(String[] args) {
        //输入小组的人数，（作业里）要求人数必须大于0，然后输入每个人的薪资，
        // 最后得到所有薪资中的最高薪资
        //平均薪资、最低薪资、得到大于10000的薪资人数
        while ( true ) {
            Scanner sc = new Scanner(System.in);
            while (true) {
                System.out.println("请输入人数");
                int a = sc.nextInt();//得到人数
                if (a > 0) {
                    double sum = 0, max = 0, min = 0, n = 0;//存储薪资

                    for (int i = 1; i <= a; i++) {
                        System.out.println("请输入第" + i + "个人薪资");
                        double salary = sc.nextDouble();//得到薪资
                        sum += salary;//累加薪资总和
                        if (salary > 18888) {
                            n++;//说明大于18888的人多一个
                        }
                        if (i == 1) {
                            max = salary;//暂时认为第一个人的工资就是最高工资
                            min = salary;//暂时认为第一个人的工资就是最低的
                        } else {
                            if (salary > max) {
                                max = salary;
                            }
                            if (salary < min) {
                                min = salary;
                            }
                        }
                    }
                    System.out.println("最高薪资为：" + max + "，平均薪资为："
                            + sum / a + "，大于18888的人数为：" + n + "，最低薪资为：" + min + "，总工资为：" + sum);
                    break;
                } else {
                    System.out.println("人数不能为0！请重新输入！！！");
                }
            }
            System.out.println("是否要继续输入，继续请输入y");
            String s = sc.next();
            if ( !s.equals("y") )
            {
                System.out.println("欢迎再次使用！！！");
                break;
            }
        }
    }
}