第一周复习总结

第一周复习总结：

第一周复习总结：

# 一、JAVA的标识符

# 二、数据类型 

# 三、类型转换

 #四、规则

#五、运算符

# 六、循环之间的区别

#七、成员变量和局部变量

#八、数组

1.创建方式：

2.数组的创建过程：

3.数组的工具类Arrays

#九、方法重载

#十、构造函数

#十一、方法的重载

#十二、构造代码块，局部代码块

#十三、继承

#十四、继承中的构造方法

#十五、继承中变量和继承中构造方法的使用

#十六、方法的重写

#十七、静态

#十八、静态代码块static{}

#十九、final 关键字

#二十、面向对象之多态

#二十一、抽象

抽象类

抽象方法

#二十二、异常

2.异常的解决方案

1. 捕获处理try-catch–自己解决

2.向上抛出throws–交给别人解决

---

# 一、JAVA的标识符

1.有字母，数字，下划线，美元符号组成
2.不能以数字开头
3.严格区分大小写
4.见名知意
5.不能使用关键字

# 二、数据类型 

类型	默认值	类型名称	字节空间
整数型	0	byte	1字节
	0	short	2字节
	0	int	4字节
	0L	long	8字节
浮点型	0.0F	float	4字节
	0.0D	double	8字节
字符型	’\u0000'  unll	char	2字节
布尔类型	false	boolean	1字节

# 三、类型转换

1.小转大   直接转型 -->  隐式转型

2.大转小   强制转型 -->  显示转型     Byte byte = (byte)a;

3.布尔类型不参与转型

4.浮点数转整数，舍弃小数部分，四舍五入

 #四、规则

1.小数默认位Double类型

2.整数默认为int类型

3.long double float 赋值后尽量跟 L D F

4.浮点数的特殊值 Infinity NaN

5.浮点数运算不精确

#五、运算符

1.普通运算符：+-*/

2.取余：%

3.自增自减：++ --

4.比较运算符：!= == > < >= <= 比较的结果都是布尔类型的

5.逻辑运算符：
&&：双与/短路与：逻辑与单与相同，全真才真，只不过增加了短路的效果
||：双或/短路或：逻辑与单或相同，全假才假，只不过增加了短路的效果

6.三目运算符：1 ？2 ：3；1是表达式，若1真，取2，若1假取3

7.赋值运算符：
= ：是普通的赋值运算符，等号右边的值交给等号左边的变量来保存
复合赋值运算符：+= -= *= /=,主要是可以简写&类型的自动转换
sum += 30; 等效于 sum = sum+30;

# 六、循环之间的区别

for：知道循环次数
while/do while：当循环次数不确定时
while：先判断，不符合规则，不执行代码
do while：代码最少被执行一次，再去判断，符合规则，再次执行代码
循环之间都可以互相替代,但是一般最好选择合适的循环结构来完成代码哦~

#七、成员变量和局部变量

成员变量：

1.所在位置：类里方法外

2.注意：成员变量有自己的默认值，不需要手动赋值

3.范围：在整个类中都生效，类消失，成员变量才会随之释放

局部变量：

1.所在位置：在方法里 / 局部代码块里

2.注意：使用时必须赋值，进行初始化

3.范围：在方法里/局部代码块中，对应的代码执行完毕，局部变量也随之释放

#八、数组

1.创建方式：

静态创建：int[] a = {1,2,3,4,5};
                  int[] a = new int[]{1,2,3,4,5};

动态创建：int[] a = new int[5];

2.数组的创建过程：

2.1在内存中开辟连续的空间,用来存放数据

2.2给数组完成初始化过程,给每个元素赋予默认值

2.3数组完成初始化会分配一个唯一的地址值

2.4把唯一的地址值交给引用类型的变量a去保存

2.5如果想要操作数组中的元素，可以根据变量保存的地址找到数组，然后根据下标来操作数组的具体元素
数组名保存的是数组的地址值，不是数组中每一个具体的元素，数组名是一个引用类型的变量

3.数组的工具类Arrays

3.1toString除了char类型以外，其他类型的数组想要查看数组的具体元素，都得使用这个方法，如果不用，打印是数组的地址值

3.2sort(数组名)，给数组进行排序

3.3copyOf(要复制的数组，新数组的长度)
如果新的长度大于原数组的长度–数组的扩容
如果新的长度小于原数组的长度–数组的缩容
如果新的长度等于原数组的长度–普通的复制
注意：不管是什么长度，都不是修改原数组，而是创建新数组

#九、方法重载

1. 我们根据方法名+参数列表确定具体调用哪个方法

2. 方法的重载:在同一个类中,存在方法名相同,但参数列表不同的方法

3. 如果在同类中,同名方法的参数个数不同,一定构成重载

4. 如果在同类中,同名方法的参数个数相同,需要查看对应位置上参数的类型,而不是参数名,与参数名无关

#十、构造函数

格式：与本类类名同名，且没有返回值类型

作用：创建对象

执行时机：每次创建对象时都会执行构造方法

#十一、方法的重载

在同一个类中，存在多个方法名相同，但参数列表不同的方法
如果在同类中，多个同名方法的参数个数不同，一定构成重载
如果在同类中，多个同名方法的参数个数相同：需要查看对应位置上的参数的类型，而不是参数名，与参数名无关
如：(int a ,String b)与(int b,String a)–不构成重载
(int a,String b)与(String a,int b)–构成–构成重载

#十二、构造代码块，局部代码块

构造代码块：

位置：类里方法外

执行时机：每次创建对象时执行，并且优先于构造方法执行

作用：用于提取所有构造方法的共性功能

局部代码块：

位置：方法里

执行时机：调用本局部代码块所处的方法时执行

作用：用于控制变量的作用范围

执行顺序:构造代码块->构造方法->普通方法->局部代码块

#十三、继承

1. 继承的关键字extends 格式： 子类 extends 父类
2. 继承相当于子类把父类的功能复制了一份
3. Java只支持单继承：一个子类只能有一个父类，一个父类可以有多个子类
4. 继承具有传递性：爷爷的功能会传给爸爸，爸爸的功能会传给孙子
5. 子类只可以使用父类的非私有资源，私有资源由于private限制,不可用
6. 子类可以拥有自己的特有功能
7. 继承是is a 强耦合的关系，依赖性非常强，比如我们看到”熊孩子”，就知道他有一个”熊父母”

#十四、继承中的构造方法

1.子类在创建对象时,默认会先调用父类的构造方法
2.原因是子类构造函数中的第1行默认存在super();–表示调用父类的无参构造
3.当父类没有无参构造时,可以通过super(参数);调用父类的其他含参构造
注意:子类必须调用父类的一个构造函数,不论是无参还是含参,选一个即可
4.构造方法不可以被继承!因为语法的原因,要求构造方法的名字必须是本类类名
不能在子类中出现一个父类名字的构造方法

#十五、继承中变量和继承中构造方法的使用

变量：父类成员变量与子类成员变量同名时，使用super.变量名指定父类的成员变量

构造方法：

1. 创建子类对象时，会先调用父类的无参构造，因为子类的构造函数中默认存在一个super();
2. 如果父类没有无参构造的话，我们就需要手动指定子类去调用父类的含参构造super(参数)；
3. 构造方法不可以被继承，原因是：构造方法名必须是本类的类名，不可能在子类中存在一个父类名字的构造方法

#十六、方法的重写

重写：子类对父类的方法不满意时，可以重写父类的方法
注意：重写是在不改变父类方法的前提下，实现功能的修改，重写后子类对象调用的就是重写后的功能
原则：两同 两小 一大
两同：方法名+参数列表相同
一大：子类方法的修饰符权限 >= 父类方法的修饰符权限
两小：子类方法的返回值类型，有两种选择：
1）子类方法的返回值类型与父类方法的返回值类型相同
2）子类方法的返回值类型是父类方法的返回值类型的子类
比如：父：void 子：void
父：int 子：int 但是：byte short long都不行！没有继承关系
父：Animal 子：Animal/Cat都可以，但不可以是Car
注意:我们还可以给方法上加@Override注解，标记这是一个重写的方法

#十七、静态

static可以修饰成员变量和方法
2.被static修饰的资源称为静态资源
3.静态资源随着类的加载而加载，最先加载，优先于对象进行加载
4.静态资源可以通过类名直接调用，也被称作类资源
5.静态被全局所有对象共享，值只有一份
6.静态资源只能调用静态资源
7.静态区域内不允许使用this与super关键字,因为this代表本类对象,super代表父类对象,有静态时还没有对象呢~

8.可以被重写

#十八、静态代码块static{}

格式：static{ }
位置：类里方法外
执行时机：随着类的加载而加载，优先于对象进行加载【只加载一次】
作用：用于加载那些需要第一时间就加载，并且只加载一次的资源，常用来初始化
顺序：静态代码块 构造代码块 构造方法 普通方法【如果普通方法里有局部代码块，执行局部代码块】
TIPS: 如果有多个静态资源，加载顺序取决于先后位置
TIPS: 静态不可以与this和super共用

#十九、final 关键字

1. 修饰类：最终类，不可以被继承
2. 修饰方法：这个方法的最终实现，不可以被重写
3. 修饰常量：值不可以被更改，并且常量定义时必须赋值
   注意：常量的定义需要使用全大写，单词之间使用下划线分隔

#二十、面向对象之多态

1. 前提：继承+重写

2. 口诀1：父类引用指向子类对象

解释：父类类型的引用类型变量保存的是子类类型的对象的地址值

3. 口诀2：编译看左边，运行看右边

解释：编译时要看父类是否定义了这个资源，运行时使用的是子类的功能

4. 资源使用情况

1. 成员变量使用的是父类的
2. 成员方法使用的是父类的方法定义，子类的方法体
3. 如果多态对象调用的是子类没有重写过的方法，方法定义与方法体使用的都是父类的，所以这个不符合多态的前提，直接使用纯纯的父类对象调用即可
4. 静态资源属于类资源，随着类的加载而加载，只会加载一次，优先于对象进行加载，可以通过类名直接调用，被全局所有对象共享，所以静态不存在重写的现象，在哪个类定义，就属于哪个类的资源
5. 我们现在学习的多态，把自己看作是父类类型，参考“花木兰替父从军”

#二十一、抽象

抽象类

1. 被abstract修饰的方法是抽象方法,抽象方法没有方法体
2. 一旦一个类中有抽象方法,这个类必须被声明成抽象类
3. 如果一个子类继承了一个抽象父类,有两种解决方案:                                                                        1)抽象子类:不实现/实现一部分抽象父类中的抽象方法                                                              2)普通子类:实现抽象父类中全部的抽象方法
4. 抽象类不能实例化
5. 抽象类有构造函数的,但是不是为了自己使用,为了子类super()调用
6. 抽象类可以定义成员变量/成员常量
7. 抽象类中可以定义全普/全抽/半普半抽
8. 如果一个类不想被外界实例化,可以把这个类声明成抽象类
9. abstract关键字不可以与private static final共用

抽象方法

1. 被关键字abstract 修饰的方法就是抽象方法
2. 抽象方法没有方法体{ }，直接以分号结束

#二十二、异常

1. 异常的继承结构

        异常层次结构中的根是Throwable
        Error：目前我们编码解决不了的问题
        Exception:异常
        编译异常：未运行代码就报错了，强制要求处理
        运行时异常：运行代码才报错，可以通过编译，不强制要求处理

2.异常的解决方案

1. 捕获处理try-catch–自己解决

异常捕获处理的格式：

 try{
   可能会抛出异常的代码
 }catch(异常的类型 异常的名字){
    万一捕获到了异常，进行处理的解决方案
 }

try-catch结构可以嵌套，如果有多种异常类型需要特殊处理的话
使用多态的思想，不论是什么子异常，统一看作父类型Exception
做出更加通用的解决方案，甚至可以只写这一个

2.向上抛出throws–交给别人解决

异常抛出的格式：
在方法的小括号与大括号之间，写：throws 异常类型
如果有多个异常，使用逗号分隔即可

private static void method3() throws ArithmeticException,InputMismatchException,Exception{ }

private static void method3() throws Exception{ }

如果一个方法抛出了异常，那么谁来调用这个方法，谁就需要处理这个异常，这里的处理也有两种方案：捕获解决 或者 继续向上抛出
不能直接把异常抛给main(),因为调用main()是JVM，没人解决了，该报错还报错，所以我们一般会在main()调用之前将异常解决掉