CGBTN2111汇总复习

Posted 程序媛 泡泡

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了CGBTN2111汇总复习相关的知识,希望对你有一定的参考价值。

CGBTN2111汇总复习

复习思路

先跟着老师走,遇到会的,快速过,遇到不会的,先做记录,后面再复习.

一阶段学习路径

1 基础语法Basic

1.基础环境配置

1. 安装JDK

JDK:Java开发工具包,我们使用的版本是1.8
注意:一台PC上可以安装多个JDK,具体环境变量配置哪个JDK,哪个就生效

2. 环境变量的配置

JAVA_HOME : 配置的是JDK安装的目录
Path : 配置的是JDK的bin目录,不新建的
CLASS_PATH:配置的是JDK的lib目录
win+R键,在运行窗口输入cmd
验证命令为 : java -version 出现JDK版本号即为成功

3. 开发工具

eclipse IDEA
注意1:开发工具无需纠结,重要的是编程的思路,对于工具而言,选一个自己喜欢的就好,重要的是提高这个自己常用软件的熟练度(快捷键 字体设置 配置JDK…面向百度进行开发)
注意2:大家在安装的时候,不要选择C盘系统盘,而且路径中不要出现中文或者空格等等其他特殊符号,因为会出现一些未知的问题

2.JDK JRE JVM

JDK:Java开发工具包(Java Development Kit)–开发的最小单位
JRE:Java运行时环境(Java Runtime Environment)–运行的最小单位
JVM:Java虚拟机(Java Virtual Machine)–负责加载并运行.class字节码文件

  1. 运行过程: 我们编写的源码是.java为后缀的,通过编译生成的是.class字节码文件,交给JVM来执行
  2. 跨平台: 只要在不同的操作系统上安装对应的JVM,就可以实现跨平台:一份代码 处处运行

2.语法基础

1.关键字

50个全小写的单词,在Java有特殊的意义,还包含2个保留字const goto

2.标识符

字母 数字 下划线 美元符号组成,不能以数字开头,区分大小写,关键字+(true false null)也不可以用作标识符,见名知意
UpperCamelCase大驼峰命名:
每个单词的首字母都要大写,比如类名:HelloWorld类名: Upper驼峰命名:每一个单词的首字母都要大写
LowerCamelCase小驼峰命名:
从第二个单词的首字母才开始大写,比如:方法名:nextLine() 变量名:deptName

3.注释

单行注释 //
多行注释 / * * /
文档注释: /** */
还可以添加一些额外的信息:作者 时间 版本 参数 返回值类型
注释可以注释内容,被注释的内容不执行,所以我们可以利用注释手段对进行分段代码测试

4.变量

  1. 成员变量:类里方法外,类消失,成员变量才会消失
    成员有自己的默认值,可以不手动赋值
  2. 局部变量:方法里/代码块里,当局部代码结束,局部变量也随之释放
  3. 局部变量使用的时候,必须赋值,可以:

声明的时候并且赋值 Cat cat = new Cat();
先声明再赋值 Cat cat; cat = new Cat();
注意:基本类型保存的是值,引用类型保存的是地址值

  1. 变量的就近原则:离谁近 就使用谁
  1. 如果想指定本类的成员变量,使用this.变量名来指定
  2. 如果想指定父类的成员变量,使用super.变量名来指定

5.八大基本类型

Java的数据类型分为两类:基本类型 + 引用类型

6.字面值规则:

  1. 整数类型的字面值类型是int
  2. 浮点类型的字面值类型是double
  3. byte short char 三种比int小的类型,可以在范围内直接赋值
  4. 三种字面值后缀 : L D F
  5. 三种字面值前缀: 0b-二进制 0-八进制 0x-十六进制
  6. 练习:查看字面值前缀
package cn.tedu.basic;
/*本类用于测试字面值前缀*/
public class TestTypePre 
    public static void main(String[] args) 
        System.out.println(100);//100,十进制,10的平方
        System.out.println(0b100);//4,二进制,2的平方
        System.out.println(0100);//64,八进制,8的平方
        System.out.println(0x100);//256,十六进制,16的平方

        System.out.println(101);//101=100+1,十进制,10的平方+10的0次方
        System.out.println(0b110);//6=4+2,二进制,2的平方+2的1次方
        System.out.println(0111);//73=64+8+1,八进制,8的平方+8的1次方+8的0次方
        System.out.println(0x101);//257=256+1,十六进制,16的平方+16的0次方
    

7.运算规则:

  1. 运算结果的数据类型与参与运算的最大类型保持一致 int+int->int double/int->double
  2. 整数运算会出现溢出的现象,一旦溢出,数据就不正确了(光年案例)
  3. byte short char三种比int小的类型,运算的时候需要先自动提升int类型,再参与运算
  4. 浮点数的特殊值:Infinity NaN
  5. 浮点数运算不精确的问题:解决方案:BigDecimal
    注意1:不能使用double类型参数的构造方法,需要使用String类型的构造函数,否则还会出现不精确的问题
    注意2:除法运算时,如果出现除不尽的现象还会报错,所以需要指定保留位数与舍入方式(四舍五入)

8.类型转换

口诀:小转大,直接转 大转小,强制转 浮变整,小数没

  1. 注意:布尔类型不参与类型转换
  2. 注意:基本类型之间能否转换,不取决于字节数,字节数只能做参考,取决于类型的取值范围
  3. 注意:我们这里所说的是基本类型之间的转换,引用类型之间的转换取决于是否有继承关系
    比如:你可以说小猫是小动物,但是不能说小猫是小汽车,不然后面的这种错误的情况会报:类型转换异常
  4. 练习题:类型之间的转换与字面值规则
package cn.tedu.basic;
/*本类用于测试类型转换
* 1.byte1--short2--char2--int4--long8--float4--double8
* */
public class TestTypeChange 
    public static void main(String[] args) 
        byte a = 10;
        short b = a;//不会报错,小转大

        int c = 1;
        long d = c;//不会报错,小转大

        float f = 3.14f;
        double e = f;//不会报错,小转大

        long g = 97525205273520L;
        float h = g;//不会报错,小转大

        char i = 'a';
        int j = i;//不会报错,小转大
        System.out.println(j);//97

        int a1 = 1;
        byte b1 = 2;
        //byte c1 = a1 + b1;//会报错,大转小
        byte c1 = (byte) (a1 + b1);//强制类型转换就不会报错了
        System.out.println(c1);//3

        byte d1 = (byte) 128;
        System.out.println(d1);//-128,强制类型转换要在小类型的范围内转,否则会发生数据溢出的问题

        short e1 = 'a';
        char f1 = 120;
        System.out.println(e1);//97
        System.out.println(f1);//'x'

        float h1 = 32874.456f;
        int i1 = (int) h1;
        System.out.println(i1);//32874

    

9.运算符

  1. 普通的四则运算符 + - * / ,普通的四则运算,并不能直接改变变量本身的值,除非 i = i*10+8
  2. 取余 % 6%4=2 6%3=0(余数为0表示整除)
  3. 自增自减运算符
    1)可以改变变量本身的值
    2)前缀式: 符号在前,先改变变量本身的值(+1/-1),再使用(打印/参与运算…)
    3)后缀式: 符号在后,先使用(打印/参与运算…),再改变变量本身的值(+1/-1)
    4)注意:不管是前缀式还是后缀式,一定是会改变变量本身的值,区别在于执行的时机不同
  4. 比较运算符
    1. 比较运算符最终的结果是布尔类型的
    2. == 比较的是左右两边的值是否相等 !=比较的是左右两边的值是否不相等
  5. 练习题:==比较的练习
package cn.tedu.basic;
/*本类用于测试运算符*/
public class TestOperator 
    public static void main(String[] args) 
        //创建小猫类的对象
        Cat c1 = new Cat();
        Cat c2 = new Cat();
        int[] a1 = 1,2,3;
        int[] a2 = 1,2,3;
        int b1 = 4;
        int b2 = 4;
        boolean f1 = true;
        boolean f2 = true;
        /*==如果比较的是引用类型,比较的值是引用类型变量保存的地址值*/
        System.out.println(c1 == c2);//false
        System.out.println(a1 == a2);//false
        /*==如果比较的是基本类型,比较的值就是字面值,也就是这个变量具体存的那个数*/
        System.out.println(b1 == b2);//true
        System.out.println(f1 == f2);//true
    


class Cat
    String name;
    int age;

    public void bark()
        System.out.println("喵喵叫");
    

  1. 逻辑运算符
    双与/短路与/&& :
    判断逻辑与&一致,增加了短路的功能全真才真,有假则假
    双或/短路或/|| :
    判断逻辑与|一致,增加了短路的功能全假才假,有真则真
    注意:我们这里所说的短路,是指在某些情况下,表达式后半部分就不用计算了,因为我们已经知道了结果,也就是被短路了,短路可以提高程序的性能,但是短路不一定会用到
  2. 三目运算符: 1 ? 2 : 3; 1是表达式,1真取2,1假取3
  3. 复合赋值运算符:+= -= *= /=是一种简写的形式,比较方便,运算时会自动进行类型转换
  4. 赋值运算符: = ,右边给左边
  5. 拼接功能:+
  6. 位运算符 : 主要参与的是二进制的运算
    &与:全真才真
    | 或:全假才假
    ^异或:相同为0 不同为1
    ~ 非: 非0为1,非1为0
  7. 优先级控制:如果表达式的运算比较复杂,需要控制优先级,可以使用小括号
  8. 拓展:instanceof

10.流程控制

1.顺序结构

顺序结构中的代码会按照顺序一行一行向下执行所有的代码语句,可以用来进行输入 输出 计算等的操作
但顺序结构不可以完成先做判断,再做选择的流程

2.分支结构

  1. 单分支结构
if(判断条件)
            如果判断条件的结果为true,就执行此处代码,不符合条件,此处跳过
 
  1. 多分支结构
if(判断条件)
    如果判断条件的结果为true,就执行此处的代码
else
    如果不符合条件,执行else处的代码

  1. 嵌套分支结构
if(判断条件1)
    符合判断条件1,执行此处代码,不符合,继续向下判断
else if(判断条件2)
    符合判断条件2,执行此处代码,不符合,继续向下判断
else if(判断条件3)
    符合判断条件3,执行此处代码,不符合,继续向下判断
else
    保底选项,以上条件均不符合的情况下,执行此处代码

4.练习:

package cn.tedu.basic;

import java.util.Scanner;

/*本类用于复习分支结构*/
public class TestIf 
    public static void main(String[] args) 
        //1.提示并接收用户输入的月份
        System.out.println("请输入您要测试的月份:");
        int month = new Scanner(System.in).nextInt();

        //2.对用户输入的数据进行判断
        if(month<=0 || month >12)
            System.out.println("您输入的数据不正确!");
        else
            //3.如果用户输入的数据正确,我们就进行季节的判断
            if(month >=3 && month <=5)
                System.out.println(month+"月是春天");
            else if(month >=6 && month <=8)
                System.out.println(month+"月是夏天");
            else if(month >=9 && month<=11)
                System.out.println(month+"月是秋天");
            else
                System.out.println("冬天就要来啦,春天还会远吗?");
            
        
    

3.选择结构

  1. 小括号中变量支持的类型:
    byte short char int String enum 与4个基本类型对应的包装类
  2. 注意: 如果配置了default默认选项,而且没有任何的case被匹配到,就会执行default这个“保底选项”
  3. case的个数 是否加break 是否加default全部都是可选的,根据自己的具体业务做决定
  4. 小括号中变量的类型必须与case后value的类型一致
  5. 执行顺序:先拿着变量的值,依次与每个case后的值做比较,如果相等,就执行case后的语句
    若这个case后没有break,就会继续向下执行下一个case,如果一直没有遇到break,就会发生穿透现象,包括default
switch (变量名)
            case value1 : 操作1;break;//可选
            case value2 : 操作2;break;//可选
            case value3 : 操作3;break;//可选
            case value4 : 操作4;break;//可选
            default:保底选项;//可选
        

4.循环结构

可以帮我们多次重复的做某一件事
1.for循环

for(开始条件;循环条件;更改条件)
		如果符合循环条件,就会执行循环体里的内容

注意1:写法小窍门:从哪开始 到哪结束 循环变量如何变化
注意2:for循环能够执行多少次,取决于循环变量可以取到几个值
2.嵌套for循环
外层循环控制的是轮数,内层循环控制的是每一轮中执行的次数
对于图形而言,外层循环控制的是行数,内层循环控制的是列数

for(开始条件;循环条件;更改条件)//外层循环
		for(开始条件;循环条件;更改条件)//内层循环
				循环体
		

注意:外层循环控制的是行数,内层循环控制的是列数
注意:外层循环控制的是轮数,内层循环控制的是在这一轮中执行的次数
3.高效for循环

for(遍历到的元素的类型 遍历到的元素的名字 :要遍历的数组/集合名)
		循环体

优点:写法简单,效率高
缺点:只能从头到尾的遍历数据,不能进行步长的选择
4.while循环

while(判断条件)
		如果符合判断条件,继续循环

注意:常用来完成死循环,但死循环必须设置出口!
练习题:while循环练习

package cn.tedu.basic;
/*本类用于复习while循环*/
public class TestWhile 
    public static void main(String[] args) 
        //需求:通过while循环打印10次"小可爱们中午好~"
        //f1();
        //需求:通过while循环打印1 2 3 ... 10
        //f2();
        //需求:通过while循环打印1 3 5 7... 99
        f3();
        //需求:通过while计算1+2+3+4...+10
        f4();
        //需求:通过while计算2+4+6+8...+100
        f5();
    

    private static void f5() 
        //需求:通过while计算2+4+6+8...+100
        int i = 2;//定义循环变量i用来控制循环
        int sum = 0;//定义变量用来保存累加的结果
        while (i<=100)
            //sum += i;
            sum = sum + i;//累加
            //i += 2;
            i = i + 2;//循环变量i每次+2
        
        System.out.println("2到100所有偶数的和为:"+sum);
    

    private static void f4() 
        //需求:通过while计算1+2+3+4...+10
        int i = 1;//用于控制循环,相当于循环变量
        int sum = 0;//用于保存求和累加的结果
        while(i<=10)
            sum = sum + i;
            i++;
        
        System.out.println("1到10累加的结果为:"+sum);
    

    private static void f3() 
        //需求:通过while循环打印1 3 5 7... 99
        int sum = 1;
        while(sum <100)
            System.out.println(sum);
            //sum = sum +2;
            sum += 2;
        
    

    private static void f2() 
        //需求:通过while循环打印1 2 3 ... 10
        //1.定义一个变量来控制执行的次数
        int i = 1;
        while(i<=10)
            System.out.println(i);
            i++;
        
    

    private static void f1() 
        //需求:通过while循环打印10次"小可爱们中午好~"
        //1.定义一个变量用来控制执行的次数
        int count = 1;
        while(count <= 10)
            System.out.println("小可爱们中午好~");
            count++;//注意count的值需要自增,否则还是一个死循环
        
    

5.do-while循环
do-while循环一定会执行一次,然后再判断,如果符合条件,再执行后面的循环

do
		循环体
while(判断条件);

循环之间的比较

  1. 如果明确知道循环的次数/需要设置循环变量的变化情况时–使用for循环
  2. 如果想写死循环–while(true)
  3. 如果需要先执行一次,再做判断–do-while循环
  4. 循环之间是可以互相替换的,但是最好使用比较合适的循环结构

11. 方法

  1. 格式: 修饰符 返回值类型 方法名(参数列表) 方法体
  2. 如何确定我们要调用哪个方法呢?方法名+参数列表
  3. 一个方法被调用,就会执行这个方法的功能,执行完毕就返回到方法被调用的位置,在第几行调用,程序就返回到第几行继续向下执行
    如果这个方法有返回值,我们有两种选择:
    1. 选择只执行功能,不接收返回值,不再继续使用这个方法的结果
    2. 选择在方法调用的位置接收这个方法的返回值,接收到的返回值可以在方法外继续使用
  4. 方法的重载:
    在同一个类中出现多个方法名相同,但参数列表不同的方法
    注意:方法是否构成重载,取决于参数列表中参数的个数与参数的类型,与参数的名字无关
    重载的意义: 重载不是为了程序员方便,而是为了方便外界调用这个名字的方法时,不管传入什么类型的参数,都可以匹配到对应的方法来执行,程序会更加的灵活
  5. 方法的传值 : 如果方法的参数类型是基本类型,传入的是实际的字面值,如果是引用类型,传入的是地址值
    形参:形式意义上的参数,比如方法参数列表的参数名,光看参数名是无法确定这个变量的值是多少的
    实参:实际意义上的参数,比如我们的局部变量,比如成员变量,比如调用方法时传入的数字
  6. 方法的重写: 子类继承了父类以后,想要在不改变父类代码的情况下,实现功能的修改与拓展
    重写遵循的规则:两同 两小 一大
    一大: 子类方法的修饰符权限 >= 父类方法的修饰符权限
    两同: 方法名与参数列表与父类方法保持一致
    两小: 子类方法的返回值类型 <= 父类方法的返回值类型,注意:这里的<=说的是继承关系,不是值的大小
    子类方法抛出的异常类型 <= 父类方法抛出的异常类型
  7. 四种权限修饰符

    8.练习题:方法调用的顺序
package cn.tedu.basic;
/*本类用于测试方法的调用*/
public class MethodDemo 
    //1.创建程序的入口函数main()
    public static void main(String[] args) 
        System.out.println("main() start...");
        m1();
        System.out.println("main() stop...");
        int a =5;
        System.out.println(a);
    

    //2.创建m1()
    private static void m1() 
        System.out.println("m1() start...");
        m2();
        System.out.println("m1() stop...");
    
    private static void m2() 
        System.out.println("m2() start...");
    

9.拓展 : 方法的递归

12. 数组

  1. 数组的创建方式:
    静态创建 int[] a = 1,2,3,4,5;
    静态创建 int[] a = new int[]1,2,3,4,5;
    动态创建 int[] a = new int[5]; 后续可以动态的给数组中的元素赋值
    注意:不管是什么样的创建方式,都需要指定数组的类型与长度
  2. 我们可以通过数组的下标来操作数组中的元素
    数组下标从0开始,最大下标是数组的长度-1,如果访问到了不是这个数组的下标,会出现数组下标越界异常
    比如:a[5]表示的就是数组中的第6个元素
  3. 数组的长度:数组一旦创建,长度不可改变,长度指的是数组中元素的个数a.length,并且数组的长度允许为0:[ ]
  4. 数组的创建过程:
    1. 根据数组的类型与长度开辟一块连续的内存空间
    2. 对数组中的每个元素进行初始化,比如int数组的默认值就是0
    3. 生成数组唯一的一个地址值,交给应用类型变量a来保存
    4. 后续可以根据数组的下标再来操作数组中的具体元素
      注意: 数组名a这个变量,保存的是数组的地址,不是数组中的具体元素
  5. 数组的工具类Arrays
    1. toString(数组名) : 除了char类型的数组以外,其他类型的数组想要查看具体元素,需要使用本方法,否则打印的是地址值
    2. copyOf(原数组名,新数组的长度) : 用来实现数组的复制 扩容 缩容
      如果新数组的长度 > 原数组长度,就扩容,反之,则缩容,如果两者长度一致,就是普通的复制数组
      注意:一定是创建了新数组,而不是对原数组的长度做操作
  6. 数组的遍历
    一般习惯使用for循环,循环变量代表的就是数组的下标,从0开始,最大值是a.length-1
  7. 冒泡排序 :
    外层循环控制比较的轮数,所以循环变量从1到n-1轮,代表的是轮数
    内层循环控制的是这一轮中比较的次数,而且是数组中两个相邻元素的比较,所以循环变量代表的是数组的下标
    8.练习:
package cn.tedu.basic;
/*本类用于复习数组的操作*/
public class TestArray 
    public static void main(String[] args) 
        //需求1:求出数组中所有元素之和
        //f1();
        //需求2:求出数组中所有元素的最大值
        f2();
    

    private static void f2() 
        //需求2:求出数组中所有元素的最大值
        //1.定义一个数组
        int[CGBTN2111汇总复习

CGBTN2111汇总复习

CGBTN2111-DAY15总结复习

CGBTN2111-DAY15总结复习

CGBTN2111-DAY15总结复习

CGBTN2111-DAY17总结复习