黑马程序员技术交流社区

标题: java基础第六天，对前五天的知识做一下总结 [打印本页]
作者: 地狱里的帅灵魂    时间: 2015-8-10 23:37
标题: java基础第六天，对前五天的知识做一下总结
1. 标识符:起名字 -- 见名知意
                命名规范:
                类,接口
                        每个单词首字母大写
                方法,变量
                        第一个首字母小写,其他首字母大写
                常量
                        全部大写
                包:
                        全部小写 cn.baidu.waimai
                注意: 不能关键字
               
        2. 关键字:java语言赋予特殊含义单词
                特点:全部小写字母,editPlus蓝色字
               
        3. 常量:在程序运行过程中,其值不发生改变
                分类:
                        字面值常量
                        自定义常量
                       
                字面值常量
                        字符串,整数,小数,字符,布尔,空(null)
                       
        4. 变量:在程序运行过程中,其值在一定范围之内可以发生改变
                本质:在内存中开辟的小空间
                格式:
                        数据类型 变量名 = 初始化值;
                        int x=10;

        数据类型:
                基本数据类型:        四类八种
                整数类型 byte， short， int(默认)， long
                浮点类型 float, double(默认)
                字符型   boolean



                                               
                引用数据类型:   类 ,接口 ,数组  
                       
               
        5. 变量类型转换
                隐式转换(默认)从小到大
                        byte,short,char-->int-->long->float-->double
                        默认整数类型:int
                        默认浮点数类型:double
                       
                显示转换(强制)从大到小
                        格式:
                                数据类型 变量名 = (目标数据类型) (数据值);
                                byte b = (byte)130;
        6. 数据类型的范围
                                                        字节                  范围
                                byte                1                                -128~127
                                char                2                                0~65535
                                short                2
                                int                        4                                -2147483648~
                                long                8                               
                                float                4
                                double                8
                                boolean                1                                true false
                       

        7. 运算符6个和运算结果       
                        运算符                                                         结果

                        算术 + - ++ --                                        计算的值               
                        赋值 = +=                                                右边赋值给左边
                        关系 < > ==                                                布尔类型
                        逻辑 & | && ||                                        布尔类型
                        位(了解)  & | ^ << >> >>>                计算的值
                        三元 int c = (x>y)?x:y;                        右边赋值给左边       

                        注意:
                                1.++ --
                                        a++ :先运算,后++
                                        ++a :先++,后运算     
                                       
                                2.&& ||
                                        短路效果:前面的结果决定了整个的运算结果,那么后面就不运算了
                               
        8. 选择语句
                if :
                        三种格式 :
                       
                格式一:
                if(条件表达式){
                        语句体；
                }

                格式二：
                if(条件表达式){
                        语句体；
                }else{
                        语句体；
                }

                格式三：
                if(条件表达式1){
                        语句体1；
                }else if(条件表达式2){
                        语句体2；
                }
                ...
                else{
                        语句体n+1；
                }
                       

                特点：
                格式1：适合做单个判断
                格式2：适合做两个判断
                格式3：适合做多个判断
                if的()中是关系表达式,必须是boolean类型

                       

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

                        注意:
                        1.break省略,但是可能产生case穿透的效果
                        2.default省略,但是异常数据没有处理
                        3.switch的()中表达式的范围 ,
                                byte,short,int,char,
                                枚举,jdk5
                                String jdk7
                        4.case后面,必须是常量值,不能是变量
                        5.停止的条件
                                1.break
                                2.运行到结尾

       
        两种选择结构的使用场景
                if语句使用场景：
                针对结果是boolean类型的判断
                针对一个范围的判断
                针对几个常量值的判断
                switch语句使用场景：
                针对几个常量值的判断(效率高)       


        9. 循环语句
                for
                格式:
                for (初始化语句; 判断条件语句; 控制条件语句){
               
                        执行语句;
                }


       
                for循环嵌套案例小结:
                    九九乘法表
                        外循环控制行:x
                                System.out.print(j+"*"+i+"="+i*j+"\t");
                        内循环控制列:y
                                System.out.println();

                        程序如下：
                        class  ForForDemo2{
                                public static void main(String[] args) {

                                        //外层循环控制行数
                                for(int i=1;i<=9;i++){

                                        //内层循环控制列数
                                        for(int j=1;j<=i;j++){
                                                System.out.print(j+"*"+i+"="+i*j+"\t");
                                        }
                                        //换行
                                        System.out.println();
                                }
               
                        }
}

                       
                while
                格式：
                基本格式:

                while(条件表达式){
                        循环体;
                }


                扩展格式:

                初始化表达式;
                while(条件表达式){
                        循环体;
                        增量表达式;
                }


                等价于for循环,可以相互的转换
                小小区别:
                        初始化语句:for循环结束,就不能使用
                                           while循环结束,还能使用
               
                                          
                do...while

                基本格式:
                        do{
                        循环体;
                        }while(条件表达式);

                扩展格式:
                        初始化表达式;
                        do{
                        循环体;
                        增量表达式;
                        }while(条件表达式);

                特点:先do一次,再去while(判断条件语句);
       

        10. break: 中断 ,结束switch或者loop
                continue: 继续, 结束当次循环,开始下次循环
                return:  返回,结束方法,非常强大  

        11. 方法:完成特定功能的代码块
                格式:
                        修饰符 返回值类型 方法名 (参数类型 参数....){
                                执行语句;

                                return        返回值;
                       
                        }
                return作用:
                        1.结束方法
                        2.返回返回值给调用者
               
                调用:

                        1.明确返回值类型,数据类型 (四类八种)
                                1.直接调用
                                2.输出调用
                                3.赋值调用**************

                        2.不明确返回值类型 (void)  
                                1.直接调用**************
                       

                写方法步骤:
                        两个明确:
                                返回值类型: int void  
                                参数列表:
                                        参数个数:参数个数
                                        参数类型:限制参数
                再拿九九乘法表做例子：
                class  ForForDemo2{
                        public static void main(String[] args){
                                chengFaBiao();       
                        }
                        public static void chengFaBiao(){
                                //外层循环控制行数
                                for(int i=1;i<=9;i++){

                                        //内层循环控制列数
                                        for(int j=1;j<=i;j++){
                                                System.out.print(j+"*"+i+"="+i*j+"\t");
                                        }
                                        //换行
                                        System.out.println();
                                }       
                        }
                }

               
               
               

        第五天数组总结

        12.数组:容器 ,存数据,
        (1)数组：
               
        (2)特点：
                        1.元素的类型一致
                        2.可以存多个元素
                        3.一旦数组创建,其长度不可以改变
        (3)定义格式
                格式1：数据类型[] 数组名;
                int[] arr ;
                格式2：数据类型 数组名[];
                int arr[];

                        动态初始化：
                        数据类型[] 数组名 = new 数据类型[长度];
                        int[] arr = new int[8];
                        静态初始化
                        数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
                        简化为
                        数据类型[] 数组名 = {元素1,元素2,…};
                        int[] arr2 = {1,2,3,4,5};
                                               

        (4)数组的初始化
                A动态初始化：
                        数据类型[] 数组名 = new 数据类型[长度];
                        int[] arr = new int[8];
                B静态初始化
                        数据类型[] 数组名 = new 数据类型[]{元素1,元素2,…};
                        简化为
                        数据类型[] 数组名 = {元素1,元素2,…};
                        int[] arr2 = {1,2,3,4,5};
                       
        (5)Java的内存分配
                栈
                堆
               
                注意：
                        a:局部变量:在方法定义中或者方法声明上定义的变量。
                        b:栈内存和堆内存的区别
                                栈：数据使用完毕，就消失。
                                堆：每一个new出来的东西都有地址
                                    每一个变量都有默认值
                                                byte,short,int,long 0
                                                float,double 0.0
                                                char '\u0000'
                                                boolean false
                                                引用类型 null
                                    数据使用完毕后，在垃圾回收器空闲的时候回收。
       
        (6)数组的常见操作
                A:遍历
                class BianLi {
                        public static void main(String[] args) {
                                //定义数组
                                int[] array=new int[]{1,46,7,78,
                                4,32,32,24,6,57,88,6,3};
                                //打印数组在堆内存中的地址值
                                System.out.println(array);
                                //直接调用arr方法
                                arr(array);
                        }
                        public static void arr(int[] array){
                                //遍历数组
                                for (int a=0;a<array.length ;a++ ){
                                        //打印数组
                                        System.out.println(array[a]);

                                }
                        }
                }
                       
                               
                       
                B:最值
                最大值：
                //求两个数的最大值
                class MaxTwo {
                        public static void main(String[] args) {
                                //定义int c接收getMax方法返回值
                                int c=getMax(3,4);
                                //打印返回值
                                System.out.println(c);
                        }
                        public static int getMax(int a,int b){
                               
                                if (a>b){
                                        return a;
                                }else{
                                        return b;
                                }
                        }
                }
                               
                C:逆序
                        方式1:

                        for循环
                        方式2：
                                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;
                                        }
                                }
                               
                        方式3：
                                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:查表
                class  ChaBiao{
                        public static void main(String[] args) {
                                String[] array=new String[]{"星期一",
                                "星期二","星期三","星期四","星期五","星期六","星期日"};
                                System.out.println(getWeek(array,8));
                        }
                        public static String  getWeek(String[] array,int index ){
                                if (index>0&&index<8){
                                        return array[(index-1)];
                                }
                                return "没有这个星期";
                       
                        }
                }


       
自己的一点总结，希望对初学者有所帮助

前五天总结.zip

3.28 KB, 下载次数: 87
作者: 地狱里的帅灵魂    时间: 2015-8-10 23:38
希望对初学者有所帮助，在此共勉
作者: 一笑过千山    时间: 2015-8-10 23:40
细致独到，学习了
作者: codersun    时间: 2015-8-10 23:43
支持一下！！！！！！！！！！！！！加油！！
作者: 地狱里的帅灵魂    时间: 2015-8-10 23:44
一笑过千山 发表于 2015-8-10 23:40
细致独到，学习了

共勉，你是自学的吗
作者: 地狱里的帅灵魂    时间: 2015-8-10 23:45
codersun 发表于 2015-8-10 23:43
支持一下！！！！！！！！！！！！！加油！！

共勉，还望大神不吝赐教
作者: yantao0401    时间: 2015-8-11 10:20
加油 加油
作者: 徐鹏辰    时间: 2015-8-11 10:33
标识符中还有一点：数字不可开头
作者: 地狱里的帅灵魂    时间: 2015-8-11 14:00
徐鹏辰 发表于 2015-8-11 10:33
标识符中还有一点：数字不可开头

受教，谢谢补充
作者: F灬灬    时间: 2015-8-11 16:04
不错不错。
作者: Wqi    时间: 2015-8-11 17:02
共勉！加油
作者: CtrlChengAo    时间: 2015-8-11 19:03
总结的很好，理论加代码，这样能够记忆更牢固
作者: 王哲zhe    时间: 2015-8-11 19:40
哎呦不错哦
作者: 酒倌浪人    时间: 2015-8-11 20:30
支持一下
作者: 地狱里的帅灵魂    时间: 2015-8-11 21:06
CtrlChengAo 发表于 2015-8-11 19:03
总结的很好，理论加代码，这样能够记忆更牢固

嗯，谢谢。继续整理
作者: aa233192133    时间: 2015-8-11 21:09
很好，楼主加油
作者: 地狱里的帅灵魂    时间: 2015-8-11 21:12
aa233192133 发表于 2015-8-11 21:09
很好，楼主加油

谢谢鼓励，继续加油
作者: 地狱里的帅灵魂    时间: 2015-8-11 21:13
王哲zhe 发表于 2015-8-11 19:40
哎呦不错哦

谢谢鼓励，共勉
作者: 落叶随尘    时间: 2015-8-11 21:33
一个复制 一个粘贴
作者: 地狱里的帅灵魂    时间: 2015-8-11 21:35
落叶随尘 发表于 2015-8-11 21:33
一个复制 一个粘贴

代码我有整理的好吧
作者: 修道解厄    时间: 2015-8-11 21:50
详细的基础常识
作者: shuguang    时间: 2015-8-11 22:04
总结的很全面!
作者: 一笑过千山    时间: 2015-8-13 14:00
地狱里的帅灵魂 发表于 2015-8-10 23:44
共勉，你是自学的吗

是的，正在自学，以前没接触过学的很man



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