数据类型、运算符、常量、变量、注释方法

水深无声 2023-09-30 10:42 1阅读 0赞

**目录**

注释方法

标识符

书写规则

数据类型

运算符

常量

变量

--------------------

## 注释方法 ##

// 单行注释
    /*
       多行注释
       多行注释
    */
    
    /**
    *  文档注释
    * */

## 标识符 ##

在代码中打上标记帮助识别的符号。  
\* 标识符分两类：1、系统预定义标识符 --- 关键字;  
\* 2、 用户自定义标识符  
\* 2-1、先人自定义的，后人用；  
\* 2-2、本人自定义的  
\*  
\*  
\* 自定义标识符命名规则：  
\* 1、硬规则 -- 不遵守就会编译不通过  
\* 只能由数字、字母 、下划线 、$组成  
\* ! 数字不能开头  
\* ! 严格区分大小写  
\* ! 不能与关键字重复  
\* 2、潜规则 -- 行规  
\* 见名知意  
\* 类名： AaaaBbbbCccc  
\* 变量名： aaaaBbbbCccc  
\* 常量名： AAAA\_BBBB\_CCCC

### 书写规则 ###

/**
     *  1、Java中所有的代码都要写在类的{}当中
     *  2、如果这个类的访问修饰符是public的，那么类名必须和
     *     java文件名保持一致；
     *  3、一篇java文件可以书写多个类（通常不这么做）,public的
     *     只能由一个；
     *  4、编译后的class文件数量与java文件数量无关，只和java文件中
     *     定义的类的数量有关。（一个类一个class文件）
     */

/**
     * main方法书写固定，是整个程序的入口
     * 1、一个项目当中可以有多个main方法；
     * 2、一个类里面只能有一个main方法；
     */

### 数据类型 ###

/*
                1、整型
                byte  short  int  long
                1      2      4    8
                常用的是int和long，int是默认的
             */
            System.out.println(1);//int
            System.out.println(1L);//long -- L大小写均可
    
            /*
                2、浮点类型
                float  double
                4       8
                默认是double
             */
            System.out.println(3.14);//double
            System.out.println(3.14f);//float - f大小写均可
    
            /*
                3、字符型
                char
                2
                每个字符都必须用单引号，里面只能有一个字符；
                但是"转义字符"例外：
                '\n' -- 换行
                '\r' -- 回车
                '\t' -- 水平制表
                '\\' -- 代表 \
    
             */
            System.out.println('A');//用单引号括起来
    //        System.out.println('AB');--报错
            System.out.println('中');
            System.out.println(' ');//空格字符
            System.out.println('\n');
            System.out.println('\\');
    
            /**
             * 布尔类型
             * boolean
             * 空间大小不确定，由JVM根据实际情况划分
             * 只有两个值：true  false
             */
            System.out.println(true);
            System.out.println(false);
    
            /**
             *  额外的常用非基本数据类型 --- 字符串
             *  String
             *  "Hello"
             *  "我饿了"
             *  "1+3"
             *  "1 + 3 = \n 4"
             */
            System.out.println("1 + 3 = \n 4");

### 运算符 ###

/*
                算术运算符： +  -  *   /   %
             */
            System.out.println(5 + 2);
            System.out.println(17 - 9);
            System.out.println(5 * 8);
            System.out.println(9 / 3);
            /*
                + : 当+号左右两端出现一个字符串的时候，那么它执行的
                是字符串拼接动作。
             */
            int result = 50;
            System.out.println("最终结果是：" + result);
            System.out.println("最终结果是：" + (3 + 7) );
    
            /*
                % : 取模，取余
                该符号是对左右两个操作数做除法，只不过最终结果不是商而是余数
    
                特殊：
                1、余数正负号，只跟第一个被除数有关；
                2、%符号的运算只在整数运算下才有意义；
    
             */
            System.out.println( 8 % 5);
            System.out.println(-8 % 5);
            System.out.println(8 % -5);
            System.out.println(-8 % -5);
            System.out.println(5.3 % 2.6);
    
            /*
                最重要的：所有的算术运算符号，如果左右两端的运算数数据类型
                一致，那么结果就是该类型的结果。
                         如果不一致，那么结果就是大的那个数据类型的结果
             */
            System.out.println( 1 / 2 );
            System.out.println( 1 / 2.0);
    
            /*
                赋值运算符：=
                把赋值运算符右边的表达式，赋给左边的变量
                1、左边只有一个变量
                2、要注意左右两边的数据类型：自动类型转换 和 强制类型转换
             */
            int a = 0, b = 0;
            a = a + 13;
    
            /*
                变形的赋值运算符（一）： +=  -=  *=  /=  %=
             */
            b += 5;// b = b + 5;
    
            /*
                变量 = 变量 + 值；
                变量 += 值；
                这两句的最终效果是一样的，但是如果出现类型不匹配的情况，
                语句一只能我们自己强制类型转换，语句二可以由该表达式帮我们进行类型转换
             */
    //        b = (int)(b + 3.14);
            b += 3.14;
            System.out.println(b);
    
            /*
                变形的赋值运算符（二）： ++  --
                又被称之为"自增长"，"自减小"
             */
            a = 100;
            a++;// a += 1;  a = a + 1;
            ++a;
            System.out.println(a);
            a--;// a -= 1; a = a - 1;
            --a;
            System.out.println(a);
            /*
                前加 ++a   前减 --a
                后加 a++   后减 a--
                单独使用a++ 和 ++a 是没有区别的（--也是同理）
             */
            int num = 10;
            System.out.println( ++num * 5 );
    
            /*
               比较运算符： >  <  >=  <=  !=  ==
               比较运算符最终的结果只能是boolean类型true或false
             */
            System.out.println(5 > num);
    
            /*
                三目运算符：  表达式1 ? 表达式2 ： 表达式3
                1、表达式1必须是一个布尔表达式；
                2、当表达式1为true的时候，用表达式2的结果作为整个三目运算符的结果；
                   当表达式1为false的时候，用表达式3的结果作为整个三目运算符的结果
             */
    
            System.out.println( num < 5 ? "男" : "女" );

### 常量 ###

//常量申明的语法： final 数据类型  常量名 = 常量值;
            final int AGE = 19;
            System.out.println(AGE);
            //为什么要给常量起名字？
            /*
                1、把业务含义带入到常量值当中；
                2、便于修改
             */

### 变量 ###

/*
                变量本质就是在内存中分配一个空间，然后可以往里面存放数据；
                且随着程序的运行，该空间的数据值可以变化。
                语法： 数据类型 变量名;
                变量声明以后需要进行初始化，否则不允许访问和使用它。
                原因是新申明的变量，里面的数据值不确定且没有意义。
                注意：1、付给变量的值需要和变量的数据类型匹配；
                     2、初始值具体是多少依赖于我们程序的需要，不一定是0;
             */
            int age = 0;//会申明一个4个字节的整型变量
            double d1 = 1.0, d2 = 1.1, d3 = 1.2;//仅对同时申明同一类型的多个变量有效
            System.out.println(age);
            age = 20;
    
    
            /*
                变量的生命周期:
                1、生 --- 从变量申明语句被执行的时候开始；
                2、死 --- 该变量声明语句所属花括号结束
             */
            {
                int newAge = age + 15;
                System.out.println(newAge);//newAge仅能在这个{}内使用
    
    
    
    //变量和赋值数据类型要匹配
            //1、类型相同
            byte b = 127;
            short s = 32767;
            int i = 1000000000;
            long l = 100000000;
    
            float f = 0.1F;
            double d = 0.1F;
    
            char c = 'A';
            boolean bool = true;
    
            String name = "HYK";
    
            //2、数据类型转换
            //数据类型大小顺序： byte < short = char < int < long < float < double
            //布尔类型不参与转换
            //2-1、小值 放入 大变量 -- 自动类型转换
            d = 0.2f;
            d = i;
            i = c;
            //2-2、强制类型转换
            //语法： (被转换类型)数据值
            //强转后果是精度丢失，注意：不是四舍五入
            i = (int)2.5;
            f = (float)2.5;
    
            System.out.println('A');
            System.out.println((int)'A');
            System.out.println(97);
            System.out.println((char)97);