CGBTN2108复习汇总

复习思路:

先抓知识结构主干，再去补充细节
先跟着老师的复习思路走，遇到会的，快速回顾
遇到忘记或者是不会的，先记录，后面自己复习的时候着重回顾

一阶段学习路径：

1 基础语法Basic

1.环境的配置

1. 安装JDK
   注意:可以安装多个JDK,我们使用的是1.8,环境变量配置哪个,哪个就生效
2. 环境变量的配置
   JAVA_HOME : 配置的是JDK安装的目录
   Path : 配置的是JDK的bin目录,不新建的
   CLASS_PATH:配置的是JDK的lib目录
3. win+R 打开 ,命令:java -version,出现版本号即为成功
4. 开发工具eclipse
5. 开发工具IDEA–设置字体大小/颜色
   注意: 安装的路径不要出现中文

2.JDK JRE JVM

JDK:Java开发工具包–开发的最小单位
JRE:Java运行时环境–运行的最小单位
JVM:Java虚拟机–负责加载并运行对应的字节码文件.class

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

3. 语法基础

1.关键字 :

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

2.标识符 :

字母 数字 下划线 美元符号组成,不能以数字开头,区分大小写,关键字+(true false null)也不可以用作标识符,见名知意

1. 类名: Upper驼峰命名:每一个单词的首字母都要大写
2. 方法名: Lower驼峰命名: 除了第一个单词以外,其他单词的首字母都要大写

3.注释 :

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

4 变量:

成员变量:类里方法外,类消失,成员变量才会消失

成员有自己的默认值,可以不手动赋值

局部变量:方法里/代码块里,当局部代码结束,局部变量也随之释放

局部变量使用的时候,必须赋值,可以:
声明的时候并且赋值 Cat cat = new Cat();
先声明再赋值 Cat cat; cat = new Cat();
注意:基本类型保存的是值,引用类型保存的是地址值

变量的就近原则:离谁近 就使用谁

1. 如果想指定本类的成员变量,使用this.变量名来指定
2. 如果想指定父类的成员变量,使用super.变量名来指定

5 八大基本类型:

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

6.字面值规则:

1. 整数类型的字面值类型是int
2. 浮点类型的字面值类型是double
3. byte short char 三种比int小的类型,可以在范围内直接赋值
4. 三种字面值后缀 : L D F
5. 三种字面值前缀: 0b-二进制 0-八进制 0x-十六进制

练习题:进制的前缀

package cn.tedu.basic;
/*本类用于测试类型的前缀*/
public class TestTypePre {
    public static void main(String[] args) {
        //10-2 10-1  10-0
        System.out.println(100);//100-10的平方
        //操作二进制-0b
        //2-2 2-1 2-0
        System.out.println(0b100);//4-2的平方
        //操作八进制
        //8-2 8-1 8-0
        System.out.println(0100);//64-8的平方
        //操作十六进制
        //16-2 16-1 16-0
        System.out.println(0x100);//256-16的平方
    }
}

7.运算规则:

1. 运算结果的数据类型与参与运算的最大类型保持一致 int+int->int double/int->double
2. 整数运算会出现溢出的现象,一旦溢出,数据就不正确了(光年案例)
3. byte short char三种比int小的类型,运算的时候需要先自动提升int类型,再参与运算
4. 浮点数的特殊值:Infinity NaN
5. 浮点数运算不精确的问题

8.类型转换

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

1. 注意:布尔类型不参与类型转换
2. 注意:基本类型之间能否转换,不取决于字节数,字节数只能做参考,取决于类型的取值范围
3. 注意:我们这里所说的是基本类型之间的转换,引用类型之间的转换取决于是否有继承关系
   比如:你可以说小猫是小动物,但是不能说小猫是小汽车,不然后面的这种错误的情况会报:类型转换异常
   

练习题:类型之间的转换与字面值规则

package cn.tedu.basic;
/*本类用来测试类型转换
* 1.byte1--short char2--int4--long8--float4--double8
* 2.小到大 直接转:隐式转换,可以直接转换
*   大到小 强制转:显式转换,需要强转,注意发生数据溢出的问题
*   浮变整 小数没:小数部分直接被舍弃
* 3.强制类型转换的格式:目标类型 变量名 = (目标类型)要转换类型的数据;
* */
public class TestTypeChage {
    public static void main(String[] args) {
        byte a = 10;
        short b = a;//不会报错,小转大

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

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

        long g = 8274624867L;
        float h = g;//不会报错,小转大
        System.out.println(h);

        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);//需要强制类型转换

        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.435F;
        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. < >= <=

   3. == 比较的是左右两边的值是否相等 !=比较的是左右两边的值是否不相等

练习题:==比较的练习

    package cn.tedu.basic;

public class TestOperator {
    public static void main(String[] args) {
        //引用类型Cat类型的变量c1 c2 保存的是对象的地址值
        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(b1 == b2);//true
        System.out.println(f1 == f2);//true

        /* == 如果比较的是引用类型,比较的也是值,地址值*/
        System.out.println(c1 == c2);//false
        System.out.println(a1 == a2);//false
    }
}

class Cat {
    String name;
    int age;

    public void bark() {
        System.out.println("小猫喜欢喵喵叫");
    }
}

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

10.流程控制

1.顺序结构

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

2.分支结构

1. 单分支结构

if(判断条件){
            如果判断条件的结果为true,就执行此处代码,不符合条件,此处跳过
 }

2. 多分支结构

if(判断条件){
    如果判断条件的结果为true,就执行此处的代码
}else{
    如果不符合条件,执行else处的代码
}

3. 嵌套分支结构

if(判断条件1){
    符合判断条件1,执行此处代码,不符合,继续向下判断
}else if(判断条件2){
    符合判断条件2,执行此处代码,不符合,继续向下判断
}else if(判断条件3){
    符合判断条件3,执行此处代码,不符合,继续向下判断
}else{
    保底选项,以上条件均不符合的情况下,执行此处代码
}

练习题:嵌套分支的练习

需求:提示并接收用户输入的月份,判断并输出属于哪个季节
1-12月是合法数据 3~5春天 6~8夏天 9~11秋天 其他情况冬天

 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后的语句只有一句,大括号可以省略不写*/
        /*return关键字除了可以帮我们返回方法的返回值以外
        * 还可以直接结束当前的方法,如果遇到了return,本方法会直接结束*/
//        if(month <0 || month >12) return;
//        System.out.println("今天天气真不错");//这句话是用来检测main()有没有结束
        if(month <= 0 || month >12){
            System.out.println("您输入的月份不正确!应该是1-12月以内");
        }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
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:保底选项;//可选
        }

练习题:根据颜色推荐菜品switch

package cn.tedu.basic;

import java.util.Scanner;

/*本类用于复习switch*/
public class TestSwitch {
    public static void main(String[] args) {
        //需求:接收用户今天输入的颜色,推荐菜品
        //1.提示并接收用户输入的颜色
        System.out.println("请输入您今天心情的颜色:");
        String color = new Scanner(System.in).nextLine();
        //2.完成选择结构
        switch (color) {
            case "红":
                System.out.println("红烧鱼");
                break;//为了避免穿透
            case "黄":
                System.out.println("菠萝炒饭");
                break;
            case "橙":
                System.out.println("水煮肉片");
                break;
            default:
                System.out.println("哎呀,没有识别到这个功能呢,正在开发中...");
        }
    }
}

4.循环结构

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

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

注意:我们定义的循环变量,用来控制循环,循环变量可以取到几个值,循环就执行几次
所以开始条件只会执行一次
注意:从哪开始 到哪结束 如何变化

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

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

2.while循环

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

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

练习题:while循环练习

package cn.tedu.basic;

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

    private static void f1() {
        //需求1:通过while循环打印10次"小可爱们中午好~"
        //1.定义一个变量用来控制次数
        int count = 1;
        //2.定义一个循环,结束条件是count>10
        while (count <= 10) {
            System.out.println("小可爱们中午好~");
            count++;//注意count的值需要自增,不然就是一个死循环
        }
        System.out.println(count);//11
    }

    private static void f2() {
        //需求2:通过while循环打印1 2 3 ... 10
        int i = 1;
        while (i <= 10) {
            System.out.println(i);
            i++;
        }
    }

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

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

    private static void f5() {
        //需求5:通过while计算:2+4+6+8...+100
        int i = 2;//循环变量控制循环
        int sum = 0;//用来保存求和的结果
        while(i <= 100){
            sum += i;//累加
            i += 2;//循环变量递增
        }
        System.out.println("2到100累加的结果为:"+sum);
    }
}

3.do-while循环

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

11. 方法

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

练习题:方法调用的顺序

package cn.tedu.basic;
/*本类用于练习方法的调用*/
public class MethodDemo {
    //1.创建入口函数
    public static void main(String[] args) {
        System.out.println("main() is start...");
        m1();
        System.out.println("main() is stop...");
    }

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

}

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轮,代表的是轮数
   内层循环控制的是这一轮中比较的次数,而且是数组中两个相邻元素的比较,所以循环变量代表的是数组的下标

练习题: 数组练习1

需求1: 求数组中所有元素之和
需求2: 求数组中所有元素的最大值

package cn.tedu.basic;

/*本类用于复习数组的操作*/
public class TestArray1 {
    public static void main(String[] args) {
        //需求1:求出数组中所有的元素之和
        f1();
        //需求2:求出数组中所有元素的最大值
        f2();
    }

    private static void f2() {
        //需求2:求出数组中所有元素的最大值
        //1.定义一个数组
        int[] a = {45, 8, 90, 34, 65, -9};
        //2.定义一个变量,用来存储结果,也就是数组中所有元素的最大值
        int max = a[0];//这个位置不能写0,应该是数组中第一个元素的值
        //3.遍历数组,比较出最大值
        for (int i = 0; i <= a.length - 1; i++) {
            //4.判断max与a[i]的大小
            if(a[i] > max){
                max = a[i];//让max保存的一直都是目前遍历到的最大值
            }
        }
        //4.循环结束,输出数组中的最大值
        System.out.println("最大值为:"+max);
    }

    private static void f1() {
        //需求1:求出数组中所有的元素之和
        //1.定义一个数组
        int[] a = {1, 2, 3, 4, 5};
        //2.定义一个变量用来保存最终的结果
        int sum = 0;
        //3.用数组的遍历来进行数据的累加
        //i:下标 0 a.length-1 ++
        for (int i = 0; i <= a.length - 1; i++) {
            sum += a[i];
        }
        System.out.println("数组元素累计的和为:" + sum);
    }
}

练习题: 数组练习2

需求: 将数组中的所有元素逆序输出(3种)
package cn.tedu.basic;

import java.util.Arrays;

/*需求: 将数组中的所有元素逆序输出(3种)*/
public class TestArray2 {
    public static void main(String[] args) {
        //f1();//实现思路1
        //f2();//实现思路2
        f3();//实现思路3
    }

    private static void f3() {
        //1.准备原数组
        int[] a = {100, 200, 300, 400, 500, 600};
        //2.遍历数组,将数组中对应位置上的元素交换位置
        for (int i = 0; i < a.length / 2; i++) {
            //3.准备一个第三方变量协助数组中的两个元素互换值
            //a[0] <-> a[a.length-1-0]
            //a[1] <-> a[a.length-1-1]
            //a[2] <-> a[a.length-1-2]
            //a[i] <-> a[a.length-1-i]
            int temp = a[i];
            a[i] = a[a.length-1-i];
            a[a.length-1-i] = temp;
        }
        System.out.println(Arrays.toString(a));
    }

    private static void f2() {
        //1.准备原数组
        int[] a = {10, 20, 30, 40, 50};
        //2.准备一个新数组,数组的长度与原数组长度相同
        int[] b = new int[a.length];
        //3.准备循环,遍历原数组,并将遍历到的元素复制到新数组中
        //i=0,a[0]->b[4]
        //i=1,a[1]->b[3]
        //i=2,a[2]->b[2]
        //i=3,a[3]->b[1]
        //i=4,a[4]->b[0]
        for (int i = 0; i < a.length; i++) {
            b[b.length - 1 - i] = a[i];
        }
        System.out.println(Arrays.toString(b));
        a = b;//把b保存的地址值交给a,这样a b两个引用类型变量保存的是同一个数组的地址值
        System.out.println(Arrays.toString(a));
    }

    private static void f1() {
        //1.准备数组
        int[] a = {1, 2, 3, 4, 5};
        //2.倒着输出
        //i:下标 从哪开始a.length-1  到哪结束0  如何变化--
        for (int i = a.length - 1; i >= 0; i--) {
            //3.把当前遍历到的元素输出
            System.out.println(a[i]);
        }
    }
}

2面向对象OOP