A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© Chrisyu 初级黑马   /  2017-11-30 19:07  /  1754 人查看  /  1 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

本帖最后由 小石姐姐 于 2017-12-7 14:59 编辑


        
                * JVM: Java虚拟机, 他是实现Java跨平台的关键, 不同系统平台上有不同的JVM
                * JRE: Java运行时环境, 是运行Java程序的一个最小环境
                        * 包括JVM和Java核心类库
                * JDK: Java开发工具包, 用于开发Java程序
                        * 包括JRE和Java的开发工具(javac)
                        
   * **JDK,JRE,JVM的作用和关系**
   *
             * JDK包含JRE 和开发工具包
             * JRE 包含 核心类库和JVM

    * 编译源代码文件: `javac 文件名.java`
                        * 编译完毕后, 会自动生成`.class`文件
        * 运行`.class`文件: `java 文件名`
                        * 注意没有后缀

   * Java基本语法
               
    **3种注释**
                        * 单行注释: `// 注释内容`
                        * 多行注释: `/* 多行的内容 */`
                        * 文档注释: `/** 文档注释内容 */`
                        
        * **关键字**
                        * 是什么: Java中赋予特殊含义的单词
                        * 特点:
                                * 字母小写
                                * 某些编辑器会高亮显示
                                
        * **常量**
                        * 概念: 在程序执行过程中, 其值不能改变
                        * 分类
                                * 字符串常量: `"Hello"`
                                * 字符常量: `'a'`
                                * 整数常量: `123`
                                * 浮点数常量: `3.14`
                                * 布尔常量: `true`
                                * 空常量: `null`
                        * 如何使用: 直接使用, 如输入
                        
  **变量**

        * 概念: 内存中的一片区域, 可以保存值. 在程序的执行过程中, 其值可以在一定范围内发生改变.
        * 变量通过数据类型来限定

      * 定义格式:
                                * `数据类型 变量名 = 初始化值;`
                                * `数据类型 变量名;`
          * 注意事项
                                * 变量没有赋值不能直接使用
                                * 变量的作用域只在定义变量所在的大括号内
                                * 一条Java语句中可以定义多个变量, 这些变量可以有初始化值, 也可以没有. 但不建议
* * **数据类型**

        * 基本数据类型(4类8种)
        *
                                * 整数
                                        * byte
                                        * short
                                        * int
                                        * long: 数字后加L
                                * 浮点数
                                        * float: 数字后加F
                                        * double
                                * 字符
                                        * char
                                * 布尔
                                        * boolean
        * 引用数据类型
        
                                * 数组
                                * 类
                                * 接口
  **标识符**
         
                        * 作用: 给包, 类, 方法, 变量起名
                        * 组成规则:
                                * Unicode字符
                                        * 数字: 不能开头
                                        * 大写, 小写英文字母
                                        * 汉字: 不建议使用
                                * 下划线: `_`
                                * 美元符号: `$`
                        * 起名的一个惯例: **见名知义**
                        
        * 类型转换
         
                        * 隐式转换: 从数据类型的小到大进行转换
                                * 规则: `byte, short, char -> int -> long -> float -> double`
                        * 强制转换: 手动强制转换类型
                                * 格式: `目标类型 变量名 = (目标类型)(被转换的数据);`

** DOS命令**

        * 打开cmd:
                * `Win + r`, 输入cmd, 回车
        * 切换盘符: `d:` , 回车
        * 切换目录: `cd 目录名`
                * 返回上一层目录: `cd ..`
                * 返回该盘符的顶层目录: `cd \`
                * 多级目录: `cd a\b\c`
        * 查看当前目录中的文件和目录: `dir`
        * 查看指定目录下的文件和目录: `dir 目录名`
        * 清空屏幕: `cls`
        * 退出cmd: `exit`

**运算符**
        
        分类:
                算术运算符
                赋值运算符
                关系运算符
                逻辑运算符
                三元运算符

**算术运算符:**

                 + : 加
                - : 减
                * : 乘
                / : 除
                % : 取余
                ++ :自增
                -- :自减

注意:
* 整数相除只能得到整数.要想得到小数,就必须有浮点参与运算

**字符参与加法运算:**

    其实是拿计算机中存储的数据来参与运算的
                'A' = 65
                'a' = 97
                '0' = 48

注意:

                * char类型在算数运算时按照数值来计算
                * 如果打印的是char类型, 则打印出的是数值所代表的字符, 而不是数值
                * 如果打印的是char和数字计算的结果, 则最终打印的是数字

**字符串参与加法运算:(拼接)**

        其实做的不是加法运算,而是字符串的拼接

**算术运算符的++和--的用法**

        自增自减,用于对变量加1或减1
        单独使用的时候++或者--放在变量的前面或者后面,结果一样.

        参与其他操作的时候:
                        ++在后面,先拿变量做操作,然后变量再++
                        ++在前面,先变量++,然后再拿变量做操作


**赋值运算符:**

        基本的赋值运算符: =
        扩展的赋值运算符: +=,-=,*=,/=,...
        (隐含强制类型转化)

        +=: 将运算符左边和右边的数据做加法, 然后将结果赋值给左边. a += 10; 相当于 a = (a的类型)(a + 10);
        -=: 将运算符左边和右边的数据做减法, 然后将结果赋值给左边. a -= 10; 相当于 a = (a的类型)(a - 10);
        *=: 将运算符左边和右边的数据做乘法, 然后将结果赋值给左边. a *= 10; 相当于 a = (a的类型)(a * 10);
        /=: 将运算符左边和右边的数据做除法, 然后将结果赋值给左边. a /= 10; 相当于 a = (a的类型)(a / 10);
        %=: 将运算符左边和右边的数据做取余, 然后将结果赋值给左边. a %= 10; 相当于 a = (a的类型)(a % 10);

        * **注意: 扩展赋值运算符隐含了强制类型转换**
                a += 10; 相当于 a = (a的类型)(a + 10);
        
**关系运算符:**

                (关系运算符的结果是boolean类型)

                == : 相等
                != : 不等
                > : 大于
                >= : 大于等于
                < : 小于
                <= : 小于等于

**逻辑运算符**:   用于连接关系表达式

        & : 与    有false则false
        | : 或    有true则true
        ^ : 异或  相同则false,不同则true
        ! : 非    true则false,false则true

        && :逻辑与(短路与),有短路效果,左边为false,右边不执行,直接false
        || :逻辑或(短路或),有短路效果,左边为true,右边不执行,直接true

**三元运算符:**

        格式:
                (关系表达式)?表达式1:表达式2;
                关系表达式? 结果为true的表达式 : 结果为false的表达式;

        三元运算符是有返回值的,所以必须定义一个变量接收返回值

**键盘录入:**

                A:导包
                        import java.until.Scanner;
                        在一个类中顺序:package > import > class
                B:创建键盘录入对象
                        Scanner sc = new Scanner(System.in);
                C:接收数据
                        int i = sc.nextInt();

               
**取余%操作的用途**

        * 判断是否是奇数偶数
        * 判断是否能被某个数整除
        * 获取一个数的个位, 十位, 百位...


//判断是否是奇数偶数

        x % 2 == 0  true是偶数, false是奇数
        x % 2 == 1  true是奇数, false是偶数


// 判断是否能被某个数整除

        x % 这个数 == 0 true则能被这个数整除


// 获取一个数的个位, 十位, 百位...

        int i = 12345;
        int ge = i % 10;
        int shi = i / 10 % 10;
        int bai = i / 100 % 10;
        int qian = i / 1000 % 10;
        ```



printlin  输出换行

print  输出不换行
**流程控制语句**:

        顺序结构
        选择结构
        循环结构

# 选择结构: #

**if语句格式:**

        1. if(关系表达式) {
                        语句体;
                }

        执行流程:
                首先判断关系表达式的结果是true还是false
                如果是true就执行语句体
                如果是false就不执行语句体

        
        
                2. if(关系表达式) {
                        语句体1;
                }else {
                        语句体2;
                }

        执行流程:
                首先判断关系表达式的结果是true还是false
                如果是true就执行语句体1
                如果是false就执行语句体2



                3. if(关系表达式1) {
                        语句体1;
                }else if(关系表达式2) {
                        语句体2;
                }... {
               
                }else {
                        语句体n+1;
                }

        执行流程:
                首先判断关系表达式1看其结果是true还是false
                如果是true就执行语句体1
                如果是false就继续判断关系表达式2看其结果是true还是false
                如果是true就执行语句体2
                如果是false就继续判断关系表达式…看其结果是true还是false
                …
                如果没有任何关系表达式为true,就执行语句体n+1               

**switch语句格式**:

                switch(表达式) {
                        case 值1:
                                语句体1;
                                break;
                        case 值2:
                                语句体2;
                                break;
                        ...
                        case 值n:
                                语句体n;
                                break;
                        default:
                                语句体n+1;
                                break;
                }
               

                switch表达式允许的数据类型: byte,short,int,char
                                都是可隐式转换为int的类型,因为byte,short,int,char可以隐式转换为int,所以也可以使用
                        JDK5以后可以是枚举
                        JDK7以后可以是字符串
                        小括号中可以是常量,也可以是变量

                case后面的值:
                        * 用来和表达式的值进行匹配
                    * 值只能是常量
                    * 值的类型应该和switch小括号中值的类型一致

                break: 表示中断的意思
                defult: 当所有的case都不匹配时,就执行defult

        执行流程:

                        首先计算表达式的值
                    然后执行符合的case
                        如果没有符合的case, 则执行default


# 循环结构 #:
               
**for循环格式:**
                        
                        for(初始化语句;判断条件语句;控制条件语句) {
                                循环体语句;
                        }

                执行流程:
                        1. 先执行初始化语句
                        2. 然后执行判断条件语句
                                * 如果为true, 则执行循环体语句
                                        * 循环体语句执行完毕后, 执行控制条件语句
                                        * 从步骤2重复
                                * 如果为false, 则for循环结束



**while循环格式:**
                        
                        while(判断条件语句) {
                                循环体语句;
                        }

                扩展格式:

                        初始化语句;
                        while(判断条件语句) {
                                循环体语句;
                                控制条件语句;
                        }

                执行流程:
                        * 先执行关系表达式
                    * 如果关系表达式为true, 则执行循环体
                        * 循环体执行完后, 继续执行关系表达式
                    * 如果关系表达式为false, 则循环结束


**do...while循环格式**:
                        
                        do {
                                循环体语句;
                        }while(判断条件语句);

                扩展格式:

                        初始化语句;
                        do {
                                循环体语句;
                                控制条件语句;
                        }while(判断条件语句);

                执行流程:

                        1. 执行初始化语句
                    2. 执行循环体语句
                    3. 执行控制条件语句
                    4. 执行判断条件语句, 看是true还是false
                        * 如果是false, 则结束循环
                        * 如果是true, 回到2继续执行循环体语句

### for, while, do...while三种循环的区别

          区别:

        * for循环
                        * 适用于知道循环次数的场景
                * while循环
                        * 适用于不知道循环次数的场景
                        * 至少执行0次循环体
                * do...while循环
                        * 适用于不知道循环次数的场景
                        * 至少执行1次循环体
                        
    * for, while: 必须判断条件成立, 才可以执行循环体
    * for循环的初始化语句的作用域: for的大括号内        


## 控制循环语句


    2个控制循环语句:

            * `break`: 直接结束循环, 或switch语句
            * `continue`: 结束本次循环, 继续执行下一次
            
### break跳转控制语句的概述和基本使用

        break的使用场景: 不能单独使用, 必须用于switch或循环中

        break的作用:
            1. 在switch语句中, 用于结束case
            2. 在循环中, 用于结束所在的循环  

### continue跳转控制语句

        continue的使用场景: 循环中

        continue的作用: 结束本次循环, 继续下一次的循环        


**switch语句的case穿透**

         * 如果switch的case语句中没有break, 则会继续执行下一个case的代码, 这称为case穿透
         
         * case穿透有时会导致代码出现问题, 但有时我们也利用case穿透简化代码        


**if语句适用于有范围的场景, 或者具体值的场景**

**switch语句适用于具体值场景, 不适用于范围的场景**


**if语句不写大括号的格式:**

    当if语句不写大括号时, 只有if语句后的第一条语句算作if语句的语句体, 其余不算

**while语句, for语句不写大括号的格式**

        当语句不写大括号时, 只有语句后的第一条语句算作语句的语句体, 其余不算



## 编程思维: 3种问题的解决方式

* 求和
* 判断符合条件
* 计数


**编程思维: 求和问题**

                        1. 定义一个变量sum, 用来存储求和的结果
                        2. for循环获取不同的数
                        3. 在for循环的循环体中使用sum变量累加每个数
                        4. for循环结束后, sum就是总和
                        
                                int sum = 0;
                                
                                for (int i = 0; i < 100; i++) {
                                       
                                        sum += i;
                                }
                                
                                System.out.println("总和是" + sum);
        
**编程思维: 求某些符合条件的数字的总和的思路**
         
                        1. 定义一个变量sum, 用来存储求和的结果
                        2. for循环获取不同的数
                        3. 在for循环的循环体中使用if判断符合条件的数
                        4. 对符合条件的数使用sum变量累加每个数
                        5. for循环结束后sum就是符合条件的数的总和
                        
                                int sum = 0;

                                for (int i = 0; i < 100; i++) {
                                       
                                        if (条件) {
                                                
                                                sum += i;
                                        }
                                }
                                
                                System.out.println("总和是" + sum);

**编程思维: 统计个数**

                        1. 定义一个变量count, 用于统计个数
                        2. for循环
                        3. 在for循环中使用if判断出符合条件的数
                        4. 当符合条件时, count++
                        5. for循环结束后, count的值就是个数
                        
                                int count = 0;

                                for (int i = 0; i < 100; i++) {
                                       
                                        if (条件) {
                                                
                                                count++;
                                        }
                                }
                                
                                System.out.println("个数是" + count);

**编程思维: 交换2个变量的值**

                        1. 定义一个临时变量temp
                        2. 先将a的值存入temp
                        3. 再将b的值存入a
                        4. 最后将temp的值存入b

                                int a = 1;
                                int b = 2;
                                
                                int temp = a;
                                a = b;
                                b = temp;


# Random #

Random是什么? 是一个随机数类

Random作用? 用于产生一个随机数

        使用步骤:
            1. 导包: import java.util.Random;
            2. 创建对象: Random r = new Random();
            3. 获取随机数: int number = r.nextInt(10);
                    获取数据的范围:[0,10) 包括0,不包括10
                nextInt(y)表示产生的数据在0到y之间, 包括0, 但不包括y


## 数组概述和定义格式

         什么是数组?   
                    数组是存储同一种数据类型的多个元素的容器

**2种定义格式**(区别在于中括号的位置不同):

                    1. 数据类型[] 数组名;
                             推荐, int[] arr;
                    2. 数据类型 数组名[];
                             int arr[];


## 数组的动态初始化


        什么是初始化?
                为数组开辟内存空间, 并为数组中的每一个元素赋一个初始值

        2种初始化:

            * 动态初始化: 只给出数组长度, 由系统给出元素的默认值
            * 静态初始化: 我们给出初始化值, 由系统给出数组长度
            

**动态初始化**

         数据类型[] 数组名 = new 数据类型[数组长度];

         例:        int[] arr = new int[3];

                int:说明数组中的元素类型是int类型
                []:说明这是一个数组
                arr:是数组的名称

                new:为数组分配内存空间
                int:说明数组中的元素的数据类型是int类型
                []:说明这是一个数组
                 3:数组的长度,其实就是数组中的元素个数


## 数组元素的访问

        数组的元素: 数组中的单个数据
        数组的索引: 元素在数组中的位置序号, 从0开始

        如何访问数组的元素?  **数组名[索引]**;



# Java中的内存分配 #
    * 栈: 存储局部变量
    * 堆: 存储new出来的实体(对象)
    * 方法区: 存储加载的类, 面向对象进阶讲解
    * 本地方法区: 和系统相关
    * 寄存器: 给CPU使用
   
* **什么是局部变量**?
        * 局部变量就是定义在方法中的变量
* **堆的特点**:
    * 每一个对象都有地址值
    * 每一个对象的数据都有默认值
            * byte,short,int,long   0
            * float,double          0.0
            * char                      '\u0000'
            * boolean               false
            * 引用类型               null
    * 使用完毕后会在垃圾回收器空闲的时候被垃圾回收器回收内存
* **栈的特点**:
    * 先进后出
    * 使用完毕后立即回收内存


## 数组的静态初始化

        什么是数组的静态初始化?
                我们给出初始化值, 由系统给出数组长度

**静态初始化2种格式**:

        数据类型[] 数组名 = new 数据类型[]{元素1, 元素2, 元素3, ...};
                int[] arr = new int[]{0, 1, 2};

        简化格式:
        数据类型[] 数组名 = {元素1, 元素2, 元素3, ...};
                int[] arr = {0, 1, 2};

静态初始化方式创建数组, 数组最开始也有默认值0, 但立刻就被静态初始化值覆盖了

## 数组操作的两个常见小问题

         ArrayIndexOutOfBoundsException: 数组索引越界异常
                产生原因:我们访问了不存在的索引
        NullPointerException: 空指针异常
                发生原因:数组名为null时使用数组名
                 如何避免: 判断数组是否为null, 如果不是null, 再操作: if(arr != null) { 操作 }
        null只能赋值给什么类型的变量? 引用类型, 包括类, 接口, 数组




## 数组操作之遍历数组

        什么是数组遍历?
                就是依次输出数组中的每一个元素
        怎么进行数组遍历?
                 一般使用for循环
        怎么获取数组的长度?
                使用数组的 length 属性, int length = arr.length;

                int[] arr = {1, 2, 3};  
        // 长度为3, 索引0, 1, 2.  最后的一个索引值=数组长度-1

        for(int i = 0; i < arr.length; i++) {
            int n = arr;
        }


## 数组操作之获取最值


    数组获取最大值的思路是什么?
            * 拿数组中的一个元素作为参照物, 让其他元素依次比较
                * 如果元素比参照物大, 就留下作为新的参照物
            * 整个循环遍历比较结束, 留下的参照物就是最大值




##二维数组的概述和基本使用


您需要登录后才可以回帖 登录 | 加入黑马