Javaweb复习资料（一）

本是古典何须时尚 2022-10-06 09:57 233阅读 0赞

### 文章目录 ###

*  Javaweb 内部复习资料
 *   *  题型与分值：
     *  考点
     *   *  1.java:
         *  2.web
         *  3.Javaweb
 *  一、Java知识
 *  1. 面向对象思想
 *   *  1.1 面向对象思想概述
     *   *  概述
         *  举例
         *  区别:
         *  特点
     *  1.2 类和对象
     *   *  什么是类
         *  什么是对象
         *  类与对象的关系
     *  1.3 类的定义
     *   *  事物与类的对比
         *  类的定义格式
         *  类的定义格式举例：
     *  1.4 对象的使用
     *   *  对象的使用格式
         *  成员变量的默认值
     *  1.5 类与对象的练习
     *  1.6 对象内存图（看得懂看，看不懂过）
     *   *  一个对象，调用一个方法内存图
         *  两个对象，调用同一方法内存图
         *  一个引用，作为参数传递到方法中内存图
     *  1.7 成员变量和局部变量区别
 *  2. Java封装
 *   *  2.1 封装概述
     *   *  概述
         *  原则
     *  2.2 封装的步骤
     *  2.3 封装的操作——private关键字
     *   *  private的含义
         *  private的使用格式
     *  2.4 封装优化1——this关键字
     *   *  this的含义
         *   *  注意：
         *  this使用格式
         *   *  注意：
     *  2.5 封装优化2——构造方法
     *   *  构造方法的定义格式
         *  注意事项
     *  2.6 标准代码——JavaBean
 *  3. 继承
 *   *  1.1 概述
     *   *  由来
         *  定义
         *  好处
     *  1.2 继承的格式
     *  1.3 继承后的特点——成员变量
     *   *  成员变量不重名
         *  成员变量重名
         *  使用格式：
         *   *  注意：
     *  1.4 继承后的特点——成员方法
     *   *  成员方法不重名
         *  成员方法重名——重写(Override)
         *  重写的应用
         *  注意：这里重写时，用到super.父类成员方法，表示调用父类的成员方法。
     *  注意事项
     *  1.5 继承后的特点——构造方法
     *  1.6 super和this
     *   *  父类空间优先于子类对象产生
         *  super和this的含义
         *  super和this的用法
     *  1.7 继承的特点
 *  4. 抽象类(应用了解，辨别重点)
 *   *  1.1 概述
     *   *  由来
         *  定义
     *  1.2 abstract使用格式
     *   *  抽象方法
         *  定义格式：
         *  抽象类
         *  抽象的使用
     *  1.3 注意事项（选择常考）
 *  5. 接口
 *   *  1.1 概述
     *  1.2 定义格式
     *   *  含有抽象方法
         *  含有默认方法和静态方法
         *  含有私有方法和私有静态方法
     *  1.3 基本的实现
     *   *  实现的概述
         *  非抽象子类实现接口：
         *  抽象方法的使用
         *  默认方法的使用
         *   *  2. 重写默认方法，代码如下：
         *  静态方法的使用
         *  私有方法的使用
     *  1.4 接口的多实现
     *   *  抽象方法
         *  默认方法
         *  静态方法
         *   *  优先级的问题
     *  1.5 接口的多继承【了解】
     *   *  小贴士：
     *  1.6 其他成员特点
     *  1.7 接口与继承综合案例
 *  6.补充知识：权限修饰符
 *   *  概述
     *  不同权限的访问能力
     *  default关键字介绍
     *   *  举例
 *  7. 补充知识：ﬁnal关键字
 *   *  1.1 概述
     *  1.2 使用方式
     *   *  修饰类
     *  修饰方法
     *  修饰变量
     *   *  1. 局部变量——基本类型
         *   *  思考，如下两种写法，哪种可以通过编译？
         *  2. 局部变量——引用类型
         *  3. 成员变量
 *  8. 常用的核心类及其方法正在整理
 *  二、Web知识
 *  1. HTML基础
 *   *  Web 标准构成
     *  HTML 初识
     *   *  HTML骨架格式
         *  HTML标签分类
         *  HTML标签关系
     *  文档类型
     *  字符集
     *  HTML标签的语义化
     *   *  为什么要有语义化标签
     *  HTML常用标签
     *   *  排版标签
         *   *  标题标签 (熟记)
             *  段落标签( 熟记)
             *  水平线标签(认识)
     *  楚乔传小案例
     *  标签（标签考试看一遍就行，熟悉即可）
     *   *  换行标签(熟记)
         *  div span标签(重点)
         *  文本格式化标签(熟记)
         *  标签属性
         *  图像标签img (重点)
         *  链接标签(重点)
         *   *  锚点定位 （难点）
             *  base 标签 基本的
         *  注释标签
     *  路径(重点、难点)
     *   *  相对路径
         *  绝对路径
     *  列表标签(Javaweb考试过就行)
     *   *  无序列表 ul （重点）
         *  有序列表 ol （了解）
         *  自定义列表（理解）
         *  链接小案例
     *  表单标签（※）
     *   *  概念
         *  input 控件(重点)
         *  label标签(理解)
         *  textarea控件(文本域)
         *  下拉菜单
         *   *  注意：
     *  表单域
     *   *   *  注意：
         *  案例 有缘网
 *  2. CSS知识——网页的美容师
 *   *  CSS初识
     *  引入CSS样式表（书写位置）（必考）
     *   *  内部样式表
         *  行内式（内联样式）
         *  外部样式表（外链式）
         *  三种样式表总结（位置）
     *  CSS样式规则
     *   *  外链案例
         *  内链案例
     *  CSS四种基础选择器（类和标签必考）
     *   *  标签选择器（元素选择器）
         *  类选择器
         *   *  类选择器小案例
             *  小案例 制作一个简易Google图标
         *  多类名选择器
         *   *  案例
         *  id选择器
         *  id选择器和类选择器区别
         *   *  案例
         *  通配符选择器
         *  案例
 *  3. JavaScript知识
 *   *  JavaScript介绍
     *   *  JavaScript是什么
         *  JavaScript最初的目的
         *  JavaScript现在的意义(应用场景)
         *  JavaScript和HTML、CSS的区别
     *  JavaScript的组成
     *  函数
     *   *  什么是函数
         *  函数的定义
         *   *  函数的调用
         *  函数的参数
         *  函数的返回值
         *  arguments的使用（了解，其实就是自动统计保存输入的参数序列）
     *  函数其它（有空就了解）
     *   *  匿名函数
         *  自调用函数
         *  函数是一种数据类型
         *  代码规范
     *  Windows对象，Document对象 （重中之重）
 *  三、JavaWeb知识
 *  1. JDBC 入门
 *   *  1.1 客户端操作 MySQL 数据库的方式：
     *   *  1.1.1什么是 JDBC
         *  使用 JDBC 的好处：
         *  1.1.2 使用 JDBC 开发使用到的包：
     *  1.2 JDBC 的核心 API
     *  1.3导入驱动 Jar 包
     *  1.4加载和注册驱动
     *   *   *  com.mysql.jdbc.Driver 源代码：
 *  2. DriverManager 类
 *   *  2.1DriverManager 作用：
     *  2.2类中的方法：
     *  2.3 使用 JDBC 连接数据库的四个参数：
     *  2.4 连接数据库的 URL 地址格式：
     *   *  2.4.1MySQL 写法：
         *  2.4.2MySQL 中可以简写：
         *  2.4.3乱码的处理
         *  2.5 案例：得到 MySQL 的数据库连接对象
         *   *  2.5.1 使用用户名、密码、URL 得到连接对象
             *  2.5.2 使用属性文件和 url 得到连接对象
 *  3. Connection 接口：
 *   *  3.1 Connection 作用：
     *  3.2 Connection 方法：
 *  4. Statement 接口
 *   *  4.1JDBC 访问数据库的步骤
     *  4.2 Statement 作用：
     *  4.3Statement 中的方法：
     *  4.4释放资源
     *  4.5执行 DDL 操作
     *   *  4.5.1需求：使用 JDBC 在 MySQL 的数据库中创建一张学生表
         *  4.5.2代码：
     *  4.6执行 DML 操作
     *   *  步骤：
         *  代码：
     *  4.7执行 DQL 操作
     *   *  4.7.1ResultSet 接口：
         *   *  接口中的方法：
         *  4.7.2常用数据类型转换表
         *  4.7.3需求：确保数据库中有 3 条以上的记录，查询所有的学员信息
         *   *  步骤：
             *  代码：
         *  4.7.4关于 ResultSet 接口中的注意事项：
 *  5. 数据库工具类 JdbcUtils
 *   *  什么时候自己创建工具类？
     *  5.1需求：
     *  5.2创建类 JdbcUtil 包含 3 个方法：
     *   *  JdbcUtil.java 代码：
     *  5.3案例：用户登陆
     *   *  5.3.1需求：
         *  5.3.2步骤：
         *  5.3.3代码

# Javaweb 内部复习资料 #

## 题型与分值： ##

一、选择题 （20分，1分/题，单选/多选）；

二、简答题 （30分，7选6， 5分/题，全做的话只判前6题）；

三、程序填空题（50分，2分/空）

百分之30 web前端 百分之30 Javaweb后台百分之40

## 考点 ##

### 1.java: ###

java 泛型与集合不考  
java部分 类之间关系 继承最重要  
核心类 常用的掌握一下就行  
内部类应该不会考到  
抽象类接口肯定考到/打call

### 2.web ###

CSS掌握四种样式表  
掌握四种选择符  
CSS不要求不要求太多  
JS 定位对象 掌握

### 3.Javaweb ###

后台 servlet原理 类 体系 方法  
生命周期 session必须掌握 重定向和转发  
jsp 原理 注释 声明 表达式 代码段 指令 JSP动作 常考include指令与include动作的区别 JSP内置对象 JSP动作publag不用掌握  
java bean 编写规则 MVC模式  
EL和JSTL和阿贾克斯不用看  
JDBC步骤掌握 prepareSTatment和statment区别

# 一、Java知识 #

# 1. 面向对象思想 #

## 1.1 面向对象思想概述 ##

### 概述 ###

Java语言是一种面向对象的程序设计语言，而面向对象思想是一种程序设计思想，我们在面向对象思想的指引下，使用Java语言去设计、开发计算机程序。 这里的对象泛指现实中一切事物，每种事物都具备自己的属性和行为。

面向对象思想就是在计算机程序设计过程中，参照现实中事物，将事物的属性特征、行为特征抽象出来，描述成计算机事件的设计思想。

它区别于面向过程思想，强调的是通过调用对象的行为来实现功能，而不是自己一步一步的去操作实现。

### 举例 ###

洗衣服:

面向过程：把衣服脱下来–>找一个盆–>放点洗衣粉–>加点水–>浸泡10分钟–>揉一揉–>清洗衣服–>拧干–>晾起来  
面向对象：把衣服脱下来–>打开全自动洗衣机–>扔衣服–>按钮–>晾起来

### 区别: ###

面向过程：强调步骤。  
面向对象：强调对象，这里的对象就是洗衣机。

### 特点 ###

面向对象思想是一种更符合我们思考习惯的思想，它可以将复杂的事情简单化，并将我们从执行者变成了指挥者。  
面向对象的语言中，包含了三大基本特征，即封装、继承和多态。

## 1.2 类和对象 ##

环顾周围，你会发现很多对象，比如桌子，椅子，同学，老师等。桌椅属于办公用品，师生都是人类。那么什么是  
类呢？什么是对象呢？

### 什么是类 ###

类：是一组相关属性和行为的集合。

可以看成是一类事物的模板，使用事物的属性特征和行为特征来描述该类事物。

现实中，描述一类事物：

*  属性：就是该事物的状态信息。
 *  行为：就是该事物能够做什么。

举例：小狗。

*  属性：名字、体重、年龄、颜色。
 *  行为：走、跑、叫。

### 什么是对象 ###

对象：是一类事物的具体体现。对象是类的一个实例（对象并不是找个女朋友），必然具备该类事物的属性和行为。

现实中，一类事物的一个实例：一只小猫。

举例：一只小猫。

属性：tom、5kg、2 years、yellow。 行为：溜墙根走、蹦跶的跑、汪汪叫。

### 类与对象的关系 ###

类是对一类事物的描述，是抽象的。对象是一类事物的实例，是具体的。

类是对象的模板，对象是类的实体。

如下图所示：抽象的人型建模与真实的人  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70]

## 1.3 类的定义 ##

### 事物与类的对比 ###

现实世界的一类事物：

*  属性：事物的状态信息。
 *  行为：事物能够做什么。

Java中用class描述事物也是如此：

*  成员变量：对应事物的属性
 *  成员方法：对应事物的行为

### 类的定义格式 ###

public class ClassName { 
    //成员变量//成员方法
    }

定义类：就是定义类的成员，包括成员变量和成员方法。  
成员变量：和以前定义变量几乎是一样的。只不过位置发生了改变。在类中，方法外。  
成员方法：和以前定义方法几乎是一样的。只不过把static去掉，static的作用在面向对象后面课程中再详细讲解。

### 类的定义格式举例： ###

public class Student { 
    	//成员变量
    	String name；//姓名int age；//年龄
    	//成员方法//学习的方法
    	publicvoid study() {  System.out.println("好好学习，天天向上");
    }
    
    //吃饭的方法
    publicvoid eat() { 
    	System.out.println("学习饿了要吃饭");
    	
    	}
    }

## 1.4 对象的使用 ##

### 对象的使用格式 ###

创建对象：

类名 对象名 = new 类名();

使用对象访问类中的成员:

对象名.成员变量；  
对象名.成员方法()；

对象的使用格式举例:

public class Test01_Student { 
    	public static void main(String[] args) {  
    		//创建对象格式：类名 对象名 = new 类名(); 
    		Student s = new Student();
    		System.out.println("s:"+s); //cn.itcast.Student@100363
    		
    		//直接输出成员变量值
    		System.out.println("姓名："+s.name); //null 
    		System.out.println("年龄："+s.age); //0 
    		System.out.println("‐‐‐‐‐‐‐‐‐‐");
    		
    		//给成员变量赋值
    		s.name = "赵丽颖"; 
    		s.age = 18;
    		
    		//再次输出成员变量的值
    		System.out.println("姓名："+s.name); //赵丽颖
    		System.out.println("年龄："+s.age); //18 
    		System.out.println("‐‐‐‐‐‐‐‐‐‐");
    		
    		//调用成员方法
    		s.study(); // "好好学习，天天向上" 
    		s.eat(); // "学习饿了要吃饭"
    	
    	}
    }

### 成员变量的默认值 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 1]

## 1.5 类与对象的练习 ##

定义手机类：

public class Phone { 
    	// 成员变量
    	String brand; 	//品牌
    	int price; 		//价格
    	String color; 	//颜色
    	
    	// 成员方法//打电话
    	public void call(String name) { 
    		System.out.println("给"+name+"打电话");
    	}
    	//发短信
    	public void sendMessage() { 
    		System.out.println("群发短信");
    	}
    }

定义测试类：

public class Test02Phone { 
    	public static void main(String[] args) { 
    		//创建对象
    		Phone p = new Phone();
    		
    		//输出成员变量值
    		System.out.println("品牌："+p.brand);//null 
    		System.out.println("价格："+p.price);//0 
    		System.out.println("颜色："+p.color);//null
    		
    		System.out.println("‐‐‐‐‐‐‐‐‐‐‐‐");
    		
    		//给成员变量赋值
    		p.brand = "锤子"; 
    		p.price = 2999; 
    		p.color = "棕色";
    		
    		//再次输出成员变量值
    		System.out.println("品牌："+p.brand);//锤子
    		System.out.println("价格："+p.price);//2999 
    		System.out.println("颜色："+p.color);//棕色
    		System.out.println("‐‐‐‐‐‐‐‐‐‐‐‐");
    		
    		//调用成员方法
    		p.call("紫霞"); 
    		p.sendMessage();
    		
    	}
    
    }

## 1.6 对象内存图（看得懂看，看不懂过） ##

### 一个对象，调用一个方法内存图 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 2]

> 通过上图，我们可以理解，在栈内存中运行的方法，遵循"先进后出，后进先出"的原则。变量p指向堆内存中的空间，寻找方法信息，去执行该方法。

> 但是，这里依然有问题存在。创建多个对象时，如果每个对象内部都保存一份方法信息，这就非常浪费内存  
> 了，因为所有对象的方法信息都是一样的。那么如何解决这个问题呢？请看如下图解。

### 两个对象，调用同一方法内存图 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 3]

> 对象调用方法时，根据对象中方法标记（地址值），去类中寻找方法信息。这样哪怕是多个对象，方法信息只保存一份，节约内存空间。

### 一个引用，作为参数传递到方法中内存图 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 4]

> 引用类型作为参数，传递的是地址值。

## 1.7 成员变量和局部变量区别 ##

变量根据定义位置的不同，我们给变量起了不同的名字。如下图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 5]

*  在类中的位置不同 **重点**
    
    成员变量：类中，方法外  
    局部变量：方法中或者方法声明上(形式参数)

*  作用范围不一样 **重点**
    
    成员变量：类中  
    局部变量：方法中

*  初始化值的不同 **重点**
    
    成员变量：有默认值  
    局部变量：没有默认值。必须先定义，赋值，最后使用
 *  在内存中的位置不同 **了解**
    
    成员变量：堆内存  
    局部变量：栈内存
 *  生命周期不同 **了解**
    
    成员变量：随着对象的创建而存在，随着对象的消失而消失  
    局部变量：随着方法的调用而存在，随着方法的调用完毕而消失

# 2. Java封装 #

## 2.1 封装概述 ##

### 概述 ###

面向对象编程语言是对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界无法直接操作和修改。封装可以被认为是一个保护屏障，防止该类的代码和数据被其他类随意访问。要访问该类的数据，必须通过指定的方式。适当的封装可以让代码更容易理解与维护，也加强了代码的安全性。

### 原则 ###

将属性隐藏起来，若需要访问某个属性，提供公共方法对其访问。

## 2.2 封装的步骤 ##

1.  使用 private 关键字来修饰成员变量。
2.  对需要访问的成员变量，提供对应的一对 getXxx 方法 、 setXxx 方法。

## 2.3 封装的操作——private关键字 ##

### private的含义 ###

1.  private是一个权限修饰符，代表最小权限。
2.  可以修饰成员变量和成员方法。
3.  被private修饰后的成员变量和成员方法，只在本类中才能访问。

### private的使用格式 ###

private 数据类型 变量名 ；

1.  使用 private 修饰成员变量，代码如下：
    
        public class Student {  
        	private String name; 
        	private int age;
        }
2.  提供 getXxx 方法 / setXxx 方法，可以访问成员变量，代码如下：
    
        public class Student {  
        	private String name; 
        	private int age;
        
        	public void setName(String n) { 
        		name = n;
        	}
        	
        	public String getName() { 
        		return name;
        	}
        	
        	public void setAge(int a) { 
        		age = a;
        	}
        	
        	public int getAge() { 
        		return age;
        	}
        }

## 2.4 封装优化1——this关键字 ##

我们发现 setXxx 方法中的形参名字并不符合见名知意的规定，那么如果修改与成员变量名一致，是否就见名知意了呢？

代码如下：

public class Student {  
    	private String name; 
    	private int age;
    	public void setName(String name) { 
    		name = name;
    	}
    
    	public void setAge(int age) { 
    		age = age;
    	}
    }

经过修改和测试，我们发现新的问题，成员变量赋值失败了。也就是说，在修改了 setXxx() 的形参变量名后，方法并没有给成员变量赋值！这是由于形参变量名与成员变量名重名，导致成员变量名被隐藏，方法中的变量名，无法访问到成员变量，从而赋值失败。所以，我们只能使用this关键字，来解决这个重名问题。

### this的含义 ###

this代表所在类的当前对象的引用（地址值），即对象自己的引用。

#### 注意： ####

方法被哪个对象调用，方法中的this就代表那个对象。即谁在调用，this就代表谁。

### this使用格式 ###

this.成员变量名；

使用 this 修饰方法中的变量，解决成员变量被隐藏的问题，代码如下：

public class Student {  
    
    	private String name; 
    	private int age;
    	
    	public void setName(String name) { 
    		//name = name; 
    		this.name = name;
    	}
    	
    	public String getName() { 
    		return name;
    	}
    	
    	public void setAge(int age) { 
    		//age = age; 
    		this.age = age;
    	}
    	
    	public int getAge() { 	
    		return age;
    	}
    }

#### 注意： ####

方法中只有一个变量名时，默认也是使用 this 修饰，可以省略不写。

## 2.5 封装优化2——构造方法 ##

当一个对象被创建时候，构造方法用来初始化该对象，给对象的成员变量赋初始值。

小贴士：无论你与否自定义构造方法，所有的类都有构造方法，因为Java自动提供了一个无参数构造方法，一旦自己定义了构造方法，Java自动提供的默认无参数构造方法就会失效。

### 构造方法的定义格式 ###

修饰符 构造方法名(参数列表){ 
    // 方法体
    
    }

构造方法的写法上，方法名与它所在的类名相同。它没有返回值，所以不需要返回值类型，甚至不需要void。使用构造方法后，代码如下：

public class Student {  
    	private String name; 
    	private int age;
    	// 无参数构造方法
    	public Student() { } 
    	// 有参数构造方法
    	public Student(String name,int age) { 
    		this.name = name; 
    		this.age = age;
    	}
    }

### 注意事项 ###

1.  如果你不提供构造方法，系统会给出无参数构造方法。
2.  如果你提供了构造方法，系统将不再提供无参数构造方法。
3.  构造方法是可以重载的，既可以定义参数，也可以不定义参数。

## 2.6 标准代码——JavaBean ##

JavaBean 是 Java语言编写类的一种标准规范。符合 JavaBean 的类，要求类必须是具体的和公共的，并且具有无  
参数的构造方法，提供用来操作成员变量的 set 和 get 方法。

public class ClassName{
    	//成员变量
    	//构造方法
    	//无参构造方法【必须】
    	//有参构造方法【建议】
    	//成员方法
    	//getXxx()
    	//setXxx()
    }

编写符合 JavaBean 规范的类，以学生类为例，标准代码如下：

public class Student { 
    	//成员变量
    	
    	private String name; 
    	private int age;
    	
    	//构造方法
    	
    	public Student() { }
    	
    	public Student(String name,int age) { 
    		this.name = name; 
    		this.age = age;
    	}
    	
    	//成员方法
    	
    	publicvoid setName(String name) { 
    		this.name = name;
    	}
    	
    	public String getName() { 
    		return name;
    	}
    	
    	publicvoid setAge(int age) { 
    		this.age = age;
    	}
    	
    	publicint getAge() { 
    		return age;
    	}
    }

测试类，代码如下：

public class TestStudent { 
    	public static void main(String[] args) { 
    		//无参构造使用
    		Student s= new Student(); 
    		s.setName("柳岩"); 
    		s.setAge(18);
    		
    		System.out.println(s.getName()+"‐‐‐"+s.getAge());
    		
    		//带参构造使用
    		Student s2= new Student("赵丽颖",18);
    		System.out.println(s2.getName()+"‐‐‐"+s2.getAge());
    		
    	}
    }

# 3. 继承 #

## 1.1 概述 ##

### 由来 ###

多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那一个类即可。

如图所示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 6]

其中，多个类可以称为子类，单独那一个类称为父类、超类（superclass）或者基类。

继承描述的是事物之间的所属关系，这种关系是： is-a 的关系。例如，图中兔子属于食草动物，食草动物属于动  
物。可见，父类更通用，子类更具体。我们通过继承，可以使多种事物之间形成一种关系体系。

### 定义 ###

继承：就是子类继承父类的属性和行为，使得子类对象具有与父类相同的属性、相同的行为。子类可以直接  
访问父类中的非私有的属性和行为。

### 好处 ###

1.  提高代码的复用性。
2.  类与类之间产生了关系，是多态的前提。

## 1.2 继承的格式 ##

通过 extends 关键字，可以声明一个子类继承另外一个父类，定义格式如下：

class 父类 { 
    ...
    }
    class 子类 extends 父类 { 
    ...
    }

继承演示，代码如下：

/* * 定义员工类Employee，做为父类 */
    class Employee { 
    String name; // 定义name属性
    // 定义员工的工作方法
    public void work() { 
    		System.out.println("老师尽心尽力地工作");
    	}
    }
    /* * 定义讲师类Teacher 继承 员工类Employee */
    class Teacher extends Employee { 
    	// 定义一个打印name的方法
    	public void printName() { 
    	System.out.println("name=" + name);
    	}
    }
    /* * 定义测试类 */
    public class ExtendDemo01 { 
    	public static void main(String[] args) { 
    		// 创建一个讲师类对象
    		Teacher t = new Teacher();
    		// 为该员工类的name属性进行赋值
    		t.name = "小明";
    		// 调用该员工的printName()方法
    		t.printName(); // name = 小明
    		// 调用Teacher类继承来的work()方法
    		t.work(); // 老师尽心尽力地工作
    	}
    }

## 1.3 继承后的特点——成员变量 ##

当类之间产生了关系后，其中各类中的成员变量，又产生了哪些影响呢？

### 成员变量不重名 ###

如果子类父类中出现不重名的成员变量，这时的访问是没有影响的。

代码如下：

class Fu { 
    	// Fu中的成员变量。
    	int num = 5;
    }
    class Zi extends Fu { 
    	// Zi中的成员变量
    	int num2 = 6;
    	// Zi中的成员方法
    	public void show() { 
    		// 访问父类中的num，
    		System.out.println("Fu num="+num); // 继承而来，所以直接访问。
    		// 访问子类中的num2
    		System.out.println("Zi num2="+num2);
    	}
    }
    class ExtendDemo02 { 
    		public static void main(String[] args) { 
    		// 创建子类对象
    		Zi z = new Zi();
    		// 调用子类中的show方法
    		z.show();
    	}
    }

演示结果：

Fu num = 5
    Zi num2 = 6

### 成员变量重名 ###

如果子类父类中出现重名的成员变量，这时的访问是有影响的。代码如下：

class Fu { 
    	// Fu中的成员变量。
    	int num = 5;
    }
    class Zi extends Fu { 
    	// Zi中的成员变量
    	int num = 6;
    	public void show() { 
    		// 访问父类中的num
    		System.out.println("Fu num=" + num);
    		// 访问子类中的num
    		System.out.println("Zi num=" + num);
    	}
    }
    class ExtendsDemo03 { 
    	public static void main(String[] args) { 
    		// 创建子类对象
    		Zi z = new Zi();
    		// 调用子类中的show方法
    		z.show();
    	}
    }

演示结果：

Fu num = 6
    Zi num = 6

子父类中出现了同名的成员变量时，在子类中需要访问父类中非私有成员变量时，需要使用 `super` 关键字，修饰父类成员变量，类似于之前学过的 this 。

### 使用格式： ###

super.父类成员变量名

子类方法需要修改，代码如下：

class Zi extends Fu { 
    	// Zi中的成员变量
    	int num = 6;
    	public void show() { 
    		//访问父类中的num
    		System.out.println("Fu num=" + super.num);
    		//访问子类中的num
    		System.out.println("Zi num=" + this.num);
    	}
    }

演示结果：

Fu num = 5
    Zi num = 6

#### 注意： ####

> Fu 类中的成员变量是非私有的，子类中可以直接访问。若Fu  
> 类中的成员变量私有了，子类是不能直接访问的。通常编码时，我们遵循封装的原则，使用private修饰成员变量，那么如何访问父类的私有成员  
> 变量呢？对！可以在父类中提供公共的getXxx方法和setXxx方法。

## 1.4 继承后的特点——成员方法 ##

当类之间产生了关系，其中各类中的成员方法，又产生了哪些影响呢？

### 成员方法不重名 ###

如果子类父类中出现不重名的成员方法，这时的调用是没有影响的。对象调用方法时，会先在子类中查找有没有对应的方法，若子类中存在就会执行子类中的方法，若子类中不存在就会执行父类中相应的方法。

代码如下：

class Fu{ 
    	public void show(){ 
    		System.out.println("Fu类中的show方法执行");
    	}
    }
    class Zi extends Fu{ 
    	public void show2(){ 
    		System.out.println("Zi类中的show2方法执行");
    	}
    }
    public class ExtendsDemo04{ 
    	public static void main(String[] args) { 
    		Zi z = new Zi();
    		//子类中没有show方法，但是可以找到父类方法去执行
    		z.show();
    		z.show2();
    	}
    }

### 成员方法重名——重写(Override) ###

如果子类父类中出现重名的成员方法，这时的访问是一种特殊情况，叫做`方法重写(Override)。`

**方法重写** ：子类中出现与父类一模一样的方法时（返回值类型，方法名和参数列表都相同），会出现**覆盖效果**，也称为重写或者复写。声明不变，重新实现。

代码如下：

class Fu { 
    	public void show() { 
    		System.out.println("Fu show");
    	}
    }
    class Zi extends Fu { 
    	//子类重写了父类的show方法
    	public void show() { 
    		System.out.println("Zi show");
    	}
    }
    public class ExtendsDemo05{ 
    	public static void main(String[] args) { 
    		Zi z = new Zi();
    		// 子类中有show方法，只执行重写后的show方法
    		z.show(); // Zi show
    	}
    }

### 重写的应用 ###

子类可以根据需要，定义特定于自己的行为。既沿袭了父类的功能名称，又根据子类的需要重新实现父类方法，从而进行扩展增强。比如新的手机增加来电显示头像的功能，

代码如下：

class Phone { 
    	public void sendMessage(){ 
    		System.out.println("发短信");
    	}
    	public void call(){ 
    		System.out.println("打电话");
    	}
    	public void showNum(){ 
    		System.out.println("来电显示号码");
    	}
    }
    
    //智能手机类
    class NewPhone extends Phone { 
    	//重写父类的来电显示号码功能，并增加自己的显示姓名和图片功能
    	public void showNum(){ 
    		//调用父类已经存在的功能使用super
    		super.showNum();
    		//增加自己特有显示姓名和图片功能
    		System.out.println("显示来电姓名");
    		System.out.println("显示头像");
    	}
    }
    public class ExtendsDemo06 { 
    	public static void main(String[] args) { 
    		// 创建子类对象
    		NewPhone np = new NewPhone()；
    		// 调用父类继承而来的方法
    		np.call();
    		// 调用子类重写的方法
    		np.showNum();
    	}
    }

### 注意：这里重写时，用到super.父类成员方法，表示调用父类的成员方法。 ###

## 注意事项 ##

1.  子类方法覆盖父类方法，必须要保证权限大于等于父类权限。
2.  子类方法覆盖父类方法，返回值类型、函数名和参数列表都要一模一样。

## 1.5 继承后的特点——构造方法 ##

当类之间产生了关系，其中各类中的构造方法，又产生了哪些影响呢？

首先我们要回忆两个事情，构造方法的定义格式和作用。

1.  构造方法的名字是与类名一致的。所以子类是无法继承父类构造方法的。
2.  构造方法的作用是初始化成员变量的。所以子类的初始化过程中，必须先执行父类的初始化动作。子类的构  
    造方法中默认有一个 super() ，表示调用父类的构造方法，父类成员变量初始化后，才可以给子类使用。

代码如下：

class Fu { 
    	private int n;
    	Fu(){ 
    		System.out.println("Fu()");
    	}
    }
    
    class Zi extends Fu { 
    	Zi(){ 
    		// super（），调用父类构造方法
    		super();
    		System.out.println("Zi（）");
    	}
    }
    public class ExtendsDemo07{ 
    	public static void main (String args[]){ 
    		Zi zi = new Zi();
    	}
    }

输出结果：

Fu（）
    Zi（）

## 1.6 super和this ##

### 父类空间优先于子类对象产生 ###

在每次创建子类对象时，先初始化父类空间，再创建其子类对象本身。目的在于子类对象中包含了其对应的父类空间，便可以包含其父类的成员，如果父类成员非private修饰，则子类可以随意使用父类成员。

代码体现在子类的构造方法调用时，一定先调用父类的构造方法。理解图解如下：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 7]

### super和this的含义 ###

*  super ：代表父类的存储空间标识(可以理解为父亲的引用)。
 *  this ：代表当前对象的引用(谁调用就代表谁)。

### super和this的用法 ###

1.  访问成员
    
        this.成员变量——本类的
        super.成员变量——父类的
        
        this.成员方法名()——本类的
        super.成员方法名()——父类的
    
    用法演示，代码如下：
    
        class Animal { 
        	public void eat() { 
        		System.out.println("animal : eat");
        	}
        }
        class Cat extends Animal { 
        	public void eat() { 
        		System.out.println("cat : eat");
        	}
        	public void eatTest() { 
        		this.eat();
        		// this 调用本类的方法
        		super.eat(); // super 调用父类的方法
        		}
        	}
        public class ExtendsDemo08 { 
        	public static void main(String[] args) { 
        		Animal a = new Animal();
        		a.eat();
        		Cat c = new Cat();
        		c.eatTest();
        	}
        }
    
    输出结果为：
    
        animal : eat
        cat : eat
        animal : eat
2.  访问构造方法
    
        this(...) ——本类的构造方法
        super(...) ——父类的构造方法
    
    > 子类的每个构造方法中均有默认的super()，调用父类的空参构造。手动调用父类构造会覆盖默认的super()。
    > 
    > super() 和 this() 都必须是在构造方法的第一行，所以不能同时出现。

## 1.7 继承的特点 ##

1. Java只支持单继承，不支持多继承。

//一个类只能有一个父类，不可以有多个父类。
    class C extends A{ } //ok
    class C extends A，B... //error

2. Java支持多层继承(继承体系)。

class A{ }
    class B extends A{ }
    class C extends B{ }

顶层父类是Object类。所有的类默认继承Object，作为父类。

3. 子类和父类是一种相对的概念。

# 4. 抽象类(应用了解，辨别重点) #

## 1.1 概述 ##

### 由来 ###

父类中的方法，被它的子类们重写，子类各自的实现都不尽相同。那么父类的方法声明和方法主体，只有声明还有  
意义，而方法主体则没有存在的意义了。我们把没有方法主体的方法称为抽象方法。Java语法规定，包含抽象方法  
的类就是抽象类。

### 定义 ###

抽象方法 ： 没有方法体的方法。  
抽象类：包含抽象方法的类。

## 1.2 abstract使用格式 ##

### 抽象方法 ###

使用 abstract 关键字修饰方法，该方法就成了抽象方法，抽象方法只包含一个方法名，而没有方法体。

### 定义格式： ###

修饰符 abstract 返回值类型 方法名 (参数列表)；

代码举例：

public abstract void run()；

### 抽象类 ###

如果一个类包含抽象方法，那么该类必须是抽象类。  
定义格式：

abstract class 类名字 { 
    }

代码举例：

public abstract class Animal { 
        public abstract void run()；
    }

### 抽象的使用 ###

继承抽象类的子类必须重写父类所有的抽象方法。否则，该子类也必须声明为抽象类。最终，必须有子类实现该父类的抽象方法，否则，从最初的父类到最终的子类都不能创建对象，失去意义。

代码举例：

public class Cat extends Animal { 
        public void run (){ 
            System.out.println("小猫在墙头走~~~")；
        }
    }
    public class CatTest { 
        public static void main(String[] args) { 
            // 创建子类对象
            Cat c = new Cat();
            // 调用run方法
            c.run();
        }
    }

输出结果：

小猫在墙头走~~~

此时的方法重写，是子类对父类抽象方法的完成实现，我们将这种方法重写的操作，也叫做实现方法。

## 1.3 注意事项（选择常考） ##

关于抽象类的使用，以下为语法上要注意的细节，虽然条目较多，但若理解了抽象的本质，无需死记硬背。

1.  抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。  
    理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。
2.  抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。  
    理解：子类的构造方法中，有默认的super()，需要访问父类构造方法。
3.  抽象类中，不一定包含抽象方法，但是有抽象方法的类必定是抽象类。  
    理解：未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设  
    计。
4.  抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象  
    类。  
    理解：假设不重写所有抽象方法，则类中可能包含抽象方法。那么创建对象后，调用抽象的方法，没有  
    意义。

# 5. 接口 #

## 1.1 概述 ##

接口，是Java语言中一种引用类型，是方法的集合，如果说类的内部封装了成员变量、构造方法和成员方法，那么接口的内部主要就是封装了方法，包含抽象方法（JDK 7及以前），默认方法和静态方法（JDK 8），私有方法（JDK 9）。

接口的定义，它与定义类方式相似，但是使用 interface 关键字。它也会被编译成.class文件，但一定要明确它并不是类，而是另外一种引用数据类型。

引用数据类型：数组，类，接口。

接口的使用，它不能创建对象，但是可以被实现（ implements ，类似于被继承）。  
一个实现接口的类（可以看做是接口的子类），需要实现接口中所有的抽象方法，创建该类对象，就可以调用方法了，否则它必须是一个抽象类。

## 1.2 定义格式 ##

public interface 接口名称 { 
    	// 抽象方法
    	// 默认方法
    	// 静态方法
    	// 私有方法
    }

### 含有抽象方法 ###

*  抽象方法：使用 abstract 关键字修饰，可以省略，没有方法体。该方法供子类实现使用。  
    代码如下：
    
        public interface InterFaceName { 
        	public abstract void method();
        }

### 含有默认方法和静态方法 ###

*  默认方法：使用 default 修饰，不可省略，供子类调用或者子类重写。
 *  静态方法：使用 static 修饰，供接口直接调用。  
    代码如下：
    
        public interface InterFaceName { 
        	public default void method() { 
        		// 执行语句
        	}
        	public static void method2() { 
        		// 执行语句
        	}
        }

### 含有私有方法和私有静态方法 ###

*  私有方法：使用 private 修饰，供接口中的默认方法或者静态方法调用。  
    代码如下：
    
        public interface InterFaceName { 
        	private void method() { 
        		// 执行语句
        	}
        }

## 1.3 基本的实现 ##

### 实现的概述 ###

类与接口的关系为实现关系，即类实现接口，该类可以称为接口的实现类，也可以称为接口的子类。实现的动作类似继承，格式相仿，只是关键字不同，实现使用 implements 关键字。

### 非抽象子类实现接口： ###

1.  必须重写接口中所有抽象方法。
2.  继承了接口的默认方法，即可以直接调用，也可以重写。  
    实现格式：
    
        class 类名 implements 接口名 { 
        	// 重写接口中抽象方法【必须】
        	// 重写接口中默认方法【可选】
        }

### 抽象方法的使用 ###

必须全部实现，代码如下：

*  定义接口：
    
        public interface LiveAble { 
        	// 定义抽象方法
        	public abstract void eat();
        	public abstract void sleep();
        }
 *  定义实现类：
    
        public class Animal implements LiveAble { 
        	@Override
        	public void eat() { 
        		System.out.println("吃东西");
        	}
        	@Override
        	public void sleep() { 
        		System.out.println("晚上睡");
        	}
        }
 *  定义测试类：
    
        public class InterfaceDemo { 
        	public static void main(String[] args) { 
        		// 创建子类对象
        		Animal a = new Animal();
        		// 调用实现后的方法
        		a.eat();
        		a.sleep();
        	}
        }
 *  输出结果：
    
        吃东西
        晚上睡

### 默认方法的使用 ###

可以继承，可以重写，二选一，但是只能通过实现类的对象来调用。

1.  继承默认方法，代码如下：

定义接口：

public interface LiveAble { 
    		public default void fly(){ 
    			System.out.println("天上飞");
    		}
    	}

定义实现类：

public class Animal implements LiveAble { 
    	// 继承，什么都不用写，直接调用
    }

定义测试类：

public class InterfaceDemo { 
    	public static void main(String[] args) { 
    		// 创建子类对象
    		Animal a = new Animal();
    		// 调用默认方法
    		a.fly();
    	}
    }

输出结果：

天上飞

#### 2. 重写默认方法，代码如下： ####

定义接口：

public interface LiveAble { 
    	public default void fly(){ 
    		System.out.println("天上飞的");
    	}
    }

定义实现类：

public class Animal implements LiveAble { 
    	@Override
    	public void fly() { 
    		System.out.println("自由自在的飞的");
    	}
    }

定义测试类：

public class InterfaceDemo { 
    	public static void main(String[] args) { 
    		// 创建子类对象
    		Animal a = new Animal();
    		// 调用重写方法
    		a.fly();
    	}
    }

输出结果：

自由自在的飞的

### 静态方法的使用 ###

静态与.class 文件相关，只能使用接口名调用，不可以通过实现类的类名或者实现类的对象调用，代码如下：  
定义接口：

public interface LiveAble { 
    	public static void run(){ 
    		System.out.println("跑起来~~~");
    	}
    }

定义实现类：

public class Animal implements LiveAble { 
    	// 无法重写静态方法
    }

定义测试类：

public class InterfaceDemo { 
    	public static void main(String[] args) { 
    		// Animal.run(); // 【错误】无法继承方法,也无法调用
    		LiveAble.run(); //
    	}
    }

输出结果：

跑起来~~~

### 私有方法的使用 ###

*  私有方法：只有默认方法可以调用。
 *  私有静态方法：默认方法和静态方法可以调用。

如果一个接口中有多个默认方法，并且方法中有重复的内容，那么可以抽取出来，封装到私有方法中，供默认方法去调用。

从设计的角度讲，私有的方法是对默认方法和静态方法的辅助。同学们在已学技术的基础上，可以自行测试。

定义接口：

public interface LiveAble { 
    	default void func(){ 
    		func1();
    		func2();
    	}
    	private void func1(){ 
    		System.out.println("跑起来~~~");
    	}
    	private void func2(){ 
    		System.out.println("跑起来~~~");
    	}
    }

## 1.4 接口的多实现 ##

之前学过，在继承体系中，一个类只能继承一个父类。而对于接口而言，一个类是可以实现多个接口的，这叫做接口的多实现。并且，一个类能继承一个父类，同时实现多个接口。

实现格式：

class 类名 [extends 父类名] implements 接口名1,接口名2,接口名3... { 
    	// 重写接口中抽象方法【必须】
    	// 重写接口中默认方法【不重名时可选】
    }
    
    [ ]： 表示可选操作。

### 抽象方法 ###

接口中，有多个抽象方法时，实现类必须重写所有抽象方法。如果抽象方法有重名的，只需要重写一次。代码如下：

定义多个接口：

interface A { 
    	public abstract void showA();
    	public abstract void show();
    }
    interface B { 
    	public abstract void showB();
    	public abstract void show();
    }

定义实现类：

public class C implements A,B{ 
    	@Override
    	public void showA() { 
    		System.out.println("showA");
    	}
    	@Override
    	public void showB() { 
    		System.out.println("showB");
    	}
    	@Override
    	public void show() { 
    		System.out.println("show");
    	}
    }

### 默认方法 ###

接口中，有多个默认方法时，实现类都可继承使用。如果默认方法有重名的，必须重写一次。代码如下：  
定义多个接口：

interface A { 
    	public default void methodA(){ }
    	public default void method(){ }
    }
    interface B { 
    	public default void methodB(){ }
    	public default void method(){ }
    }

定义实现类：

public class C implements A,B{ 
    	@Override
    	public void method() { 
    		System.out.println("method");
    	}
    }

### 静态方法 ###

接口中，存在同名的静态方法并不会冲突，原因是只能通过各自接口名访问静态方法。

#### 优先级的问题 ####

当一个类，既继承一个父类，又实现若干个接口时，父类中的成员方法与接口中的默认方法重名，子类就近选择执行父类的成员方法。

代码如下：

定义接口：

interface A { 
    	public default void methodA(){ 
    		System.out.println("AAAAAAAAAAAA");
    	}
    }

定义父类：

class D { 
    	public void methodA(){ 
    		System.out.println("DDDDDDDDDDDD");
    	}
    }

定义子类：

class C extends D implements A { 
    	// 未重写methodA方法
    }

定义测试类：

public class Test { 
    	public static void main(String[] args) { 
    		C c = new C();
    		c.methodA();
    	}
    }

输出结果:

DDDDDDDDDDDD

## 1.5 接口的多继承【了解】 ##

一个接口能继承另一个或者多个接口，这和类之间的继承比较相似。接口的继承使用 extends 关键字，子接口继承父接口的方法。如果父接口中的默认方法有重名的，那么子接口需要重写一次（事真多。。。）。代码如下：

定义父接口：

interface A { 
    	public default void method(){ 
    		System.out.println("AAAAAAAAAAAAAAAAAAA");
    	}
    }
    interface B { 
    	public default void method(){ 
    		System.out.println("BBBBBBBBBBBBBBBBBBB");
    	}
    }

定义子接口：

interface D extends A,B{ 
    	@Override
    	public default void method() { 
    		System.out.println("DDDDDDDDDDDDDD");
    	}
    }

### 小贴士： ###

子接口重写默认方法时，default关键字可以保留。

子类重写默认方法时，default关键字不可以保留。

## 1.6 其他成员特点 ##

接口中，无法定义成员变量，但是可以定义常量，其值不可以改变，默认使用public static ﬁnal修饰。

接口中，没有构造方法，不能创建对象。

接口中，没有静态代码块。

## 1.7 接口与继承综合案例 ##

[https://yangyongli.blog.csdn.net/article/details/117792639][https_yangyongli.blog.csdn.net_article_details_117792639]

# 6.补充知识：权限修饰符 #

## 概述 ##

在Java中提供了四种访问权限，使用不同的访问权限修饰符修饰时，被修饰的内容会有不同的访问权限，

*  public：公共的。
 *  protected：受保护的
 *  default：默认的
 *  private：私有的

## 不同权限的访问能力 ##

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th>public</th> 
   <th>protected</th> 
   <th>default（空的）</th> 
   <th>private</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>同一类中</td> 
   <td>√</td> 
   <td>√</td> 
   <td>√</td> 
   <td>√</td> 
  </tr> 
  <tr> 
   <td>同一包中(子类与无关类)</td> 
   <td>√</td> 
   <td>√</td> 
   <td>√</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>不同包的子类</td> 
   <td>√</td> 
   <td>√</td> 
   <td></td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>不同包中的无关类</td> 
   <td>√</td> 
   <td></td> 
   <td></td> 
   <td></td> 
  </tr> 
 </tbody> 
</table>

可见，public具有最大权限。private则是最小权限。  
编写代码时，如果没有特殊的考虑，建议这样使用权限：

*  成员变量使用 `private` ，隐藏细节。
 *  构造方法使用 `public` ，方便创建对象。
 *  成员方法使用 `public` ，方便调用方法。

小贴士：不加权限修饰符，其访问能力与default修饰符相同

## default关键字介绍 ##

今天复习偶尔看到了有default关键字，这是有生之年第一次见到这个关键字，然后百度了一下，发现是Java8的新特性，所以干脆详细学习一下，整理了下面的东西。

default常用于接口中，从它的中文意思行来看，大概能猜个差不多，我们本来写Java接口的时候，是不能有方法体的函数，就类似于C++中的虚函数，default关键字在接口中修饰方法时，方法可以有方法体，来看一个例子。

### 举例 ###

Default类

public interface Default { 
     
        default public void method(){ 
            System.out.println("接口中的方法");
        }
    }

一个接口，method方法在使用关键字default后可以有方法体了。

public class DefaultImpl implements Default { 
     
        @Override
        public void method() { 
            System.out.println("类中的方法");
        }
     
        public static void main(String[] args){ 
            Default d = new DefaultImpl();
            d.method();
        }
    }

DefaultImpl实现了Default接口，最终运行结果：

类中的方法

而此时如果Default接口再加一个方法呢，如果这个方法没有default关键字修饰，则DefaultImpl没有实现这个方法就会报错，这就体现了default关键字的作用。我们继续修改Default接口。

Default接口如下：

public interface Default { 
     
        default public void method(){ 
             System.out.println("接口中的方法");
        }
     
        default public void doSomeThing(){ 
             System.out.println("在接口中搞事情");
        }
    }

DefaultImpl并没有重写doSomeThing方法

public class DefaultImpl implements Default { 
    	@Override
    	public void method() { 
    	     System.out.println("类中的方法");
    	}
    	// 此时没有去重写接口中的方法doSomeThing
    	// 在这里会默认生成一个，子类对象调用时候会直接使用接口中的doSomeThing方法
    	public static void main(String[] args){ 
    	    Default d = new DefaultImpl();
    	    d.method();
    	    d.doSomeThing();
    	}
    }

运行结果如下：

类中的方法
    在接口中搞事情

运行结果符合Java多态的特性，default关键字可以让接口中的方法可以有默认的函数体，当一个类实现这个接口时，可以不用去实现这个方法，当然，这个类若实现这个方法，就等于子类覆盖了这个方法，最终运行结果符合Java多态特性。

# 7. 补充知识：ﬁnal关键字 #

## 1.1 概述 ##

学习了继承后，我们知道，子类可以在父类的基础上改写父类内容，比如，方法重写。那么我们能不能随意的继承API中提供的类，改写其内容呢？显然这是不合适的。为了避免这种随意改写的情况，Java提供了 final 关键字，用于修饰不可改变内容。

ﬁnal： 不可改变。可以用于修饰类、方法和变量。

*  类：被修饰的类，不能被继承。
 *  方法：被修饰的方法，不能被重写。
 *  变量：被修饰的变量，不能被重新赋值。

## 1.2 使用方式 ##

### 修饰类 ###

格式如下：

final class 类名 { 
    }

查询API发现像 `public final class String` 、 `public final class Math` 、 `public final class Scanner`等，很多我们学习过的类，都是被ﬁnal修饰的，目的就是供我们使用，而不让我们所以改变其内容。

## 修饰方法 ##

格式如下：

修饰符 final 返回值类型 方法名(参数列表){ 
    	//方法体
    }

重写被 final 修饰的方法，编译时就会报错。

## 修饰变量 ##

### 1. 局部变量——基本类型 ###

基本类型的局部变量，被ﬁnal修饰后，只能赋值一次，不能再更改。代码如下：

public class FinalDemo1 { 
    	public static void main(String[] args) { 
    		// 声明变量，使用final修饰
    		final int a;
    		// 第一次赋值
    		a = 10;
    		// 第二次赋值
    		a = 20; // 报错,不可重新赋值
    		// 声明变量，直接赋值，使用final修饰
    		final int b = 10;
    		// 第二次赋值
    		b = 20; // 报错,不可重新赋值
    		}
    	}

#### 思考，如下两种写法，哪种可以通过编译？ ####

写法1：

final int c = 0;
    for (int i = 0; i < 10; i++) { 
    	c = i;
    	System.out.println(c);
    }

写法2：

for (int i = 0; i < 10; i++) { 
    	final int c = i;
    	System.out.println(c);
    }

根据 final 的定义，写法1报错！写法2，为什么通过编译呢？

因为每次循环，都是一次新的变量c。

### 2. 局部变量——引用类型 ###

引用类型的局部变量，被ﬁnal修饰后，只能指向一个对象，地址不能再更改。但是不影响对象内部的成员变量值的  
修改，代码如下：

public class FinalDemo2 { 
    	public static void main(String[] args) { 
    		// 创建 User 对象
    		final
    		User u = new User();
    		// 创建 另一个 User对象
    		u = new User(); // 报错，指向了新的对象，地址值改变。
    		// 调用setName方法
    		u.setName("张三"); // 可以修改
    	}
    }

### 3. 成员变量 ###

成员变量涉及到初始化的问题，初始化方式有两种，只能二选一：

1.  显示初始化；
    
        public class User { 
        	final String USERNAME = "张三";
        	private int age;
        }
2.  构造方法初始化:
    
        public class User { 
        	final String USERNAME ;
        	private int age;
        	public User(String username, int age) { 
        		this.USERNAME = username;
        		this.age = age;
        	}
        }

被ﬁnal修饰的常量名称，一般都有书写规范，所有字母都大写。

# 8. 常用的核心类及其方法正在整理 #

********************************
        
        
        
        
        
        
        
        
        
    *******************************

# 二、Web知识 #

# 1. HTML基础 #

## Web 标准构成 ##

Web标准不是某一个标准，而是由W3C和其他标准化组织制定的一系列标准的集合。

主要包括结构（Structure）、表现（Presentation）和行为（Behavior）三个方面。

结构标准：结构用于对网页元素进行整理和分类，咱们主要学的是HTML。 最重要
    表现标准：表现用于设置网页元素的版式、颜色、大小等外观样式，主要指的是CSS。
    行为标准：行为是指网页模型的定义及交互的编写，咱们主要学的是 Javascript

理想状态我们的源码： .HTML .css .js

## HTML 初识 ##

一般先学习HTML+CSS， 这里我们先定一个小目标，先学HTML,后学习CSS。

HTML（英文Hyper Text Markup Language的缩写）中文译为“超文本标签语言”。是用来描述网页的一种语言。

所谓超文本，因为它可以加入图片、声音、动画、多媒体等内容，不仅如此，它还可以从一个文件跳转到另一个文件，与世界各地主机的文件连接。

<h1> 我是一个大标题 </h1>

注意： 体会 文本 标签 语言 几个词语

*  HTML 指的是超文本标记语言 (**H**yper **T**ext **M**arkup **L**anguage)
 *  HTML 不是一种编程语言，而是一种标记语言 (markup language)
 *  标记语言是一套标记标签 (markup tag)

总结： HTML 作用就是用标记标签来描述网页，把网页内容在浏览器中展示出来。

用文字来描述网页标签

### HTML骨架格式 ###

HTML 有自己的语言语法骨架格式：

1 HTML标签：
    
    作用所有HTML中标签的一个根节点。 最大的标签   根标签
    
    2 head标签： 文档的头部
    
    文档的头部描述了文档的各种属性和信息，包括文档的标题、在 Web 中的位置以及和其他文档的关系等。绝大多数文档头部包含的数据都不会真正作为内容显示给读者。
    
    注意在head标签中我们必须要设置的标签是title
    
    3.title标签： 文档的标题
    
    作用：让页面拥有一个属于自己的标题。
    
    4.body标签：文档的主体  以后我们的页面内容 基本都是放到body里面的
    
    body 元素包含文档的所有内容（比如文本、超链接、图像、表格和列表等等。）

### HTML标签分类 ###

在HTML页面中，带有“< >”符号的元素被称为HTML标签，如上面提到的 <HTML>、<head>、<body>都是HTML骨架结构标签。所谓标签就是放在“< >” 标签符中表示某个功能的编码命令，也称为HTML标签或 HTML元素

1.双标签

<标签名> 内容 </标签名>

该语法中“<标签名>”表示该标签的作用开始，一般称为“开始标签（start tag）”，“</标签名>” 表示该标签的作用结束，一般称为“结束标签（end tag）”。和开始标签相比，结束标签只是在前面加了一个关闭符“/”。

比如 <body>我是文字  </body>

2.单标签

<标签名 />

单标签也称空标签，是指用一个标签符号即可完整地描述某个功能的标签。

比如  <br />

### HTML标签关系 ###

标签的相互关系就分为两种：  
1.嵌套关系

2.并列关系

**倡议**： 如果两个标签之间的关系是嵌套关系，子元素最好缩进一个tab键的身位。如果是并列关系，最好上下对齐。

## 文档类型<!DOCTYPE> ##

<!DOCTYPE html>

同学你用啥手机？你咋回答？

这句话就是告诉我们使用哪个html版本？ 我们使用的是 html 5 的版本。 html有很多版本，那我们应该告诉用户和浏览器我们使用的版本号。

标签位于文档的最前面，用于向浏览器说明当前文档使用哪种 HTML 或 XHTML 标准规范，必需在开头处使用标签为所有的XHTML文档指定XHTML版本和类型，只有这样浏览器才能按指定的文档类型进行解析。

注意： 一些老网站可能用的还是老版本的文档类型比如 XHTML之类的，但是我们学的是HTML5,而且HTML5的文档类型兼容很好(向下兼容的原则)，所以大家放心的使用HTML5的文档类型就好了。

## 字符集 ##

utf-8是目前最常用的字符集编码方式，常用的字符集编码方式还有gbk和gb2312。

gb2312 简单中文 包括6763个汉字

BIG5 繁体中文 港澳台等用

GBK包含全部中文字符 是GB2312的扩展，加入对繁体字的支持，兼容GB2312

UTF-8则包含全世界所有国家需要用到的字符

记住一点，以后我们统统使用UTF-8 字符集, 这样就避免出现字符集不统一而引起乱码的情况了。

## HTML标签的语义化 ##

白话： 所谓标签语义化，就是指标签的含义。

### 为什么要有语义化标签 ###

1.  方便代码的阅读和维护
2.  同时让浏览器或是网络爬虫可以很好地解析，从而更好分析其中的内容
3.  使用语义化标签会具有更好地搜索引擎优化

核心：合适的地方给一个最为合理的标签。

语义是否良好： 当我们去掉CSS之后，网页结构依然组织有序，并且有良好的可读性。

白话，一眼看去，就知道那个是重点，结构是什么，知道每块的内容是干啥的。

遵循的原则：先确定语义的HTML ，再选合适的CSS。

## HTML常用标签 ##

首先 HTML和CSS是两种完全不同的语言，我们学的是结构，就只写HTML标签，认识标签就可以了。 不会再给结构标签指定样式了。

HTML标签有很多，这里我们学习最为常用的，后面有些较少用的，我们可以查下手册就可以了。

### 排版标签 ###

排版标签主要和css搭配使用，显示网页结构的标签，是网页布局最常用的标签。

#### 标题标签 (熟记) ####

单词缩写： head 头部. 标题 title 文档标题

为了使网页更具有语义化，我们经常会在页面中用到标题标签，HTML提供了6个等级的标题，即

标题标签语义：  作为标题使用，并且依据重要性递减

其基本语法格式如下：

注意： h1 标签因为重要，尽量少用，不要动不动就向你扔了一个h1。 一般h1 都是给logo使用，或者页面中最重要标题信息。

#### 段落标签( 熟记) ####

单词缩写： paragraph 段落 \[ˈpærəgræf\] 无须记这个单词

在网页中要把文字有条理地显示出来，离不开段落标签，就如同我们平常写文章一样，整个网页也可以分为若干个段落，而段落的标签就是

是HTML文档中最常见的标签，默认情况下，文本在一个段落中会根据浏览器窗口的大小自动换行。

#### 水平线标签(认识) ####

单词缩写： horizontal 横线 \[ˌhɔrəˈzɑntl\] 同上

在网页中常常看到一些水平线将段落与段落之间隔开，使得文档结构清晰，层次分明。这些水平线可以通过插入图片实现，也可以简单地通过标签来完成，

--------------------

就是创建横跨网页水平线的标签。其基本语法格式如下：

<hr />是单标签

在网页中显示默认样式的水平线。

## 楚乔传小案例 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 8]  
代码：

<!DOCTYPE html>
    <html lang="en">
    <head>
    	<meta charset="UTF-8">
    	<title>Document</title>
    </head>
    <body>
     <h1>楚乔传</h1>
     <div>中国大陆 67集（TV版）/58集（DVD版）</div>
    <p>《楚乔传》是由慈文传媒、蜜淘影业、克顿传媒联合出品的女性励志传奇古装剧。由吴锦源执导，嘉纹、杨涛、陈岚编剧，赵丽颖、林更新、窦骁、李沁领衔主演，邓伦、金士杰特邀出演，王彦霖、牛骏峰、黄梦莹、田小洁、孙宁、金瀚、邢昭林、曹曦月、朱圣祎、阮圣文、李若嘉、苗苗等联合出演。[1] 
    该剧改编自潇湘冬儿小说《11处特工皇妃》，讲述了西魏乱世中，一个特立独行的女奴楚乔，在协助建立新政权过程中关于守护、背叛、信仰、爱情的故事。</p>
    
    <p>
    	<p>链接域内网页</p>
    <a href="test.html#next">另外一个页面的第4集</a>
    
    </p>
    
     第1集 <br />
     <a href="#two">第2集</a><br />  
     <a href="#three">第3集</a><br />
     <a href="#four">第4集</a><br />
     <a href="five">第5集</a><br />
    <img src="images/1.jpg" height="500" width="400" alt="">
    
    <h3>第1集(分集以TV版为准)</h3>
    　　摇摇晃晃的囚车上，一名少女正在闭目沉睡。梦境里皆是血雨腥风，恍恍惚惚中，她只记得有人唤她楚乔，又有人叫她荆小六。她不知道自己从哪里来，又将去往何方，前路茫茫。囚车里传来低低的啜泣声，楚乔从梦境里回过神来。周遭都是一片陌生，有一个自称卷毛头的小姑娘听得楚乔肚子咕咕叫，便将自己藏着的窝头分了一半给她。楚乔告诉卷毛头，自己叫做荆小六，卷毛头便唤她小六姐姐。女奴们被带往围场。
    　　西魏皇城，燕北世子燕洵，西魏十三皇子裕王元嵩，魏氏门阀长房嫡子魏舒烨，赵氏门阀次子赵西风和宇文门阀三房庶孙宇文怀策马出城去了一处围场。女奴们便被人从帐篷中赶了出来，站在围场中央，手执兵器的官兵将她们团团围住。少女们身上穿的衣服，都写上了几名少年的名字。
    　　见此情形，站在高台上的少年们不解宇文怀的意图。宇文怀得意的笑笑，告诉其他几位少年，这不是一次普通的围猎。此次的猎物不仅有狼，还有这些新鲜的少女奴隶，大家可以射畜生，也可以射别人的奴隶，一炷香之后，看看谁剩下的奴隶最多，就算谁赢。
    　　裕王觉得这种玩法太过残忍，表示反对。而赵西风却觉得很有意思，鼓动大家兴奋起来。几个人相持不下，言辞便激烈起来。眼见赵西风吵嚷着要求放狼，裕王便推托等宇文玥来了再开始。宇文怀却阴阴一笑，只道宇文玥怕是正在春宵一刻。
    　　而另一边，宇文家青山院。一身白衣的宇文门阀长房嗣孙宇文玥，刚刚推门走进房间，就见床上躺着一位美人。但他只是淡淡地瞟了一眼躺在床上的美人，便径自走到书桌前坐了下来。美人见状，主动诱之。宇文玥却不动声色，将计就计，引得美人主动出手行刺，才一举擒住了她。解决掉刺客，宇文玥这才吩咐人备马，往围场上奔去。
    　　正当还在宇文玥赶往围场的路上之时，围场上已是一片哀号惨叫景象。两侧的围栏闸门被打开，二十多只凶猛的恶狼登时冲进围场，张大血盆大口，咆哮着向少女们冲去。楚乔观察了一下周围地形，大喊着叫少女们逃离空旷的围场，躲向有植物的山丘。一片慌乱中，高台上的箭已经向少女们射了过来，不消片刻功夫，身边已有好几人倒下。楚乔拉着卷毛头，频频躲过高台上射来的箭支和饿狼的追捕，引起了少年们的注意。
    　　慌乱中，一头饿狼在前方挡住了去路，楚乔让卷毛头先躲起来，自己去将那头饿狼引开。燕洵世子见状，搭箭拉弓射杀了饿狼，救下了楚乔。刚刚逃过一劫的楚乔又被一前一后两只饿狼围住。被逼入绝境的她，为了求生，捡起地上的箭支，狠狠的插进了饿狼的咽喉。远处的沙丘上，骑马而立的宇文玥，看着围场中的倔强少女，不由得在心底赞叹她，天生的战士。
    　　围场中的少女越来越少，宇文怀看着底下顽强的楚乔，不禁玩心大起。他飞身上马，呼喝着手下人马进围场里去追杀剩下的女奴。其他几名少年都紧随其后，燕洵世子一路上只顾着射杀饿狼，并不对女奴下手。
    　　渐渐地，围场中的女奴越来越少，饿狼也越来越少。只有一队人马，在荒野中狂奔，向着少女们逃跑的方向追去，不断地还是有女奴在倒下。楚乔拉着卷毛头，在沙丘上拼命地跑着，一时也不敢慢下来，她知道，要想活命，就不能够停下脚步。
    　　远处传来了结束的响箭声，所有人都勒马停下。宇文怀却心有不甘，他还是拉弓朝着女奴射了过去，跑在后面的卷毛头应声倒地。楚乔回过身，紧紧地抱住了卷毛头，似是被风化一般，一动也不动。心有不甘的宇文怀，不想让身上写了“玥”字的楚乔活下来，不顾之前约定，依旧朝着楚乔射了一箭。一旁的燕洵见了，搭箭射向宇文怀的箭，却还是稍稍差了几毫厘，只射下几缕箭尾的翎毛。最后关头，宇文玥悄无声息地用弩箭挡下了这一箭，救了楚乔一命。
    　　而伤心欲绝的楚乔，自然没有注意到，她是怎么在几位少年的争论下活下来的。她此刻心里只有恨，以至于在燕洵世子询问她的名字的时候，她也只是冷冷的回答，等到有一天我不用再仰视你的时候，我自然会告诉你。
    　　侥幸活下来的楚乔，却因惹得宇文怀不悦，便被管家朱顺关进了宇文家的柴房。躺在地上的楚乔心里恨极了，她恨这个世道，那些贵族比饿狼还要可怕，人命比草芥还要低贱的世道。在昏暗的柴房里，浑身是伤的楚乔暗暗发誓，早晚有一天，自己定要让这些人血债血偿。
    　　一名男子手提食盒走了进来，一到楚乔跟前，就满脸心疼地唤楚乔小六，说自己是五哥。楚乔并不认识他，微微有些抗拒他的接近。男子从食盒里拿出一碗饭，饭上放着一块楚乔最爱吃的红烧肉，楚乔含泪接过，觉得吃到了自己这一生最好吃的东西。
    　　燕洵来找宇文玥，请他帮忙解决淳公主要替他办生辰宴的事情。面色冷冷的宇文玥，三言两语，就将燕洵的难题化解。
    　　柴房里，楚乔还在昏迷。昏睡中，她似乎想起自己同一名男子打斗，不慎落入水中，在湍急的河流中，浑身发冷。有人将暖炉放在了她的手里，楚乔便醒了过来，原来是姐妹们在照顾她。
    
    <h3 id="two">第2集</h3> 
    
    　　楚乔伤病还未痊愈，便被宋大娘遣来干活。大姐汁湘为楚乔求情，却被宋大娘骂了一通。管家朱顺前来通知，过两日少爷宇文玥要在府上为燕洵世子举办生辰宴，谁要是敢出一点差错，便要将她打死，众人皆唯唯应了。楚乔便被宋大娘安排去搬花草，朱顺却叫住汁湘，说自己并没有为难楚乔，让汁湘报答他。眼见他就要对汁湘动手动脚，楚乔突然过来问汁湘兰花的位置，汁湘成功躲过朱顺的纠缠。宇文怀吩咐朱顺往宇文玥的酒里下毒，楚乔将这一切都收在眼里，却不动声色地看着。汁湘被安排给宇文玥斟酒，宇文玥察觉出不妥，不肯饮酒。宇文怀便笑言仿效古人，主人不饮酒，就杀美人。宇文玥知道有诈，依旧不肯饮酒。汁湘举着酒杯，苦苦请求。楚乔不愿见姐姐白白做了他们内斗的牺牲品，伺机打翻了酒杯，将众人的注意力吸引到了自己身上。楚乔便求诸位公子放过自己的姐姐，表示自己愿意替姐姐受罚。宇文怀见状，就要让人杀了楚乔。燕洵表示既是自己的生辰，便不愿见着打打杀杀，为楚乔求情。宇文怀却表示宇文府的规矩不能坏，不肯轻饶。燕洵建议玩个游戏，让老天来决定楚乔的生死。他拿出自己腰间的腰牌，腰牌一面龙纹，一面篆字，将它扔在地上，让楚乔来猜哪面朝上，若是猜对了，便免她死罪。楚乔看懂了燕洵的暗示，猜对了龙纹朝上，侥幸逃过一死，却是活罪难逃。楚乔被倒吊在树上已是晚间时分，宇文玥带人过来将她放了下来，却讽刺她。在姐妹们的帮助下逃出府外的楚乔，无意之中听到了朱顺与锦烛的对话，得知临惜有危险，又回到了宇文府。却不想，刚回到宇文府中，就看见宇文玥亲手将临惜杀掉，一脚踢进火堆之中。楚乔想冲进火堆救临惜出来，却被宇文玥踢起的石子打中小腿扑倒在地，当场被侍卫拿住。伤心欲绝的楚乔指责宇文玥滥杀无辜，自己的哥哥根本就不是细作。宇文玥却道，自己滥杀无辜又如何。受了伤的楚乔回到柴房，告诉了姐妹们五哥死去的消息。伤心的小八怨怪楚乔是个克星，克死了自己的家人，汁湘不让小八这样说楚乔，姐妹为了此事吵了起来。浓浓的难过夹杂着满满的无奈，倾袭着每一个荆家姐妹的心。
    
    <h3 id="three">第3集</h3>
    　　青山院灵堂肃穆，宇文玥一身孝衣，沉静的面色里透出几分隐隐的忧伤。宇文玥刚刚下令封棺，便被院子里闯进来的一位不速之客阻拦。来人正是三房的宇文怀，他不顾侍卫阻拦，出言嚣张傲慢，扬言要亲自开棺验尸。宇文玥百般阻拦未果，两人便在灵堂上动起手来。正在难分难解之间，宇文怀掷出去的剑让院门口立着的一位太监险险避过，继而尖锐的声音响起“护驾！贵妃娘娘在此，谁敢造次？”此言一出，惊得院里的宇文玥急急撇下了手中的武器，来向贵妃娘娘问安。宇文怀心知贵妃是宇文玥请来的救兵，却也无可奈何，只得停了手。一身雍容的贵妃娘娘开口便质问宇文怀，何以在青山院里闹事？宇文怀却恶人先告状，只道是宇文玥执意封棺，还逼得自己动手。宇文玥便回禀贵妃，祖父是身中西域奇毒而亡，自己是怕此毒再行伤人，便先焚毁杂物再封棺。柴房里，清醒过来的楚乔郁郁寡欢，连汁湘姐姐送来的药汤也不愿意喝。汁湘知道她是因为临惜的死自责便劝慰她，生逢乱世大家都是身不由己，叫她不要再责怪自己。楚乔的目光却透出坚毅，她告诉汁湘，自己是不会让临惜白白死去的，自己一定会好好活下去。说罢，端起药汤一饮而尽。婢女们都在院子里干活，就见有侍卫抬着一具尸体走了出去。婢女们纷纷议论，这是被送去极乐阁的婢女锦兰，因未被老太爷看上，便被折磨致死。宋大娘前来挑选送往极乐阁的婢女，楚乔被宋大娘指名要送去极乐阁。汁湘为了救下妹妹，便求了宋大娘，由自己顶替了楚乔去了极乐阁。极乐阁里，同汁湘一起被送进去的女孩子，没有一个人活着出来，汁湘也不例外。楚乔带着小七小八躲在暗处，亲眼看着汁湘被装在一辆破车上送出来，难过至极的三人，却不敢哭出声音，只能眼睁睁看着自己姐姐的尸体被人扔掉。事后，楚乔悄悄将汁湘的尸首埋了。姐妹三人拿着弄来的纸钱，在临惜和汁湘的坟前烧着，却被受了罚的宋大娘撞个正着。宋大娘想拉着她们去向宇文怀邀功，遂与楚乔姐妹三人起了争执。几人撕打之中，宋大娘从桥上滑落，被楚乔拉住，却终是因为太过沉重而落下了水。小七小八十分害怕，楚乔安慰她们，若是有一日东窗事发，自己会一力承当，叫姐妹们不要担心。可是她们谁也没有瞧见，有一个躲在暗处的影子，早已将这发生在深夜里的一切，尽数看在眼底。宇文玥依旧一副淡淡神情，只说人太过聪明了不见得是好事。燕洵不理会宇文玥的冷淡，只跟他说起他们宇文家的内斗，表示自己并不喜欢这些，自己只想做草原上自由翱翔的雄鹰。问及宇文玥想成为什么的时候，宇文玥也只是微微沉吟。燕洵却不理会宇文玥，他想起了楚乔，便从宇文玥的桌子上顺了一瓶伤药，径自来找楚乔了。却正巧撞上有侍卫要带楚乔去受罚，燕洵轻轻松松就替她解了围。但楚乔冷漠的神色却让燕洵很不解，楚乔告诉燕洵，自己的哥哥姐姐新丧，自己也朝不保夕，自然高兴不起来。
    
    <h3 id="four">第4集</h3>
    　　宇文玥挑选侍寝婢女的消息很快传了开来，听着小七小八的议论声，楚乔心底里萌生出了求生的新芽。她猛地意识到，自己只有离开宇文怀的爪牙，才能保护妹妹们的性命，才能为兄姐报仇。自己就像是墙角的弱草，只有借助强者的力量，才能与顽石对抗！楚乔下定决心要参加择选，她不顾别人异样的眼光，勇敢地走进了青山院。只可惜，她只是一个带着铁铃铛的奴婢，根本没有资格参加择选。但楚乔知道，自己已经没有退路，她一定要参加这次的择选。她不屈不挠地留了下来，固执的跪在院子里不肯起来。宇文玥听闻，只道她是不自量力，便由着她跪，并不理会她。屋外烈日当头，楚乔在烈日下烤着，却依旧坚持着。时间一分一秒流逝，外头已是月上中天，楚乔还在院子中跪着，宇文玥默不作声地在暗处瞧着倔强的楚乔，面上若有所思。侍卫想要劝楚乔回去，却见楚乔并无退意，就要将她架走。宇文玥却出来制止了侍卫，他看着跪在地上的楚乔，问她为什么要来参加择选。楚乔目光坚定的看着他，说自己想要活下去。宇文玥并不相信楚乔的意图，他继续问楚乔，自己亲手杀死了她的哥哥，她却来求着自己收她做侍寝婢女，尊严何在。楚乔面无表情，目光却依旧坚定，作为奴婢，命都保不住，哪里还有尊严。宇文玥看了一眼楚乔，问她是否知道侍寝婢女是要在主人床底之间承欢侍奉。楚乔紧紧握住了自己的手，卑微地叩头，请公子留下奴婢。宇文玥似是沉思了一会儿，便向侍卫下令，准许楚乔参加择选。择选开始，众多的婢女聚到一起，便免不了生出是非。楚乔本就是因着公子格外开恩才得以参选，自然引得其他人对其不满。银铃铛的大丫鬟锦烛，看不惯楚乔私自放飞公子豢养的鹦鹉，想暗地里使坏抓坏楚乔的衣服，不想，却被楚乔反手夺走了衣衫，弄得失了仪态。宇文玥将这一切都瞧在眼里，看出了楚乔身手敏捷，倒是个练武的苗子。第一场是蒲棋，楚乔并不太懂，遂很惨淡地输掉一局。第二局是烹茶，依旧不是楚乔的强项，但她知道自己不能再输了。楚乔仔细观察着周围的婢女们如何烹茶，突然计上心头。她跑到井边打了新鲜的井水上来，又顺手摘了一片叶子，照着别的婢女的法子，有样学样，也烹制出了一杯甘冽的茶水。楚乔赢了第二局。第三局，默记梵文佛经，一柱香时间去记，再用一柱香时间默写。楚乔虽然不会握笔，更不会写字，但她却凭借超人的记忆，将佛经一字不差地默写了下来。但楚乔却因为没有署名，而被宇文玥责问。楚乔却道，规则里并没有要求署名，自己只是按照规则来做，并无不妥。宇文玥要求只要楚乔能够在经文上署上自己的名字，这一局就算她赢。这可难不倒楚乔，她从自己的头发上拿下铜铃铛，蘸了墨，稳稳地印了上去。宇文玥不再说话，但他却在回过身以后，在嘴角勾起了一抹微不可察的笑意。中选后的楚乔被带来见宇文玥，宇文玥再次问她，为何要来做自己的侍寝婢女。楚乔跪下回话，自己是为了活下去。宇文玥不信楚乔会忘记自己亲手杀了她哥哥的仇恨，而楚乔却表示自己已经答应过姐姐，要好好照顾两个妹妹。
    
    <h3 id="five">第5集</h3>
    　　楚乔一觉醒来，忽觉身边有些异样，那躺在不远处的不就是冷脸面瘫的宇文玥嘛，尖叫声不经思考就脱口而出。宇文玥不慌不忙的坐起身，冷言嘲她大惊小怪，这侍寝的机会不正是她想要的吗。楚乔凌厉出手反抗，宇文玥趁此机会教她功夫，两人之间不免有了肢体接触，宇文玥将她拦腰抱起，旋转数圈。宇文玥第一次招人侍寝，在青山院里极为轰动。一大早锦烛赶去送汤。听到房外的动静，宇文玥特意与楚乔亲密搂抱，温柔宠溺地亲自喂她吃粥，锦烛出去后，宇文玥立马推开了楚乔，好像刚才温柔似水的不是他一样，冷言让她整理被她玷污的床铺。楚乔瞥了眼床上的落红，面露不屑，明明就是他故意弄上的。楚乔侍寝后还是身份低下的铁铃铛，比之锦烛这样银铃铛的大丫鬟还是差了很多。锦烛对楚乔嫉妒不已，小七、小八听不下去了，出言为楚乔抱不平。锦烛气而动起手来，楚乔随手就制住了她。碧水河畔，杨柳依依，楚乔坐在栈桥边，奋力地洗着衣服。燕洵牵马来到河边找她，调笑宇文玥为楚乔取的名字-星儿，正好与宇文玥的玥字相和，燕洵满脸揶揄，笑说宇文玥矫情。楚乔懒得和他计较，端起盆就要走。燕洵不依不饶，耍赖般的把自己的爱驹交给她牵着。楚乔的性子甚合燕洵心意，他特意去找宇文玥要讨了她去，否则就赖在青山院不走了。女奴们居住的小院里，楚乔的特殊待遇遭到以锦烛为首的部分女奴妒忌，连带着她的两位妹妹小七、小八也受到排挤，处处被为难。楚乔为妹妹出头，惹得锦烛满脸怒气，与她动起手来，甚至不惜暗箭伤人，千钧一发之际，宇文玥及时出手，才免得楚乔被伤。锦烛恶人先告状，假惺惺地说是在维护青山院的规矩。宇文玥长身玉立，脸色平静无波看不出喜怒，只说要将楚乔带回去惩罚。他们走后，锦烛的跟随者们趾高气昂，对小七、小八嘲讽更加变本加厉，仿佛宇文玥的态度已经说明了一切。而随宇文玥而去的楚乔，不想白白受到惩罚，她向宇文玥说明当时情况，表明自己只是看不惯弱者被欺负。宇文玥面色冷峻，告诉她强者为王，身为弱者没资格为人讨公道。楚乔心有不甘，请他指点何为强者。假山流水淙淙，走过水上蜿蜒的石块，宇文玥带楚乔进入密室。宇文玥让她掷石头，烛火晃动，乱箭齐发，楚乔一时应付不来，但渐渐地身手越来越快，闪躲越发及时。接下来的三个时辰，楚乔都要和乱箭、石子为伴。她不断被击中，但眼神却越发坚韧，要报仇，就要忍常人所不能忍
    </body>
    </html>

## 标签（标签考试看一遍就行，熟悉即可） ##

### 换行标签(熟记) ###

单词缩写： break 打断 ,换行

在HTML中，一个段落中的文字会从左到右依次排列，直到浏览器窗口的右端，然后自动换行。如果希望某段文本强制换行显示，就需要使用换行标签

<br />

这时如果还像在word中直接敲回车键换行就不起作用了。

### div span标签(重点) ###

div span 是没有语义的 是我们网页布局主要的2个盒子 css+div

div 就是 division 的缩写 分割， 分区的意思 其实有很多div 来组合网页。

span, 跨度，跨距；范围

语法格式：

### 文本格式化标签(熟记) ###

在网页中，有时需要为文字设置粗体、斜体或下划线效果，这时就需要用到HTML中的文本格式化标签，使文字以特殊的方式显示。

b i s u 只有使用 没有 强调的意思 strong em del ins 语义更强烈

### 标签属性 ###

属性就是特性 比如 手机的颜色 手机的尺寸 ，总结就是手机的。。

手机的颜色是黑色 手机的尺寸是 8寸

水平线的长度是 200

图片的宽度 是 300 键 值对

使用HTML制作网页时，如果想让HTML标签提供更多的信息，可以使用HTML标签的属性加以设置。其基本语法格式如下：

<标签名 属性1="属性值1" 属性2="属性值2" …> 内容 </标签名>

在上面的语法中，

1.标签可以拥有多个属性，必须写在开始标签中，位于标签名后面。

2.属性之间不分先后顺序，标签名与属性、属性与属性之间均以空格分开。

3.任何标签的属性都有默认值，省略该属性则取默认值。

采取 键值对 的格式 key=“value” 的格式

比如:

属性 是 宽度

值 是 400

### 图像标签img (重点) ###

单词缩写： image 图像

HTML网页中任何元素的实现都要依靠HTML标签，要想在网页中显示图像就需要使用图像标签，接下来将详细介绍图像标签以及和他相关的属性。其基本语法格式如下：

该语法中src属性用于指定图像文件的路径和文件名，他是img标签的必需属性。

### 链接标签(重点) ###

单词缩写： anchor 的缩写 \[ˈæŋkə®\] 。基本解释 锚, 铁锚 的

在HTML中创建超链接非常简单，只需用标签环绕需要被链接的对象即可，其基本语法格式如下：

<a href="跳转目标" target="目标窗口的弹出方式">文本或图像</a>

href：用于指定链接目标的url地址，当为标签应用href属性时，它就具有了超链接的功能。 Hypertext Reference的缩写。意思是超文本引用

target：用于指定链接页面的打开方式，其取值有\_self和\_blank两种，其中\_self为默认值，\_blank为在新窗口中打开方式。

**注意：**

1.  外部链接 需要添加 http:// www.baidu.com
2.  内部链接 直接链接内部页面名称即可 比如 < a href=“index.html”> 首页
3.  如果当时没有确定链接目标时，通常将链接标签的href属性值定义为“\#”(即href="\#")，表示该链接暂时为一个空链接。
4.  不仅可以创建文本超链接，在网页中各种网页元素，如图像、表格、音频、视频等都可以添加超链接。

#### 锚点定位 （难点） ####

通过创建锚点链接，用户能够快速定位到目标内容。  
创建锚点链接分为两步：

1.使用“a href=”#id名>“链接文本"</a>创建链接文本（被点击的）
      <a href="#two">   
    
    2.使用相应的id名标注跳转目标的位置。
      <h3 id="two">第2集</h3>

#### base 标签 基本的 ####

base 可以设置整体链接的打开状态

base 写到 之间

把所有的连接 都默认添加 target="\_blank"

### 注释标签 ###

在HTML中还有一种特殊的标签——注释标签。如果需要在HTML文档中添加一些便于阅读和理解但又不需要显示在页面中的注释文字，就需要使用注释标签。其基本语法格式如下：

ctrl + /       或者 ctrl +shift + /

注释内容不会显示在浏览器窗口中，但是作为HTML文档内容的一部分，也会被下载到用户的计算机上，查看源代码时就可以看到。

## 路径(重点、难点) ##

实际工作中，通常新建一个文件夹专门用于存放图像文件，这时再插入图像，就需要采用“路径”的方式来指定图像文件的位置。

路径可以分为： 相对路径和绝对路径

### 相对路径 ###

以引用文件之网页所在位置为参考基础，而建立出的目录路径。因此，当保存于不同目录的网页引用同一个文件时，所使用的路径将不相同，故称之为相对路径。

1.  图像文件和HTML文件位于同一文件夹：只需输入图像文件的名称即可，如<img src=“logo.gif” />。
2.  图像文件位于HTML文件的下一级文件夹：输入文件夹名和文件名，之间用“/”隔开，如<img src=“img/img01/logo.gif” />。
3.  图像文件位于HTML文件的上一级文件夹：在文件名之前加入“…/” ，如果是上两级，则需要使用 “…/ …/”，以此类推，如<img src="…/logo.gif" />。

### 绝对路径 ###

绝对路径以Web站点根目录为参考基础的目录路径。之所以称为绝对，意指当所有网页引用同一个文件时，所使用的路径都是一样的

“D:\\web\\img\\logo.gif”，或完整的网络地址，例如“http://www.itcast.cn/images/logo.gif”。

## 列表标签(Javaweb考试过就行) ##

什么是列表？

容器里面装载着文字或图表的一种形式，叫列表。

列表最大的特点就是 整齐 、整洁、 有序

### 无序列表 ul （重点） ###

无序列表的各个列表项之间没有顺序级别之分，是并列的。其基本语法格式如下：

比如下面这些，新闻是没有顺序的，不用排队，先到先得，后发布先显示。

![Image 1][]

脚下留心：

1. <ul></ul>中只能嵌套<li></li>，直接在<ul></ul>标签中输入其他标签或者文字的做法是不被允许的。
     2. <li>与</li>之间相当于一个容器，可以容纳所有元素。
     3. 无序列表会带有自己样式属性，放下那个样式，一会让CSS来！

### 有序列表 ol （了解） ###

有序列表即为有排列顺序的列表，其各个列表项按照一定的顺序排列定义，有序列表的基本语法格式如下：

所有特性基本与ul 一致。

但是实际工作中， 较少用 ol img src=“media/1.jpg” />

### 自定义列表（理解） ###

定义列表常用于对术语或名词进行解释和描述，定义列表的列表项前没有任何项目符号。其基本语法如下：

### 链接小案例 ###

<!DOCTYPE html>
    <html lang="en">
    <head>
    	<meta charset="UTF-8">
    	<title>Document</title>
    	<base target="_blank" />
    	
    </head>
    <body>
    	友情链接:
    	<a href="https://www.videos.com/">huohuo</a>
    	<a href="http://www.baidu.com">百度</a>
    	<a href="http://www.baidu.com">新浪</a>
    	<a href="http://www.baidu.com">搜狐</a>
    	<a href="http://www.baidu.com" target="_self">谷歌</a>
    </body>
    </html>

## 表单标签（※） ##

### 概念 ###

表单目的是为了收集用户信息。

在我们网页中， 我们也需要跟用户进行交互，收集用户资料，此时也需要表单。

在HTML中，一个完整的表单通常由表单控件（也称为表单元素）、提示信息和表单域3个部分构成。

比如当我们在注册用户时，就包括：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 9]

1.  表单控件：  
    包含了具体的表单功能项，如单行文本输入框、密码输入框、复选框、提交按钮、重置按钮等。
2.  提示信息：  
    一个表单中通常还需要包含一些说明性的文字，提示用户进行填写和操作。
3.  表单域：  
    他相当于一个容器，用来容纳所有的表单控件和提示信息，可以通过他定义处理表单数据所用程序的url地址，以及数据提交到服务器的方法。如果不定义表单域，表单中的数据就无法传送到后台服务器。

### input 控件(重点) ###

input 输入的意思

在上面的语法中，<input />标签为单标签，type属性为其最基本的属性 类型 ，其取值有多种，用于指定不同的控件类型。除了type属性之外，<input />标签还可以定义很多其他的属性，其常用属性如下表所示。

type 说明了属于那种表单  
radio 如果是一组，我们必须给他们命名相同的名字 name 这样就可以多个选其中的一个啦  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 10]

### label标签(理解) ###

label 标签为 input 元素定义标注（标签）。

作用： 用于绑定一个表单元素, 当点击label标签的时候, 被绑定的表单元素就会获得输入焦点

**如何绑定元素呢？**

for 属性规定 label 与哪个表单元素绑定。

### textarea控件(文本域) ###

text 文本框 只能写一行文本呢

textarea 文本域

如果需要输入大量的信息，就需要用到<textarea></textarea>标签。通过textarea控件可以轻松地创建多行文本输入框，其基本语法格式如下：

比如说发评论的输入框

### 下拉菜单 ###

使用select控件定义下拉菜单的基本语法格式如下 select 选择

#### 注意： ####

1.  <select></select>中至少应包含一对<option></option>。
2.  在option 中定义selected =" selected "时，当前项即为默认选中项。

## 表单域 ##

在HTML中，form标签被用于定义表单域，即创建一个表单，以实现用户信息的收集和传递，form中的所有内容都会被提交给服务器。创建表单的基本语法格式如下：

<form action="url地址" method="提交方式" name="表单名称">
      各种表单控件
    </form>

**常用属性：**

1.  Action  
    在表单收集到信息后，需要将信息传递给服务器进行处理，action属性用于指定接收并处理表单数据的服务器程序的url地址。
2.  method  
    用于设置表单数据的提交方式，其取值为get或post。
3.  name  
    用于指定表单的名称，以区分同一个页面中的多个表单。

#### 注意： ####

每个表单都应该有自己表单域。

### 案例 有缘网 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 11]

<!DOCTYPE html>
    <html lang="en">
    <head>
    	<meta charset="UTF-8">
    	<title>有缘婚姻网</title>
    </head>
    <body>
    	<table width="600" border="0" cellspacing="0" cellpadding="0" align=center>
    		<caption><h4 style="color: pink;font-size: 25px;">你我尽在有缘</h4> </caption>
    		<tr height="30"> 
    			<td>姓名：</td>
    			<td><input type="text" value="二芳" style="color:#ccc;" /> </td>
    		</tr>
    		<tr height="30"> 
    			<td>所在地区：</td>
    			<td><input type="text" value="沧州青县" style="color:#ccc;" /> </td>
    		</tr>
    		<tr height="30"> 
    			<td>电话号码：</td>
    			<td><input type="text" value="13785662655" style="color:#ccc;" /> </td>
    		</tr>
    
    		<tr height="30"> 
    			<td>用户名：</td>
    			<td><input type="text" value="喜子" style="color:#ccc;" /> </td>
    		</tr>
    		<tr height="30"> 
    			<td>密码</td>
    			<td><input type="password" value="" style="color:#ccc;" /> </td>
    		</tr>
    
    			
    		<tr height="30">
    			<td>出生日期</td>
    			<td>
    				<select name="" id="">
    					 <option value="">选择年份</option>  
    					 <option value="">1990</option>  
    					 <option value="">1991</option>  
    					 <option value="">1992</option>  
    					 <option value="">1993</option>  
    					 <option value="">1994</option>  
    					 <option value="">1995</option>  
    					 <option value="">1996</option>  
    					 <option value="">1997</option>  
    				</select>
    				<select name="" id="">
    					 <option value="">选择月份</option>  
    					 <option value="">1月份</option>  
    					 <option value="">2月份</option>  
    					 <option value="">3月份</option>  
    					 <option value="">4月份</option>  
    					 <option value="">5月份</option>  
    					 <option value="">6月份</option>  
    					 <option value="">7月份</option>  
    					 <option value="">8月份</option>  
    					 <option value="">9月份</option>  
    					 <option value="">10月份</option>  
    					 <option value="">11月份</option>  
    					 <option value="">12月份</option>  
    				</select>
    
    			</td>
    		</tr>
    			
    		<tr height="30">
    			<td>籍贯</td>
    			<td>
    				<select name="" id="">
    					 <option value="">籍贯</option>  
    					 <option value="" selected="selected">沧州</option>  
    					 <option value="">哈尔滨</option>  
    					 <option value="">青岛</option>  
    					 <option value="">大连</option>  
    				
    				</select>
    				
    			</td>
    		</tr>
    
    		<tr height="30">
    			<td>性别</td>
    			<td style="color: blue;">
    				<input type="radio" name="sex" checked="checked"/> 男  
    				 <input type="radio" name="sex" /> 女
    				<input type="radio" name="sex"/> 人妖 
    			</td>
    			
    		</tr height="30">
    		<tr>
    			<td>喜欢的类型</td>
    			<td>
    				  <input type="checkbox" name="love">妖娆
    				     <input type="checkbox" name="love">气质
    				    <input type="checkbox" name="love">嬉皮内柔
    				   <input type="checkbox" name="love" checked="checked" />呼呼噜噜
    			</td>
    			
    		</tr>
    
    		<tr height="30">
    			<td>上传头像</td>
    			<td>
    				<input type="file" >
    				
    			</td>
    			
    		</tr>
    		<tr height="60">
    			<td>给我留言</td>
    			<td>
    				<textarea name="" id="" cols="50" rows="10" style="color: #ccc;">不支持富文本
    				</textarea>
    				
    			</td>
    			
    		</tr>
    		<tr>
    			<td></td>
    			<td>
    				<input type="button" value="注册">
    				<input type="submit" value="提交">
    				<input type="reset" value="重置">
    			</td>
    		</tr>	
    	</table>
    </body>
    </html>

# 2. CSS知识——网页的美容师 #

CSS的出现，拯救了混乱的HTML，当让更加拯救了我们web开发者。 让我们的网页更加丰富多彩。

CSS的最大贡献就是： 让 HTML 从样式中解脱苦海， 实现了 HTML 专注去做 结构呈现。 而样式交给 CSS 后，你完全可以放心的洗洗睡了！

## CSS初识 ##

CSS(Cascading Style Sheets)美化样式

CSS通常称为CSS样式表或层叠样式表（级联样式表），主要用于设置HTML页面中的文本内容（字体、大小、对齐方式等）、图片的外形（宽高、边框样式、边距等）以及版面的布局等外观显示样式。

CSS以HTML为基础，提供了丰富的功能，如字体、颜色、背景的控制及整体排版等，而且还可以针对不同的浏览器设置不同的样式。

## 引入CSS样式表（书写位置）（必考） ##

### 内部样式表 ###

内嵌式是将CSS代码集中写在HTML文档的head头部标签中，并且用style标签定义，其基本语法格式如下：

语法中，style标签一般位于head标签中title标签之后，也可以把他放在HTML文档的任何地方。

type=“text/CSS” 在html5中可以省略， 写上也比较符合规范， 所以这个地方可以写也可以省略。

### 行内式（内联样式） ###

内联样式，又有人称行内样式、行间样式、内嵌样式。是通过标签的style属性来设置元素的样式，其基本语法格式如下：

<标签名 style="属性1:属性值1; 属性2:属性值2; 属性3:属性值3;"> 内容 </标签名>

语法中style是标签的属性，实际上任何HTML标签都拥有style属性，用来设置行内式。其中属性和值的书写规范与CSS样式规则相同，行内式只对其所在的标签及嵌套在其中的子标签起作用。

### 外部样式表（外链式） ###

链入式是将所有的样式放在一个或多个以.CSS为扩展名的外部样式表文件中，通过link标签将外部样式表文件链接到HTML文档中，其基本语法格式如下：

复习： link 是个单标签哦

该语法中，link标签需要放在head头部标签中，并且必须指定link标签的三个属性，具体如下：

1.  href：定义所链接外部样式表文件的URL，可以是相对路径，也可以是绝对路径。
2.  type：定义所链接文档的类型，在这里需要指定为“text/CSS”，表示链接的外部文件为CSS样式表。
3.  rel：定义当前文档与被链接文档之间的关系，在这里需要指定为“stylesheet”，表示被链接的文档是一个样式表文件。

### 三种样式表总结（位置） ###

<table> 
 <thead> 
  <tr> 
   <th>样式表</th> 
   <th align="left">优点</th> 
   <th>缺点</th> 
   <th>使用情况</th> 
   <th>控制范围</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>行内样式表</td> 
   <td align="left">书写方便，权重高</td> 
   <td>没有实现样式和结构相分离</td> 
   <td>较少</td> 
   <td>控制一个标签（少）</td> 
  </tr> 
  <tr> 
   <td>内部样式表</td> 
   <td align="left">部分结构和样式相分离</td> 
   <td>没有彻底分离</td> 
   <td>较多</td> 
   <td>控制一个页面（中）</td> 
  </tr> 
  <tr> 
   <td>外部样式表</td> 
   <td align="left">完全实现结构和样式相分离</td> 
   <td>需要引入</td> 
   <td>最多，强烈推荐</td> 
   <td>控制整个站点（多）</td> 
  </tr> 
 </tbody> 
</table>

## CSS样式规则 ##

使用HTML时，需要遵从一定的规范。CSS亦如此，要想熟练地使用CSS对网页进行修饰，首先需要了解CSS样式规则，具体格式如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 12]  
在上面的样式规则中:

1.选择器用于指定CSS样式作用的HTML对象，花括号内是对该对象设置的具体样式。  
2.属性和属性值以“键值对”的形式出现。  
3.属性是对指定的对象设置的样式属性，例如字体大小、文本颜色等。  
4.属性和属性值之间用英文“:”连接。  
5.多个“键值对”之间用英文“;”进行区分。  
可以用段落 和 表格的对齐的演示。

### 外链案例 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 13]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 14]

### 内链案例 ###

<!DOCTYPE html>
    <html lang="en">
    <head>
    	<meta charset="UTF-8">
    	<title>Document</title>
    	<style> h4 { color: deeppink; } p { color: #036; } h3 { color: green; } div { color: orange; } </style>
    	<link rel="stylesheet" href="css/style.css">
    </head>
    <body>
    <h3>忆江南(1)</h3>
    
    <div>唐.白居易</div>
    
    <p>江南好，风景旧曾谙。(2) 日出江花红胜火，春来江水绿如蓝，(3) 能不忆江南。</p>
    
    <h4>作者介绍</h4>
    
    <p>白居易(772－846) ，字乐天，太原(今属山西)人。唐德宗朝进士，元和三年(808)拜左拾遗，后贬江州(今属江西)司马，移忠州(今属四川)刺史，又为苏州(今属江苏)、同州(今属陕西大荔)刺史。晚居洛阳，自号醉吟先生、香山居士。其诗政治倾向鲜明，重讽喻，尚坦易，为中唐大家。也是早期词人中的佼佼者，所作对后世影响甚大。</p>
    
    <h4>注释</h4>
    <p>
    	
    (1)据《乐府杂录》，此词又名《谢秋娘》，系唐李德裕为亡姬谢秋娘作。又名《望江南》、《梦江南》等。分单调、双调两体。单调二十七字，双凋五十四字，皆平韵。(2)谙(音安)：熟悉。(3)蓝：蓝草，其叶可制青绿染料。
    
    </p>
    <h4>品评</h4>
    
    <p>此词写江南春色，首句“江南好”，以一个既浅切又圆活的“好”字，摄尽江南春色的种种佳处，而作者的赞颂之意与向往之情也尽寓其中。同时，唯因“好”之已甚，方能“忆”之不休，因此，此句又已暗逗结句“能不忆江南”，并与之相关阖。次句“风景旧曾谙”，点明江南风景之“好”，并非得之传闻，而是作者出牧杭州时的亲身体验与亲身感受。这就既落实了“好”字，又照应了“忆”字，不失为勾通一篇意脉的精彩笔墨。三、四两句对江南之“好”进 　行形象化的演绎，突出渲染江花、江水红绿相映的明艳色彩，给人以光彩夺目的强烈印象。其中，既有同色间的相互烘托，又有异色间的相互映衬，充分显示了作者善于著色的技巧。篇末，以“能不忆江南”收束全词，既托出身在洛阳的作者对江南春色的无限赞叹与怀念，又造成一种悠远而又深长的韵味，把读者带入余情摇漾的境界中。</p>
    </body>
    </html>

## CSS四种基础选择器（类和标签必考） ##

### 标签选择器（元素选择器） ###

标签选择器是指用HTML标签名称作为选择器，按标签名称分类，为页面中某一类标签指定统一的CSS样式。其基本语法格式如下：

标签名{ 属性1:属性值1; 属性2:属性值2; 属性3:属性值3; }  或者 元素名{ 属性1:属性值1; 属性2:属性值2; 属性3:属性值3; }

标签选择器最大的优点是能快速为页面中同类型的标签统一样式，同时这也是他的缺点，不能设计差异化样式。

标签选择器 可以把某一类标签全部选择出来 div span

### 类选择器 ###

类选择器使用“.”（英文点号）进行标识，后面紧跟类名，其基本语法格式如下：

.类名{ 属性1:属性值1; 属性2:属性值2; 属性3:属性值3; }

标签调用的时候用 class=“类名”  即可。

类选择器最大的优势是可以为元素对象定义单独或相同的样式。 可以选择一个或者多个标签

1.长名称或词组可以使用中横线来为选择器命名。
    2.不建议使用“_”下划线来命名CSS选择器。

输入的时候少按一个shift键;

浏览器兼容问题 (比如使用\_tips的选择器命名，在IE6是无效的)  
　能良好区分JavaScript变量命名(JS变量命名是用“\_”)

3.不要纯数字、中文等命名， 尽量使用英文字母来表示。

#### 类选择器小案例 ####

![在这里插入图片描述][20200626210044488.png]

<!DOCTYPE html>
    <html lang="en">
    <head>
    	<meta charset="UTF-8">
    	<title>Document</title>
    	<style> /*div { div 标签选择器 吧所有的div 选择 改为红色 color: red; }*/ /*上面点声明 ，下面class调用*/ .leixuanzeqi{ color: blue; } </style>
    </head>
    <body>
    	<div class="leixuanzeqi">我是类选择器</div>
    	<div>我是类选择器</div>
    	<div>我是类选择器</div>
    	<div>我是类选择器</div>
    	<div>我是类选择器</div>
    	<div class="leixuanzeqi">我是类选择器</div>
    </body>
    </html>

#### 小案例 制作一个简易Google图标 ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 15]

<!DOCTYPE html>
    <html lang="en">
    <head>
    	<meta charset="UTF-8">
    	<title>Document</title>
    	<style> /*千万别忘了它*/ span { /*标签选择器 让所有的span 都变成 150 */ font-size: 150px; } .g { color: blue; } .o { color: red; } .o2 { color: orange; } .l { color: green; } /* 类选择器 可以选择 一个 或者 多个 标签*/ </style>
    </head>
    <body>
    	<span class="g">G</span>
    	<span class="o">o</span>
    	<span class="o2">o</span>
    	<span class="g">g</span>
    	<span class="l">l</span>
    	<span class="o">e</span>
    	<div class="nav"></div>  
    	<div class="banner"></div>  
    </body>
    </html>

### 多类名选择器 ###

我们可以给标签指定多个类名，从而达到更多的选择目的。

**注意：**

1.  样式显示效果跟HTML元素中的类名先后顺序没有关系,受CSS样式书写的上下顺序有关。
2.  各个类名中间用空格隔开。

多类名选择器在后期布局比较复杂的情况下，还是较多使用的。

#### 案例 ####

![在这里插入图片描述][20200626211836780.png]

<!DOCTYPE html>
    <html lang="en">
    <head>
    	<meta charset="UTF-8">
    	<title>多类名选择器</title>
    	<style> .red { color: red; } .font20 { font-size: 20px; color: blue; } .fontw { font-weight: 700; } </style>
    </head>
    <body>
    	<div class="font20 red fontw">多类名选择器</div>
    	<p class="red fontw" >多类名选择器</p>
    	<p>多类名选择器</p>
    	<p class="red">多类名选择器</p>
    	<div>多类名选择器</div>
    </body>
    </html>

### id选择器 ###

id选择器使用“\#”进行标识，后面紧跟id名，其基本语法格式如下：

#id名{ 属性1:属性值1; 属性2:属性值2; 属性3:属性值3; }

该语法中，id名即为HTML元素的id属性值，大多数HTML元素都可以定义id属性，元素的id值是唯一的，只能对应于文档中某一个具体的元素。

用法基本和类选择器相同。

就像一张身份证，姓名是类名选择器，身份证号是ID选择器  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 16]

### id选择器和类选择器区别 ###

W3C标准规定，在同一个页面内，不允许有相同名字的id对象出现，但是允许相同名字的class。

类选择器（class） 好比人的名字， 是可以多次重复使用的， 比如 张伟 王伟 李伟 李娜

id选择器 好比人的身份证号码， 全中国是唯一的， 不得重复。 只能使用一次。

**id选择器和类选择器最大的不同在于 使用次数上。**

#### 案例 ####

![在这里插入图片描述][20200626211954191.png]

<!DOCTYPE html>
    <html lang="en">
    <head>
    	<meta charset="UTF-8">
    	<title>Document</title>
    	<style> #last { color: pink; } </style>
    </head>
    <body>
    	<div>id选择器</div>
    	<div>id选择器</div>
    	<div>id选择器</div>
    	<div id="last" class="red">id选择器</div>
    </body>
    </html>

### 通配符选择器 ###

通配符选择器用“\*”号表示，他是所有选择器中作用范围最广的，能匹配页面中所有的元素。其基本语法格式如下：

* {  属性1:属性值1; 属性2:属性值2; 属性3:属性值3; }

例如下面的代码，使用通配符选择器定义CSS样式，清除所有HTML标记的默认边距。

* { 
      margin: 0;                    /* 定义外边距*/
      padding: 0;                   /* 定义内边距*/
    }

### 案例 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 17]

<!DOCTYPE html>
    <html lang="en">
    <head>
    	<meta charset="UTF-8">
    	<title>Document</title>
    	<style> * { * /** 代表所有标签的意思 使用较少 */ color: red; } </style>
    </head>
    <body>
    	<div>我是标签</div>
    	<p>我是段落</p>
    	<span>我是标签</span>
    	<table>我是表格</table>
    </body>
    </html>

# 3. JavaScript知识 #

## JavaScript介绍 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 18]

### JavaScript是什么 ###

JavaScript 编程语言 流程控制

Netscape在最初将其脚本语言命名为LiveScript，后来Netscape在与Sun合作之后将其改名为JavaScript。JavaScript最初受Java启发而开始设计的，目的之一就是“看上去像Java”，因此语法上有类似之处，一些名称和命名规范也借自Java。JavaScript与Java名称上的近似，是当时Netscape为了营销考虑与Sun微系统达成协议的结果。Java和JavaScript的关系就像张雨和张雨生的关系，只是名字很像。

Java 服务器端的编程语言

JavaScript 运行在客户端(浏览器)的编程语言

JavaScript是一种运行在`客户端`的`脚本语言`  
JavaScript的解释器被称为JavaScript引擎，为浏览器的一部分，广泛用于客户端的脚本语言，最早是在HTML（标准通用标记语言下的一个应用）网页上使用，用来给HTML网页增加动态功能。

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-FAP5ubjr-1594811136860)(media/bulaideng.png)\]

### JavaScript最初的目的 ###

演示：http://baixiu.uieee.com/admin/login.php  
最初的目的是为了处理表单的验证操作。

### JavaScript现在的意义(应用场景) ###

JavaScript 发展到现在几乎无所不能。

1.  网页特效
2.  服务端开发(Node.js)
3.  命令行工具(Node.js)
4.  桌面程序(Electron)
5.  App(Cordova)
6.  控制硬件-物联网(Ruff)
7.  游戏开发(cocos2d-js)

### JavaScript和HTML、CSS的区别 ###

1.  HTML：提供网页的结构，提供网页中的内容
2.  CSS: 用来美化网页
3.  JavaScript: 可以用来控制网页内容，给网页增加动态的效果

## JavaScript的组成 ##

\[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-esS9LcoN-1623498246606)(…/AppData/Roaming/Typora/typora-user-images/1623414105594.png)\]

## 函数 ##

### 什么是函数 ###

> 把一段相对独立的具有特定功能的代码块封装起来，形成一个独立实体，就是函数，起个名字（函数名），在后续开发中可以反复调用
> 
> 函数的作用就是封装一段代码，将来可以重复使用

### 函数的定义 ###

*  函数声明

function 函数名(){ 
      // 函数体
    }

*  函数表达式

var fn = function() { 
      // 函数体
    }

*  特点：
    
    函数声明的时候，函数体并不会执行，只要当函数被调用的时候才会执行。  
    函数一般都用来干一件事情，需用使用动词+名词，表示做一件事情 `tellStory` `sayHello`等

#### 函数的调用 ####

*  调用函数的语法：

函数名();

*  特点：
    
    函数体只有在调用的时候才会执行，调用需要()进行调用。  
    可以调用多次(重复使用)

代码示例：

// 声明函数
    function sayHi() { 
      console.log("吃了没？");
    }
    // 调用函数
    sayHi();
    
    // 求1-100之间所有数的和
    function getSum() { 
      var sum = 0;
      for (var  i = 0; i < 100; i++) { 
        sum += i;
      }
      console.log(sum);
    }
    // 调用
    getSum();

### 函数的参数 ###

*  为什么要有参数

function getSum() { 
      var sum = 0;
      for (var i = 1; i <= 100; i++) { 
        sum += i;
      }
      console.log();
    }
    
    // 虽然上面代码可以重复调用，但是只能计算1-100之间的值
    // 如果想要计算n-m之间所有数的和，应该怎么办呢？

*  语法：

// 函数内部是一个封闭的环境，可以通过参数的方式，把外部的值传递给函数内部
    // 带参数的函数声明
    function 函数名(形参1, 形参2, 形参...){ 
      // 函数体
    }
    
    // 带参数的函数调用
    函数名(实参1, 实参2, 实参3);

*  形参和实参
    
    > 1.  形式参数：在声明一个函数的时候，为了函数的功能更加灵活，有些值是固定不了的，对于这些固定不了的值。我们可以给函数设置参数。这个参数没有具体的值，仅仅起到一个占位置的作用，我们通常称之为形式参数，也叫形参。
    > 2.  实际参数：如果函数在声明时，设置了形参，那么在函数调用的时候就需要传入对应的参数，我们把传入的参数叫做实际参数，也叫实参。

var x = 5, y = 6;
    fn(x,y); 
    function fn(a, b) { 
      console.log(a + b);
    }
    //x,y实参，有具体的值。函数执行的时候会把x,y复制一份给函数内部的a和b，函数内部的值是复制的新值，无法修改外部的x,y

### 函数的返回值 ###

> 当函数执行完的时候，并不是所有时候都要把结果打印。我们期望函数给我一些反馈（比如计算的结果返回进行后续的运算），这个时候可以让函数返回一些东西。也就是返回值。函数通过return返回一个返回值

返回值语法：

//声明一个带返回值的函数
    function 函数名(形参1, 形参2, 形参...){ 
      //函数体
      return 返回值;
    }
    
    //可以通过变量来接收这个返回值
    var 变量 = 函数名(实参1, 实参2, 实参3);

函数的调用结果就是返回值，因此我们可以直接对函数调用结果进行操作。

返回值详解：

*  如果函数没有显示的使用 return语句 ，那么函数有默认的返回值：undefined
 *  如果函数使用 return语句，那么跟再return后面的值，就成了函数的返回值
 *  如果函数使用 return语句，但是return后面没有任何值，那么函数的返回值也是：undefined
 *  函数使用return语句后，这个函数会在执行完 return 语句之后停止并立即退出，也就是说return后面的所有其他代码都不会再执行。

`推荐的做法是要么让函数始终都返回一个值，要么永远都不要返回值。`

### arguments的使用（了解，其实就是自动统计保存输入的参数序列） ###

JavaScript中，arguments对象是比较特别的一个对象，实际上是当前函数的一个内置属性。也就是说所有函数都内置了一个arguments对象，arguments对象中存储了传递的所有的实参。arguments是一个伪数组，因此及可以进行遍历

*  案例

求任意个数的和

<!DOCTYPE html>
    <html lang="en">
    <head>
      <meta charset="UTF-8">
      <title>$永远的24k纯帅$</title>
      <script>
    
        //计算两个数字的和
    // function f1(x, y) { 
    // return x + y;
    // }
    // //计算三个数字的和
    // function f2(x, y, z) { 
    // return x + y + z;
    // }
    // //计算四个数字的和
    // function f3(x, y, z, k) { 
    // return x + y + z + k;
    // }
    // //计算五个数字的和
    // function f4(a, b, c, d, e) { 
    // return a + b + c + d + e;
    // }
    // //计算六个数字的和
    // function f5(a, b, c, d, e, f) { 
    // return a + b + c + d + e + f;
    // }
        //计算n个数字的和
        //定义一个函数,如果不确定用户是否传入了参数,或者说不知道用户传了几个参数,没办法计算,但是如果在函数中知道了参数的个数,也知道了，每个参数的值.可以
    
        //定义
    // function f1() { 
    // //获取的是函数在调用的时候,传入了几个参数
    // //console.log(arguments.length);
    // //使用arguments对象可以获取传入的每个参数的值
    // console.log(arguments);
    // }
    //
    // f1(10,20,30,40,100,200);//调用
    
    
    
        function f1() { 
          //arguments----->数组使用------伪数组---
          var sum=0;
          for(var i=0;i<arguments.length;i++){ 
            sum+=arguments[i];
          }
          return sum;
        }
    
        console.log(f1(10,20,30));
      </script>
    </head>
    <body>
    
    
    </body>
    </html>

## 函数其它（有空就了解） ##

### 匿名函数 ###

> 匿名函数：没有名字的函数

匿名函数如何使用：

将匿名函数赋值给一个变量，这样就可以通过变量进行调用
    匿名函数自调用

关于自执行函数（匿名函数自调用）的作用：防止全局变量污染。

### 自调用函数 ###

> 匿名函数不能通过直接调用来执行，因此可以通过匿名函数的自调用的方式来执行

(function () { 
      alert(123);
    })();

### 函数是一种数据类型 ###

function fn() { }
    console.log(typeof fn);

*  函数作为参数

因为函数也是一种类型，可以把函数作为两一个函数的参数，在两一个函数中调用

*  函数做为返回值

因为函数是一种类型，所以可以把函数可以作为返回值从函数内部返回，这种用法在后面很常见。

function fn(b) { 
      var a = 10;
      return function () { 
        alert(a+b);
      }
    }
    fn(15)();

### 代码规范 ###

1.命名规范	
    2.变量规范   
    	var name = 'zs';	
    3.注释规范
    	// 这里是注释
    4.空格规范
    5.换行规范
    var arr = [1, 2, 3, 4];
    if (a > b) { 
    
    }
    for(var i = 0; i < 10; i++) { 
    
    }
    function fn() { 
    
    }

## Windows对象，Document对象 （重中之重） ##

知识太杂，这里看老师PPT就行

# 三、JavaWeb知识 #

JDBC书上没有看这里，其余的书上都有，其余的就看看知识点，做后面课后题

补充：其余Javaweb知识：[https://yangyongli.blog.csdn.net/article/details/117915099][https_yangyongli.blog.csdn.net_article_details_117915099]

--------------------

官方参考文档：[https://docs.oracle.com/javase/tutorial/jdbc/basics/index.html][https_docs.oracle.com_javase_tutorial_jdbc_basics_index.html]  
以下代码案例链接：  
[https://download.csdn.net/download/weixin\_45525272/19571149][https_download.csdn.net_download_weixin_45525272_19571149]

--------------------

# 1. JDBC 入门 #

## 1.1 客户端操作 MySQL 数据库的方式： ##

使用第三方客户端来访问 MySQL：SQLyog、Navicat、SQLWave、MyDB Studio、EMS SQL Manager for MySQL  
![在这里插入图片描述][20210611143213771.png]

使用 MySQL 自带的命令行方式、通过 Java 来访问 MySQL 数据库

### 1.1.1什么是 JDBC ###

JDBC 规范定义接口，具体的实现由各大数据库厂商来实现。

JDBC 是 Java 访问数据库的标准规范，真正怎么操作数据库还需要具体的实现类，也就是数据库驱动。每个数据库厂商根据自家数据库的通信格式编写好自己数据库的驱动。所以我们只需要会调用 JDBC 接口中的方法即可，数据库驱动由数据库厂商提供。

### 使用 JDBC 的好处： ###

1.  程序员如果要开发访问数据库的程序，只需要会调用 JDBC 接口中的方法即可，不用关注类是如何实现的。
2.  使用同一套 Java 代码，进行少量的修改就可以访问其他 JDBC 支持的数据库

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 19]

### 1.1.2 使用 JDBC 开发使用到的包： ###

<table> 
 <thead> 
  <tr> 
   <th>会使用到的包</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>java.sql</td> 
   <td>所有与 JDBC 访问数据库相关的接口和类</td> 
  </tr> 
  <tr> 
   <td>javax.sql</td> 
   <td>数据库扩展包，提供数据库额外的功能。如：连接池</td> 
  </tr> 
  <tr> 
   <td>数据库的驱动</td> 
   <td>由各大数据库厂商提供，需要额外去下载，是对 JDBC 接口实现的类</td> 
  </tr> 
 </tbody> 
</table>

## 1.2 JDBC 的核心 API ##

<table> 
 <thead> 
  <tr> 
   <th>接口或类</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>DriverManager</code>类</td> 
   <td>1. 管理和注册数据库驱动 2. 得到数据库连接对象</td> 
  </tr> 
  <tr> 
   <td><code>Connection</code> 接口</td> 
   <td>一个连接对象，可用于创建 Statement 和 PreparedStatement 对象</td> 
  </tr> 
  <tr> 
   <td><code>Statement</code>接口</td> 
   <td>一个 SQL 语句对象，用于将 SQL 语句发送给数据库服务器。</td> 
  </tr> 
  <tr> 
   <td><code>PreparedStatemen</code>接口</td> 
   <td>一个 SQL 语句对象，是 Statement 的子接口</td> 
  </tr> 
  <tr> 
   <td><code>ResultSet</code>接口</td> 
   <td>用于封装数据库查询的结果集，返回给客户端 Java 程序</td> 
  </tr> 
 </tbody> 
</table>

## 1.3导入驱动 Jar 包 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 20]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 21]

## 1.4加载和注册驱动 ##

<table> 
 <thead> 
  <tr> 
   <th>加载和注册驱动的方法</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>Class.forName</code>(数据库驱动实现类)</td> 
   <td>加载和注册数据库驱动，数据库驱动由 mysql 厂商 ——“com.mysql.jdbc.Driver”</td> 
  </tr> 
 </tbody> 
</table>

注册驱动代码：

public class Demo1  { 
    	public static void main(String[] args) throws ClassNotFoundException { 
    		//抛出类找不到的异常，注册数据库驱动
    		Class.forName("com.mysql.jdbc.Driver");
    	}
    }

#### com.mysql.jdbc.Driver 源代码： ####

// Driver 接口，所有数据库厂商必须实现的接口，表示这是一个驱动类。
    public class Driver implements java.sql.Driver {  
    	public Driver() throws SQLException { 
    	}
    
    	static {  
    		try { 
    			DriverManager.registerDriver(new Driver());   
    			//注册数据库驱动
    		} 
    		catch (SQLException var1) { 
    			throw new RuntimeException("Can't register driver!"); 
    			}
    		}
    	
    }

注：从 JDBC3 开始，目前已经普遍使用的版本。可以不用注册驱动而直接使用。Class.forName这句话可以省略。

# 2. DriverManager 类 #

## 2.1DriverManager 作用： ##

1)管理和注册驱动  
2)创建数据库的连接

## 2.2类中的方法： ##

<table> 
 <thead> 
  <tr> 
   <th>DriverManager 类中的静态方法</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>Connection getConnection (String url, String user, String password)</code></td> 
   <td>通过连接字符串，用户名，密码来得到数据库的连接对象</td> 
  </tr> 
  <tr> 
   <td><code>Connection getConnection (String url, Properties info)</code></td> 
   <td>通过连接字符串，属性对象来得到连接对象</td> 
  </tr> 
 </tbody> 
</table>

## 2.3 使用 JDBC 连接数据库的四个参数： ##

<table> 
 <thead> 
  <tr> 
   <th>JDBC 连接数据库的四个参数</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>用户名</td> 
   <td>登录的用户名</td> 
  </tr> 
  <tr> 
   <td>密码</td> 
   <td>登录的密码</td> 
  </tr> 
  <tr> 
   <td>连接字符串 URL</td> 
   <td>不同的数据库 URL 是不同的，mysql 的写法：<code>jdbc:mysql://localhost:3306/数据库[?参数名=参数值]</code></td> 
  </tr> 
  <tr> 
   <td>驱动类的字符串名</td> 
   <td>com.mysql.jdbc.Driver</td> 
  </tr> 
 </tbody> 
</table>

## 2.4 连接数据库的 URL 地址格式： ##

协议名:子协议://服务器名或 IP 地址:端口号/数据库名?参数=参数值

### 2.4.1MySQL 写法： ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 22]

### 2.4.2MySQL 中可以简写： ###

前提：必须是本地服务器，端口号是 3306

jdbc:mysql:///数据库名

### 2.4.3乱码的处理 ###

如果数据库出现乱码，可以指定参数: `?characterEncoding=utf8`，表示让数据库以 UTF-8 编码来处理数据。

jdbc:mysql://localhost:3306/数据库?characterEncoding=utf8

### 2.5 案例：得到 MySQL 的数据库连接对象 ###

#### 2.5.1 使用用户名、密码、URL 得到连接对象 ####

package com.sqltest; 
    import java.sql.Connection;
    import java.sql.DriverManager; 
    import java.sql.SQLException;
    
    /** * 得到连接对象*/
    public class Demo2 { 
        public static void main(String[] args) throws SQLException 
        {  
    	    String url = "jdbc:mysql://localhost:3306/day24";
    		//1) 使用用户名、密码、URL 得到连接对象
            Connection connection = DriverManager.getConnection(url, "root", "root");
    		//com.mysql.jdbc.JDBC4Connection@68de145
            System.out.println(connection); 
    	}
    }

#### 2.5.2 使用属性文件和 url 得到连接对象 ####

package com.sqltest;
    
    import java.sql.Connection; 
    import java.sql.DriverManager; 
    import java.sql.SQLException;
    import java.util.Properties;
    
    public class Demo3 { 
        public static void main(String[] args) throws SQLException { 
    		//url 连接字符串
            String url = "jdbc:mysql://localhost:3306/day24";
    		//属性对象
            Properties info = new Properties();
    		//把用户名和密码放在 info 对象中
    
            info.setProperty("user","root"); 	
            info.setProperty("password","root");
            Connection connection = DriverManager.getConnection(url, info);
    		//com.mysql.jdbc.JDBC4Connection@68de145 System.out.println(connection);
        }
    }

# 3. Connection 接口： #

## 3.1 Connection 作用： ##

Connection 接口，具体的实现类由数据库的厂商实现，代表一个连接对象。

## 3.2 Connection 方法： ##

<table> 
 <thead> 
  <tr> 
   <th>Connection 接口中的方法</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>Statement createStatement()</code></td> 
   <td>创建一条 SQL 语句对象</td> 
  </tr> 
 </tbody> 
</table>

# 4. Statement 接口 #

## 4.1JDBC 访问数据库的步骤 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 23]

1.  注册和加载驱动(可以省略)
2.  获取连接
3.  Connection 获取 Statement 对象
4.  使用 Statement 对象执行 SQL 语句
5.  返回结果集
6.  释放资源

## 4.2 Statement 作用： ##

代表一条语句对象，用于发送 SQL 语句给服务器，用于执行静态 SQL 语句并返回它所生成结果的对象。

## 4.3Statement 中的方法： ##

<table> 
 <thead> 
  <tr> 
   <th>Statement 接口中的方法</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>int executeUpdate(String sql)</td> 
   <td>用于发送 DML 语句，增删改的操作，insert、update、delete<br>参数：SQL 语句：<br>返回值：返回对数据库影响的行数</td> 
  </tr> 
  <tr> 
   <td>ResultSet executeQuery(String sql)</td> 
   <td>用于发送 DQL 语句，执行查询的操作。select<br>参数：SQL 语句<br>返回值：查询的结果集</td> 
  </tr> 
 </tbody> 
</table>

## 4.4释放资源 ##

1.  需要释放的对象：ResultSet 结果集，Statement 语句，Connection 连接
2.  释放原则：先开的后关，后开的先关。ResultSet  Statement  Connection
3.  放在哪个代码块中：finally 块

## 4.5执行 DDL 操作 ##

### 4.5.1需求：使用 JDBC 在 MySQL 的数据库中创建一张学生表 ###

![在这里插入图片描述][20210611151454420.png]

### 4.5.2代码： ###

package com.itheima;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.SQLException;
    import java.sql.Statement;
    
    /** * 创建一张学生表*/
    public class Demo4DDL { 
    
        public static void main(String[] args) { 
            //1. 创建连接
            Connection conn = null; Statement statement = null;
            try { 
                conn = DriverManager.getConnection("jdbc:mysql:///day24", "root", "root");
                //2. 通过连接对象得到语句对象
                statement = conn.createStatement();
                //3. 通过语句对象发送 SQL 语句给服务器
    //4. 执行 SQL
                statement.executeUpdate("create table student (id int PRIMARY key auto_increment, " + "name varchar(20) not null, gender boolean, birthday date)");
    //5. 返回影响行数(DDL 没有返回值) 
    		System.out.println("创建表成功");
            } catch (SQLException e) { 
                e.printStackTrace();
            }
    //6. 释放资源
            finally { 
        //关闭之前要先判断
                if (statement != null) { 
                    try { 
                        statement.close();
                    } catch (SQLException e) { 
                        e.printStackTrace();
                    }
        
                }
                if (conn != null) {  
                    try { 
                        conn.close();
                    } catch (SQLException e) { 
                        e.printStackTrace();
                    }
                }
            }
        }
    }

## 4.6执行 DML 操作 ##

需求：向学生表中添加 4 条记录，主键是自动增长

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 24]

### 步骤： ###

1.  创建连接对象
2.  创建 Statement 语句对象
3.  执行 SQL 语句：executeUpdate(sql)
4.  返回影响的行数
5.  释放资源

### 代码： ###

package com.sqltest;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.SQLException;
    import java.sql.Statement;
    
    
    /** * 向学生表中添加 4 条记录，主键是自动增长*/
    public class Demo5DML { 
    
        public static void main(String[] args) throws SQLException { 
    // 1) 创建连接对象
            Connection connection = DriverManager.getConnection("jdbc:mysql:///day24", "root", "root");
    // 2) 创建 Statement 语句对象
            Statement statement = connection.createStatement();
    // 3) 执行 SQL 语句：
    		executeUpdate(sql) ;
    		int count = 0;
    // 4) 返回影响的行数
            count += statement.executeUpdate("insert into student values(null, '孙悟空', 1, '1993-03- 24')");
            count += statement.executeUpdate("insert into student values(null, '白骨精', 0, '1995-03- 24')");
            count += statement.executeUpdate("insert into student values(null, '猪八戒', 1, '1903-03- 24')");
            count += statement.executeUpdate("insert into student values(null, '嫦娥', 0, '1993-03- 11')");
            System.out.println("插入了" + count + "条记录");
    // 5) 释放资源
            statement.close();
            connection.close();
        }
    
    }

## 4.7执行 DQL 操作 ##

### 4.7.1ResultSet 接口： ###

作用：封装数据库查询的结果集，对结果集进行遍历，取出每一条记录。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 25]

#### 接口中的方法： ####

<table> 
 <thead> 
  <tr> 
   <th>ResultSet 接口中的方法</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>boolean next()</code></td> 
   <td>1) 游标向下移动 1 行<br>2) 返回 boolean 类型，如果还有下一条记录，返回 true，否则返回 false</td> 
  </tr> 
  <tr> 
   <td>数据类型 <code>getXxx()</code></td> 
   <td>1) 通过字段名，参数是 String 类型。返回不同的类型<br>2) 通过列号，参数是整数，从 1 开始。返回不同的类型</td> 
  </tr> 
 </tbody> 
</table>

### 4.7.2常用数据类型转换表 ###

<table> 
 <thead> 
  <tr> 
   <th>SQL 类型</th> 
   <th>Jdbc 对应方法</th> 
   <th>返回类型</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>BIT(1) bit(n)</td> 
   <td><code>getBoolean()</code></td> 
   <td>boolean</td> 
  </tr> 
  <tr> 
   <td>TINYINT</td> 
   <td><code>getByte()</code></td> 
   <td>byte</td> 
  </tr> 
  <tr> 
   <td>SMALLINT</td> 
   <td><code>getShort()</code></td> 
   <td>short</td> 
  </tr> 
  <tr> 
   <td>INT</td> 
   <td><code>getInt()</code></td> 
   <td>int</td> 
  </tr> 
  <tr> 
   <td>BIGINT</td> 
   <td><code>getLong()</code></td> 
   <td>long</td> 
  </tr> 
  <tr> 
   <td>CHAR,VARCHAR</td> 
   <td><code>getString()</code></td> 
   <td>String</td> 
  </tr> 
  <tr> 
   <td>Text(Clob) Blob</td> 
   <td><code>getClob()``getBlob()</code></td> 
   <td>Clob Blob</td> 
  </tr> 
  <tr> 
   <td>DATE</td> 
   <td><code>getDate()</code></td> 
   <td>java.sql.Date 只代表日期</td> 
  </tr> 
  <tr> 
   <td>TIME</td> 
   <td><code>getTime()</code></td> 
   <td>java.sql.Time 只表示时间</td> 
  </tr> 
  <tr> 
   <td>TIMESTAMP</td> 
   <td><code>getTimestamp()</code></td> 
   <td>java.sql.Timestamp 同时有日期和时间</td> 
  </tr> 
 </tbody> 
</table>

注意：java.sql.Date、Time、Timestamp(时间戳)，三个共同父类是：java.util.Date

### 4.7.3需求：确保数据库中有 3 条以上的记录，查询所有的学员信息 ###

#### 步骤： ####

1.  得到连接对象
2.  得到语句对象
3.  执行 SQL 语句得到结果集 ResultSet 对象
4.  循环遍历取出每一条记录
5.  输出的控制台上
6.  释放资源结果：

#### 代码： ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 26]

package com.sqltest;
    
    import java.sql.*;
    
    /** * 查询所有的学生信息*/
    public class Demo6DQL { 
    
        public static void main(String[] args) throws SQLException { 
    //1) 得到连接对象
    	Connection connection =DriverManager.getConnection("jdbc:mysql://localhost:3306/day24","root","root");
    //2) 得到语句对象
            Statement statement = connection.createStatement();
    //3) 执行 SQL 语句得到结果集 ResultSet 对象
            ResultSet rs = statement.executeQuery("select * from student");
    //4) 循环遍历取出每一条记录
            while(rs.next()) { 
                int id = rs.getInt("id");
                String name = rs.getString("name"); boolean gender = rs.getBoolean("gender"); Date birthday = rs.getDate("birthday");
        //5) 输出的控制台上
                System.out.println("编号：" + id + ", 姓名：" + name + ", 性别：" + gender + ", 生日：" + birthday);
            }
    	    //6) 释放资源
    	    rs.close(); 
    	    statement.close(); 
    	    connection.close();
        }
    }

### 4.7.4关于 ResultSet 接口中的注意事项： ###

1.  如果光标在第一行之前，使用 rs.getXX()获取列值，报错：Before start of result set
2.  如果光标在最后一行之后，使用 rs.getXX()获取列值，报错：After end of result set
3.  使用完毕以后要关闭结果集 ResultSet，再关闭 Statement，再关闭 Connection

# 5. 数据库工具类 JdbcUtils #

## 什么时候自己创建工具类？ ##

如果一个功能经常要用到，我们建议把这个功能做成一个工具类，可以在不同的地方重用。

## 5.1需求： ##

上面写的代码中出现了很多重复的代码，可以把这些公共代码抽取出来。

## 5.2创建类 JdbcUtil 包含 3 个方法： ##

1.  可以把几个字符串定义成常量：用户名，密码，URL，驱动类
2.  得到数据库的连接：`getConnection()`
3.  关闭所有打开的资源：  
    `close(Connection conn, Statement stmt)`，`close(Connection conn, Statement stmt, ResultSet rs)`

### JdbcUtil.java 代码： ###

package com.sqltest.utils; 
    import java.sql.*;
    /** * 访问数据库的工具类*/
    public class JdbcUtils { 
    
        //可以把几个字符串定义成常量：用户名，密码，URL，驱动类
        private static final String USER = "root"; 
        private static final String PWD = "root";
        private static final String URL = "jdbc:mysql://localhost:3306/day24";
        private static final String DRIVER= "com.mysql.jdbc.Driver";
    
        /** * 注册驱动*/
        static { 
            try { 
                Class.forName(DRIVER);
            } catch (ClassNotFoundException e) {  e.printStackTrace();
            }
        }
    
        /** * 得到数据库的连接*/
        public static Connection getConnection() throws SQLException { 
            return DriverManager.getConnection(URL,USER,PWD);
        }
    
        /** * 关闭所有打开的资源*/
        public static void  close(Connection conn, Statement stmt) { 
            if (stmt!=null) { 
                try { 
                    stmt.close();
                } catch (SQLException e) { 
                    e.printStackTrace();
                }
            }
            if (conn!=null) { 
                try { 
                    conn.close();
                } catch (SQLException e) { 
                    e.printStackTrace();
                }
            }
        }
    
        /** * 关闭所有打开的资源*/
        public static void close(Connection conn, Statement stmt, ResultSet rs) { 
            if (rs!=null) { 
                try { 
                    rs.close();
                } catch (SQLException e) { 
                    e.printStackTrace();
    
                }
            }
            close(conn, stmt);
        }
    
    }

## 5.3案例：用户登陆 ##

### 5.3.1需求： ###

1.  有一张用户表
2.  添加几条用户记录
    
        create table user (
        id int primary key auto_increment, 
        name varchar(20),
        password varchar(20) 
        )
        
        insert into user values (null,'jack','123'),(null,'rose','456');
        
        -- 登录, SQL 中大小写不敏感
        select * from user where name='JACK' and password='123';
        
        -- 登录失败
        select * from user where name='JACK' and password='333';
3.  使用 Statement 字符串拼接的方式实现用户的登录, 用户在控制台上输入用户名和密码。

### 5.3.2步骤： ###

1.  得到用户从控制台上输入的用户名和密码来查询数据库
2.  写一个登录的方法  
    a. 通过工具类得到连接  
    b. 创建语句对象，使用拼接字符串的方式生成 SQL 语句  
    c. 查询数据库，如果有记录则表示登录成功，否则登录失败  
    d. 释放资源

### 5.3.3代码 ###

package com.sqltest;
    
    import com.itheima.utils.JdbcUtils; 
    import javax.xml.transform.Result;
    import java.sql.Connection; 
    import java.sql.ResultSet; 
    import java.sql.SQLException; 
    import java.sql.Statement; 
    import java.util.Scanner;
    
    public class Demo7Login { 
    
        //从控制台上输入的用户名和密码
        public static void main(String[] args) { 
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入用户名：");
            String name = sc.nextLine();
            System.out.println("请输入密码：");
            String password = sc.nextLine();
            login(name, password);
    
        }
    
        /** * 登录的方法*/
        public static void login(String name, String password) { 
            //a) 通过工具类得到连接
            Connection connection = null;
            Statement statement = null;
            ResultSet rs = null;
            try { 
                connection = JdbcUtils.getConnection();
                //b) 创建语句对象，使用拼接字符串的方式生成 SQL 语句
                statement = connection.createStatement();
                //c) 查询数据库，如果有记录则表示登录成功，否则登录失败
                String sql = "select * from user where name='" + name + "' and password='" + password + "'";
                System.out.println(sql);
                rs = statement.executeQuery(sql);
    
                if (rs.next()) { 
                    System.out.println("登录成功，欢迎您：" + name);
                }
                else { 
                    System.out.println("登录失败"); }
            } catch (SQLException e) { 
                e.printStackTrace();
            } finally { 
                //d) 释放资源
                JdbcUtils.close(connection, statement, rs); 
            }
    
        }
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70]: /images/20221005/c4fe30f71cbb44ef8e88ab799a26e3e0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 1]: /images/20221005/b68e2fdf38794ca2ac6123fb9e47285c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 2]: /images/20221005/15564e097a86453d8036d44bdc70d5a8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 3]: /images/20221005/cfe7a96551644010b4ebfbf91fc0f31e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 4]: /images/20221005/2db862b58f56409e95f20a81f00a9d2c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 5]: /images/20221005/04f6206c921f4c77bc05bae4ce9bb200.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 6]: /images/20221005/a848d00498b44afda01da94fcb84c919.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 7]: /images/20221005/9de00a0729b34fb2a430a745b19d8009.png
[https_yangyongli.blog.csdn.net_article_details_117792639]: https://yangyongli.blog.csdn.net/article/details/117792639
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 8]: /images/20221005/549767ae5bc943f29a7a5e754d30bd73.png
[Image 1]: 
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 9]: /images/20221005/e8bfa455175044c3896c3b2cfbb0938d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 10]: /images/20221005/1b95806417e84159aeaf602e23986218.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 11]: /images/20221005/336862b874404069973288270155d48b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 12]: /images/20221005/0d3e9b24fbe8452482c4d2533ef6898f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 13]: /images/20221005/0ee65fe2bd6b49c79be16f68282f0d08.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 14]: /images/20221005/6328a6ee76c6466cbbc26e4b6dedf6ec.png
[20200626210044488.png]: /images/20221005/ccdb09a237e34053a8d6b9a557d1d92e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 15]: /images/20221005/526e4e1019dc47c3b7c80315014bbec1.png
[20200626211836780.png]: /images/20221005/05101ceead7841fa92d8670c21377287.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 16]: /images/20221005/8267e6cf420d4e278901d0c3f8e08258.png
[20200626211954191.png]: /images/20221005/364e795948e1486c9a3a6c2b6a2cb42a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 17]: /images/20221005/5fb5ee08c0ec48e296169278b0e447a4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 18]: /images/20221005/2dd38b0f2436429bb09b0996f6125fa5.png
[https_yangyongli.blog.csdn.net_article_details_117915099]: https://yangyongli.blog.csdn.net/article/details/117915099
[https_docs.oracle.com_javase_tutorial_jdbc_basics_index.html]: https://docs.oracle.com/javase/tutorial/jdbc/basics/index.html
[https_download.csdn.net_download_weixin_45525272_19571149]: https://download.csdn.net/download/weixin_45525272/19571149
[20210611143213771.png]: /images/20221005/94cf4b376f274a6eb644368bf750ffc5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 19]: /images/20221005/f18d583555d74ff581f048e56d2439ce.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 20]: /images/20221005/6d8d398886d84cafb77b053c36a1dd65.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 21]: /images/20221005/9935f4cb1a0f48be9b87a37aaa0bb52e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 22]: /images/20221005/b3ae460eb1f04e34a33d5c4a537cc35e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 23]: /images/20221005/f29b5da2babe4ddfb94e6369822e997b.png
[20210611151454420.png]: /images/20221005/727b4585413141a08b84c96b13fa58ae.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 24]: /images/20221005/1e205a5b59064055a2367faf9e41b082.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 25]: /images/20221005/ab8822a627674ab8b3825215645eef22.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUyNTI3Mg_size_16_color_FFFFFF_t_70 26]: /images/20221005/6ad18c3015e542d39143178ada644ce1.png