黑马程序员技术交流社区

标题: Java0618基础班第5天手敲笔记 [打印本页]

作者: jkdong    时间: 2015-6-26 18:57
标题: Java0618基础班第5天手敲笔记
回顾:
        循环结构:
       
                for
                while
                do while

day05
        不管是函数还是数组,本天的课程目标就是学会怎么去用这些东西以及能够处理在使用过程中遇到的问题。
        所以对与今天学习过程中概念性的东西,要求理解即可,像大部分定义;对于应用性质的和格式要求的东西,
        都是要求掌握的,像函数的格式、函数和数组的使用之类的。
       
        函数:(方法)
                定义:
                        定义在类中具有特定功能的小程序
                作用:
                        对某种特定功能的封装,方便复用
                实质:
                        就是把原来定义在主函数中的具有相同功能的一段代码进行封装,方便调用和复用
                函数
                        修饰符 返回值类型 函数名(参数类型 形式参数1,参数类型 形式参数2)
                        {
                                执行语句;
                                return返回值;
                        }
                       
                        解释:
                                修饰符:public static
                                返回值类型:这段程序的最终返回值结果的类型
                                函数名:函数名称,方便调用
                                参数:
                                        参数类型:其实就是数据类型
                               
                                        形式参数:接受实际参数的变量。仅仅起到传递的作用
                                        实际参数:实际参与运算的变量
                                执行语句:按照正常逻辑的完成的功能代码
                                返回值:程序的结果
                                return 返回值;谁调用就反给谁,返回值为viod时此处可省略()
                函数注意事项
                        函数是平级关系,不要在main方法中定义方法
                        函数只有被调用时才执行(main由jvm调用)
                        使用时
                                有返回值的:赋值调用,输出调用,可以单独调用一般没意义
                                没有返回值的:只能单独调用
                形式参数和实际参数
                        方法调用的时候,传递的是实际参数
                        方法定义的时候,声明的是形式参数
                方法的结束
                        通过关键字return
                        注意细节:
                        void 类型函数 最后一行默认有return
                       
                定义函数的思路
                        明确参数列表
                        明确返回值类型
               
                程序测试;要充分       
                        正确的
                        错误的
                        边界值
                       
                局部变量的注意问题:
               
                        局部变量如果没有显示的初始化值,不会有默认初始化值
                        boolean flag;
                        if ()
                        {
                                flage = true;
                        }
                        else
                        {
                                flag = false;
                        }
                        //此时使用flag是非此即彼
                       
                        原则:保证变量在使用之前已经初始化成功就可以
                       
                函数的重载:
                        重载是发生在同一个类里
                        方法名一样
                        参数列表不同(个数不同,类型不同,顺序不同)
                        fun()
                       
                       
        数组:
                何为数组:
                        同一种类型的集合,存储容器

                好处:
                        给其中的元素进行编号,方便调用(从0开始编号)
                        这个编号叫索引

                格式
                        元素类型[] 数组名 = new 元素类型[元素的个数或者数组长度]
                        数组定义时必须给定长度
                        示例:int[] arr = new int[5];
                                定义了一个叫arra的数组类型 有5个元素
                        数据类型
                                基本类型                                        栈里
                                引用数据类型:类 接口 数组  堆里
                        左边:
                                int 数据的类型
                                [] 表示数组
                                arr 数组名字
                        右边
                                new 申请内存空间
                                int 数据类型
                                [] 表示数组
                                6        数组长度
                               
                        内存结构
                                Java运行时需要在内存中分配空间,根据不同功能划分也不同区域:
                       
                                栈内存:存放局部变量,方法的执行,数据使用完就释放
                                        局部变量:定义在方法中或者方法声明上的形式参数叫局部变量
                                        当数据数据使用完毕(超出作用域),内存自动释放
                                堆内存:所有new出来的实例(对象)
                                        数组和对象:new建立的实例,
                                        堆里的实例都有地址值,而且地址值都是不一样的(一new就会创建新的实例)
                                                一般用十六进制值表示(地址本身为十进制)                               
                                        实例都有默认值:整型0、浮点0.0、字符型'\u0000'(表现为空字符'')、布尔型false
                                                0和0.0表示的意义不一样
                                        实体不再使用时(没有引用指向时),转为垃圾,由垃圾回收器不定期自动回收
                                                Java有垃圾自动回收机制       
                                方法区:方法,String常量池,静态区
                                                面向对象介绍
                                本地方法区:跟系统相关的方法,我们不管它
                                寄存器:由cpu执行区域
                                计算机内存机制会越来越完善,现在画的其实不对,以后完善
                数组定义方式
                        格式1:
                                元素类型[] 数组名 = new 元素类型[元素的个数或者数组长度]
                                        数组定义时必须给定长度
                                        示例:int[] arr = new int[5];
                                方式1变形:不推荐
                                        元素类型 数组名[] = new 元素类型[元素的个数或者数组长度]
                                        示例:int arr[] = new int[5];
                                注意:
                                        方式1变形的名字引用也是arr,而不是arr[]
                                       
                        方式2:明确所有元素前提下
                                数据类型[] 数组名 = new 数据类型[]{元素1,元素2...}
                                举例:int arr = new int[]{1,2,3}
                                方式2变形
                                        数据类型[] 数组名 = {元素1,元素2...}
                                        示例:int[] arr = {1,2,3,4,5}
                定义数组常见错误(除0异常)
                        产生越界异常,访问了不存在的索引
                                java.lang.ArrayIndexOutOfBoundsException:
                        空指针异常,实例已经不存在
                                java.lang.ArrayIndexOutOfBoundsException:
                多个引用指向同一数组
                        //定义一个数组
                        int[] arr = new int[3];

                        arr[0] = 1;
                        arr[1] = 3;
                        arr[2] = 5;
                        //arr[3] = 1;越界

                        //再定义一个数组
                        int[] arr2 = arr;
                        arr2[1] = 10;
                        System.out.println(arr[1]);//3--10
                        System.out.println(arr2[2]);//5
                       
                数组操作:
                        数组遍历:把数组定义成一个方法
                                把数组存储起来就是为了引用,而要使用必须使用索引
                                获取数组中的元素叫做数组遍历
                       
                        获取数组中的最大值
                                思路
                                        需要进行比较并定义变量每次比较后较大的值或者角标
                                        对数组中的元素遍历取出和变量中记录的元素进行比较
                                                如果遍历到的元素大于变量中记录的元素 就用变量记录该较大值
                                        遍历结束该变量就是最大值
                                        定义功能来实现
                                                明确一        结果     数组中的元素
                                                明确二        未知内容 数组
                        元素查找
                                确切的说是普通查找
                                        是该元素在数组中第一次出现的索引
                                思路
                                        依次遍历
                                        与key进行比较
                二维数组                       
                        一维数组
                                int[] arr = {1,2,3}
                        二维数组
                                以一维数组为元素的数组
                                多个一维数组的长度可以不一样
                                二维数组中的存储的是一维数组的地址

                        格式:
                                方式1:标准二维数组  规则矩形
                                        数据类型[][] 变量名 = new 数据类型[n][m];
                                        int[][] arr = new int[3][2];
                                解释
                                        定义了一个名为arr二维数组
                                        二维数组有3个一维数组(行)
                                        每个一维数组中有2个元素
                                        给第一个一维数组的的名称分别为:arr[0]
                                        给第一个一维数组1索引位赋值78:arr[0][1] = 78;
                                方式2:非规则矩形
                                        数据类型[][] 变量名 = new 数据类型[n][];
                                        int[][] arr = new int[3][];
                                解释
                                        二维数组中有三个一维数组
                                        每一个一维数组都是默认初始值null
                                        可以对这三个一维数组分别初始化
                                方式3
                                        数据类型[][] 变量名 = {{x1,x2},{y1,y2,y3},{}};
                                        int[][] arr = {{1,2,3},{4,5},{6,7,8,9}}
                                       
                                        --注意数组长度可以为0,想拿数组元素时必须先判断是否为空数组
                                                若为空则报角标越界
                        二维数组的遍历
                                思路
                                二维数组每一个元素是一维数组
                                        获取每一个一维数组
                                一维数组遍历
                                做法:
                                双层for循环
                                        外循环控制一维数组个数
                                        内循环控制每一个一维数组的每个元素

                                main()
                                {
                                        for (int x= 0;x<arr.length;x++)
                                        {
                                                for (int y=0,y<arr[x].length,y++)
                                                {
                                                        System.out.print(arr[x][y]+"\t");
                                                }
                                                System.out.println();
                                        }
                                }
                               
                                也可
                                main()
                                {
                                        for (int x= 0;x<arr.length;x++)
                                        {
                                                if(y==arr[x].length-1)
                                                {
                                                        System.out.println(arr[x][y]);
                                                }
                                                else
                                                {
                                                        System.out.println(arr[x][y]);
                                                }
                                        }
                                }
                        注意事项
                                数组的长度要用length属性去获取不要数
                               
                day05重点:       
                      函数的定义和使用

                     一维数组的定义和应用

作者: 终结丶天涯    时间: 2015-6-26 19:38
呃呃呃,很认真
作者: 一败tu地    时间: 2015-6-26 21:46
兵哥记得好详细
作者: 小路8866    时间: 2015-6-28 13:41
支持支持,不错不错

作者: lijianfeng123    时间: 2015-8-10 23:49
不错,这笔记很详细
作者: codersun    时间: 2015-8-11 00:09
加油!!!!!!!!!!!!!!!!!!
作者: 刘登飞    时间: 2015-8-13 17:08
相当到位  还没参加基础班,自学到这部分
作者: nancexp    时间: 2015-8-14 10:54
笔记记的好详细啊 !!  

作者: 七了个七    时间: 2015-8-14 19:59
楼主好样的




欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2