java期末复习笔记

课程大纲

说实话，看到底也不知道这东西能考什么，所以把笔记总体整理了一下。内容为万金油内容，可以理会。
课程大纲也是本文的全部目录，查看时请看是否和你书的大纲一样，这里只放大部分考试知识点，想要入门java的仅供参考。内容参考老师的上课笔记，自己加以整理和补充
首先记住一点，继承，接口的实现要记得，然后各种类的框架要记得

java开发入门

java发展历程（可能）

1.java语言诞生于20世纪90年代
2.前身是SUN公司开发的用于智能化家电的名为Oak(橡树)的语言，基础是c和c++（91年开始研发）
3.1993年，WWW(网页)的发展，Oak语言创建动态网页，改名为java
4.1995年，Java被定位于网络应用的程序设计语言

java特点（可能）

（1）简单易学。
（2）面向对象。是一种以对象为中心，以消息为驱动的面向对象的编程语言。
（3）平台无关性
（4）分布式
（5）可靠性
（6）安全性
（7）多线程
（8）支持网络编程
（9）编译和解释并存
注：此对象非彼对象，其是物体的抽象存在就像你想找一个什么样的对象，其在你脑中只是一个抽象概念，当你遇到一个和你想得一样的时候其抽象概念就变成了实体概念。java的大概编程思想就是这样

java版本（可能）

（1）java SE（java platform Standard Edition),以前称为J2S3,java平台标准版，主要用于桌面应用软件的编程
（2）java ME （java Platform Micro Edition),以前称为 J2M3,精简版，应用于嵌入式系统的开发，如手机和PDA编程
（3）java EE (java Platform Enterprise Editon),以前称为J2EE，企业版，功能最为强大，用于分布式的网络程序的开发

java运行过程

源文件–编译–>字节码文件—>运行
注:java程序是先编译后运行的，是一门强解释语言。python是边编译边执行的，是一门弱解释语言。(这里有点忘记概念了，但注意差别就好)

java类结构（注意编程题）

首先是最简单的一条，一个java源程序可以有很多类，但只能有一个公共类即public class，其次公共类的类名要和源程序的命名保持一致。
接着是java的程序框架，我们可能在我们的开发环境中不会在意程序框架，但是在考试中我们是要用的，所以请大家牢记下边的内容

public class HelloWorld{                    ---------类名
       public static void main(String[] args){    ----入口函数

       }
}

其次加上记事本创建文件的流程：
1。编辑源程序，编辑完成后注意更改文件的后缀名
2.用javc 文件名的方式去编译文件
3.用java 类名 的方式去运行程序
这里以helloWorld.java为例

javac helloWorld.java //编译
java helloWorld //执行

注：java程序是严格区分大小写和中英文富豪的

java环境的配置

详细请参考:https://blog.csdn.net/DypBellwether/article/details/117885831?spm=1001.2014.3001.5501
也是自己写的博客，开的比较清晰

java编程基础（选择填空）

注释

注释是每门编程语言中都用，java提供了三种注释

1. 单行注释 // 注释内容
2. 多行注释 /* 注释内容 */
3. 文档注释 /** 注释内容 */

数据类型（注意理论题）

基础数据类型

整型(byte,short,int,long)
浮点型(float,double)
布尔型(boolean)
字符类型(char,String)

引用数据类型

类（class)、数组、字符串、接口（interface)

数组的创建

数组创建有三种方式：

数据类型[] 数组名 = new 数据类型[空间大小]
int[] a=new int;
int a[] = new int;
int a ={};

标识符

标识符是赋给类，方法或变量等的名字，规则如下：
以字母大小写，下划线，美元符号开始的一个字符序列
除开始的第一个字符外，后可跟字母，数字，下划线，美元符号
标识符区分大小写
没有长度限制

变量

变量名不要使用关键字（public static void main if while for),但是可以包含关键字 static
变量名定义：

//数据类型 变量名
int a;

类型转换（注意理论题）

自动转换

负值时：类型自动兼容，目标大
表达是运算是，从高到底转换
及类型字节小的数据很自动转换为大类型
就比如小桶里的水放进到大的桶里边，发生异常的可能很小

强制转换

转换格式

(数据类型)变量
long a =1000;
int b = (int)a

子类父类转换

父类转化为子类强制转换
子类转化为父类子佛那个转换

变量作用范围（注意理论题）

变量的作用范围仅存在与在被定义的打括号中
超出范围不能使用

流程控制（编程必出）

流程控制也等于选择分支或者循环，就是我们在程序运行的过程需要做出选择或者是需要做重复操作时使用

顺序和分支结构

顺序结构

复合语句：大括号括起来多条语句，视为一个整体，也称为语句块
依次执行复合语句就被称为顺序控制
注意：java不允许两个嵌套的复合语句中声明同名的变量

分支结构

选择语句的典型是if和switch
if是满足条件执行代码块，不满足则跳过此部分

//第一种方式单选择
if(条件表达式){
	执行语句;
}
//单选择第二种
if(条件表达式){
	执行语句;
}else{
	语句;//一般输出提示条件未筛选出或不符合条件
}
//第二种多选择分支
if(条件表达式){
	执行语句;
}else if(条件表达式){
	执行语句;
}

switch是和java的多分支类似(这里但只概念，不带语法格式),此表达式可以是我们选出的结果，每一个case是一种结果。default我们没找到结果所输出的，每一个case中都要有break语句

switch(表达式）{
	case 常量表达式1:
		语句序列1；
		break;
	case 常量表达式2：
		语句序列2；
		break;
	...
	default:
		语句序列n;
}

项目命名
公司开发 com.公司名.项目名.模块名
个人开发
indi.姓名缩写.项目名.模块名 ----个人项目，多人完成
pers.姓名缩写.项目名.模块名 ----个人项目，独立完成，代码可公开
priv.姓名缩写.项目名.模块名 ----个人项目,独立完成，代码不公开

循环结构

循环结构即多次执行循环体中的代码，循环结构有for，while和do-while
for循环结构

for (表达式1；表达式2;表达式3){
    循环体语句；
}

表达式1通常是对变量赋初值的工作，可以多个，用逗号连接,只执行一次
表达式2通常是一个条件判断，得到的结果或者为true，或者为false,如果为true，则执行循环体,如果为false，退出循环
表达式3通常是对循环控制变量的修改，使得表达式2趋于false，从而退出循环
执行顺序：先执行表达式1对变量赋初值，然后判断表达式2，决定是否循环，接着执行表达式3，修改循环控制变量，使得表达式2趋于false，从而结束循环

注意：
1）表达式1可以省略，但分号不能省略，则在for循环结构之前要先赋初值
2）表达式2可以省略，在循环体中要有判断条件，分号不能省略
3）表达式3可以省略，如果省略，在循环体中要控制循环变量变化

while循环

while (条件){
    循环体;
}

注意：
1)条件表达式可以恒为真，循环体中应该有结束循环的判断（例如if），以此结束循环
2）注意条件表达式后面的括号后不要出现";"

do-while循环

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

适合循环输入，直到满足某个条件，退出循环
注意：
1）条件表达式后面的括号后要出现";"
2）不论条件表达式结果是否为真，循环体至少执行一次
其次我们也可以通过方法来解决部分循环问题，下面介绍方法，至于方法解决循环问题，后续在加

方法

方法算是一个独立的代码块。主要解决代码复用问题
代码复用;即相同的代码多次重复使用，我们为了解决这一问题从而衍生出来的方法
方法体结构：

返回类型  方法名（形参列表）{
    方法体;
    [return ]
}
//以两数和为例，这里我们不要返回值，即直接输出
void int sum(int a,int b){
	System.out.println(a+b);
}

[修饰符]  返回值类型  函数名（形参）{
	函数体;
}
//这个与上个有所不同，这个在方法调用是需要定义变量去接收返回值
static int sum(int a,int b){
	renturn a+b;
}

java中调用方法，通常采用“对象名.方法名(实参)”的形式调用
如果main调用其他的方法，其他方法也定义为static修饰的
实参的个数，类型和顺序都必须和形参一致
java中函数传递参数，默认的也是值传递
这里引入一个小问题–方法重载
两同一不同：同一个类中，相同的方法名不同的参数（参数的个数不同，参数的类型不同，参数顺序不同）
那我们上边的例子，如果我们把下边的参数换成double或者是long就能构成方法重载

结束循环（注意两者区别，理论题）

break 和countinue
break 结束当前循环，直接结束一层，非结束所有
countinue 结束本次循环开始下次

如何选择循环结构：（注意理论题）

如果循环次数确定，可以选择for循环，
如果循环次数未知，条件控制的循环，使用while或者do…while
如果循环条件在循环之前明确，使用while
如果循环体至少执行一次，使用do…while

流程控制结束，建议大家看看冒泡排序或者一些常见的数组操作

面向对象编程（大题）

三大特征

封装

隐藏私有的成员变量，通过关键字private实现

继承

子承父类，子类继承父类的所有属性。通过关键词extends实现

class A extends b{} 

作用：
1.提高代码的重用率
2.子类不可以直接访问父类中的私有的内容
3.java中支支持单类继承，即一个类只能继承一个父类；反之，一个父类可以用多个子类。
5.通过继承是的类之间产生关联，是多态的基础
super待变引用父类的成员变量

多态

一种事务呈现出来的多种状态

多态的实现

1.实现继承
2.方法重写
3，父类引用指向子类对象

Person p = new Student();
p.eat();//学生类重写Person方法
p.study();//

类和对象（注意理论题）

概念

类是抽象的，概念性的，共性构成，类似于模板
对象是具体化了的类

关系

类是对象的抽象，对象是类的具体化

类的构成

成员变量：描述属性，也称为域变量
成员方法：动态的，完成功能，也可以操作成员变量，也称为成员函数

成员变量和局部变量的不同点

1.局部变量一定要进行初始化，成员变量可以不赋初值
2.局部变量在栈内存中，成员变量在堆内存中
3.成员变量可以被修饰符修饰，局部万辆一般没有
4.内存中的生存时间。成员变量随着对象的创建而产生，局部变量随着方法的调用产生，方法调用结束，局部变量释放掉
可能

访问构成（概率）

关键字	可访问的范围
private	只能类内访问，类外不可见
default	不加修饰符，即为default，类内可见，统一包内可见
protected	类内可见，子类可见，同一包内可见
public	任意位置可见

构造器

一种特殊的方法，创建对象时会被自动调用，只一次，不人为进行调用，通过构造器在对象创建的时候进行初始化的工作(为成员变量进行赋值)
特点：
1.构造器的名字和类名完全一致
2.构造器没有返回值，所以前边不加void
3.构造器前边可以有修饰词，例如public，peivate(虽然类外不可以调用但是内部其他的构造器可以调用该私有的构造器)
4.构造器只能在对象的创建的时候调用(用new创建对象的时候)，不能在程序中随时直接调用(不同于一般的方法)
注意：
1.构造器可以重载。一旦定义了有参构造器，系统将不再提供无参构造
2.为了避免错误产生，一般情况下，定义有参构造，同时自定义一个无参构造
3.一个构造器可以调用其他构造器，如果调用，不使用构造器的名字，而是使用this(参数)的形式，并且需要放在该构造器的第一行
4.构造器可以可以写n个，那么最多可以有n-1个构造器可以通过this()调用户其他构造器

this

代表只想向前对象的引用，表示当前对象或者正在创建的对象
如果引用当前类的成员变量或者成员方法，都可以在前面加上this
补充
this：每个成员方法的内部都有一个隐含的引用变量，指向“调用该方法的当前对象”，称为this引用变量，简称this
构造器中的this代表正在创建的对象
注意：
如果构造器的形参与成员变量的名字一致，要在成员变量的名字前加上this，进行区分

static

static是一个关键字，可以用来修饰成员变量和成员方法。单一说是因为其有特殊意义。用过此关键字修饰的变量可以在编译的直接加入到静态池(具体不知道怎么形容)中。不可以去访问实例成员，访问实例成员会报空指针错误

静态成员变量

引入静态成员，使用static修饰，属于整个类，前边提到会提前加载，所以它属于整个类。
没有static修饰的成员，成为实力成员，属于某个具体对象的
注意：
1.静态成员变量在一个公共的存储单元中存放，属于整个类，属于所有对象
2.访问时，可以使用"类名.成员变量" 或者 “对象名.成员变量”，一旦修改，影响全部
3.静态的成员，任意对象将其修改后，影响所有的对象
4.静态成员存放在静态域中，都一公分，所有对象共享
5.静态变量早于对象的创建。
6.静态成员初始化 (1)定义时直接初始化 (2)在静态代码块中初始化
7.普通方法内可以访问静态成员变量

静态方法

使用static修饰的方法，称之为静态方法，通过对静态的成员试试操作，或者调用其他的静态方法
注意：
静态方法也无法访问实力变量
静态方法布恩那个使用this调用，因为它不是具体的对象
静态方法随着类的加载而加载，内存中独一份，所有对象共享
4.可以通过 类名.方法名() 或者 对象名.方法名

final

修饰对象不同，表达的含义也不同
final修饰类，该类不能作为父类，被继承
final修饰方法，则该方法不能重写
final修饰变量，则该变量即为常量，final修饰的通常大写

重写和重载的区别（注意理论题）

重载：两同一不同。同一类中，同意方法名。不同参数
重写：在子类中，重写父类方法，要求方法名完全一致，参数完全一致，返回类型完全一致。
注意：重写是，权限修饰不小于父类同名方法的权限

抽象类

抽象类用abstract修饰类
父类定义若干方法，子类基本全部实现，通过子类创建对象，父类不在创建对象
注意：
1.抽象类不产生具体的对象
2.抽象类可以包含成员和构造器(凡是类都有构造器)
3.抽象类中的抽象方法，可以省略方法体
4.抽象类不一定包含抽象方法，但是包含抽象方法的类一定是抽象类
5.抽象类不可以使用final修饰，因为抽象类要被继承，但是final不允许继承
适用情况：
1.只需要该类作为父类，不产生具体的实例，将其声明为抽象类
2.类中包含了方法，但不知道如何让具体的实现该方法

接口

接口声明interface
格式：

interface 接口名称{
	常量;
	抽象方法;
}

注意：
1.方法默认前面使用public abstract进行修饰
2.常量默认使用public static final进行修饰
3.定义的接口，类可以去实现接口中的抽象方法，使用关键字implements
4.类只能单继承，但是接口可以实现多个
2，接口没有构造器
6.接口一般体现一种共嫩南瓜，此类功能嗯那个被类实现：implements
7.实现接口的类，必须要重写接口中的所有的抽象方法
8.接口和接口直接也有继承关系，可以多继承

异常处理

错误和异常

错误：java虚拟机无法解决的严重问题。不编写针对代码的处理代码
例如
java.lang.StackOverflowError
OutOfMemoryError
异常：其他因编程错误或偶然外在因素导致的一般性问题，可以编写针对性代码进行处理
例如
ArrayIndexOutOfBoundsException
ArithmeticException
InputMismatchException
ClassCastException
NullPointerException
编译时异常，javac命令执行时出现异常
运行时异常，编译时无错误，再执行java命令时出现的异常
一旦异常产生，终止程序，会产生对应的异常类对象，并抛出(自动抛出，手动抛出需要加throws)

Throwable
	|--Error:错误，程序不进行处理
	|--Exception:异常，编写程序时考虑对异常处理
		|--RuntimeException
		|--其他

异常处理

try…catch

结构

try{
    可能出现问题的代码；
}catch (异常类名1  对象名){
    针对异常类1进行处理的代码；
}catch (异常类名2  对象名){
    针对异常类2进行处理的代码；
}
。。。
finally{
    无论如何都要执行的代码；//一般进行资源的释放
}

注意：
1）try括起来的代码可能多条异常产生，先处理第一个遇到的异常，将该异常与后面的catch结构依次（从上到下）进行比较，匹配则执行处理代码，执行完，跳过其后的多条catch语句（即后面的catch语句不再执行）
2）一旦将异常进行了处理，则try…catch结构之后的代码正常运行
3）如果多个异常之间是互斥的，则catch的上下顺序可以调换
4）如果多个异常类之间存在继承关系，则必须将子类放在上面
5）finall捕获异常的最后一步通过finall语句为异常处理程序提供一个统一的出口，使得在控制流转到程序的其他部分之前，能够对程序的状态做统一的管理
6）即便在任意一个catch处理代码中有return返回语句，finally中的代码也会执行，因此常用来进行资源的释放；例外的，如果catch中最后的语句是System.exit（0）;则退出虚拟机，finally的语句也不再执行

声明抛出异常(throws)

如果一个方法中的语句，可能产生异常，但是并不确定对该异常如何处理，则可以显式的声明抛出异常，表示该方法将不对此异常进行处理，则由该方法的调用者负责处理
示例

public void readFile(String str) throws 异常类名 {
     .... //此处代码可能产生异常，但不确定如何处理，则声明抛出异常
}

注意：
1.如果方法的调用着也不知道如何让处理，可以继续声明抛出异常
2.更常见的，在方法的调用者内部使用try…catch结构进行处理

自定义异常

如果没有合适的系统提供异常类，用户可以自定义异常类
示例：

class  异常类名  extends Excepiton{
     无参构造(){
 	super();  //调用父类的无参构造
     }
    有参构造(字符串){
    	super(字符串); //调用父类的有参构造
   }
}

在可能产生该类异常的地方抛出异常类对象

throw  new 有参构造(字符串);

一旦抛出，则有错误提示，处理方法：
1.在方法头上声明异常抛出
2.再调用方法的位置进行处理，可以使用try’…catch结构实施处理

补充：
子类中重写父类方法时，不能抛出比重写方法范围更大的异常类型，否则出错

集合

容器：java中以类库形式提供给用户开发程序时可以直接使用的数据结构，存放各种数据类型的数据（配合泛型使用）存放在java.util中，使用时要导入包
特点：
1.只存放对象（引用数据类型）
2.实质上存放的时对应的引用，对象本身在堆内存中
3.可以存放不同的数据类型

java.lang.Object 
      |---Iterable(可迭代接口，方便遍历操作）
	|---Collection（容器接口）
	    |----List接口（有序，可重复）
                          |---ArrayList类（底层使用数组）
	          |---LinkedList类（底层使用链表）
	    |----Set接口（无序，不可重复）
	          |---HashSet类
	          |---TreeSet类
      |----Map接口（键值对，类似函数）
	|---HashMap类
	|---TreeMap类

自动封箱和拆箱

在需要对象的位置，如果出现了基本数据类型，会自动转换为封装类对象，自动装箱
用的是一个类对象，需要一个基本数据类型，自动转换为基本数据类型，自动拆箱

泛型

概念:泛型是类型化的参数即用一个字母代替数据类型，在使用时具体化数据类型
使用风险：
1）任何类型都可以添加到集合中，类型不安全风险，每次读取数据都要进行强转，容易出现类型转换异常
2）通过泛型，可以规定集合中存放的类型，使得错误在编译阶段就可以发现

泛型的定义

[修饰符]  class 类名<T>

注意：
1.T代表数据类型，不表示具体的值
2.在应用时要指明类型，不要用T
泛型方法：

[修饰符] <T>  返回值类型  方法名(T 参数)

在定义时只需要将泛型类参数放在返回值之前即可
强调：
1.泛型方法不一定出现在泛型类中
2.泛型方法在调用时，在方法名前指明使用的具体引用了类型

I/O流

1.File类是java.io包下表示文件的类，提供了文件操作的相关方法，可以新建、读、写、删除等操作
注意：
创建文件对象时，构造器中参数可以使用绝对地址，也可以使用相对地址，目录结构直接使用连接符“\”或者"/"
d:\hello\a.txt
d:/hello/a.txt
文件相关操作方法：
1）file.isDirectory() 判读是否目录
2）file.mkdir() 创建目录
3）file.isFile() 判读是否文件
4)file.list()和重载的方法file.list(filter)，前者返回目录下的所有文件的文件名构成的字符串数组；后者返回目录下所有符合过滤器要求的文件名构成的字符串数组
5）listFiles(); // 获得表示目录下所有文件的数组
注意：如果需要遍历或删除的目录下有子目录及下一级子目录，则需要递归实现遍历和删除操作；注意删除是直接从磁盘删除，因此删除前要确认文件

2.字节流
byte—返回可能是乱码
1）输入输出流有两个抽象的顶层父类InputStrem和OutputStream，不能产生对象
1-1）FileInputStream是操作文件的字节输入流，产生对象，调用方法
1-2）FileOutputStream是操作文件的字节输出流，产生对象，调用方法；通常是清空源文件，写入新内容，如果希望追加写入，即在文件末尾位置添加，则需要使用重载的构造器
1-3）BufferedInputStream和BufferedOutputStream是带有缓冲区的输入输出流类，提高效率
注意：
a.异常处理时，try…catch…finally结构中，finally是一定要执行的代码，通常用来进行资源的释放
b.进行输入输出操作时，往往容易导致IO异常，因此将此类操作放在try…catch结构中，并在函数头加上throws抛出异常
c.在实现输入输出操作时，为了提高效率，可以使用字节数组，通过read和write方法的重载方法，提高读写效率

3.字符流
int—char，可以在记事本下直接查看
1）抽象的顶层父类 Reader和 Writer，无法产生对象
2）字符流和字节流一样，通常读写是成对出现的，文件操作的字符流常用 FileReader和FileWriter
3）带有缓冲的包装类，构造器中参数是FileReader和FileWriter对象
FileReader reader = new FileReader(“d:/hello/source/src.txt”);
// 创建一个BufferedReader缓冲对象
BufferedReader br = new BufferedReader(reader);
FileWriter writer = new FileWriter(“d:/hello/target/des.txt”);
// 创建一个BufferdWriter缓冲区对象
BufferedWriter bw = new BufferedWriter(writer);

4.转换流：字节流和字符流之间的转换
1.JDK提供了两个类可以将字节流转换为字符流
InputStreamReader
OutputStreamReader
1-1)InputStreamReader是Reader的子类，可以将一个字节输入流转换成字符输入流，方便读取字符
1-2）OutputStreamReader是Writer的子类，可以将一个字节输出流转换为字符输出流，方便写入字符

数据库连接

操作步骤

1.把相应驱动放入到项目中。步骤如1-1，1-2或者1-3；三个是两部，三是直接创建的，12属于间接
2.注册驱动
3.获取链接
4.创建环境
5.执行语句
6.利用游标访问需要访问的数据
（注意）流程

1）把相应数据库的驱动（.jar）加入到项目中
    1-1）在src下创建文件夹lib
    1-2）把驱动的mysql-connector-java-8.0.23.jar复制到该文件夹中
    1-3）包含到项目中，右键单击lib文件夹，选择“build path---add to Bulid path”
2）注册驱动
  加载mysql驱动,registerDriver()方法容易重复注册，因此常使用如下方法实施注册
  Class.forName("com.mysql.cj.jdbc.Driver");
注意：
  6.0之前版本   ---com.mysql.jdbc.Driver
  6.0之后版本   ----com.mysql.cj.jdbc.Driver
3）获取连接Connection
连接数据库，获得连接对象
Connection conn= DriverManager.getConnection("jdbc:mysql://localhost:3306/mydb","root","root");
System.out.println("连接数据库成功！");
4）创建Statement对象，该对象可以执行sql语句
创建执行环境Statement stat = conn.createStatement();
5）执行语句返回结果集ResultSet，通过next()遍历访问结果集
ResultSet result = stat.executeQuery("select * from user");
6）利用游标访问需要的数据
while (result.next()) {
	System.out.print(result.getString("name")+" ");
	System.out.println(result.getInt("userid"));
}