【笔记】一个刚接触java的小白分享一下自己的学习笔记
身为一名刚接触编程的小白以后会在这个帖子里分享一些自己学习时的笔记希望以后可以一起共同进步！在学习Java的过程中我个人认为JavaOOP是最难的，因为这些对于一个新手来说思想是抽象的，很难理解。接下来我就把我的学习中的个人笔记分享一下（可能涉及的面不是很全接受批评，共同进步）JavaOOP什么是对象？
名称(形容词) -- > 描述 事物 特征
动词--> 描述 事物 功能
对象= 名词(特征-->成员变量)+ 动词(功能-->方法)
万物皆对象
很多人对于对象理解的不清晰就是因为你的思维逻辑还没有进入一个合适编程式的状态，会把很多抽象的东西想的非常困难，甚至超出宇宙的奥秘，从本来可以用简单的思维完成的思考，想的超出了人类的逻辑，开始思考人类自身然后想的脑阔痛，也想不出来。什么是面向对象的编程？
就是描述程序中所存在的对象，以及对象和对象之间的关系。什么是类？
类就是具有共同特征对象的集合-->不存在现实世界中，是一种抽象。
对象类在现实世界的具体体现-->存在于现实世界中
类的共同特征：
以人为例
人类-->类
共同特征:
吃、喝、玩、乐....--->动词
姓名、性别、年龄、身高、体重 ..-- > 名词通过类如何描述对象?
类名 引用名 = new 构造方法调用
什么是 this关键字？
this-->当前对象
什么是当前对象？正在调用含有this关键字的对象
什么是构造方法?
a) 构造方法的结构
(1) 构造方法没有返回类型
(2) 构造方法的名称和当前类的类名一致
b) 构造方法的作用
(1) 是实例化对象的必须步骤
(2) 在对象产生的同时，给对象的特征(成员变量或者属性)做初始化
c)构造方法的产生的时机
(1) 如果没有自定义构造方法，系统会在new 对象的过程中自动的创建一个不带参数的构造方法
(2) 如果有了自定义构造方法,系统就不会创建不带参数的构造方法面向对象的核心
抽象/封装/继承/多态
抽象:在完成某功能的过程中通过分析抽离出该功能需要的各种数据(属性、方法.....)
继承：子承父业
好处:
1、子类可以直接使用父类的资源
2、站在巨人的肩膀上起步可以更高
类比到开发编码中:
优势:
1、提高代码的重用性
2、提高代码的扩展性
继承的语法:
子类extends父类
问题:
(1)一个子类能不能同时继承多个父类?
JAVA中的继承是单继承
(2)继承能不能传递?
A extends B
B extendsC
A是否可以使用C和B中的资源?
可以
所有的类都基层自一个顶层类Object继承中构造方法的特点？
当实例化子类对象的时候会先调用父类构造方法再调用自己的构造方法
super关键字?
当前类的父类对象
super():系统自动生成在每个类的构造方法第一行,表示当前类的父类不带参数的构造方法（如果是自己编写一定要在构造方法的第一行）封装
利用一种机制来控制数据的可见性，这种机制-->访问修饰符
四个访问修饰符
public->protect->默认->private(从左往右可见性逐渐缩小)
public所修饰的数据在任何情况下都是可见的(本类、同一个包下的不同类之间、同一个包下的父子类之间、在不同包下的父子类或者无关类之间)
private所修饰的数据只在本类中是可见的
protect和默认所修饰的数据,在同一个包下和public是一样的;不同包下protected是有可能被访问到的,但是默认的是一定不能访问的。
3、javabean-->是一种封装数据的方法
要求:
(1) 类必须是public的
(2) 所有的属性必须是private的
(3) 为每一个属性提供一组setter/getter方法用于访问(设置/取值)
//setter赋值方法
public void set首字母大写的属性名(参数) {
this.属性名 =参数;
}
//getter取值方法
public String get首字母大写的属性名() {
return this.属性名;
}
(4) 必须含有至少一个无参构造方法
问题:
1、能不能设计出只读或者只写的属性
只读:
属性private
只为属性提供getter方法
只写:
属性private
只为属性提供setter方法
4、多态:一个事物在不同条件下所呈现出的不同状态
例子：水
0度以下:固态
0~100度:液态
100以上:气态
在程序中的多态是怎么表现的?
1、从未微(从方法)观角度
方法在不同条件下呈现的不同状态:
(a) 方法的重载：扩展本类中同类型方法的功能
(1) 在同一个类中
(2) 方法名必须相同
(3) 参数列表不能相同(参数的数量不同，参数类型不同，不同数据类型的顺序不同，相同类型但是顺序不同不叫参数列表不同)
(4) 返回类型没有限制
(5) 访问修饰符没有限制
(6) 和异常的关系.....
问题:
(1) 构造方法是否能重载?
答：可以
(2) Object类中是否有重载的方法?
答：有,wait()方法
(b)方法的重写:子类方法覆盖父类方法的功能
(1) 父子类之间
(2) 方法名相同
(3) 参数列表相同
(4) 返回类型相同
(5) 访问修饰符子类方法的访问的不能小于父类方法的
(7) 和异常的关系.....
问题:
(1)构造方法是否能重写?
答：不行
(2)Object类中是否会被有重写的方法?
答：有,Object中的equals()和toString()、hasCode()
2、从宏观(从对象)角度
对象在不同条件下呈现的不同状态
对象多态的前提:
(1) 必须在父子类之间
(2) 必须有方法重写
(3)必须有父类引用指向子类对象
A是 B的父类
B b = new B();一般实例化
A a = new B();父类引用指向子类对象
为什么要使用多态?
简化代码结构,提高代码的可维护新
理解多态:
1、实例化对象的时候
父类引用 = 之类对象
2、方法的参数
定义:public void 方法名(父类引用)
调用:方法名(之类对象)
3、方法的返回值
public 父类 方法名(参数列表){
return 之类对象
}
以后的笔记我会更新在再这个帖子下面，希望这种面向对象的理论性笔记能对那些想要加入编程的人们有一些帮助。
本帖最后由 小松悟 于 2018-4-18 16:08 编辑
上面排版有点失误这这重新整理一下{:1_909:}
JavaOOP
什么是对象？
名称(形容词) -- > 描述 事物 特征
动词--> 描述 事物 功能
对象= 名词(特征-->成员变量)+ 动词(功能-->方法)
万物皆对象
很多人对于对象理解的不清晰就是因为你的思维逻辑还没有进入一个合适编程式的状态，会把很多抽象的东西想的非常困难，甚至超出宇宙的奥秘，从本来可以用简单的思维完成的思考，想的超出了人类的逻辑，开始思考人类自身然后想的脑阔痛，也想不出来。
什么是面向对象的编程？
就是描述程序中所存在的对象，以及对象和对象之间的关系。
什么是类？
类就是具有共同特征对象的集合-->不存在现实世界中，是一种抽象。
对象类在现实世界的具体体现-->存在于现实世界中
类的共同特征：
以人为例
人类-->类
共同特征:
吃、喝、玩、乐....--->动词
姓名、性别、年龄、身高、体重 ..-- > 名词
通过类如何描述对象?
类名 引用名 = new 构造方法调用
什么是 this关键字？
this-->当前对象
什么是当前对象？
正在调用含有this关键字的对象
什么是构造方法?
a) 构造方法的结构
(1) 构造方法没有返回类型
(2) 构造方法的名称和当前类的类名一致
b) 构造方法的作用
(1) 是实例化对象的必须步骤
(2) 在对象产生的同时，给对象的特征(成员变量或者属性)做初始化
c)构造方法的产生的时机
(1) 如果没有自定义构造方法，系统会在new 对象的过程中自动的创建一个不带参数的构造方法
(2) 如果有了自定义构造方法,系统就不会创建不带参数的构造方法
面向对象的核心
抽象/封装/继承/多态
抽象:在完成某功能的过程中通过分析抽离出该功能需要的各种数据(属性、方法.....)
继承：子承父业
好处:
1、子类可以直接使用父类的资源
2、站在巨人的肩膀上起步可以更高
类比到开发编码中:
优势:
1、提高代码的重用性
2、提高代码的扩展性
继承的语法:
子类extends父类
问题:
(1)一个子类能不能同时继承多个父类?
JAVA中的继承是单继承
(2)继承能不能传递?
A extends B
B extendsC
A是否可以使用C和B中的资源?
可以
所有的类都基层自一个顶层类Object
继承中构造方法的特点？
当实例化子类对象的时候会先调用父类构造方法再调用自己的构造方法
super关键字?
当前类的父类对象
super():系统自动生成在每个类的构造方法第一行,表示当前类的父类不带参数的构造方法（如果是自己编写一定要在构造方法的第一行）
封装
利用一种机制来控制数据的可见性，这种机制-->访问修饰符
四个访问修饰符
public->protect->默认->private(从左往右可见性逐渐缩小)
public所修饰的数据在任何情况下都是可见的(本类、同一个包下的不同类之间、同一个包下的父子类之间、在不同包下的父子类或者无关类之间)
private所修饰的数据只在本类中是可见的
protect和默认所修饰的数据,在同一个包下和public是一样的;不同包下protected是有可能被访问到的,但是默认的是一定不能访问的。
3、javabean-->是一种封装数据的方法
要求:
(1) 类必须是public的
(2) 所有的属性必须是private的
(3) 为每一个属性提供一组setter/getter方法用于访问(设置/取值)
//setter赋值方法
public void set首字母大写的属性名(参数) {
this.属性名 =参数;
}
//getter取值方法
public String get首字母大写的属性名() {
return this.属性名;
}
(4) 必须含有至少一个无参构造方法
问题:
1、能不能设计出只读或者只写的属性
只读:
属性private
只为属性提供getter方法
只写:
属性private
只为属性提供setter方法
4、多态:一个事物在不同条件下所呈现出的不同状态
例子：水
0度以下:固态
0~100度:液态
100以上:气态
在程序中的多态是怎么表现的?
1、从未微(从方法)观角度
方法在不同条件下呈现的不同状态:
(a) 方法的重载：扩展本类中同类型方法的功能
(1) 在同一个类中
(2) 方法名必须相同
(3) 参数列表不能相同(参数的数量不同，参数类型不同，不同数据类型的顺序不同，相同类型但是顺序不同不叫参数列表不同)
(4) 返回类型没有限制
(5) 访问修饰符没有限制
(6) 和异常的关系.....
问题:
(1) 构造方法是否能重载?
答：可以
(2) Object类中是否有重载的方法?
答：有,wait()方法
(b)方法的重写:子类方法覆盖父类方法的功能
(1) 父子类之间
(2) 方法名相同
(3) 参数列表相同
(4) 返回类型相同
(5) 访问修饰符子类方法的访问的不能小于父类方法的
(7) 和异常的关系.....
问题:
(1)构造方法是否能重写?
答：不行
(2)Object类中是否会被有重写的方法?
答：有,Object中的equals()和toString()、hasCode()
2、从宏观(从对象)角度
对象在不同条件下呈现的不同状态
对象多态的前提:
(1) 必须在父子类之间
(2) 必须有方法重写
(3)必须有父类引用指向子类对象
A是 B的父类
B b = new B();一般实例化
A a = new B();父类引用指向子类对象
为什么要使用多态?
简化代码结构,提高代码的可维护新
理解多态:
1、实例化对象的时候
父类引用 = 之类对象
2、方法的参数
定义:public void 方法名(父类引用)
调用:方法名(之类对象)
3、方法的返回值
public 父类 方法名(参数列表){
return 之类对象
}
1、final:终态
a)修饰类:终态类-->不能被继承
b)修饰成员变量:终态变量-->当变量赋值完一次以后就不能被修改
c)修饰方法:终态方法-->方法不能被重写
d)修饰方法的参数:终态参数-->参数只能取值不能赋值
e)修饰对象的引用:终态引用-->引用指向的地址不能改变
2、static:静态
a)修饰成员变量:修改变量的特性由隶属对象的变量变成隶属于类的变量(如果:变量final static的那么说明该变量即不能重新赋值又是属于类的属性，这种属性一般叫常量)
所以该变量的调用方式不在需要用对象调用:类名.静态属性名
b)修饰方法:修改方法的特性由隶属对象的方法变成隶属于类的方法
所以该方法的调用方式不在需要用对象调用:类名.静态方法名
c)修饰块:
static{
}是在构造方法前运行的，所以静态块中可以放一些资源的初始化操作(例如：JDBC驱动的加载)
注意:静态资源和非静态资源在JVM的加载时机问题
静态资源只能调用静态资源,非静态调用即可以调用静态资源也可以调用非静态资源
Why?
静态资源的加载比非静态资源要更早！程序内容的不是按从上往下的顺序初始化
3、abstract、interface:是一种思想,对编程的一种,对程序脉络把控思路重要体现
abstract抽象
a)修饰类:抽象类
b)修饰方法:抽象方法(没有方法体的方法)
抽象类中可以有普通方法也可以有抽象方法;抽象方法必须在抽象类中;抽象类不能被实例化;抽象类中的抽象方法是需要子类重写，非抽象的方法可以使用之类继承或者修改成static的来调用;如果子类不能完全重写父类中所有的抽象方法，那么子类也应该是抽象的;抽象类中定义成员变量没有限制，要使用该成员变量的时候方法可以使用之类继承或者修改成static的来调用;抽象类只能单继承
interface接口(抽象的抽象类)
接口中的方法必须是抽象方法,而且默认的方法就是public abstract的;接口中的成员变量默认就是public static final;接口不能实例化;接口中的所有都需要之类重写,如果实现类不想重写接口中所有的抽象方法，那么该实现类也应该是抽象的;接口是可以多实现的.
问题:
1、抽象类能否继承抽象类？可以
2、接口能否继承接口?可以
3、接口能否实现接口?不可以
4、接口能否继承抽象类?不可以
5、抽象类能否实现接口?可以
1、异常
什么是异常?
异常是程序编译或者运行时的一种不正常的状态，但是这种不正常的状态不一定会出现
异常对程序有什么影响?
程序的稳定性安全性降低,程序会挂起
为什么要使用异常?
增加程序的稳定性安全性,至少要让程序能正常结束
异常和错误是不是一个概念?
错误是无法处理的，除非把程序逻辑修改正确
异常是可以处理，修改程序逻辑或者使用异常处理机制
2、异常类：java会报大部分经常出现的异常用一个类来描述，一点系统出现了异常就表示一定会有或者需要有一个异常类的对象来对应
3、常见的异常类:
ArithmeticException(除0异常)
ArrayIndexOutOfBoundsException(数组下标越界异常)
ClassNotFoundException(没有发现类异常)
NullPointerException(空指针异常)
NumberFormatException(数据格式化异常)
4、异常类的层次结构
Object
-->Throwable
-->Error-->XXError(错误类以及错误类的子类)
-->Exception(异常)
-->非RunnTimeException(非运行时异常,在编译的时候就会有提示，必须要用一场处理机制处理,但是处理完毕后运行的时候不能保证没有问题出现)
-->ClassNotFoundException、SQLException
-->RunnTimeException(运行时异常,在编译的时候就不会有提示,可以不用异常处理机制处理,但是运行的时候不能保证没有问题出现)
-->ArithmeticException、ArrayIndexOutOfBoundsException、NullPointerException、NumberFormatException
5、异常堆栈信息的分析:
Exception in thread "main" iava.lang,ArithmeticException:/ by zero
at com.svse.demo02.MySystem.cfys(M/System.iava:23)
at com.svse.demo02.Test.main(Test.iava:11)
首先读第一行,告诉我们是什么错误
从第一行向下找第一次出现的自己的类名的位置，点击后方的链接，会跳转到异常出现的具体位置
接下来，可以使用异常处理机制处理
6、异常处理机制(try-catch-finally throws throw)
try{}:把可能出现异常的代码放在在其中
catch(异常引用){}:尝试去捕获try中出现的异常,如果捕获成功,那么程序会从try块直接跳入catch块执行;如果没有捕获成功，程序按照既定流程执行
finally{}:不管程序中有没有异常都必须执行的代码块
问题:在try-catch中有return会不会影响finally{}里内容的执行?
不会
如果一段程序出现多个异常，尽量避免出现try-catch嵌套
for (int i = 0; i < array.length; i++) {
try {
try {
System.out.println(array / array );
}catch(ArithmeticException e) {
System.out.println("除数不能为0");
}
}catch(ArrayIndexOutOfBoundsException e) {
System.out.println("数组下标越界");
}
}
原则:
1、如果有for,if等结构体，那么try-catch应该在这个结构体的外部
2、嵌套try-catch尽量的修改成多重try-catch
try {
for (int i = 0; i < array.length; i++) {
System.out.println(array / array );
}
}catch(ArithmeticException e) {
System.out.println("除数不能为0");
}catch(ArrayIndexOutOfBoundsException e) {
System.out.println("数组下标越界");
}catch(Exception e) {
System.out.println("程序有异常");
}
System.out.println("程序继续");
(注意:多重catch捕获的时候，捕获的异常类的引用，从小往大来编写)
问题:
try-catch可以搭配使用，try-finally能不能搭配使用,catch-finally能不能搭配使用?
try-finally可以搭配使用,catch-finally不能搭配使用
7、throws：抛出异常(可以抛出多个异常)
在程序出现异常的位置，不对异常继续处理，但是又想让当前这块程序能执行，那么可以把当前位置出现的异常从当前的方法中抛出;或者提供一种思路
throws的位置:方法的结尾
public void method() throws 异常列表
注意:当一场从某个方法中抛出以后，那个方法调用了这个抛出异常的方法，那么异常就引入到哪个方法中去了;而且抛出是可以多层抛出;在层次结构的抛出中抛出的的异常可以越来越抽象
问题:
方法重载和重写对抛出异常有没有什么限制?
8、throw 自定义异常
系统异常无法满足要求的时候，可以定义新的异常，这个异常要按照异常的层次结构来定义
步骤:
1、自定义异常类:
public class LoginFailException extends Exception {
public LoginFailException(String message) {
super(message);
}
}
2、在合适位置生成异常类对象
public class UserDAOImpl implements UserDAO{
@Override
public void findByUnameAndPwd(String uname, String upwd) throws LoginFailException {
// TODO Auto-generated method stub
if ("admin".equals(uname)&&"123123".equals(upwd)) {
}else {
//生成自定义异常
throw new LoginFailException("登陆失败，用户名或者密码错误!");
}
}
}
3、在合适的位置处理异常
public static void main(String[] args) {
UserDAO userDAO = new UserDAOImpl();
try {
userDAO.findByUnameAndPwd("admin", "123123");
System.out.println("登陆成功");
} catch (LoginFailException e) {
System.out.println(e.getMessage());
}
}
1、java中的常用类
(1)常用类所在的包:
(a)java.lang包:默认包,系统自动导入(此包以外的在别的包下的资源，使用前都需要导入)
(b)java.util包:工具包，提供了很多的工具类
(c)java.text包:格式化，提供了格式化数据的工具
(d)java.sql包:jdbc操作，提供了jdbc操作的接口
(e)java.io包:输入输出，提供数据的写入写出操作工具
(f)java.net包:网络开发,提供了网络编程的一些工具
(2)常用类:
Java.lang包:
(1)包装类：把基本数据类型转换成对象,可以使用对象中提供的更丰富的功能
byte Byte
short Short
int Integer
long Long
float Float
double Double
char Character
boolean Boolean
(注：包装类用的最多的地方就是字符串转换成各种数据类型)
(2)String类:字符串类，提供了很多关于字符串的操作
a)String怎么实例化的
(1)String s = "字符串";
(2)String s = new String(“字符串”);
问题:
以下的两种方式分别创建了多少个对象?
String s = "abc";
String s1 = new String(“abc”);
String s2 = new String(“abc”);
以上一共创建了:3个
以上两种有什么区别?
String s = "abc";在创建对象的过程中使用的是字符串池保持数据
String s1 = new String()创建对象是使用堆栈来保持数据
那么:
String s1 = “wangwei”
String s2 = “wangwei”
创建了几个对象?1个
所以在开发的时候应该用第一种方式创建字符串，这样可以更节省内存空间
b)String的不变性
问题:
String s = “abc”;
s = s +”efg”;
创建几个对象?2个
什么叫字符串的不变性:当字符串的内容发生变化的时候总是会新创建一个字符串
1、集合类:和数组类似用于存储多个数据一种容器
(1)集合类和数组的区别?
(a)数组在存储数据前必须要先确定数组长度
(b)一个数组中存储的数据的数据类型是统一的
(2)集合的层次结构
Iterable接口(提供所有底层迭代的方法)
-->Collection接口(提供所有集合的CRUD等操作的规范)
-->List接口(提供List接口下实现类的CRUD等操作的规范)
-->ArrayList、LinkedList、Vector
-->Set接口(提供Set接口下实现类的CRUD等操作的规范)
-->HashSet、TreeSet
Map接口(提供看key-value方式集合的CRUD操作规范)
-->HashMap、HashTable
问题:
1、Collection接口下的集合类和Map接口下的实现的区别?
Collection接口下的集合类中存储的元素是以元素所在集合中的位置来定位和操作的
Map接口下集合类中存储的元素是以key值最为标志来定位和操作的
2、List接口下的实现类和Set接口下的实现类有什么区别?
区别1:
(1)List接口下的实现类存储的元素在集合中位置是不会发生变化
(2)Set接口下的实现类在存储数据的时候会有一套排序机制对存储的位置进行修改
区别2：
List接口下的实现类可以存储重复对象;Set接口下的实现类不能存重复对象
3、Map集合存储的数据的特点?
存储数据的时候是key-value都要保存;取值的时候是利用key来获取value；如果需要便利的时候，需要使用values()方法取出所有的value值后再遍历;在存储数据的时候会有一套排序机制对存储的位置进行修改
4、ArrayList和LinkedList有什么区别?
ArrayList在存储数据的时候是利用数组的方式来存储数据;利用下标来标识每个元素在集合中的位置
LinkedList在存储数据的时候是利用链表的方式来存储数据;每个元素没有下标，利用收尾相连的方式确定元素在集合中的位置
ArrayList和LinkedList存储效率差异:
ArrayList在查询的时候效率高;添加和删除的时候LinkedList效率更高
5、ArrayList和Vector有什么区别?
ArrayList:数据操作是不同步的;线程不同步;一个线程操作集合的时候其他线程可以进行操作; 数据相对不安全，但是效率会比较高
Vector:数据操作是同步的;线程同步;一个线程操作集合的时候其他线程无法进行操作; 数据相对安全，但是效率会比较低
6、集合加泛型和不加泛型有什么区别?
集合加泛型也就是规定了集合的存储的数据类型；但规定了数据类型后就是取值的时候不需要考虑数据类型转换的问题； 集合不加泛型没规定集合中存储数据的类型，集合可以存储所有的数据类型，问题是取值的时候无法确定统一的数据类型
6_1、集合的装箱(向上转型)和拆箱操作(向下转型)?
在不加泛型的集合中，所有的数据在存储到集合之前会自动向上转型成Object对象再进行保存;在取出数据的时候需要手动的强制类型转换成原来存储时的数据类型
7、Collection和Collections有什么区别？
Collection是集合的顶层接口提供了集合操作的规范;
Collections是一个集合的工具类，提供了大量的static方法来对集合进行操作(排序、反转、比较....),这些方法大部分的返回值也是集合类型
(3)集合的操作：
CRUD(增、删、改、查)
ArrayList:add()、clear()、remove()、get()、set()、size()、普通for循环遍历、foreach遍历、迭代器遍历
HashSet:add()、clear()、remove()、size()、没有提供查某个和修改方法、foreach遍历、迭代器遍历
HashMap:put()、clear()、remove()、修改方法也是put()、get()、size()、普通for循环遍历、foreach遍历、迭代器遍历
c)解决字符串不变性的方法
如果要对一个字符串进行频繁的修改操作，那么不要直接使用String类型来操作，而可以使用StringBuffer来操作
StringBuffer的实例化:
StringBuffer strbuf = new StringBuffer(“待操作的字符串”)
利用StringBuffer提供的方法对字符串进行操作:
append():追加
charAt():返回字符串中某个下标对应的字符
delete():删除字符串中的内容
Insert():在字符串中插入新内容
replace():替换字符串中内容
reverse():反转字符串内容
subString():切割字符串内容
(3) Math类:数学类，提供很多数据计算的方法
该类下所有的属性和方法都是static的,可以直接使用Math.调用,不需要实例化Math对象
常用的方法:
abs():绝对值
floor():取出比当前浮点数小的最大整数
ceil():取出比当前浮点数大的最小整数
round()：四舍五入取整
random():0~1的随机数
max():最大数
min():最小数
练习:生成(1000~10000之间的随机数)
java.util包
(1)Random类:随机数类，提供了生成随机数的各种方法
(2)集合类:用来存储多条数据的工具类
1、JDBC操作:
JDBC就是java操作数据库的方法
2、JDBC最大的特点?
JDBC中提供的是一组接口(提供的是操作数据库的规范),而不是具体的操作方法,这些具体的操作方法是由各个数据库厂商按照JDBC接口的规范来编写的,所以就有sqlserver的JDBC的实现(微软编写);MySql的JDBC实现(甲骨文编写);Oracle的JDBC实现(甲骨文编写),那么我们在编写JDBC代码的时候第一件事情，从各个厂商的官网下载jdbc的实现(xx.jar包)
3、JDBC操作的步骤:
(1)加载驱动
Class.forName(驱动类的完整路径的字符串)
(通过反射的方式的获取驱动类的对象)
-->(2)通过Connection对象实现数据库的连接
Connection conn = DriverManager.getConnection(“连接字符串”,”登陆数据库的用户名”,”登陆数据库的密码”)
(连接字符串的作用:通知java程序需要链接到哪个数据库上)
sqlserver连接字符串:jdbc:sqlserver://localhost:1433;databaseName=pubs
mysql链接字符串:jdbc:mysql://localhost:3306/dbinfo
Jdbc:数据库类型://数据库管理系统地址:数据库端口号 数据库名
-->(3)通过Statement(语句)对象来发送sql语句到数据库
(1)Statement st =conn.createStatement();
(2)PreparedStatementps=prepareStatement(String sql);
Statement 是 PreparedStatement 父接口;Statement 的创建不需要sql语句,PreparedStatement 需要传递sql语句,所以PreparedStatement也叫预定义语句对象;使用PreparedStatement的好处是:1、可读性强可维护性高(可以使用占位符),2、执行效率更高,3、更安全(防止sql注入问题)
-->(4)执行sql语句获得数据库的反馈，ResultSet对象或者int数据
(1)int i = st.executeUpdate(String sql)或者ResultSet res = st.executeQuery(String sql )
(2)int i = ps.executeUpdate()或者ResultSet res = ps.executeQuery();
-->(5)关闭释放资源
rs.close()、ps.close()、conn.close()
注意:关闭顺序，先关闭后打开的资源
组织JDBC操作的时候要引入MVC分层思想:
为什么要有分层思想?
采用各司其责的方式开发，提高代码的重用性、可维护性、可扩展性
MVC就是一种分层思想:
M：MODEL（数据模型层）-->用来描述数据结构(需要操作的数据对象,如果是针对数据库那么就是表的映射)
DAO层:Data Access Object(数据操作层),放置JDBC数据库操作代码
Service层:业务层,描述系统功能
C:CONTROL(控制层)接受视图层的数据;调用业务层的功能；返回数据到视图层
V：VIEW(视图层)-->展示数据、收集数据
1、IO流(input/output)
a)所有计算机中输入和输出操作都是java.io.*包下面的所有的类来负责完成
b)输入或者输出的介质:硬盘上的文件,计算机的内存,网络......
c) 文件可以使用java api中的File类来概括,需要操作的具体文件就是这个类的一个对象
File对象的创建:
File file = new File(文件路径的字符串);//注意:路径的描述:“d:/1.txt”或者”d:\\1.txt”
控制File对象的常用方法:
createNewFile()：创建新文件
delete():删除文件
exists()：判断文件是否存在
getPath()：获取文件路径
getName():获取文件名称
isDirectory()：判断文件是否是目录
isFile():判读文件是否是文件
length()：文件长度
mkdir():创建目录
setReadOnly()：文件设置成只读
setWritable():文件设置成可以写
d) 文件的内容需要由IO流来操作
IO流分类:
(1)字节流:一次输入或者输出只有1个字节
输入字节流:InputStream是所有输入字节流的父类,负责读取操作
输出字节流:OutputStream是所有输出字节流的父类,负责写入操作
(2)字符流:一次输入或者输出只有1个字符(2个字节)
输入字符流:Writer是所有输入字符流的父类,负责写入操作
输出字符流:Reader是所有输出字符流的父类,负责读取操作
(3)转换流:对字节流或者字符串进行转换
字节流转字符流:
InputStreamReader\OutputStreamWriter
把字节流或者字符流转换缓冲字节流或缓存字符流
BufferedInputStream/BufferedOutputStream
BufferedReader/BufferedWriter
(e)RandomAccessFile类
RandomAccessFile是用来访问那些保存数据记录的文件的，你就可以用seek( )方法来访问记录，并进行读写了。该类仅限于操作文件。RandomAccessFile不属于InputStream和OutputStream类系的,它是一个完全独立的类，所有方法(绝大多数都只属于它自己)都是从零开始写的.
RandomAccessFile的工作方式是，把DataInputStream和DataOutputStream结合起来，再加上它自己的一些方法，比如定位用的getFilePointer( )，在文件里移动用的seek( )，以及判断文件大小的length( )、skipBytes()跳过多少字节数。此外，它的构造函数还要一个表示以只读方式(“r”)，还是以读写方式(“rw”)打开文件的参数 (和C的fopen( )一模一样)。它不支持只写文件。
(f)对象序列化和反序列化
把对象保存到文件中的过程叫对象序列化;把保持到文件中的对象信息还原一个原来的对象这个过程就反序列化。
对象要能够被序列化必须有一个前提,该对象必须实现Serializable接口,这个接口没有任何东西，这个接口只是一个标记，说明该类的对象是可以被序列化的
对象序列化需要使用ObjectOutputStream;对象的反序列化需要使用ObjectInputStream
至此我的oop笔记就告一段落了！
构造方法：【作用是初始化对象】
特点：无返回值，方法名与类名相同
系统默认提供无参构造方法，当程序员提供构造方法时系统不再提供无参方法。
方法重载的特点：
方法名相同参数列表不同【个数和类型不同】与返回值访问修饰符有关
位置：本类
this：当前类对象的引用
this.属性
this.方法
this();调用构造方法
封装
步骤：
1、私有化属性
2、提供公有的getter/setter方法
3、在getter/setter方法中加入控制语句
ststic：静态的：
静态的属于类
在类加载时静态成员就会被加载到内存当中
实例成员只有创建对象时才会被加载到内存当中
静态成员不能直接调用非静态成员，非静态可以调用静态成员【原因就是加载的先后顺序】 继承：
1、子类可以直接使用父类的资源(私有成员除外) 这个。。。。不用分享吧，想学的都有 楼主是在哪里学呢？
加油，吾爱因你更精彩 加油加油 blueios 发表于 2018-4-14 18:42
加油加油
谢谢支持和鼓励{:1_893:}