CGBTN2109汇总复习
Posted 程序媛 泡泡
tags:
篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了CGBTN2109汇总复习相关的知识,希望对你有一定的参考价值。
CGBTN2109汇总复习
复习思路
先抓知识结构主干,再去慢慢补充细节拓展
遇到会的,快速回顾
遇到忘记或者是不会的,先记录,后面自己复习的时候着重回顾
一阶段学习路径
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字节码文件
- 运行过程: 我们编写的源码是.java为后缀的,通过编译生成的是.class字节码文件,交给JVM来执行
- 跨平台: 只要在不同的操作系统上安装对应的JVM,就可以实现跨平台:一份代码 处处运行
2.语法基础
1.关键字
50个全小写的单词,在Java有特殊的意义,还包含2个保留字const goto
2.标识符
字母 数字 下划线 美元符号组成,不能以数字开头,区分大小写,关键字+(true false null)也不可以用作标识符,见名知意
UpperCamelCase大驼峰命名:
每个单词的首字母都要大写,比如类名:HelloWorld类名: Upper驼峰命名:每一个单词的首字母都要大写
LowerCamelCase小驼峰命名:
从第二个单词的首字母才开始大写,比如:方法名:nextLine() 变量名:deptName
3.注释
单行注释 //
多行注释 / * * /
文档注释: /** */
还可以添加一些额外的信息:作者 时间 版本 参数 返回值类型
注释可以注释内容,被注释的内容不执行,所以我们可以利用注释手段对进行分段代码测试
4.变量
- 成员变量:类里方法外,类消失,成员变量才会消失
成员有自己的默认值,可以不手动赋值 - 局部变量:方法里/代码块里,当局部代码结束,局部变量也随之释放
- 局部变量使用的时候,必须赋值,可以:
声明的时候并且赋值 Cat cat = new Cat();
先声明再赋值 Cat cat; cat = new Cat();
注意:基本类型保存的是值,引用类型保存的是地址值
- 变量的就近原则:离谁近 就使用谁
- 如果想指定本类的成员变量,使用this.变量名来指定
- 如果想指定父类的成员变量,使用super.变量名来指定
5.八大基本类型
Java的数据类型分为两类:基本类型 + 引用类型
6.字面值规则:
- 整数类型的字面值类型是int
- 浮点类型的字面值类型是double
- byte short char 三种比int小的类型,可以在范围内直接赋值
- 三种字面值后缀 : L D F
- 三种字面值前缀: 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.运算规则:
- 运算结果的数据类型与参与运算的最大类型保持一致 int+int->int double/int->double
- 整数运算会出现溢出的现象,一旦溢出,数据就不正确了(光年案例)
- byte short char三种比int小的类型,运算的时候需要先自动提升int类型,再参与运算
- 浮点数的特殊值:Infinity NaN
- 浮点数运算不精确的问题:解决方案:BigDecimal
注意1:不能使用double类型参数的构造方法,需要使用String类型的构造函数,否则还会出现不精确的问题
注意2:除法运算时,如果出现除不尽的现象还会报错,所以需要指定保留位数与舍入方式(四舍五入)
8.类型转换
口诀:小转大,直接转 大转小,强制转 浮变整,小数没
- 注意:布尔类型不参与类型转换
- 注意:基本类型之间能否转换,不取决于字节数,字节数只能做参考,取决于类型的取值范围
- 注意:我们这里所说的是基本类型之间的转换,引用类型之间的转换取决于是否有继承关系
比如:你可以说小猫是小动物,但是不能说小猫是小汽车,不然后面的这种错误的情况会报:类型转换异常
- 练习题:类型之间的转换与字面值规则
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.运算符
- 普通的四则运算符 + - * / ,普通的四则运算,并不能直接改变变量本身的值,除非 i = i*10+8
- 取余 % 6%4=2 6%3=0(余数为0表示整除)
- 自增自减运算符
1)可以改变变量本身的值
2)前缀式: 符号在前,先改变变量本身的值(+1/-1),再使用(打印/参与运算…)
3)后缀式: 符号在后,先使用(打印/参与运算…),再改变变量本身的值(+1/-1)
4)注意:不管是前缀式还是后缀式,一定是会改变变量本身的值,区别在于执行的时机不同 - 比较运算符
- 比较运算符最终的结果是布尔类型的
- == 比较的是左右两边的值是否相等 !=比较的是左右两边的值是否不相等
- 练习题:==比较的练习
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("小猫喜欢喵喵叫");
}
}
- 逻辑运算符
双与/短路与/&& :
判断逻辑与&一致,增加了短路的功能全真才真,有假则假
双或/短路或/|| :
判断逻辑与|一致,增加了短路的功能全假才假,有真则真
注意:我们这里所说的短路,是指在某些情况下,表达式后半部分就不用计算了,因为我们已经知道了结果,也就是被短路了,短路可以提高程序的性能,但是短路不一定会用到 - 三目运算符: 1 ? 2 : 3; 1是表达式,1真取2,1假取3
- 复合赋值运算符:+= -= *= /=是一种简写的形式,比较方便,运算时会自动进行类型转换
- 赋值运算符: = ,右边给左边
- 拼接功能:+
- 位运算符 : 主要参与的是二进制的运算
&与:全真才真
| 或:全假才假
^异或:相同为0 不同为1
~ 非: 非0为1,非1为0 - 优先级控制:如果表达式的运算比较复杂,需要控制优先级,可以使用小括号
- 拓展:instanceof
10.流程控制
1.顺序结构
顺序结构中的代码会按照顺序一行一行向下执行所有的代码语句,可以用来进行输入 输出 计算等的操作
但顺序结构不可以完成先做判断,再做选择的流程
2.分支结构
- 单分支结构
if(判断条件){
如果判断条件的结果为true,就执行此处代码,不符合条件,此处跳过
}
- 多分支结构
if(判断条件){
如果判断条件的结果为true,就执行此处的代码
}else{
如果不符合条件,执行else处的代码
}
- 嵌套分支结构
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 <1 || 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.选择结构
- 小括号中变量支持的类型:
byte short char int String enum 与4个基本类型对应的包装类 - 注意: 如果配置了default默认选项,而且没有任何的case被匹配到,就会执行default这个“保底选项”
- case的个数 是否加break 是否加default全部都是可选的,根据自己的具体业务做决定
- 小括号中变量的类型必须与case后value的类型一致
- 执行顺序:先拿着变量的值,依次与每个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(开始条件;循环条件;更改条件){
如果符合循环条件,就会执行循环体里的内容
}
注意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) {
//需求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);
}
}
5.do-while循环
do-while循环一定会执行一次,然后再判断,如果符合条件,再执行后面的循环
do{
循环体
}while(判断条件);
循环之间的比较
- 如果明确知道循环的次数/需要设置循环变量的变化情况时–使用for循环
- 如果想写死循环–while(true){}
- 如果需要先执行一次,再做判断–do-while循环
- 循环之间是可以互相替换的,但是最好使用比较合适的循环结构
11. 方法
- 格式: 修饰符 返回值类型 方法名(参数列表){ 方法体 }
- 如何确定我们要调用哪个方法呢?方法名+参数列表
- 一个方法被调用,就会执行这个方法的功能,执行完毕就返回到方法被调用的位置,在第几行调用,程序就返回到第几行继续向下执行
如果这个方法有返回值,我们有两种选择:- 选择只执行功能,不接收返回值,不再继续使用这个方法的结果
- 选择在方法调用的位置接收这个方法的返回值,接收到的返回值可以在方法外继续使用
- 方法的重载:
在同一个类中出现多个方法名相同,但参数列表不同的方法
注意:方法是否构成重载,取决于参数列表中参数的个数与参数的类型,与参数的名字无关
重载的意义: 重载不是为了程序员方便,而是为了方便外界调用这个名字的方法时,不管传入什么类型的参数,都可以匹配到对应的方法来执行,程序会更加的灵活 - 方法的传值 : 如果方法的参数类型是基本类型,传入的是实际的字面值,如果是引用类型,传入的是地址值
形参:形式意义上的参数,比如方法参数列表的参数名,光看参数名是无法确定这个变量的值是多少的
实参:实际意义上的参数,比如我们的局部变量,比如成员变量,比如调用方法时传入的数字 - 方法的重写: 子类继承了父类以后,想要在不改变父类代码的情况下,实现功能的修改与拓展
重写遵循的规则:两同 两小 一大
一大: 子类方法的修饰符权限 >= 父类方法的修饰符权限
两同: 方法名与参数列表与父类方法保持一致
两小: 子类方法的返回值类型 <= 父类方法的返回值类型,注意:这里的<=说的是继承关系,不是值的大小
子类方法抛出的异常类型 <= 父类方法抛出的异常类型 - 四种权限修饰符
8.练习题:方法调用的顺序
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...");
以上是关于CGBTN2109汇总复习的主要内容,如果未能解决你的问题,请参考以下文章