查看: 93|回复: 0

[郑州1909] 初识java基本知识点总结(二)


19-10-21 22:21:59 | [复制链接]

2

主题

3

帖子

11

积分

菜鸟

Rank: 1

发表于 19-10-21 22:21:59 | 显示全部楼层 |阅读模式
一.选择结构,分支结构
        1.选择结构
        if(布尔表达式){
                //代码块1
        }
        //  代码块2
       
                执行流程:
                        首先执行布尔表达式的判断,若为true,则执行代码块1,代码块2
                                                  若为false,则执行代码块2
        if(布尔表达式){
                //代码块1
        }else{
                //代码块2
        }
                       
                首先执行布尔表达式的判断,若为true,则执行代码块1
                                              若为false,则执行代码块2        
       
        if(布尔表达式1){
                //代码块1
        }else if(布尔表达式2){
                //代码块2
        }else if(布尔表达式3){
                //代码块3
        }else{
                //代码块4
        }
       
        if(布尔表达式1){
                //代码块1
                if(布尔表达式2){
                        //代码块2
                }
        }else{
                //代码块3
        }
       
        2.分支结构
         
                switch(表达式/值){  //  byte    short   int  char   String(JDK1.7以后)
                        case 值1 : 逻辑代码1;break;
                        case 值2 : 逻辑代码2;break;
                        case 值3 : 逻辑代码3;break;
                        case 值4 : 逻辑代码4;break;
                        case 值5 : 逻辑代码5;break;
                        case 值6 : 逻辑代码6;break;
                        default:逻辑代码7;
                }
                case后面的值,只会比对成功一次(如果case都不成功,则default成功),其他case将不再进行判断,代码块直接执行
                case后面的值不允许重复
        局部变量
                概念:  声明在函数内部或者代码块内部的变量   必须先赋值,后使用
                作用范围: 从定义行开始,到定义它的代码块结束
                注意:  多个局部变量,在重合的作用范围内,不允许命名冲突
                               
        常见进制
                二进制:  0b  开头
                八进制:  0开头    010   011
                十进制:   ....
                十六进制: 0x开头
二.循环结构
        概念:通过某个条件,多次执行一段代码
        分类:
               
                        while(布尔表达式){
                                //逻辑代码
                        }
                        //后续代码
                        特点:  先判断,再执行   循环次数  0  ~  N次
                                        循环次数不明确
                       
                do{
                        //代码块
                }while(布尔表达式)
               
                        特点:  先执行,在判断     执行 1  ~  N次
               
                for(循环初值;循环条件;循环递增量){
                        //代码块
                }
                        特点:  先判断,在执行    执行次数已知   
       
        循环三要素:
                循环初值   循环条件    循环递增量
        循环嵌套
        流程控制
                continue    结束当次循环,转入下一次循环的执行
                break       跳出直接包含break关键字的循环
三.函数
目前程序中存在哪些问题?
        所有的代码都书写在主函数中,导致代码过多,可读性差
        存在代码冗余,降低了程序的可维护性
函数
        是实现某一特定功能的代码
        注意:
                定义在类以内,其他函数以外
                在函数体中填充主函数中重复出现的功能性代码
        语法:
                封装函数的语法
                public static 返回值类型 函数名(形参列表){
                        //主函数中重复出现的功能性代码
                }
                调用的语法:
                函数名(实参);
               
        返回值类型:
                void   没有返回值
                八种基本数据类型+引用类型
        对于有返回值的函数,要求无论如何都会返回给调用者一个数值,且返回数值的类型要与 返回值类型 这一项兼容
        语法关键字   return
        函数的嵌套调用
四.数组
        概念:一组连续的空间,存储多个相同类型的数值
                类型:任意类型
                        八种基本数据类型+引用类型
                        double[] d;
                        String[] strs;
        语法:
                1.先声明,再分配空间
                        int[] a;
                        a = new int[5];
                2.声明并分配空间
                        int[] a = new int[5];
                3.声明并赋值,显式赋值
                        int[] a = new int[]{2,5,4,8,7};
                4.声明赋值
                        int[] a = {2,5,4,8,56};
        数组的访问
                1.index 下标    有效范围   0  ~  数组长度-1
                2.数组名[下标]  //  对数组元素进行访问
                3.数组的长度     数组名.length
                4.数组的最大下标     数组名.length-1
        数组的默认值:
                整数  :  0
                小数  :  0.0
                boolean : false
                char   :  '\u0000'   --  空格
                引用类型 :  null
        数组的扩容
                1.手动书写
                2.System.arraycopy(原数组,原数组起始,新数组,新数组起始,长度);
                3.java.util.Arrays
                   Arrays.copyof(原数组,新长度)    //   返回带有原值的新数组
        数值传递
                基本类型的引用,传递的是具体的数值
                对象类型的引用,传递的是地址
        二维数组
                是一维数组的一维数组
                定义:
                        1.先声明,再开辟内存  
                                int[][]  a;
                                a = new int[5][3];
                        2.声明的同时,初始化
                                int[][] a = {{1,2,30},{4,5,6}};
                        3.声明并初始化
                                int[][] a = new int[][]{{1,2,3},{5,4,6}}
                        4.声明并开辟内存
                                int[][] a = new int[5][3];
                注意:
                        开辟空间时,至少要指定高维度
                        声明的同时,初始化操作    必须在同一行
                        开辟内存,初始化数据
                    高维必须声明。
        可变长参数
                概念:可以接收多个同类型的参数,个数不同,使用方式与数组相同
                语法:   数据类型... 变量名
                赋值:  可以为可变长参数赋予  0  ~  N个  值
                好处: 与数组不同,使用更便利
                注意:  可变长参数用于函数的形参   且可变长参数只允许有一个
                                可变长参数必须位于形参列表的最后
                                public  static int add(double d,int... a);
                面试题:
                        public static void main(String[] a){}
                        public static void main(String[] args){}
                        public static void main(String... a){}
                        public static void main(String...args){}

您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

订阅|小黑屋|手机版|千锋教育论坛 ( 京ICP备12003911号-3

GMT+8, 19-11-17 04:54 , Processed in 0.331396 second(s), 37 queries .

Powered by Discuz! X3.2

© 2001-2017 Comsenz Inc.

快速回复 返回顶部 返回列表