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

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© 231555849   /  2015-10-30 00:31  /  5353 人查看  /  70 人回复  /   2 人收藏 转载请遵从CC协议 禁止商业使用本文

DAY 3总结
1.流程控制语句
        a.顺序结构 自上而下,依次执行
        b.选择结构 if语句,switch语句
        c.循环结构 for语句,while 语句,do while 语句

2.if语句  三种格式

                格式1: if(条件表达式){
                        语句体;
                }
                执行流程:如果表达式的值为true,执行语句体,为false时,执行后面的语句.
               
                格式2: if(条件表达式){
                        语句体1;
                }else {
                        语句体2;
                }
                执行流程:如果表达式的值为true,执行语句体1,为false时,执行语句体2.
               
                格式3: if(条件表达式1){
                        语句体1;
                }else if(条件表达式2){
                        语句体2;
                }else ....
                }else{
                        语句体N;
                }
                执行流程:如果条件表达式1的值为true则执行语句体1,为false则继续判断条件表达式2的值,为true
                则执行表达式2,为false继续重得前面的动作,当所有的都不符时走最后的语句体N.
               
                三种if语句的区别:格式1单个判断
                                                 格式2两个判断
                                                 格式3多个判断
                                格式2与三元运算符的区别:三元运算符是一个算术符,返回的是一个数值,当格式2的语句体是输出语句
                                时是不能够用三元运算符来替换的.总的来说就是三元不一定替换格式2,格式2一定替换三无.
                               
                if语句的注意事项:1无论条件表达式有多么复杂,其结果一定是boolean类型.
                                                 2当条件表达式后面跟的是一条语句时,大括号可以省略,建议不要省.
                                                 3有左大括号不能有分号,有分号不能有左大括号.
                                                 4else后面不能再跟条件判断语句,只有if后面才有
                                                 
                if语句使用场景: 1针对表达式是一个boolean类型的判断
                                                 2针对一个范围的判断    
                if语句可以嵌套
3.switch语句 格式: switch(表达式) {
                                                case 值1:
                                                        语句体1;
                                                        break;
                                                case 值2:
                                                        语句体2;
                                                        break;
                                                ....
                                                default:
                                                        语句体N;
                                               
                                        }
               
                        格式解释:表达式只能为byte short int char JDK1.5以后可以枚举,JDK1.7以后可以String.
                                        case后面跟的值是要和表达式比较的值
                                        语句体:代码
                                        break: 表示中断
                                        default:给不正确的情况给出提示,相当于else
                        执行流程:1先计算表达式的值
                                         2和case后面的值依次比较,对应就执行相应的语句体
                                         3如果都不匹配,就执行default语句
                       
                        switch语句注意事项:1case后面的值只能是常量,不能是变量,且不能出现相同的.
                                                                2default可以省略但是不建议,且可以出现在任何位置,最后执行
                                                                3break也可以省略,但不建议,会发生case穿透
                                                                4结束条件:遇到break就结束
                                                                                        执行到程序末尾结束
                        switch与if使用场景:前者适用于固定值判断,后者适用于范围值判断.
                       
4.for循环结构. for(初始化语句;条件判断语句;条件控制语句) {
                                                                        循环语句体
                                                }
                                执行流程:先执行初始化语句,再执行条件判断语句,如果返回true,就执行循环体语句,
                                如果返回false,跳出循环.循环体语句执行完后,进行条件控制语句,再进行条件判断语句...
                               
                                注意事项基本与if相同,在这里就不写了.
                                常见例题:1求和1-100,
                                                 2打印水仙花数
                                                  3统计回文数
5while循环结构  初始化语句;
                                   while(条件判断语句) {
                                        循环体语句;
                                        条件控制语句;
                                   }
                                 执行流程与for差不多就不写了.

                                 
6do while循环结构  初始化语句;
                                        do{
                                        循环体语句;
                                        条件控制语句;
                                        }while(条件判断语句);
                                执行流程:先走循环体语句,再条件控制语句,再进条件判断语句,TRUE就继续循环,false跳出循环.

7三种循环结构小结 :  for 与 while 区别:1使用上,因为for的变量是定义括号内,使用完后会消失,如果循环
                                                                                        结束完之后仍想继续使用变量用while.
                                                                                        2 理解上for是用于一个范围,如果不太确定则用while
                                                for,while与do while 区别.后者至少执行一次循环体,前者要经过条件判断语句.
介绍了两种死循环 while(true){} 和for(;;){}
8循环的嵌套 利用forfor 画星星  外层控制行数,内层控制列数
                                          几个练习: 5行6列星星
                                                                  直角三角形
                                                                  九九乘法表
回复 使用道具 举报
昨天休息,自习了一天,面对对象有点难理解,还是要多看,我发现总结虽然不错,不过有点浪费时间,下次写重点吧.进度要跟上啊啊啊啊啊啊啊
回复 使用道具 举报
顶顶顶顶顶顶顶顶顶顶!!!!!!!!!!!!
回复 使用道具 举报
Day04 总结
控制语句中的跳转语句
        break:
                可以用在switch语句中,表示结束switch语句
                也可以用在循环中表示跳出当前循环.
        continue:
                只能用在循环中,表示中止本次循环,继续下次循环。

        标号:内层循环控制外层循环

        return: 返回结果。 结束函数.

方法(掌握)
        (1)方法:就是完成特定功能的代码块。
                注意:在很多语言里面有函数的定义,而在Java中,函数被称为方法。
        (2)格式:
                修饰符 返回值类型 方法名(参数类型 参数名1,参数类型 参数名2...) {
                        方法体语句;
                        return 返回值;
                }

                修饰符:目前就用 public static。后面再详细讲解其他修饰符
                返回值类型:就是功能结果的数据类型
                方法名:就是起了一个名字,方便我们调用该方法。
                参数类型:就是参数的数据类型
                参数名:就是变量
                参数分类:
                        实参:实际参与运算的数据
                        形参:方法上定义的,用于接收实际参数的变量
                方法体语句:就是完成功能的代码块
                return:结束方法
                返回值:就是功能的结果,由return带给调用者。
        (3)两个明确:
                返回值类型:结果的数据类型
                参数列表:参数的个数及对应的数据类型
        (4)方法调用
                A:有明确返回值的方法
                        a:单独调用,没有意义
                        b:输出调用,不是很好,因为我可能需要不结果进行进一步的操作。但是讲课一般我就用了。
                        c:赋值调用,推荐方案
                B:void类型修饰的方法
                        a:单独调用
        (5)案例:
                A:求和方案
                B:获取两个数中的较大值
                C:比较两个数据是否相同
                D:获取三个数中的最大值
                E:输出m行n列的星形
                F:输出nn乘法表
        (6)方法的注意事项
                A:方法不调用不执行
                B:方法之间是平级关系,不能嵌套定义
                C:方法定义的时候,参数是用,隔开的
                D:方法在调用的时候,不用在传递数据类型
                E:如果方法有明确的返回值类型,就必须有return语句返回。
        (7)方法重载
                在同一个类中,方法名相同,参数列表不同。与返回值无关。
               
                参数列表不同:
                        参数的个数不同。
                        参数的对应的数据类型不同。
        (8)方法重载案例
                不同的类型的多个同名方法的比较。
               
数组(掌握)
        (1)数组:存储同一种数据类型的多个元素的容器。
        (2)特点:每一个元素都有编号,从0开始,最大编号是长度-1。
                 编号的专业叫法:索引
        (3)定义格式
                A:数据类型[] 数组名;
                B:数据类型 数组名[];
               
                推荐是用A方式,B方法就忘了吧。
                但是要能看懂
        (4)数组的初始化
                A:动态初始化
                        只给长度,系统给出默认值
                       
                        举例:int[] arr = new int[3];
                B:静态初始化
                        给出值,系统决定长度
                       
                        举例:int[] arr = new int[]{1,2,3};
                        简化版:int[] arr = {1,2,3};
        (5)Java的内存分配
                A:栈 存储局部变量
                B:堆 存储所有new出来的
                C:方法区(面向对象部分详细讲解)
                D:本地方法区(系统相关)
                E:寄存器(CPU使用)
               
                注意:
                        a:局部变量 在方法定义中或者方法声明上定义的变量。
                        b:栈内存和堆内存的区别
                                栈:数据使用完毕,就消失。
                                堆:每一个new出来的东西都有地址
                                    每一个变量都有默认值
                                                byte,short,int,long 0
                                                float,double 0.0
                                                char '\u0000'
                                                boolean false
                                                引用类型 null
                                    数据使用完毕后,在垃圾回收器空闲的时候回收。
        (6)数组内存图
                A:一个数组
                B:二个数组
                C:三个数组(两个栈变量指向同一个堆内存)
        (7)数组的常见操作
                A:遍历
                        方式1:
                                public static void printArray(int[] arr) {
                                        for(int x=0; x<arr.length; x++) {
                                                System.out.println(arr[x]);
                                        }
                                }
                               
                        方式2:
                                public static void printArray(int[] arr) {
                                        System.out.print("[");
                                        for(int x=0; x<arr.length; x++) {
                                                if(x == arr.length-1) {
                                                        System.out.println(arr[x]+"]");
                                                }else {
                                                        System.out.println(arr[x]+", ");
                                                }
                                        }
                                }
                B:最值
                        最大值:
                                public static int getMax(int[] arr) {
                                        int max = arr[0];
                                       
                                        for(int x=1; x<arr.length; x++) {
                                                if(arr[x] > max) {
                                                        max = arr[x];
                                                }
                                        }
                                       
                                        return max;
                                }
                               
                        最小值:
                                public static int getMin(int[] arr) {
                                        int min = arr[0];
                                       
                                        for(int x=1; x<arr.length; x++) {
                                                if(arr[x] < min) {
                                                        min = arr[x];
                                                }
                                        }
                                       
                                        return min;
                                }
                C:逆序
                        方式1:
                                public static void reverse(int[] arr) {
                                        for(int x=0; x<arr.length/2; x++) {
                                                int temp = arr[x];
                                                arr[x] = arr[arr.length-1-x];
                                                arr[arr.length-1-x] = temp;
                                        }
                                }
                               
                        方式2:
                                public static void reverse(int[] arr) {
                                        for(int start=0,end=arr.length-1; start<=end; start++,end--) {
                                                int temp = arr[start];
                                                arr[start] = arr[end];
                                                arr[end] = temp;
                                        }
                                }
                D:查表
                                public static String getString(String[] strArray,int index) {
                                        return strArray[index];
                                }
                E:基本查找
                        方式1:
                                public static int getIndex(int[] arr,int value) {
                                        for(int x=0; x<arr.length; x++) {
                                                if(arr[x] == value) {
                                                        return x;
                                                }
                                        }
                                       
                                        return -1;
                                }
                               
                        方式2:
                                public static int getIndex(int[] arr,int value) {
                                        int index = -1;
                               
                                        for(int x=0; x<arr.length; x++) {
                                                if(arr[x] == value) {
                                                        index = x;
                                                        break;
                                                }
                                        }
                                       
                                        return index;
                                }
回复 使用道具 举报
DAY05总结
1:二维数组(理解)
        (1)元素是一维数组的数组。
        (2)格式:
                A:数据类型[][] 数组名 = new 数据类型[m][n];
                B:数据类型[][] 数组名 = new 数据类型[m][];
                C:数据类型[][] 数组名 = new 数据类型[][]{{...},{...},{...}};
                D:数据类型[][] 数组名 = {{...},{...},{...}};
        (3)案例(掌握):
                A:二维数组的遍历
                B:二维数组的求和
                C:杨辉三角形

2:两个思考题(理解)
        (1)Java中的参数传递问题
                Java中只有值传递。
               
                基本类型:形式参数的改变不影响实际参数
                引用类型:形式参数的改变直接影响实际参数
        (2)数据加密问题
                综合的小案例。
       
3:面向对象(掌握)
        (1)面向对象
                面向对象是基于面向过程的编程思想
        (2)面向对象的思想特点
                A:是一种更符合我们思考习惯的思想
                B:把复杂的事情简单化
                C:让我们从执行者变成了指挥者
               
                举例:
                        买电脑
                        洗衣服
                        做饭
                        ...
                        万事万物皆对象
        (3)把大象装进冰箱(理解)
                A:面向过程实现
                B:面向对象实现
               
                注意:如何让我们的操作更符合面向对象思想呢?
                A:有哪些类
                B:每个类有哪些成员
                C:类与类的关系
        (4)类与对象
                A:现实世界的事物
                        属性        事物的基本描述
                        行为        事物的功能
                B:Java语言中最基本的单位是类。所以,我们要用类来体现事物
                C:类
                        成员变量        事物属性
                        成员方法        事物行为
                D:类:是一组相关的属性和行为的集合。是一个抽象的概念。
                  对象:是该类事物的具体存在,是一个具体的实例。(对象)
                  
                  举例:
                        学生:类
                        班长:对象
        (5)类的定义及使用
                A:类的定义
                        成员变量        定义格式和以前一样,就是位置不同,在类中,方法外。
                        成员方法        定义格式和以前一样,就是去掉了static。
                B:使用类的内容
                        a:创建对象? 格式
                                类名 对象名 =  new 类名();
                        b:如何使用成员变量和成员方法呢
                                对象名.成员变量
                                对象名.成员方法()
        (6)案例:
                A:学生类的定义和使用
                B:手机类的定义和使用
        (7)内存图
                A:一个对象的内存图
                B:二个对象的内存图
                C:三个对象的内存图
        (8)Java程序的开发,设计和特征
                A:开发:就是不断的创建对象,通过对象调用功能
                B:设计:就是管理和维护对象间的关系
                C:特征
                        a:封装
                        b:继承
                        c:多态
4:成员变量和局部变量的区别(理解)
        (1)在类中的位置不同
                成员变量:类中方法外
                局部变量:方法定义中或者方法声明上
        (2)在内存中的位置不同
                成员变量:在堆中
                局部变量:在栈中
        (3)生命周期不同
                成员变量:随着对象的创建而存在,随着对象的消失而消失
                局部变量:随着方法的调用而存在,随着方法的调用完毕而消失
        (4)初始化值不同
                成员变量:有默认值
                局部变量:没有默认值,必须定义,赋值,然后才能使用
               
类作为形式参数的问题?(理解)
        (1)如果你看到一个方法需要的参数是一个类名,就应该知道这里实际需要的是一个具体的对象。

5:匿名对象(理解)
        (1)没有名字的对象
        (2)应用场景
                A:调用方法,仅仅只调用一次的时候。
                b:可以作为实际参数传递。
                c:如果用来进行成员变量进行赋值,但是没有意义,因为匿名对象使用一次后就是垃圾,会回收,他在堆内存的新建对象由于没有指向也会消失.
               
6:封装(理解)
        (1)隐藏实现细节,提供公共的访问方式
        (2)好处:
                A:隐藏实现细节,提供公共的访问方式
                B:提高代码的复用性
                C:提高代码的安全性
        (3)设计原则
                把不想让外界知道的实现细节给隐藏起来,提供公共的访问方式
        (4)private是封装的一种体现。
                封装:类,方法,private修饰成员变量

private关键字(掌握)
        (1)私有的意义,可以修饰成员变量和成员方法
        (2)特点:
                被private修饰的后的成员只能在本类中被访问
        (3)private的应用:
                以后再写一个类的时候:
                        把所有的成员变量给private了
                        提供对应的getXxx()/setXxx()方法
回复 使用道具 举报
今天考试了,考的不好,才84分,班里扮猪吃老虎的太多,GTMDDWH!!!!!!
回复 使用道具 举报
今天休息,自习了一天,复习了以前的内容,感觉还是有点收获的
回复 使用道具 举报
木子子木 来自手机 中级黑马 2015-11-4 23:49:05
28#
坚持就是胜利!
回复 使用道具 举报
LLLLL 中级黑马 2015-11-5 11:46:53
29#
66666666666666666666666666666
回复 使用道具 举报
支持你,希望你能坚持下去,然后回过头来,看看自己的历史,会被自己感动的!
回复 使用道具 举报
jlq 中级黑马 2015-11-5 13:55:18
31#
enen   陪佩服一下
回复 使用道具 举报
由于被管理员警告不允许发总结贴,从今天开始不发了,谢谢大家支持,希望大家在黑马有一个好的收获!!
回复 使用道具 举报
希望能坚持,加油
回复 使用道具 举报
66666666666666
回复 使用道具 举报
加加油!
回复 使用道具 举报
今天又考试了,这两天学的不咋的,面向对象...第二次考试72分...唉...
回复 使用道具 举报
坚持就是胜利!!!
回复 使用道具 举报
API 86分....隔壁班点招结束了,而我感觉什么也不会...
回复 使用道具 举报
很棒,共勉。
回复 使用道具 举报
好久没来了,估计这个贴都沉了.明天又要考IO流了,集合86分.马上要点招了,心情有点不开心,我只想在地下默察默察 ~~~
回复 使用道具 举报
您需要登录后才可以回帖 登录 | 加入黑马