JAVA 入门基础—— 变量（成员变量、局部变量）、标识符、运算符、定义类、定义方法、数据类型、数组、方法调用

    1.变量
        概述:就是一个容器,用于存储数据的
        语法:
            1.声明的同时直接赋值
                数据类型 变量名 = 值;
                String name = "我是程序员";

            2.先声明后赋值
                声明: 数据类型 变量名;  String name;
                赋值: 变量名 = 值;        name = "程序媛";

        标识符命名规则:
            1.只能由字母,数字,下划线,美元符号组成
            2.不能以数字开头
            3.不能与关键字重名
            4.严格区分大小写

        标识符命名规范:
            知名达意 

    2.运算符
        算术运算符: +    -    *    /    %
            注意:2个整数相除,得到的结果一定是整数

        比较运算符: >  >=  <  <=   ==    !=
                // 比较表达式的结果一定是 boolean 类型的数据,所以比较表达式可以作为if结构的条件判断

        逻辑运算符:
        // 逻辑运算符的2边一定要是 boolean 类型的数据

             && 逻辑与    只要有false,逻辑&&表达式的结果就是 false,只有当两边同时为true ,逻辑&&表达式的结果才是true
                         遇 false ,则 false
                 
             || 逻辑或    只要有true,逻辑||表达式的结果就是 true,只有当两边同时为 false,逻辑||表达式的结果才是 false;
                         遇 true ,则 true
                         
             ! 逻辑非        真变假    假变真
             
             
             &      遇 false 则 false
             |       遇 true ,则 true    
         

         && 短路的问题        只要逻辑&&的左边为 false ,逻辑&&的右边就不会运算
         || 短路的问题      只要逻辑||的左边为 true,逻辑||的右边就不会运算

        复合赋值运算符: =    +=    -=    *=    /=    %=

        自增\自减运算符:
            ++        --

            // 表达式的值        变量的值
        // 表达式 : 由运算符连接起来的式子就是表达式
        // ++ 运算符
 
             num++ 后自增表达式:
                 运算法则:先取变量(num)自身的值作为表达式的值,然后将变量自身+1
                 
             ++num 前自增表达式:
                 运算法则:先将变量自身的值+1,然后将变量的值作为表达式的值
                 
                 总结: 不管是前自增还是后自增,变量自身的值都得+1
                 
           num-- 后自减表达式:
                 运算法则:先取变量(num)自身的值作为表达式的值,然后将变量自身-1
                 
             --num 前自减表达式:
                 运算法则:先将变量自身的值-1,然后将变量的值作为表达式的值
                 
                 总结:不管是前自减还是后自减,变量自身的值都得-1
  
               int num = 3;
                
               int res = ++num - num-- - ++num + num++ + ++num;
                                4/4       4/3           4/4         4/5          6/6
                int res = (++num) - (num--) - (++num) + (num++) + (++num);// 4-4-4+4+6
                System.out.println(res);//6
               System.out.println(num);//6
                
                 int num = 3;
                int res = num--;
               System.out.println(res);//3
               System.out.println(num);//2
                
                int num = 3;
                int res = --num;
                System.out.println(res);//2
               System.out.println(num);//2
                
                int num = 3;
               int res = ++num;
                System.out.println(res);//4
                System.out.println(num);//4
                
                int num = 3;
                int res = num++;
               System.out.println(res);//3
               System.out.println(num);//4

    3.定义类\定义方法

        定义类的语法:
            public class 类名{// 类名:符合标识符命名规则    从第一个单词开始所有单词的首字母大写
                // 属性(变量)
                // 方法(方法)
                
            }

        定义方法的语法:
            public 返回值类型 方法名(数据类型 参数1,数据类型 参数2,...){

                // 方法体

                返回值: 根据方法的功能是否有返回值,如果方法没有返回值,返回值类型就是 void
                        如果有返回值,返回值的数据类型就是方法的返回值类型,并且要有 return 语句

                方法名: 自己取

                参数: 用来传递数据的

            }

            注意:
                1.方法和方法之间是平行关系
                2.方法不调用不会执行

    4. 选择结构
        

    补充:

        // 成员变量: 定义在类里面,方法的外面的变量,系统会自动赋默认值
        // 局部变量: 定义在方法里面的变量,系统不会赋默认值
        // 变量没有赋值是不能直接使用的

        常用的数据类型            初始值
            
            int                               0
    
            float                          0.0

            double                      0.0

            char                         空(0)

            String                        null

            boolean                   false

 

 

 

     1.数组 
        概述: 数组是一个容器,可以存储多个相同类型的数据 ,数组的长度是固定的

        语法:
            1. 先声明,后初始化
                声明: 数据类型[] 数组名;
                    String[] names;

                初始化: 数组名 = new 数据类型[长度];
                    names = new String[4];

            2.声明的同时初始化
                数据类型[] 数组名 = new 数据类型[长度];  // 常用  推荐
                String[] names = new String[4];

            3.快速初始化数组
                数据类型[] 数组名 = {值1,值2,值3,...}; // 推荐
                String[] names = {"张三","李四","王五","赵六"};

                数据类型[] 数组名 = new 数据类型[]{值1,值2,值3,...};// 常见
                String[] names = new String[]{"张三","李四","王五","赵六"};

            赋值:
                数组名[索引] = 值;
                names[0] = "班长";

            取值:
                数组名[索引]

        特点:索引: 索引是从0开始的 ,最大的索引是 : 数组长度-1
            长度:数组的长度是数组的一个属性    int len = 数组名.length;
            

        注意: 数组越界(索引越界)

    2.字符串:
        构造方法:
            1.用来创建该类的对象
            2.通过new来调用

             API 是代码说明书

    1. 调用方法的语法:  对象.方法名(参数);

                concat(): 拼接字符串                     +   任何数据类型和字符串相加  都会拼接成新的字符串 
                
                length() : 求字符串的长度 

                isEmpty() :　判断字符串是否为空串

                equals（）：　判断２个字符串是否相等（区分大小写）

                equalsIgnoreCase（）：　判断２个字符串是否相等　　(忽略大小写)

                charAt（）：　获取字符串某个索引位置的字符

                contains（）：　判断字符串是否包含某个特定序列

                endsWith（）：　判断字符串是否以某个特定序列结尾

                startsWith（）：　判断字符串是否以特定序列开头

                indexOf（）：　获取某个字符或者字符串第一次出现的位置的索引

                lastIndexOf（）：　获取某个字符或字符串最后出现的位置的索引

                replace（）　：　替换字符串中的特定序列

                split（）　：　拆分字符串

                substring（int beginIndex,int endIndex）：　切割字符串  包含 前面(beginIndex)  ,不包含后面(endIndex)

                toLowerCase():      把字符串转换为小写

                toUpperCase():     把字符串转换为大写

                trim() :清除字符串前后的空格和换行符

        补充:
            如果是基本数据类型,一般用 “==” 判断是否相等
            如果是字符串,一般用 equals 判断是否相等
            字符串中每一个字符都有对应的索引,并且索引是从0开始的,最大的索引是字符串的长度 - 1
            
            StringIndexOutOfBoundsException       字符串索引越界异常