1.java的执行顺序 java（编译） Java（运行） 编写源码----------->字码文件----------->执行
2.编写源码注意 a.类名和文件名一致. b.括号要成对出现.
3.println和print的区别 println会换行 print不会 4.转义字符 \n表示换行 \t表示空格
5.java注释 //：单行注释 /* */：表示多行注释 /** */表示文本注释
6.java代码规范 a.类名要用oublic修饰 b.一行只写一个语句 c.注意{}的位置 d.代码层次关系缩进（tab键
第二章 变量，数据类型和运算符
2.1变量 变量：一个数据存储空间表示（代词）
2.2变量的基本语法 数据类型 变量名 //声明变量 =变量值； //赋值
2.3变量的使用 a.变量必需声明，并且初始化够才能使用. b.变量名不能重复.
2.4常见数据类型 int（整数） double（双精度浮点数） char（字符） String（字符串）
补充：8种基本数据类型
byte （字节类型）
short （短整型）
char （字符型）
int （整型）
long （长整型）
float （单精度浮点型）
double （双精度浮点型）
boolean （布尔型）
2.5变量命名规则 变量名：由数字，字符，下划线，美元符号组成， 但是不能以数字开头
2.6赋值运算 变量名=表达式；
2.7算术运算符 +，-，*（乘），/（除取整），
%（取余） ++，（自增）等价于 本身= 本身+1 --，（自减）等价于 本身= 本身-1
2.8类型转换
2.8.1分类
a.自动类型转换
b.强制类型转换
2.8.2自动类型转换
大类型 = 小类型
2.8.3强制类型转换 小类型 = （小类型）大类型
注意：强制类型转换是可能会出现溢出
2.9关系运算符 >（大于），<（小于） ==（等于） ！=（不等于） >=（大于等于） <=（小于等于）
注意：==表示：等于， 表示：赋值
3.0 boolean类型 只有true和false两个值
3.1运算符运算优先级 （） > 算术运算符 > 关系运算符 > 逻辑运算符 > 赋值运算（=） +，-... >， <... ||（或）&&（与）！（非）
选择结构
第一种：
if（条件）{
//代码块
}
解释：如果条件结果为true，那么执行代码块，否则不执行
第二种：
if（条件）{
//代码块1
}else{
//代码块2
}
解释：如果条件结果为true，那么执行代码块1，否则执行代码块2
第三种：
if（条件）{
//代码块1
}else if（条件2）{
//代码块2
}......{
...
}else{
//代码块n
}
解释：如果条件1结果为true，那么执行代码块1
如果条件1为false，那么将执行下一个条件
判断，依次重复上面的过程.
注意：
判断字符串是否相同用 str1.equals（str2）
判断数字相同用num1 == num2
2.switch...case 选择结构
switch（表达式值）{
case 值1：语句;break;
case 值2：语句;break;
.....
default：语句n；
}
解释：如果表达式的值为值1，那么执行语句1，
如果表达式的值为值2，那么执行语句2，
........
如果表达式从上至下都没有找到匹配到值，那么执行default后面的语句n.
注意：
1）.表达式值可是整型，字符型。jdk1.7以后可以是sting类型
2）.break：表示终止，表达式整个swtich语句结果.
3）.如果匹配到值，并且没有执行break，那么从匹配到那个值的语句
开始，下面的每一个语句都会执行，知道整个程序结束后者遇到break.
循环结构
1.while循环
while（条件）{
//代码块
}
解释：如果条件的结构为true，那么执行代码块
当代码块执行完后，又会执行条件，
依次循环，知道结果为false，整个循环结束.
2.程序调试
第一步：设置断点（左键双击）
第二步：debug方式执行代码
第三步：逐条执行条码调试（f6）
第四步：检查代码（看变量值的变化）
注意：在右上角可以切换java视图和debug视图.
3.do...while循环
do{
//代码块
}while(条件){ //代码块
}
解释：先执行代码块，然后进行条件判断.
如果条件为true，那么继续执行代码块
依次循环，知道条件为false，整个循环结束.
注意：
变量的作用域：从变量声明开始到它所在代码块结束.
4.while和do....while区别
a.执行顺序不一样
b.do...while中的循环体至少会执行一次;
而while中的循环体在结果为false时，不会被执行.
5.for循环
语法：
for（初始化表达式；条件表达式；循环变量变化表达式）{
//循环体
}
初始化表达式：用于初始化循环变量值
条件表达式：如果为true则执行循环体，否则退出
循环变量表达式：用于循环变量的控制如i++..
执行顺序：
第一步：初始化表达式（只会执行一次）
第二步：条件表达式；如果为true则执行第三步，否则退出循环.
第三步：循环体
第四步：循环变量表达式，执行完之后，再执行第二步，依次循环.
注意：
for循环中三个表达式都可以省略.
如果第二个表达式没有写，那么它的结果为true.
数组
1.数组的声明定义
数组类型[] 变量名 = new 数据类型 [长度];
例：int [] ary = new int [5]；
2.取值，赋值.
取值：数组名[下标];
int a = ary [1];
赋值：变量 = 数组名[下标];
例：ary [1] = 10;
3.数组的遍历
数组的长度：数组名.length;
for（int i=0;i<数组名.length;i++）{
//数组名[i]：访问每个元素的值
}
4.数组常见的异常
ArrayIndexOutOfBoundsException //数组下标越界
当访问数组的下标超过0~length-1时，就会出现以上错误.
注意：数组下标范围：0~length-1
5.数组的常用方法
Arrays.toString（数组名）; //展示数组内容
Arrays.sort（数组名）; //数组按升序排序
6.后序遍历
for{int i = ary.length-1; i>=0; i--
ary[i];
}
7.比较字符串的大小
如果a.compareToIgnoreCase（b）>0 为true 那么a大于b.
如果a.compareToIgnoreCase（b）<0 为true 那么a小于b.
如果a.compareToIgnoreCase（b）==0 为true 那么a等于b.
8.break和continue
continue：继续（表示结束本轮循环，进入下一个循环）
break：终止，结束（表示终止当前循环结构）
注意：多层循环，只会对直接的循环起作用
类和对象
1.对象和类
类是对象的抽象，对象是类的具体事例.
例：人是类，小明是对象.
2.创建对象
语法：类名 对象名 = new 类名（）；
例：Person p = new Person();
注意：类名也是数据类型.语法也可以写成.
数据类型 变量名 = new 数据类型（）；
3.类的语法
public class 类名 {
//属性 --->特征
//方法 --->行为
}
4.定义属性
class 类{
//属性的数据类型 属性名;
例：int age；//表示年龄
}
属性的访问: 对象名.属性名;
属性的赋值：对象名.属性名 = 值;
5.方法的访问：
对象名.方法名（）;
无参方法
1.方法的定义
public 返回值 方法名（）{
//方法体
}
注意：
如果没有返回值，那么返回值类型是void.
如果有返回值，那么必须用return 返回值，并且该值的数据类型必须是定义方法
时的数据类型.
return的作用：
a.返回值
b.结束方法.（与break类似）
2.写方法时注意
第一点：定义void为返回值类型时，不能使用return+返回值.
第二点：方法不能返回多个值.
第三点：方法不能嵌套.
第四点：不能在方法外部直接写程序逻辑代码.
3.成员变量和局部变量的区别
a.作用域不同
局部变量的作用域仅限于定义它的方法
成员变量的作用域在整个类内部都是可见的
b.初始值不同
java会给成员变量一个初始值
java不会给局部变量赋予初始值
注意：
a.相同的方法中，局部变量名不能重复
b.不同方法中，局部变量名可以重复
c.同一个类中，成员变量名和局部变量可以相同，一般以局部变量为准.（就近原则）
4.java.lang.NullpointerException(空指针异常)
原因：对象的值为null，并且对次对象进行了操作.
解决方案：找到次对象的数据来源，查看到new对象的代码
是否执行或是否编写，根据不同的原因去解决问题.
注意：
写任何代码
第一点代码的执行过程.
第二点：值来自于哪里.
建议：
1.别先写代码，先写步骤.
2.不要关注实现细节
有参方法
1.方法的定义
public 返回值类型 方法名（参数类型1，参数名1，参数类型2，参数名2，.....参数类型n）{
//方法体
}
2.有参数的调用
a.如果同一个类中，方法可以直接调用.
b.如果不同的类，方法必须通过对象调用，
对象名.方法名（实参，实参2...）
注意：
1）实参的数据类型，参数的个数，参数的顺序要跟形象保持一致.
2）调用有返回值的方法，一般要接受返回值，并作出相应的处理.
3.包
a.包：文件夹（从src目录下开始算起）
例：oo.day01
b.包命名规范
包由小写字母组成，不能以圆点开头或结尾.
c.当使用不同包中的类时，必须用import将这个类导入到
指定的类中，（如果是同一个包中的类，不需要import，java会自动导入）.
4.字符串（String）的定义
String str = “内容”
String str = new String（）; //内容为null
String str = new String（“内容”）;
5.java.lang.*
字符串所在的包是java.lang.
注意：所有在java.lang包下的类，我们使用时，不需要import.
6.常用方法
str.length(); //字符串的长度
str.indexOf(str1); //子串str1出现的下标.（从前往后找）.
str.lastIndexOf(str1); //子串str1出现的下标（从后往前找）.
str.substring(begin); //截取从下标begin开始到末尾的子串.
str.substring(begin，end); //截取从下标begin开始到下标end的子串.
str.trim(); //去掉首尾空白
str.toLowerCase(); //返回字符串的小写
str.toUpperCase(); //返回字符串大写
7.从现实抽象出类的步骤
第一：找出分类（分析出类）
第二：找出类的特征（分析类的相关属性）
第三：找出类的行为（分析类的方法）
8.常量（经常出现的变量值）
语法：public static final 数据类型 变量名 = 变量值；
注意：
变量名的所有字母都大写，多个单词用下划线（_）分割.
例：public static final String SEX_MALE=“Q仔”；
常量的访问方式：
类名.常量名；
构造方法(特殊方法，用来创建对象 没写就会默认有构造方法)
1.语法：
public 类名 （参数列表）{
//方法体
}
2使用
类名 对象 new 构造方法名（参数）；
例： Dog d = new Dog（）；
3 构造方法的作用
a.创建对象.
b.初始化值（属性值）
4构造方法和普通方法的区别：
a.构造方法没有返回值类型（return....）
b.构造方法的方法名就是类名，普通方法可以任意取.
c.构造方法的调用：new 构造方法名（参数）
普通方法的调用：对象名.方法名（参数）
注意：当你没有写构造函数时，java会提供默认的无参构造函数.
例：
public Dog{
}
方法重载
1.方法重载：
方法名一样，参数列表不一样.
注意：重载与返回值类型和访问修饰符无关.
2.static和final
static：静态的
用static修饰的属性，直接可以类名.方法名访问
final：最终的
用final修饰的属性，它的值初始化后，不能再改变
注意：static不能再方法中修饰局部变量
补充：
后++，先把本身的值作为表达式的值，然后本身+1;
例：i++
前++，先本身加1，然后再把值作为表达式的值;
例：++i
后-- 先把本身的值作为表达式的值，然后本身-1;
例：i--
前-- 先本身-1，然后再把值作为表达式的值;
例：--i
封装
1.封装：隐藏类内部细节
2.封装 步骤：
第一步：将属性私有化.（private）
第二步：提供getter/setter方法（getXxxx（），setXxxx（））.
第三步：在getter/setter中加入控制语句.
3. this关键词
this：表示当前对象.
调用属性：this.属性名
调用方法：this.方法名（）；
this()：表示调用构造函数.
注意：this()，必需写在构造函数的第一行.
继承（extends）
1. 继承：遗传
2. 语法
public class 子类 extends 父类{
//代码块
}
例：public class Dog extends Pet {
//代码块
}
3. 继承的特点
a.子类可以继承父类的非私有的属性和方法
b.不能继承构造方法
c.继承默认权限修饰符的方法和属性，子类和父类必需在同一包中
4. super（父类）
super.属性名; //表示访问父类的属性
super.方法名(参数); //表示访问父类的方法
super(参数);//表示访问父类的构造函数；
注意：super()访问父类构造函数时，必需写在第一行;
抽象类（abstract）
1. 抽象类
语法：public abstract class 类名(){};
2. 抽象方法
语法：public abstract 返回值类型 方法名（参数列表）;
例：public abstract void print();
注意：抽象方法有abstract修饰，并且抽象方法没有方法体.
3. 抽象类和抽象方法的特点
a.都用abstract修饰
b.抽象方法没有方法体
c.抽象类不能实例化，并且继承必需重写抽象类中的所有抽象方法
注意：
1.抽象类中不一定有抽象方法
2.含有抽象类方法的类，一定是抽象类（接口）
重写
1. 重写就是子类重写定义父类的方法
2. 重写规则
a.方法名和参数列表相同.
b.修饰符访问权限子类和父类相同或者比父类大.
c.返回值类型子类和父类相同或者是父类的返回值类型的子类
d.异常跟父类相同或者范围更小
重写时：
子类的东西都要与父类保持一致
方法重写：
位置相同,方法名相同,参数列表相同,返回值相同或是其子类,访问修饰符不能比父类严格
方法重载：位置同类,方法名相同,参数列表不相同,返回值无关,访问修饰符无关
final
final修饰的类不能被继承
final修饰的方法不能重写
final修饰的属性不能被修改
多态
1. 多态含义：一个事物的多种形态
2. 多态的表现
行为（方法）多态：重写和重载.
引用多态（动态绑定）：编译时的类型和运行时不一致的这种现象叫做动态绑定.
例：父类 = 子类.
pet p = new Dog（）；
3.向上转型和向下转型
向上转型：父类 = 子类；
向下转型：子类 = （子类）父类；
例：Dog d = Dog（）p；
注意：java.lang.ClassCastException：类型转换异常.
父类的运行时类型跟要转成的子类的类型不一致
注意：引用多态存在继承关系
instanceof
语法：对象A instanceof 类型B；
判断对象A的类型是否是类型B，如果是就返回true，否则返回false.
例：d instanceof Dog
实现多态的两种形式
a.使用父类作为方法形参实现多态
public void play(Pet p){}
b.使用父类作为方法返回值实现多态
public Pet getPet(int type){}
接口
1. 语法
public interface 接口名 extends 接口1，接口2..{
//1.常量
//2.抽象方法
}
2.特点
a.用interface修饰
b.接口可以继承接口，多继承
c.接口内只能定义常量和抽象方法
d.接口不能实例化，但是可以作为子类的引用
e.实现接口的子类都必需实现它的所有抽象方法
foreach循环和...
... :形参里面出现，表示的是可变参数
foreach循环:
语法：for(int 下标 = 0;i < 数组的长度;i++){ 数组元素值 数组[i]}
语法：for(数组元素类型 数组的元素值：数组){}
异常
1.异常：程序执行过程中出现的影响程序正常运行的现象.
2.异常语法
try{
//代码块
}catch(异常类型 e){
//代码块
}catch（异常类型 2 e2）{
//代码块
}...{
//代码块
}finally{
//代码块
}
注意：
try：表示可能出现异常的代码块.
catch：抓取异常，并进行处理,可以抓取多个异常,
异常的范围要从小到大抓取,并且只会执行第一个匹配的异常类型.
finally：最终的，不管是否出现异常，finally中的代码块始终会执行.
除虚拟机停止(System.exit(1))这种情况外.
注意：
finally 和 return的执行顺序：
先执行return,把返回结果保存在返回结果区域，并没有返回，再执行finally,
最后,把保存在结果区域的结果返回给调用者.
3.throws声明异常
a.就是当前方法，不能解决这个异常的时候，必须把这个异常交给上一个调用者去处理.
b.语法
访问修饰符 返回值类型 方法名(参数列表)[throws 异常]{}
java异常体系
Throwable
error: (出现不能通过的程序处理的错误)
Exception:可以同程序抓取或者抛出的错误.
检查异常（非运行时异常）:编译阶段会出现的异常
SqlException,
IOException,
ClassNotFoundException
非检查异常（运行时异常RunTimeE）
NullPointerException,
ArrayIndexOfBoundsException,
ClassCastException,
注意：
checked异常，是必需处理的
运行时异常，可以不处理
导入第三方jar包
第一步：右击工程名，新建一个文件夹（Fold），名字为lib.
第二步：把第三方jar包复制到lib目录下.
第三步：右击工程名---->properties
---->java build path
---->libraries
---->add jar
---->再从项目的lib目录下选中你要的jar包
---->确定.
使用log4j
第一步：导入log4j jar包
第二步：写配置文件
注意：
文件名和文件路径
（开发）（生成）
log4j.rootLogger=debug | info
第三步:使用log4j
a.导入log4j类
import org.apache.log4j.Logger；
b.在指定类中，写属性
private static Logger logger = Logger.getLogger(指定类名.class);
c.在指定行写日志
logger.debug("日志信息");
logger.info("信息");
集合框架
Collection Map
List Set HashMap
ArrayList LinkedList HashSet
1. List的方法
List<元素类型> list = new LinkedList<元素类型>();
list.add(元素); //增加元素
list.add(index，元素); //向指定位置插入元素
list.remove(下标); //删除指定下标的元素
list.remove(元素); //删除指定元素
list.get(index); //获取指定下标元素
list.contains(元素); //集合中是否包含指定元素
2. Collection，List，Set的区别
Collection:不唯一，无序
List：不唯一，有序
Set：唯一，无序
3 .ArrayList和LinkedList的区别
a.都实现了List
b.ArrayList是可边长数组方式实现，查询效率高.
LinkedList是链表方式实现，增加和删除效率高.
4. List常用方法
List <Object> list = new ArrayList<Object>();
list.add(Obj); //增加元素
list.get(下标); //获取指定下标元素
list.size(); //长度
list.remove(Obj); //删除指定元素
list.contains(Obj); //是否包含指定元素
5 .Map 常用方法（键值对方式存储数据）
Map<Object,Object> maps = new HashMap<Object,Object>();
maps.put(key,value); //增加元素
maps.get(key); //获取指定key的值
maps.size(); //长度
maps.remove(key); //删除指定元素
maps.containsKey(key); //是否包含指定key
注意：
key是唯一的，如果重复那么后面的会覆盖前面的.
value是可以重复的.
6. Vector和ArrayList的异同
实现原理、功能相同、可以互用
Vector线程安全，ArrayList重速度轻安全，线程非安全
长度需增长时，Vector默认增长一倍，ArrayList增长50%
Hashtable和HashMap的异同
Hashtable继承Dictionary类，HashMap实现Map接口
Hashtable线程安全，HashMap线程非安全
Hashtable不允许null值，HashMap允许null值
一.什么是JDBC？
java中连接数据库的一种技术
是java各种应用程序和数据库之间的桥梁
由一组使用java语言编写的类和接口组成
二、JDBC中常用的API？
DriverManager类：管理不同数据库的jdbc驱动
Connection接口：负责连接数据库并担任传递数据的任务
Statement接口：由Connection产生，负责执行sql语句
PreparedStatement是Statement的子接口
除了具备父接口Statement的能力外，还具有4高（安全性、性能、可读性、可维护性）功能
ResultSet接口：负责保存和处理Statement返回的查询结果
三、使用JDBC如何连接sqlserver数据库？
1、加载驱动
编码前的准备工作
1.将sqljdbc2008.jar文件复制粘贴到项目的文件夹中
2.将项目和jdbc驱动关联编码，加载驱动
Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver"); //处理异常try…catch
2、编写数据库连接字符串、设置登录名、密码
2.1 final String url=”jdbc:sqlserver://localhost:1433;databasename=存在的数据库名”;
2.2 final String name = ”sqlserver身份验证的登录名”;
2.3 final String pwd = ”登录名对应的密码”;
3、使用DriverManger类的getConnection()方法，
关联url、name、pwd，返回一个Connection接口
Connection conn=DriverManger. getConnection(url ,name , pwd);
四、使用Statement接口对表的数据执行[增、删、改]操作
1、加载驱动连接数据库
2、 在try…catch外面，声明Statement变量并赋初值null
（或用PreparedStatement代替Statement）
Connection con=null;
Statement stm=null;
PreparedStatement pst=null;
3、 定义变量，保存sql语句（insert、delete、update语句）
使用PreparedStatement接口，sql语句中values()中的值，使用?
4、 DriverManager.getConnection()的下一行编写代码
Statement变量=Connection变量.createStatement();
PreparedStatement变量= Connection变量. prepareStatement(sql);
5、调用Statement变量的executeUpdate(sql)执行sql语句
int rows=executeUpdate(sql); //返回受影响的行数
为sql语句中的？赋值
PreparedStatement变量.set数据类型(数字，值);
调用PreparedStatement变量的executeUpdate()执行sql语句
int rows=executeUpdate();//返回受影响的行数
6、根据受影响的行数，判断sql语句执行是否成功---if(rows>0)
7、释放相关的资源
finally｛
try{
if(Statement变量或PreparedStatement变量!=null)
Statement变量(或PreparedStatement变量).close();
if(Connection变量!=null)
Connection变量.close ();
} catch (SQLException e){
e.printStackTrace ();
}
｝
五、使用JDBC查询表中的数据（ResultSet接口）
1、 加载sql2008 jdbc驱动包
（自动添加try…catch，手动添加finally语句块用于释放资源）
2、 在try…catch…finally语句块的外面，
a.声明3个接口(Connection、Statement或PreparedStatement、ResultSet的变量且赋值null)
b.在finally块中，调用这3个接口的close()释放资源
（有顺序：1.rs.close() 2.pstm.close() 3.con.close() ）
3、 编写数据库连接字符串url
（jdbc:sqlserver://localhost:1433;databasename=存在的数据库名）
4、 使用DriverManager.getConnection(url,”登录名”,”登录密码”);
获取Connection接口的对象
5、 编写sql查询语句，保存到字符串的变量中
6、 获取发送并执行sql查询语句的接口对象
a) 父接口Statement对象
Connection接口变量.createStatement ();
b)子接口PreparedStatement对象
Connection接口变量. prepareStatement (sql);
7、 调用Statement或PreparedStatement接口的方法,执行sql查询语句，返回ResultSet
a) 父接口Statement对象
ResultSet变量=Statement接口变量.executeQuery(sql);
b) 子接口PreparedStatement对象
ResultSet变量=Statement接口变量.executeQuery();
8、 使用while循环，调用ResultSet接口变量的get数据类型(数字或列名)方法，来获取表中列的值
while(ResultSet接口变量.next()){
ResultSet接口变量.get数据类型(数字或列名);
get数据类型(数字); //数字从1开始
get数据类型(“列名”);
}
// 增、删、改操作
public int getExecute(String sql, ArrayList<?> list) {
con = getDB();// 调用打开数据库的连接的方法
int rows =0;
try {
pst = con.prepareStatement(sql);
//list集合为null，说明sql语句中没有?
if (list != null) {
for (int i = 0; i < list.size(); i++) {
pst.setObject(i + 1, list.get(i));
}
rows=pst.executeUpdate();
}
} catch (SQLException e) {
e.printStackTrace();
}
return rows;
}
// 查
public ResultSet getExecuteQuery(String sql ,ArrayList<?> list) {
con = getDB();// 调用打开数据库的连接的方法
try {
pst = con.prepareStatement(sql);
//list集合为null，说明sql语句中没有?
if (list != null) {
for (int i = 0; i <list.size(); i++) {
pst.setObject(i + 1, list.get(i));
}
}
rs = pst.executeQuery();
} catch (SQLException e) {
e.printStackTrace();
}
return rs;
}
数据持久化
持久化：将程序中的数据在瞬间状态下和持久状态间转换的机制(JDBC)
主要持久化操作：保存、删除、读取、和查找。
采用面向接口编程，可以降低代码间的耦合性，提高代码的可扩展性和可维护性。
DAO模式
- DAO ( DataAccessObjects ,数据存取对象) ：
位于业务逻辑和持久化数据之间实现对持久化数据的访问
2.组成部分：
DAO接口：把对数据库的所有的操作定义成抽象方法，可以提供多种实现。
DAO实现类：针对不同数据库给出DAO接口定义方法的具体实现。
实体类：用于存放于传输对象数据。
数据库连接和关闭工具类：避免数据库连接和关闭代码的重复使用，方便修改
3.DAO模式提供了访问关系型数据库系统所需操作的接口，将数据访问和业务逻辑分 离，对上层提供面向对象的数据访问接口
4.优势：① 隔离了数据访问代码和业务逻辑代码；② 隔离了不同数据库实现。
分层开发
优势：
- 每一层专注于自己功能的实现，便于提高质量
- 便于分工协作，提高效率
- 便于代码复用
- 便于程序扩展
特点：
- 每一层都有自己的职责
- 上层不关心下层的实现细节，上层通过下层提供的对外接口来实现其功能
- 上层调用下层的功能，下层不能调用上层的功能；下层为上层提供服务，而不使用上层提供的功能
原则：
① 封装性原则：每个层次向外提供公开的统一接口，隐藏内部的功能实现细节，其他层次不能也没有必要了解其内部细节。
② 顺序访问原则：下一层为上一层提供服务，而不使用上一层提供的服务
(业务逻辑层 ----> 数据访问层 业务逻辑层 <---- 数据访问层)
实体类
特征：1.属性一般用private修饰（getter/setter方法—---用public修饰）；
2.最好实现java.io.Serializable接口支持序列化机制，可以将该对象转换成字节序列而保存在磁盘上或在网络上传输；
3.对实体类提供无参构造方法，根据业务需要提供相应的有参构造方法；
4.定义属性serialVersionUID，解决不同版本之间的序列化问题
(private static final long serialVersionUID=2070056025956126480L)
方法调用时：
表示层——>业务逻辑层——>数据访问层
写代码时：
数据访问层——>业务逻辑层——>表示层
实体类（表在面向对象中的实现）：
表名——类名、字段——属性 编写一个实体类，将一个表用类实现；包名——entity或models存放实体类
测试类、网页、界面UI(表示层)——main方法所在的类
业务逻辑层(桥梁作用)：
表示层的数据，传递到数据访问层
BaseDAO类：
对表进行操作的类（包存放）——数据访问层 对数据库的访问和操作（辅助类）
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
