XenServer

XenServer简介

Citrix Xenserver，思杰基于Xen的虚拟化服务器。Citrix XenServer是一种全面而易于管理的服务器虚拟化平台，基于强大的 Xen Hypervisor 程序之上。Xen技术被广泛看作是业界最快速、最安全的虚拟化软件。XenServer 是为了高效地管理 Windows(R) 和 Linux(R)虚拟服务器而设计的，可提供经济高效的服务器整合和业务连续性。

准备工作

1. 在XenServer官网下载ISO文件，需要注册账号；

2. 利用镜像制作软件做启动盘,我这里用的是UltraISO,关于镜像的写入，链接里都有相关教程

3. 安装XenServer的服务器CPU必须支持虚拟化，Intel (VT-X) 或者AMD (AMD-V)

4. 服务器选择u盘启动

安装步骤

一、选择键盘类型：US。

二、这个是欢迎界面，选择“OK”即可。

三、这个是使用协议，我们必须得接受，否则就不能继续安装了！

四、这个是警告，告诉你XenServer所需要的硬件条件，我们选择“OK”即可。

六、这个是存储设备选择界面，第一个是本地磁盘—sda;第二个是自动精简配置—thin provisioning ，主要是针对XenDesktop MCS，如果想详细了解，可以上查查。我们这里就直接选择本地。

七、这个是安装方式选择界面，一共有三种：本地、HTTP/FTP、NFS，我们这里直接用本地，一般在公司都会用ftp或nfs通过网络安装。

八，提示我们，要不要追加安装补丁包，我们不用就直接选择“NO”。

九、光盘验证，这里提示让我们选择要不要验证我们的安装光盘有没有错，第一为忽略，即直接跳过，第二个为验证安装源，我们的选择跳过即可。

十、这里要我们输入root的密码，一般在企业中，我们的密码最好复杂些并且要记下来。

十一、这里为XenServer主机的网络设置，有DHCP自动获取和静态IP两种，具体情况要看个人的安装网络环境。

十二、这里为配置XenServer主机的主机名与DNS。DNS 就是公司的DNS服务器，不懂就问网管了。

十三、区时选择，我们选择亚洲—“Asia”。

十四、具体时区，我们直接使用上海—“Shanghai”即可。

十五、这个是设置NTP，主要是与校准时钟有关，特别是在服务器集群时，我们所有的服务器时间必须得一致，否则很容易出现一些很奇怪的问题。当然，你也可以都选择第二个，本地时间，这个的话，就不必设置ntpserver了，不过它为在安装结束后让你手动设置时间的。NTPServer可以到http://www.ntp.org/ 这里看看如何设置。

十六、安装界面

十七、安装过程

安装完毕后，它会提示让你重启，重新启动后即可完成XenServer8.2的安装。

一，IP地址的配置，XenServer 安装好之后，就是这个界面了。可以配置IP 地址，DNS等。

安装过程中遇到的问题

1. 进行时第二步中出现，this host does not appear to have ang network interfaces

解决方案：Xenserver版本问题，更换新的Xenserver版本。（刚开始用的7.0，后来换的8.2 没有出现此问题）

2.安装完之后出现界面不能加载，如下图问题

解决方案：rm -rf /etc/modules-load.d/，删除之后即可正常启动，具体原因是由于内核加载文件版本较旧，删除之后会更新内核加载文件

XenCenter

XenCenter 简介

​ XenCenter是用来管理和维护XenServer主机的，创建、管理、删除虚拟机等几乎所有的操作都在XenCenter中完成

简单来说XenCenter就是XenServer的管理工具

XenCenter 安装

1. 浏览器输入XenServer的Ip，得到以下Web页面

2. 页面说明

3. 点击Xencenter的下载链接进去下载然后进行安装

XenCenter安装过程中出现的问题及解决方法

1. windows的.Net版本过低，安装不了，如下图

   

   解决方案：更新windows版本或更新.Net

2. XenCenter的版本要与XenServer版本对应，低版本的XenCenter不能连接高版本的XenServer主机。

利用XenCenter搭建虚拟机

安装说明

在XenServer安装虚拟机，和传统的操作系统安装不同的是，需要把镜像文件单独放在别的机器上可以以文件共享的方式也可以以NFS的方式，也可以在本地进行iso目录的挂载，然后去装虚拟机，本次使用的也是最后这种方式。

安装步骤

1. 创建一个myiso文件夹来存放iso文件，mkdir /myiso

2. 执行xe sr-create name-label=iso type=iso device-config:location=/iso device-config:legacy_mode= true content-type=iso 命令 建立iso档型式的储存库(SR - Storage Repositories)，新增成功，上传那些iso文件档至主机的/iso即可。在XenCenter会出现一个项目 （如果没有出现对应的ISO光盘，在存储位置点击重新扫描即可。）

3. 新建vm选择要安装的vm类型版本

   

4. 设置vm名称

   

5. 选择安装介质，选择我们之前上传到/myiso目录下的镜像

   

6. 选择主服务器

   

7. 配置服务器的cpu以及内存

   

8. 配置硬盘大小最大不能超过2T

   

9. 配置网络接口

   

10. 然后点击完成即可安装好了

    

11. 然后进入正常的ubuntu安装界面，进行安装

    安装过程中出现的问题

12. 根目录大小，可以在重新挂载，默认200Gb，具体如图

    

    （如果安装时没有挂载可以，安装完成之后，用命令进行挂载）

2. 安装过程中，最后有个OPSSH安装，勾上，省的去手动安装

3. 安装过程中，有个IP设置，默认是DHCP、也可以手动改为静态IP，（安装完可在/etc/netplan下的配置文件中更改）

   Subnet ： 192.168.3.0/24

   address： 192.168.3.32

   gateway： 192.168.3.1

   nameserver： 8.8.8.8

最后

由于要进行多台安装，一台一台安装比较麻烦，可以进行vm复制进行快速安装

首先 ，启动Eclipse dian点file 创建yi’g一个新的maven项目

注意创建的时候，要钩选这个，而且默认的创建项目的位置是你当初设置的位置，如果你想更改，点击browse 即可更改，在这里呢我选择默认的路径，ran’然后点击next

、

这里的groupid和artifactId被统称为“坐标”是为了保证项目唯一性而提出的，如果你要把你项目弄到maven本地仓库去，你想要找到你的项目就必须根据这两个id去查找。
　　groupId一般分为多个段，这里我只说两段，第一段为域，第二段为公司名称。域又分为org、com、cn等等许多，其中org为非营利组织，com为商业组织。举个apache公司的tomcat项目例子：这个项目的groupId是org.apache，它的域是org（因为tomcat是非营利项目），公司名称是apache，artigactId是tomcat。
　　比如我创建一个项目，我一般会将groupId设置为cn.lyh，cn表示域为中国，lyh是我个人姓名缩写，artifactId设置为ZhenaiSpider，表示你这个项目的名称是ZhenaiSpider，依照这个设置，你的包结构最好是cn.lyh.ZhenaiSpider打头的，如果有个包叫single，它的全路径就是cn.lyh.ZhenaiSpider.single

设置完成之后我们的maven项目就算搭建好了 ，接下来我们会看到一个pom.xml 文件，打开之后是这样的

我们需要去http://mvnrepository.com/ 这个网站去找我们所需要的依赖 我们不会一次性导入所有依赖 只有在需要的时候才会去导入，

接下来呢 我们要用到的技术是HTTP 协议+爬虫(jsoup - HTML) 当然了 为了提高效率我们用的是多线程去爬取数据（关于Java的多线程 可参考其他帖子，这里就不一一赘述了）

关于Http协议：

HTTP协议其实就是用来定义Web客户端如何从Web服务器请求Web页面，以及服务器如何把Web页面传送给客户端。HTTP协议采用了请求/响应模型。客户端向服务器发送一个请求报文，请求报文包含请求的方法、URL、协议版本、请求头部和请求数据。服务器以一个状态行作为响应，响应的内容包括协议的版本、成功或者错误代码、服务器信息、响应头部和响应数据。

简单的来说 在浏览器地址栏键入URL，点击链接之后会经历以下流程

1、浏览器向 DNS 服务器请求解析该 URL 中的域名所对应的 IP 地址;

2、解析出 IP 地址后，根据该 IP 地址和默认端口 80，和服务器建立TCP连接;

3、浏览器发出读取文件(URL 中域名后面部分对应的文件)的HTTP 请求，该请求报文作为 TCP 三次握手的第三个报文的数据发送给服务器;

4、服务器对浏览器请求作出响应，并把对应的 html 文本发送给浏览器;

5、释放 TCP连接;

6、浏览器将该 html 文本并显示内容; 　

Jsoup　：

所谓的爬虫，简单的来说 一个网页 ，就是一个文本文件，所谓的爬虫就是一个利用解析器，把我们所需要的信息从网页中拿出来 并把这些信息保存到本地 或者写到数据库里。而jsoup就是Java的 一个强大的Html解析器，它可直接解析某个URL地址、HTML文本内容。它提供了一套非常省力的API，可通过DOM，CSS以及类似于jQuery的操作方法来取出和操作数据。而我们可以去打开浏览器，而在我们的项目中要用到jsoup 我们需要去找依赖并下载下来，打开网站搜索jsoup

第一个就是 然后我用的是最新的1.11.3

点击你所需要的版本

分析url：

通过分析，其实我们可以发现，每个网站的url 都是有规律的 ，如图

然后我们用 Java去模拟 去请求

请求完成之后，剩下的工作就是通过返回的字符串来进行对文本的解析

这时候我们就要通过强大的jsoup去进行解析

首先我们要知道 在浏览器中 我们是可以看到网页的源码的，在浏览器中按f12 即可进入 或者直接鼠标右键 会出来查看源代码，但推荐用前者

例如：

我们要通过网页的源代码去拿wo’m我么所需要的数据，比如性别，是否结过婚，年龄，是否购车，是否有房，学历情况，收入等等一系列信息

我们从网页源码中可以发现 id 是放在这儿的 ，然后我们 用 select 方法 拿出 ID 然后在用.text() 方法拿到值 这样我们就 获取到了这个用户的id ，利用此方法我们可以拿到这个页面的任何信息

下面这个截图只是个参考 大家要去自己分析看看 是不是这样，试试自己是否能够分析出来想要的结果

这样我们的的爬虫基本上就结束了，下次我将会wei为大家分享 如何将获取到的的数据保存到Mysql 数据库中 然后为大家介绍制做报表的神器Echarts 本次分享就先到这儿，若文中有什么不足的地方希望大家可以在评论区进行指点。大家可以加关注，继续看我下次的分享哦

Mysql

1，第一当然还是先下载了，进入网站即可选择相应的版本https://dev.mysql.com/downloads/file/?id=476696

2.我们这里是5.7.22,打开网址，翻到最下面，点击如下，直接下载就好

3，解压，进行初始化数据库

在bin目录下，执行以下的命令来初始化数据库（cmd下）：

D:\b\mysql-5.7.21-winx64\bin>mysqld –initialize，

获取初始化以后的用户名root,和密码：

然后你会发现解压的目录下，多了一个叫data的文件夹

打开之后，有一个后缀为err的文件，用notepade++ 打开 或者记事本也可以

，

在这个文件的最后，每个人的不一样 但localhost： 后面的就是你的密码

4，接下来呢，测试启动mysql

在解压目录下的bin目录下 输入以下指令mysqld –console

如果显示如图信息，就证明你安装成功了。切记不要关闭这个窗口。

5，登陆

密码就是刚才那个文件夹里的那个，但你会发现在这个密码下什么都做不了

修改密码：输入以下指令即可修改密码，如下1234就是我所修改之后的密码，

mysql> set password=password(‘1234’);

显示以下信息就代表修改成功了

Query OK, 0 rows affected, 1 warning (0.00 sec)

修改完成之后，我们再执行 show tables jiu’就会发现可以执行了

显示的这些信息都是你所包含的表

6，方便起见，我们将mysql 安装成windows服务，在bin目录下，执行如下指令即可完成安装

接下来呢我们配置环境变量，这样我们就可以在cmd中启动mysql了

在path 下添加到mysql的bin，如下图

然后打开cmd 输入 net start mysql 即可启动mysql(要注意在执行之前我们要关掉之前测试启动mysql的那个窗口)

当然了 停止mysql 的命令是 net stop mysql

7，再登陆

-u用户名 -p

对于本机来说：

你可以设置远程登陆，即在别人的机器上也可以登录你的数据库，具体设置方法如下

1.先查看一下你的用户列表

你会发现 在root 那栏 只有localhost 即代表只有本机才可以登陆，接下来呢将localhosthuan换成% 这样就可以实现远程登陆了

到这里呢我们的mysql 基本上就设置好了

接下来呢我们去xia项目中添加mysql的依赖

关于mysql的语句，我们在这里简单地说几个

1.创建数据库，后面的 character set utf8 是设置 数据库的编码方式 为utf8 （一般都会是utf8 ）

2，进入这个数据库

3，创建一个表

3，查看数据库下的表

这时会发现 我们刚才创建的表就出现了

4，向表中写数据

基本操作就这些 其他操作，如删除表，删除字段等等 可自行百度查阅

接下来呢，我们用java语句去操作数据库，即jdbc，关于jdbc 给大家一个lian链接 感觉写的挺不错，这里就不赘述了

https://www.cnblogs.com/wuyuegb2312/p/3872607.html

这里我们使用DButils操作数据库。使用 c3p0做连接池，之所以使用连接池是因为每次操作数据库，都重新创建一个连接。Connection 使用连接池：保证连接的重用，回收连接。

接下来呢，我么要做的就是要添加，c3p0的依赖，

https://mvnrepository.com/ 然后搜索c3p0 找到相应的依赖，然后拷贝到我们的pom.xml 文件夹下 即可自动下载依赖

​

​ com.mchange

​ c3p0

​ 0.9.5.2

​

然后添加c3p0的配置文件 c3p0p-config.xml

<?xml version=“1.0” encoding=“UTF-8”?>

<propertyname=“jdbcUrl”>jdbc:mysql:///hyxy?characterEncoding=UTF8&useUnicode=true&useSSL=false

​ <property name=“driverClass”>com.mysql.jdbc.Driver

​ <property name=“user”>root

​ <property name=“password”>1234

​

​ <property name=“checkoutTimeout”>3000

​

​ <property name=“initialPoolSize”>3

​

​ <property name=“maxPoolSize”>10

​ <property name=“minPoolSize”>3

​

​ <property name=“maxStatements”>200

创建一个连接池，通过读取上面的配置文件

package cn.hyxy.zhenai.util;
import javax.sql.DataSource;
import com.mchange.v2.c3p0.ComboPooledDataSource;
public class DSUtils {
//1:声明dataSour e
private static DataSource DATASOURCE;
//2:开发一个静态的代码块，只执行一次
static {
DATASOURCE = new ComboPooledDataSource();
}
//3:获取Da
public static DataSource getDataSource() {
return DATASOURCE;
}
}

使用dbutils

导入dbutils的依赖

我们来设计我们的表格

输入指令 ，来创建这个表格

CREATE TABLE dogs(

id BIGINT,

NAME VARCHAR(50),

age INT,

workaddr VARCHAR(20),

height INT,

salary VARCHAR(30),

homeaddr VARCHAR(30),

married VARCHAR(10),

grade VARCHAR(10),

worker VARCHAR(20),

house VARCHAR(10),

car VARCHAR(10),

sex VARCHAR(10)

);

然后我们利用程序 将爬取的数据写入到数据库，为了更可观的查看我们爬取的数据，我们可以利用数据库管理和开发工具

例如navicat premium

将数据写入到数据库中，在spider 中写一个方法 ，传入我们所获取的信息，利用这个方法将我们传进的信息，写入到数据库中

public void insert(String sql, String id, String name,String sex, String age, String workaddr, String height, String salary,
String homeaddr, String married, String grade, String worker, String house, String car) throws Exception {
QueryRunner run = new QueryRunner(DSUtils.getDataSource());
run.update(sql, id, name,sex, age, workaddr, height, salary, homeaddr, married, grade, worker, house, car);
}

这样呢我们就成功将我们获取的信息写入到我们的数据库了 然后将spider 跑起来 其获取信息

我们的爬虫到这儿 就完成了，下次我们就要利用这些数据做成报表，使信息更可观的表现如下图

诸如此类，大家可自行设计不同的报表类型，明天再和大家继续分享，文中若有不足，欢迎大家的指正。

一、 进行jdk安装及环境变量的配置

由于是基于java的项目 所以先进行jdk的相关安装及配置：

1，本次使用的是jdk1.8（当然了 也可以使用其他的版本）

http://www.oracle.com/technetwork/java/javase/downloads/jdk8-downloads-2133151.html

进入这个地址即可进行相应的下载

2，下载完成之后进行解压，解压到一个没有中文和空格路径的目录下

3，配置环境变量

打开我的电脑 右键属性找到高级设置，右下角有环境变量打开即可进行设置，

在系统变量 点击新建 然后输入变量名以及变量值

变量名： JAVA_HOME

​ 变量值 ：JDK的解压目录

例如

然后找到系统变量中的path 双击打开 然后右侧栏点击新建 然后再点击浏览找到jdk目录下的bin目录

如图这样 就已经完成了

然后点击确定 应用 即可

然后验证是否安装成功按住win+r 然后输入cmd 进入命令行 输入java -version 如果如图显示 就证明你就已经配置成功了

二 、下载IDE(集成开发环境） （这里我用的是Eclipse)

1，下载Eclipse

进入官网即可下载http://www.eclipse.org/downloads/

我这里下载的是Mars 版本 但要注意的是 要下载ee 不要下载se

然后解压并启动

这个是让你选择工作空间 ，选择以后你的所有的项目都会保存在这个文件夹下

2，打开以后进行基本的配置

在菜单栏上有个Windows 点开 然后点击preference 输入work 点击workspqce 将编码方式设置为UTF-8

进行到这里以后我们就可以写出一个基本的Java程序了 但我们的spider是基于maven的所以我们还要进行配置maven依赖工具

三、 创建maven 依赖工具

1，下载 解压http://mirrors.shu.edu.cn/apache/maven/maven-3/3.5.4/binaries/apache-maven-3.5.4-bin.zip

点击 即可进入官网下载

2，配置环境变量 和上面类似

M2_HOME = 解压目录

在path下新建然后浏览 找到解压目录下的bin

然后打开命令行进行验证看是否成功 输入mvn -v 若显示如下 则成功

2，配置maven

Mave会从中心仓库下载所需要的依赖包，放到本地（由于服务器在国外 下载过程可能会较慢）

找到解压目录下的config 文件夹 打开 然后打开里面的settings.xml文件，然后将它放到你的c盘user文件夹下的你的用户名的.m2的文件夹下 例如C:/user/wangjian/.m2/settings.xml （若没有.m2 文件夹 请创建 此时要用命令行来创建，打开cmd 然后输入mkdir .m2 然后文件夹就创建好了）

然后用notepad++ 打开这个settings.xml文件 并修改参数 如图 （notapade++ 百度即可找到 或者其他工具打开也可以 ）

刚开始是这样的 然后修改如下：那个黑字部分 就是下载的依赖所保存的地方 黑字部分是路径 你要自己设置你自己的哦！

然后呢我们就在Eclipse 中集成maven

还是菜单栏的Windows下的 Preferences 然后如图 输入maven

到这里基本上就配置成功了，加关注，明天继续分享哦！

首先要导入地图的js包 我放到了 百度网盘上 大家下载下来之后 解压放到assert文件夹下 即可

https://pan.baidu.com/s/1TPB7pzewfg43MXaiw24I8g

然后获取数据， 由于全国省份较多 我们可以百度，如图

然后拷贝 到一个新建的txt文件夹下（我在这儿是a.txt） 然后将所有的中文 逗号换成英文的

然后在这个目录下打开命令行执行native2ascii a.txt b.txt 然后将 b.txt文件里的内容全选 新建 如下图所示的文件夹

然后如图 写入china = 然后将b里的内容拷贝到等号的后面

然后获取数据 将数据导入地图 就大功告成了（是不是有点不可思议呢^_^）

public List<Map<String, Object>> queryChina() {
List<Map<String, Object>> list = new ArrayList<>();
// 读取所有的省信息
Properties prop = new Properties();
try {
prop.load(ZhenaiDao.class.getClassLoader().getResourceAsStream(“zhenai.properties”));
String china = prop.getProperty(“china”);
String[] privs = china.split(“,”);
QueryRunner run = new QueryRunner(ds);
String sql = “select count(1) from dogs where homeaddr like ?”;
for(String priv:privs) {
int cnt = run.query(sql, new ScalarHandler(),priv+”%”).intValue();
Map<String, Object> map = new HashMap<>();
map.put(“name”, priv);
map.put(“value”, cnt);
//放到
list.add(map);
}
} catch (Exception e) {
e.printStackTrace();
}
return list;

<%@ page language=”java” contentType=”text/html; charset=UTF-8” pageEncoding=”UTF-8”%><%@ taglib uri=”http://java.sun.com/jsp/jstl/core" prefix=”c”%><!DOCTYPE html>

效果如图示

这样呢我们的项目就大功告成了，我也会将整个项目打包供大家下载参考，关于优化spider的项目代码我也会打包供大家参考

链接：https://pan.baidu.com/s/1qFzq7Qa_MEbXbhLHBRokMQ 密码：7efk (zhenaiweb)

链接：https://pan.baidu.com/s/1Ty7m8aV5BArukppMEuIyYg 密码：vysq （zhenaispider 未优化）

已优化的 在我的在我的下载资源里有 大家可以去下载参考

Mysql

1，第一当然还是先下载了，进入网站即可选择相应的版本https://dev.mysql.com/downloads/file/?id=476696

2.我们这里是5.7.22,打开网址，翻到最下面，点击如下，直接下载就好

3，解压，进行初始化数据库

在bin目录下，执行以下的命令来初始化数据库（cmd下）：

D:\b\mysql-5.7.21-winx64\bin>mysqld –initialize，

获取初始化以后的用户名root,和密码：

然后你会发现解压的目录下，多了一个叫data的文件夹

打开之后，有一个后缀为err的文件，用notepade++ 打开 或者记事本也可以

，

在这个文件的最后，每个人的不一样 但localhost： 后面的就是你的密码

4，接下来呢，测试启动mysql

在解压目录下的bin目录下 输入以下指令mysqld –console

如果显示如图信息，就证明你安装成功了。切记不要关闭这个窗口。

5，登陆

密码就是刚才那个文件夹里的那个，但你会发现在这个密码下什么都做不了

修改密码：输入以下指令即可修改密码，如下1234就是我所修改之后的密码，

mysql> set password=password(‘1234’);

显示以下信息就代表修改成功了

Query OK, 0 rows affected, 1 warning (0.00 sec)

修改完成之后，我们再执行 show tables jiu’就会发现可以执行了

显示的这些信息都是你所包含的表

6，方便起见，我们将mysql 安装成windows服务，在bin目录下，执行如下指令即可完成安装

接下来呢我们配置环境变量，这样我们就可以在cmd中启动mysql了

在path 下添加到mysql的bin，如下图

然后打开cmd 输入 net start mysql 即可启动mysql(要注意在执行之前我们要关掉之前测试启动mysql的那个窗口)

当然了 停止mysql 的命令是 net stop mysql

7，再登陆

-u用户名 -p

对于本机来说：

你可以设置远程登陆，即在别人的机器上也可以登录你的数据库，具体设置方法如下

1.先查看一下你的用户列表

你会发现 在root 那栏 只有localhost 即代表只有本机才可以登陆，接下来呢将localhosthuan换成% 这样就可以实现远程登陆了

到这里呢我们的mysql 基本上就设置好了

接下来呢我们去xia项目中添加mysql的依赖

关于mysql的语句，我们在这里简单地说几个

1.创建数据库，后面的 character set utf8 是设置 数据库的编码方式 为utf8 （一般都会是utf8 ）

2，进入这个数据库

3，创建一个表

3，查看数据库下的表

这时会发现 我们刚才创建的表就出现了

4，向表中写数据

基本操作就这些 其他操作，如删除表，删除字段等等 可自行百度查阅

接下来呢，我们用java语句去操作数据库，即jdbc，关于jdbc 给大家一个lian链接 感觉写的挺不错，这里就不赘述了

https://www.cnblogs.com/wuyuegb2312/p/3872607.html

这里我们使用DButils操作数据库。使用 c3p0做连接池，之所以使用连接池是因为每次操作数据库，都重新创建一个连接。Connection 使用连接池：保证连接的重用，回收连接。

接下来呢，我么要做的就是要添加，c3p0的依赖，

https://mvnrepository.com/ 然后搜索c3p0 找到相应的依赖，然后拷贝到我们的pom.xml 文件夹下 即可自动下载依赖

​

​ com.mchange

​ c3p0

​ 0.9.5.2

​

然后添加c3p0的配置文件 c3p0p-config.xml

<?xml version=“1.0” encoding=“UTF-8”?>

<propertyname=“jdbcUrl”>jdbc:mysql:///hyxy?characterEncoding=UTF8&useUnicode=true&useSSL=false

​ <property name=“driverClass”>com.mysql.jdbc.Driver

​ <property name=“user”>root

​ <property name=“password”>1234

​

​ <property name=“checkoutTimeout”>3000

​

​ <property name=“initialPoolSize”>3

​

​ <property name=“maxPoolSize”>10

​ <property name=“minPoolSize”>3

​

​ <property name=“maxStatements”>200

创建一个连接池，通过读取上面的配置文件

package cn.hyxy.zhenai.util;
import javax.sql.DataSource;
import com.mchange.v2.c3p0.ComboPooledDataSource;
public class DSUtils {
//1:声明dataSour e
private static DataSource DATASOURCE;
//2:开发一个静态的代码块，只执行一次
static {
DATASOURCE = new ComboPooledDataSource();
}
//3:获取Da
public static DataSource getDataSource() {
return DATASOURCE;
}
}

使用dbutils

导入dbutils的依赖

我们来设计我们的表格

输入指令 ，来创建这个表格

CREATE TABLE dogs(

id BIGINT,

NAME VARCHAR(50),

age INT,

workaddr VARCHAR(20),

height INT,

salary VARCHAR(30),

homeaddr VARCHAR(30),

married VARCHAR(10),

grade VARCHAR(10),

worker VARCHAR(20),

house VARCHAR(10),

car VARCHAR(10),

sex VARCHAR(10)

);

然后我们利用程序 将爬取的数据写入到数据库，为了更可观的查看我们爬取的数据，我们可以利用数据库管理和开发工具

例如navicat premium

将数据写入到数据库中，在spider 中写一个方法 ，传入我们所获取的信息，利用这个方法将我们传进的信息，写入到数据库中

public void insert(String sql, String id, String name,String sex, String age, String workaddr, String height, String salary,
String homeaddr, String married, String grade, String worker, String house, String car) throws Exception {
QueryRunner run = new QueryRunner(DSUtils.getDataSource());
run.update(sql, id, name,sex, age, workaddr, height, salary, homeaddr, married, grade, worker, house, car);
}

这样呢我们就成功将我们获取的信息写入到我们的数据库了 然后将spider 跑起来 其获取信息

我们的爬虫到这儿 就完成了，下次我们就要利用这些数据做成报表，使信息更可观的表现如下图

诸如此类，大家可自行设计不同的报表类型，明天再和大家继续分享，文中若有不足，欢迎大家的指正。

Quick Start

Create a new post

1

$ hexo new "My New Post"

More info: Writing

Run server

1

$ hexo server

More info: Server

Generate static files

1

$ hexo generate

More info: Generating

Deploy to remote sites

1

$ hexo deploy

More info: Deployment

接口（Interface），在java中，是一个抽象类型，是抽象方法的集合，接口通常以interface来声明，一个类通过继承接口的方式，从而来继承接口的抽象方法

接口并不是类，编写接口的方式和类很相似，但是他门属于不同的概念，类描述对象的属性和方法接口则包含类要实现的方法

除非实现接口的类是抽象类，否则该类要定义接口中的所有方法

接口无法被实例化，但是可以被实现。一个实现接口的类必须实现接口内所描述的所有方法，否则就必须声明为抽象类。另外，在Java中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象

接口与类的相似点

• 一个接口可以有多个方法。
• 接口文件保存在 .java 结尾的文件中，文件名使用接口名。
• 接口的字节码文件保存在 .class 结尾的文件中。
• 接口相应的字节码文件必须在与包名称相匹配的目录结构中。

接口与类的区别：

• 接口不能用于实例化对象。
• 接口没有构造方法。
• 接口中所有的方法必须是抽象方法。
• 接口不能包含成员变量，除了 static 和 final 变量。
• 接口不是被类继承了，而是要被类实现。
• 接口支持多继承。

接口特性

• 接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错）。
• 接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误）。
• 接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。

抽象类和接口的区别

• 抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。
• 抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。
• 接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。
• 一个类只能继承一个抽象类，而一个类却可以实现多个接口。

注：JDK 1.8 以后，接口里可以有静态方法和方法体了。

接口的声明

接口的声明语法格式如下：

1
2
3
4

[可见度] interface 接口名称 [extends 其他的接口名] {
        // 声明变量
        // 抽象方法
}

Interface关键字用来声明一个接口。下面是接口声明的一个简单例子。

1
2
3
4
5
6
7
8

import java.lang.*;
//引入包
 
public interface NameOfInterface
{
   //任何类型 final, static 字段
   //抽象方法
}

接口有以下特性：

• 接口是隐式抽象的，当声明一个接口的时候，不必使用abstract关键字。
• 接口中每一个方法也是隐式抽象的，声明时同样不需要abstract关键字。
• 接口中的方法都是公有的。

实例

1
2
3
4
5

/* 文件名 : Animal.java */
interface Animal {
   public void eat();
   public void travel();
}

接口的实现

当类实现接口的时候，类要实现接口中所有的方法。否则，类必须声明为抽象的类。

类使用implements关键字实现接口。在类声明中，Implements关键字放在class声明后面。

实现一个接口的语法，可以使用这个公式：

1

...implements 接口名称[, 其他接口名称, 其他接口名称..., ...] ...

实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

/* 文件名 : MammalInt.java */
public class MammalInt implements Animal{
 
   public void eat(){
      System.out.println("Mammal eats");
   }
 
   public void travel(){
      System.out.println("Mammal travels");
   } 
 
   public int noOfLegs(){
      return 0;
   }
 
   public static void main(String args[]){
      MammalInt m = new MammalInt();
      m.eat();
      m.travel();
   }
}

结果如下

重写接口中声明的方法时，需要注意以下规则：

• 类在实现接口的方法时，不能抛出强制性异常，只能在接口中，或者继承接口的抽象类中抛出该强制性异常。
• 类在重写方法时要保持一致的方法名，并且应该保持相同或者相兼容的返回值类型。
• 如果实现接口的类是抽象类，那么就没必要实现该接口的方法。

在实现接口的时候，也要注意一些规则：

• 一个类可以同时实现多个接口。
• 一个类只能继承一个类，但是能实现多个接口。
• 一个接口能继承另一个接口，这和类之间的继承比较相似。

接口的继承

一个接口能继承另一个接口，和类之间的继承方式比较相似。接口的继承使用extends关键字，子接口继承父接口的方法。

下面的Sports接口被Hockey和Football接口继承：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

// 文件名: Sports.java
public interface Sports
{
   public void setHomeTeam(String name);
   public void setVisitingTeam(String name);
}
 
// 文件名: Football.java
public interface Football extends Sports
{
   public void homeTeamScored(int points);
   public void visitingTeamScored(int points);
   public void endOfQuarter(int quarter);
}
 
// 文件名: Hockey.java
public interface Hockey extends Sports
{
   public void homeGoalScored();
   public void visitingGoalScored();
   public void endOfPeriod(int period);
   public void overtimePeriod(int ot);
}

Hockey接口自己声明了四个方法，从Sports接口继承了两个方法，这样，实现Hockey接口的类需要实现六个方法。

相似的，实现Football接口的类需要实现五个方法，其中两个来自于Sports接口。

接口的多继承

在Java中，类的多继承是不合法，但接口允许多继承。

在接口的多继承中extends关键字只需要使用一次，在其后跟着继承接口。 如下所示：

1

public interface Hockey extends Sports, Event

没有任何方法的接口被称为标记接口。标记接口主要用于以下两种目的：

• 建立一个公共的父接口：

  正如EventListener接口，这是由几十个其他接口扩展的Java API，你可以使用一个标记接口来建立一组接口的父接口。例如：当一个接口继承了EventListener接口，Java虚拟机(JVM)就知道该接口将要被用于一个事件的代理方案。

• 向一个类添加数据类型：

  这种情况是标记接口最初的目的，实现标记接口的类不需要定义任何接口方法(因为标记接口根本就没有方法)，但是该类通过多态性变成一个接口类型。

标记接口定义如下：

1
2
3
4

package java.util;
public interface EventListener{
    ....
}

Java 包（package）

为了更好地组织类，Java 提供了包机制，用于区别类名的命名空间。

包的作用

• 1、把功能相似或相关的类或接口组织在同一个包中，方便类的查找和使用。
• 2、如同文件夹一样，包也采用了树形目录的存储方式。同一个包中的类名字是不同的，不同的包中的类的名字是可以相同的，当同时调用两个不同包中相同类名的类时，应该加上包名加以区别。因此，包可以避免名字冲突。
• 3、包也限定了访问权限，拥有包访问权限的类才能访问某个包中的类。

Java 使用包（package）这种机制是为了防止命名冲突，访问控制，提供搜索和定位类（class）、接口、枚举（enumerations）和注释（annotation）等。

包语句的语法格式为：

1

package pkg1[．pkg2[．pkg3…]];

例如,一个Something.java 文件它的内容

1
2
3
4

package net.java.util;
public class Something{
   ...
}

那么它的路径应该是 net/java/util/Something.java 这样保存的。 package(包) 的作用是把不同的 java 程序分类保存，更方便的被其他 java 程序调用。

一个包（package）可以定义为一组相互联系的类型（类、接口、枚举和注释），为这些类型提供访问保护和命名空间管理的功能。

以下是一些 Java 中的包：

• java.lang-打包基础的类
• java.io-包含输入输出功能的函数

开发者可以自己把一组类和接口等打包，并定义自己的包。而且在实际开发中这样做是值得提倡的，当你自己完成类的实现之后，将相关的类分组，可以让其他的编程者更容易地确定哪些类、接口、枚举和注释等是相关的。

由于包创建了新的命名空间（namespace），所以不会跟其他包中的任何名字产生命名冲突。使用包这种机制，更容易实现访问控制，并且让定位相关类更加简单。

创建包

创建包的时候，你需要为这个包取一个合适的名字。之后，如果其他的一个源文件包含了这个包提供的类、接口、枚举或者注释类型的时候，都必须将这个包的声明放在这个源文件的开头。

包声明应该在源文件的第一行，每个源文件只能有一个包声明，这个文件中的每个类型都应用于它。

如果一个源文件中没有使用包声明，那么其中的类，函数，枚举，注释等将被放在一个无名的包（unnamed package）中。

例子

让我们来看一个例子，这个例子创建了一个叫做animals的包。通常使用小写的字母来命名避免与类、接口名字的冲突。

在 animals 包中加入一个接口（interface）：

1
2
3
4
5
6
7

/* 文件名: Animal.java */
package animals;
 
interface Animal {
   public void eat();
   public void travel();
}

接下来，在同一个包中加入该接口的实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

package animals;
 
/* 文件名 : MammalInt.java */
public class MammalInt implements Animal{
 
   public void eat(){
      System.out.println("Mammal eats");
   }
 
   public void travel(){
      System.out.println("Mammal travels");
   } 
 
   public int noOfLegs(){
      return 0;
   }
 
   public static void main(String args[]){
      MammalInt m = new MammalInt();
      m.eat();
      m.travel();
   }
}

然后，编译这两个文件，并把他们放在一个叫做animals的子目录中。 用下面的命令来运行：

1
2
3
4
5

$ mkdir animals
$ cp Animal.class  MammalInt.class animals
$ java animals/MammalInt
Mammal eats
Mammal travel

import 关键字

为了能够使用某一个包的成员，我们需要在 Java 程序中明确导入该包。使用 “import” 语句可完成此功能。

在 java 源文件中 import 语句应位于 package 语句之后，所有类的定义之前，可以没有，也可以有多条，其语法格式为：

1

import package1[.package2…].(classname|*);

如果在一个包中，一个类想要使用本包中的另一个类，那么该包名可以省略。

例子

下面的 payroll 包已经包含了 Employee 类，接下来向 payroll 包中添加一个 Boss 类。Boss 类引用 Employee 类的时候可以不用使用 payroll 前缀，Boss 类的实例如下。

1
2
3
4
5
6
7
8
9

package payroll;
 
public class Boss
{
   public void payEmployee(Employee e)
   {
      e.mailCheck();
   }
}

如果 Boss 类不在 payroll 包中又会怎样？Boss 类必须使用下面几种方法之一来引用其他包中的类。

使用类全名描述，例如：

1

payroll.Employee

用 import 关键字引入，使用通配符 “*”

1

import payroll.*;

使用 import 关键字引入 Employee 类:

1

import payroll.Employee;

类文件中可以包含任意数量的 import 声明。import 声明必须在包声明之后，类声明之前。

package 的目录结构

类放在包中会有两种主要的结果：

• 包名成为类名的一部分，正如我们前面讨论的一样。
• 包名必须与相应的字节码所在的目录结构相吻合。

下面是管理你自己 java 中文件的一种简单方式：

将类、接口等类型的源码放在一个文本中，这个文件的名字就是这个类型的名字，并以.java作为扩展名。例如：

1
2
3
4
5
6
7

// 文件名 :  Car.java
 
package vehicle;
 
public class Car {
   // 类实现  
}

接下来，把源文件放在一个目录中，这个目录要对应类所在包的名字。

1

....\vehicle\Car.java

现在，正确的类名和路径将会是如下样子：

• 类名 -> vehicle.Car
• 路径名 -> vehicle\Car.java (在 windows 系统中)

通常，一个公司使用它互联网域名的颠倒形式来作为它的包名.例如：互联网域名是 runoob.com，所有的包名都以 com.runoob 开头。包名中的每一个部分对应一个子目录。

例如：有一个 com.runoob.test 的包，这个包包含一个叫做 Runoob.java 的源文件，那么相应的，应该有如下面的一连串子目录：

1

....\com\runoob\test\Runoob.java

编译的时候，编译器为包中定义的每个类、接口等类型各创建一个不同的输出文件，输出文件的名字就是这个类型的名字，并加上 .class 作为扩展后缀。 例如：

1
2
3
4
5
6
7
8
9

/ 文件名: Runoob.java
 
package com.runoob.test;
public class Runoob {
      
}
class Google {
      
}

现在，我们用-d选项来编译这个文件，如下：

1

$javac -d . Runoob.java

这样会像下面这样放置编译了的文件：

1
2

.\com\runoob\test\Runoob.class
.\com\runoob\test\Google.class

可以像下面这样来导入所有 \com\runoob\test\ 中定义的类、接口等：

1

import com.runoob.test.*;

编译之后的 .class 文件应该和 .java 源文件一样，它们放置的目录应该跟包的名字对应起来。但是，并不要求 .class 文件的路径跟相应的 .java 的路径一样。你可以分开来安排源码和类的目录。

1
2

<path-one>\sources\com\runoob\test\Runoob.java
<path-two>\classes\com\runoob\test\Google.class

样，你可以将你的类目录分享给其他的编程人员，而不用透露自己的源码。用这种方法管理源码和类文件可以让编译器和java 虚拟机（JVM）可以找到你程序中使用的所有类型。

类目录的绝对路径叫做 class path。设置在系统变量 CLASSPATH 中。编译器和 java 虚拟机通过将 package 名字加到 class path 后来构造 .class 文件的路径。

\classes 是 class path，package 名字是 com.runoob.test,而编译器和 JVM 会在 \classes\com\runoob\test 中找 .class 文件。

一个 class path 可能会包含好几个路径，多路径应该用分隔符分开。默认情况下，编译器和 JVM 查找当前目录。JAR 文件按包含 Java 平台相关的类，所以他们的目录默认放在了 class path 中。

抽象类

• 在面向对象中，所有的对象都是通过类来描述的，但是并不是所有的类都是用来描绘对象的，如果一个类中没有包含最够的信息来描绘一个具体的对象，这样的类就是抽象类

• 抽象类除了不能实例化对象外，类的其他功能依然存在，成员变量，成员方法和构造方法的访问方式和普通类一样

• 由于抽象类不能实例化对象，所以抽象类u必须被继承，才能被使用，
• 在Java中抽象类表示的是一种继承关系，一个类只能继承一个抽象类，而一个类却可以实现多个接口

在Java语言中使用abstract class来定义抽象类，如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

public abstract class Employee
{
   private String name;
   private String address;
   private int number;
   public Employee(String name, String address, int number)
   {
      System.out.println("Constructing an Employee");
      this.name = name;
      this.address = address;
      this.number = number;
   }
   public double computePay()
   {
     System.out.println("Inside Employee computePay");
     return 0.0;
   }
   public void mailCheck()
   {
      System.out.println("Mailing a check to " + this.name
       + " " + this.address);
   }
   public String toString()
   {
      return name + " " + address + " " + number;
   }
   public String getName()
   {
      return name;
   }
   public String getAddress()
   {
      return address;
   }
   public void setAddress(String newAddress)
   {
      address = newAddress;
   }
   public int getNumber()
   {
     return number;
   }
}

该类和普通类没什么不同，尽管类是抽象类，但是它仍然有3个成员变量，7个成员方法，和一个构造方法，如：

1
2
3
4
5
6
7
8
9
10
11

public class AbstractDemo
{
   public static void main(String [] args)
   {
      /* 以下是不允许的，会引发错误 */
      Employee e = new Employee("George W.", "Houston, TX", 43);
 
      System.out.println("\n Call mailCheck using Employee reference--");
      e.mailCheck();
    }
}

当编译时会产生以下错误

继承抽象类

我们能通过一般的方法继承Employee类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

/* 文件名 : Salary.java */
public class Salary extends Employee
{
   private double salary; //Annual salary
   public Salary(String name, String address, int number, double salary)
   {
       super(name, address, number);
       setSalary(salary);
   }
   public void mailCheck()
   {
       System.out.println("Within mailCheck of Salary class ");
       System.out.println("Mailing check to " + getName()+" with salary "+salary);
   }
   public double getSalary()
   {
       return salary;
   }
   public void setSalary(double newSalary)
   {
       if(newSalary >= 0.0)
       {
          salary = newSalary;
       }
   }
   public double computePay()
   {
      System.out.println("Computing salary pay for " + getName());
      return salary/52;
   }
}

尽管我们不能实例化一个Employee类的对象，但是如果我们实例化一个Salary类对象，该对象将从Employee类继承7个成员方法，且通过该方法可以设置获取三个成员变量

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

* 文件名 : AbstractDemo.java */
public class AbstractDemo
{
   public static void main(String [] args)
   {
      Salary s = new Salary("Mohd Mohtashim", "Ambehta, UP", 3, 3600.00);
      Employee e = new Salary("John Adams", "Boston, MA", 2, 2400.00);
 
      System.out.println("Call mailCheck using Salary reference --");
      s.mailCheck();
 
      System.out.println("\n Call mailCheck using Employee reference--");
      e.mailCheck();
    }
}

运行结果如下：

抽象方法

如果你想设计这样一个类，该类包含一个特别的成员方法，该方法的具体实现由它的子类确定，那么你可以在父类中声明该方法为抽象方法。

Abstract 关键字同样可以用来声明抽象方法，抽象方法只包含一个方法名，而没有方法体。

抽象方法没有定义，方法名后面直接跟一个分号，而不是花括号。如：

1
2
3
4
5
6
7
8
9
10

public abstract class Employee
{
   private String name;
   private String address;
   private int number;
   
   public abstract double computePay();
   
   //其余代码
}

声明抽象方法会造成以下两个结果：

• 如果一个类包含抽象方法，那么该类必须是抽象类。
• 任何子类必须重写父类的抽象方法，或者声明自身为抽象类。

继承抽象方法的子类必须重写该方法。否则，该子类也必须声明为抽象类。最终，必须有子类实现该抽象方法，否则，从最初的父类到最终的子类都不能用来实例化对象。

如果Salary类继承了Employee类，那么它必须实现computePay()方法，如：

1
2
3
4
5
6
7
8
9
10
11
12

public class Salary extends Employee
{
   private double salary; // Annual salary
  
   public double computePay()
   {
      System.out.println("Computing salary pay for " + getName());
      return salary/52;
   }
 
   //其余代码
}

抽象类总结

• 抽象类不能被实例化(初学者很容易犯的错)，如果被实例化，就会报错，编译无法通过。只有抽象类的非抽象子类可以创建对象。
• 抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类。
• 抽象类中的抽象方法只是声明，不包含方法体，就是不给出方法的具体实现也就是方法的具体功能。
• 构造方法，类方法（用 static 修饰的方法）不能声明为抽象方法。
• 抽象类的子类必须给出抽象类中的抽象方法的具体实现，除非该子类也是抽象类。

Java 封装

在面向对象程式设计方法中，封装（英语：Encapsulation）是指一种将抽象性函式接口的实现细节部分包装、隐藏起来的方法。

封装可以被认为是一个保护屏障，防止该类的代码和数据被外部类定义的代码随机访问。

要访问该类的代码和数据，必须通过严格的接口控制。

封装最主要的功能在于我们能修改自己的实现代码，而不用修改那些调用我们代码的程序片段。

适当的封装可以让程式码更容易理解与维护，也加强了程式码的安全性。

封装的优点

• 良好的封装能够减少耦合。
• 类内部的结构可以自由修改。
• 可以对成员变量进行更精确的控制。
• 隐藏信息，实现细节。

实现Java封装的步骤

1. 修改属性的可见性来限制对属性的访问（一般限制为private），例如：

1
2
3
4
5

public class Person {
    private String name;
    private int age;
}
这段代码中，将name和age属性设置为私有的，只能本类才能访问，其他类都访问不了，如此就对信息进行了隐藏。

2. 对每个值属性提供对外的公共方法访问，也就是创建一对赋取值方法，用于对私有属性的访问，例如

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

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

采用this关键字是为了解决实例变量（private String name）和局部变量（setName(String name)中的name变量）之间发生的同名的冲突。

实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

/* 文件名: EncapTest.java */
public class EncapTest{
 
   private String name;
   private String idNum;
   private int age;
 
   public int getAge(){
      return age;
   }
 
   public String getName(){
      return name;
   }
 
   public String getIdNum(){
      return idNum;
   }
 
   public void setAge( int newAge){
      age = newAge;
   }
 
   public void setName(String newName){
      name = newName;
   }
 
   public void setIdNum( String newId){
      idNum = newId;
   }
}

以上实例中public方法是外部类访问该类成员变量的入口。

通常情况下，这些方法被称为getter和setter方法。

因此，任何要访问类中私有成员变量的类都要通过这些getter和setter方法。

通过如下的例子说明EncapTest类的变量怎样被访问：

1
2
3
4
5
6
7
8
9
10
11

public class RunEncap{
   public static void main(String args[]){
      EncapTest encap = new EncapTest();
      encap.setName("James");
      encap.setAge(20);
      encap.setIdNum("12343ms");
 
      System.out.print("Name : " + encap.getName()+ 
                             " Age : "+ encap.getAge());
    }
}

以上就是今天学到的java内容，java果然博大精深，怪不得人生苦短，我用python，学了几天java深深体会到了python的精炼

重写是子类对父类的允许访问的方法的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！

重写的好处在于子类可以根据需要，定义特定于自己的行为。 也就是说子类能够根据需要实现父类的方法。

重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如： 父类的一个方法申明了一个检查异常 IOException，但是在重写这个方法的时候不能抛出 Exception 异常，因为 Exception 是 IOException 的父类，只能抛出 IOException 的子类异常。

在面向对象原则里，重写意味着可以重写任何现有方法。实例如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

class Animal{
   public void move(){
      System.out.println("动物可以移动");
   }
}
 
class Dog extends Animal{
   public void move(){
      System.out.println("狗可以跑和走");
   }
}
 
public class TestDog{
   public static void main(String args[]){
      Animal a = new Animal(); // Animal 对象
      Animal b = new Dog(); // Dog 对象
 
      a.move();// 执行 Animal 类的方法
 
      b.move();//执行 Dog 类的方法
   }
}

以上实例编译运行结果如下：

1
2

动物可以移动
狗可以跑和走

在上面的例子中可以看到，尽管 b 属于 Animal 类型，但是它运行的是 Dog 类的 move方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

class Animal{
   public void move(){
      System.out.println("动物可以移动");
   }
}
 
class Dog extends Animal{
   public void move(){
      System.out.println("狗可以跑和走");
   }
   public void bark(){
      System.out.println("狗可以吠叫");
   }
}
 
public class TestDog{
   public static void main(String args[]){
      Animal a = new Animal(); // Animal 对象
      Animal b = new Dog(); // Dog 对象
 
      a.move();// 执行 Animal 类的方法
      b.move();//执行 Dog 类的方法
      b.bark();
   }
}

以上实例编译运行结果如下：

1
2
3
4
5

TestDog.java:30: cannot find symbol
symbol  : method bark()
location: class Animal
                b.bark();
                 ^

该程序将抛出一个编译错误，因为b的引用类型Animal没有bark方法。

方法的重写规则

• 参数列表必须完全与被重写方法的相同。
• 返回类型与被重写方法的返回类型可以不相同，但是必须是父类返回值的派生类（java5 及更早版本返回类型要一样，java7 及更高版本可以不同）。
• 访问权限不能比父类中被重写的方法的访问权限更低。例如：如果父类的一个方法被声明为 public，那么在子类中重写该方法就不能声明为 protected。
• 父类的成员方法只能被它的子类重写。
• 声明为 final 的方法不能被重写。
• 声明为 static 的方法不能被重写，但是能够被再次声明。
• 子类和父类在同一个包中，那么子类可以重写父类所有方法，除了声明为 private 和 final 的方法。
• 子类和父类不在同一个包中，那么子类只能够重写父类的声明为 public 和 protected 的非 final 方法。
• 重写的方法能够抛出任何非强制异常，无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。
• 构造方法不能被重写。
• 如果不能继承一个方法，则不能重写这个方法。

Super 关键字的使用

当需要在子类中调用父类的被重写方法时，要使用 super 关键

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

class Animal{
   public void move(){
      System.out.println("动物可以移动");
   }
}
 
class Dog extends Animal{
   public void move(){
      super.move(); // 应用super类的方法
      System.out.println("狗可以跑和走");
   }
}
 
public class TestDog{
   public static void main(String args[]){
 
      Animal b = new Dog(); // Dog 对象
      b.move(); //执行 Dog类的方法
 
   }
}

以上实例编译运行结果如下：

1
2

动物可以移动
狗可以跑和走

重载(Overload)

重载(overloading) 是在一个类里面，方法名字相同，而参数不同。返回类型可以相同也可以不同。

每个重载的方法（或者构造函数）都必须有一个独一无二的参数类型列表。

最常用的地方就是构造器的重载。

重载规则:

• 被重载的方法必须改变参数列表(参数个数或类型不一样)；
• 被重载的方法可以改变返回类型；
• 被重载的方法可以改变访问修饰符；
• 被重载的方法可以声明新的或更广的检查异常；
• 方法能够在同一个类中或者在一个子类中被重载。
• 无法以返回值类型作为重载函数的区分标准。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

public class Overloading {
    public int test(){
        System.out.println("test1");
        return 1;
    }
 
    public void test(int a){
        System.out.println("test2");
    }   
 
    //以下两个参数类型顺序不同
    public String test(int a,String s){
        System.out.println("test3");
        return "returntest3";
    }   
 
    public String test(String s,int a){
        System.out.println("test4");
        return "returntest4";
    }   
 
    public static void main(String[] args){
        Overloading o = new Overloading();
        System.out.println(o.test());
        o.test(1);
        System.out.println(o.test(1,"test3"));
        System.out.println(o.test("test4",1));
    }
}

结果如下：

1
2
3
4
5
6
7
8
9
10

Compiling Overloading.java.......
-----------OUTPUT-----------
test1
1
test2
test3
returntest3
test4
returntest4
[Finished in 1.4s]

重写与重载之间的区别

总结

方法的重写(Overriding)和重载(Overloading)是java多态性的不同表现，重写是父类与子类之间多态性的一种表现，重载可以理解成多态的具体表现形式。

• (1)方法重载是一个类中定义了多个方法名相同,而他们的参数的数量不同或数量相同而类型和次序不同,则称为方法的重载(Overloading)。
• (2)方法重写是在子类存在方法与父类的方法的名字相同,而且参数的个数与类型一样,返回值也一样的方法,就称为重写(Overriding)。
• (3)方法重载是一个类的多态性表现,而方法重写是子类与父类的一种多态性表现。

多态

多态是同一个行为具有多个不同表现形式或形态的能力。

多态就是同一个接口，使用不同的实例而执行不同操作

比如键盘上的按键，在不同应用有不同的功能

多态的优点

• 消除类型之间的耦合关系
• 可替换性
• 可扩充性
• 接口性
• 灵活性
• 简化性

多态存在的三个必要条件

• 继承
• 重写
• 父类引用指向子类对象

比如：

1

Parent p = new Child();

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。

多态的好处：可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。

如下列多态例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

public class Test {
    public static void main(String[] args) {
      show(new Cat());  // 以 Cat 对象调用 show 方法
      show(new Dog());  // 以 Dog 对象调用 show 方法
                
      Animal a = new Cat();  // 向上转型  
      a.eat();               // 调用的是 Cat 的 eat
      Cat c = (Cat)a;        // 向下转型  
      c.work();        // 调用的是 Cat 的 work
  }  
            
    public static void show(Animal a)  {
      a.eat();  
        // 类型判断
        if (a instanceof Cat)  {  // 猫做的事情 
            Cat c = (Cat)a;  
            c.work();  
        } else if (a instanceof Dog) { // 狗做的事情 
            Dog c = (Dog)a;  
            c.work();  
        }  
    }  
}
 
abstract class Animal {  
    abstract void eat();  
}  
  
class Cat extends Animal {  
    public void eat() {  
        System.out.println("吃鱼");  
    }  
    public void work() {  
        System.out.println("抓老鼠");  
    }  
}  
  
class Dog extends Animal {  
    public void eat() {  
        System.out.println("吃骨头");  
    }  
    public void work() {  
        System.out.println("看家");  
    }  
}

执行以上程序，输出结果为：

1
2
3
4
5
6

吃鱼
抓老鼠
吃骨头
看家
吃鱼
抓老鼠

虚函数

虚函数的存在是为了多态。

Java 中其实没有虚函数的概念，它的普通函数就相当于 C++ 的虚函数，动态绑定是Java的默认行为。如果 Java 中不希望某个函数具有虚函数特性，可以加上 final 关键字变成非虚函数。

重写

我们将介绍在 Java 中，当设计类时，被重写的方法的行为怎样影响多态性。

我们已经讨论了方法的重写，也就是子类能够重写父类的方法。

当子类对象调用重写的方法时，调用的是子类的方法，而不是父类中被重写的方法。

要想调用父类中被重写的方法，则必须使用关键字 super。如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

/* 文件名 : Employee.java */
public class Employee {
   private String name;
   private String address;
   private int number;
   public Employee(String name, String address, int number) {
      System.out.println("Employee 构造函数");
      this.name = name;
      this.address = address;
      this.number = number;
   }
   public void mailCheck() {
      System.out.println("邮寄支票给： " + this.name
       + " " + this.address);
   }
   public String toString() {
      return name + " " + address + " " + number;
   }
   public String getName() {
      return name;
   }
   public String getAddress() {
      return address;
   }
   public void setAddress(String newAddress) {
      address = newAddress;
   }
   public int getNumber() {
     return number;
   }
}

假设下面的类继承Employee类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

/* 文件名 : Salary.java */
public class Salary extends Employee
{
   private double salary; // 全年工资
   public Salary(String name, String address, int number, double salary) {
       super(name, address, number);
       setSalary(salary);
   }
   public void mailCheck() {
       System.out.println("Salary 类的 mailCheck 方法 ");
       System.out.println("邮寄支票给：" + getName()
       + " ，工资为：" + salary);
   }
   public double getSalary() {
       return salary;
   }
   public void setSalary(double newSalary) {
       if(newSalary >= 0.0) {
          salary = newSalary;
       }
   }
   public double computePay() {
      System.out.println("计算工资，付给：" + getName());
      return salary/52;
   }
}

1
2
3
4
5
6
7
8
9
10
11

/* 文件名 : VirtualDemo.java */
public class VirtualDemo {
   public static void main(String [] args) {
      Salary s = new Salary("员工 A", "北京", 3, 3600.00);
      Employee e = new Salary("员工 B", "上海", 2, 2400.00);
      System.out.println("使用 Salary 的引用调用 mailCheck -- ");
      s.mailCheck();
      System.out.println("\n使用 Employee 的引用调用 mailCheck--");
      e.mailCheck();
    }
}

以上实例编译运行结果如下：

1
2
3
4
5
6
7
8
9

Employee 构造函数
Employee 构造函数
使用 Salary 的引用调用 mailCheck -- 
Salary 类的 mailCheck 方法 
邮寄支票给：员工 A ，工资为：3600.0

使用 Employee 的引用调用 mailCheck--
Salary 类的 mailCheck 方法 
邮寄支票给：员工 B ，工资为：2400.0

例子解析

• 实例中，实例化了两个 Salary 对象：一个使用 Salary 引用 s，另一个使用 Employee 引用 e。
• 当调用 s.mailCheck() 时，编译器在编译时会在 Salary 类中找到 mailCheck()，执行过程 JVM 就调用 Salary 类的 mailCheck()。
• 因为 e 是 Employee 的引用，所以调用 e 的 mailCheck() 方法时，编译器会去 Employee 类查找 mailCheck() 方法 。
• 在编译的时候，编译器使用 Employee 类中的 mailCheck() 方法验证该语句， 但是在运行的时候，Java虚拟机(JVM)调用的是 Salary 类中的 mailCheck() 方法。

以上整个过程被称为虚拟方法调用，该方法被称为虚拟方法。

Java中所有的方法都能以这种方式表现，因此，重写的方法能在运行时调用，不管编译的时候源代码中引用变量是什么数据类型。

态的实现方式

方式一：重写：

就是java重写与重载

方式二：接口

• 生活中的接口最具代表性的就是插座，例如一个三接头的插头都能接在三孔插座中，因为这个是每个国家都有各自规定的接口规则，有可能到国外就不行，那是因为国外自己定义的接口类型。
• java中的接口类似于生活中的接口，就是一些方法特征的集合，但没有方法的实现。具体可以看 java接口 这一章节的内容。

继承的概念

继承时java面向对象编程技术的一块基石，因为它允许创建分等级层次的类

继承就是子类继承父类的特征和行为，使得子类对象具有父类的实例域和方法，或子类从父类集成方法，使得子类具有父亲相同的行为

类的继承格式

在java中通过extends关键字可以申明一个类是从另一个类继承而来的，一般形式如下：

1
2
3
4
5

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

类的好处

开发动物类，其中动物分别为企鹅以及老鼠，要求如下：

• 企鹅：属性（姓名，id），方法（吃，睡，自我介绍）
• 老鼠：属性（姓名，id），方法（吃，睡，自我介绍）

企鹅类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

public class Penguin { 
    private String name; 
    private int id; 
    public Penguin(String myName, int  myid) { 
        name = myName; 
        id = myid; 
    } 
    public void eat(){ 
        System.out.println(name+"正在吃"); 
    }
    public void sleep(){
        System.out.println(name+"正在睡");
    }
    public void introduction() { 
        System.out.println("大家好！我是"         + id + "号" + name + "."); 
    } 
}

老鼠类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

public class Mouse { 
    private String name; 
    private int id; 
    public Mouse(String myName, int  myid) { 
        name = myName; 
        id = myid; 
    } 
    public void eat(){ 
        System.out.println(name+"正在吃"); 
    }
    public void sleep(){
        System.out.println(name+"正在睡");
    }
    public void introduction() { 
        System.out.println("大家好！我是"         + id + "号" + name + "."); 
    } 
}

从这两段代码可以看出来，代码存在重复了，所以要解决这两段代码的问题，就需要继承，将两段代码中相同的部分提取出来组成 一个父类：

公共父类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

public class Animal { 
    private String name;  
    private int id; 
    public Animal(String myName, int myid) { 
        name = myName; 
        id = myid;
    } 
    public void eat(){ 
        System.out.println(name+"正在吃"); 
    }
    public void sleep(){
        System.out.println(name+"正在睡");
    }
    public void introduction() { 
        System.out.println("大家好！我是"         + id + "号" + name + "."); 
    } 
}

这个Animal类就可以作为一个父类，然后企鹅类和老鼠类继承这个类之后，就具有父类当中的属性和方法，子类就不会存在重复的代码，维护性也提高，代码也更加简洁，提高代码的复用性（复用性主要是可以多次使用，不用再多次写同样的代码） 继承之后的代码：

企鹅类

1
2
3
4
5

public class Penguin extends Animal { 
    public Penguin(String myName, int myid) { 
        super(myName, myid); 
    } 
}

老鼠类

1
2
3
4
5

public class Mouse extends Animal { 
    public Mouse(String myName, int myid) { 
        super(myName, myid); 
    } 
}

继承类型

需要注意的是 Java 不支持多继承，但支持多重继承。

继承的特性

• 子类拥有父类非 private 的属性、方法。
• 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。
• 子类可以用自己的方式实现父类的方法。
• Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一个父类，多重继承就是，例如 A 类继承 B 类，B 类继承 C 类，所以按照关系就是 C 类是 B 类的父类，B 类是 A 类的父类，这是 Java 继承区别于 C++ 继承的一个特性。
• 提高了类之间的耦合性（继承的缺点，耦合度高就会造成代码之间的联系越紧密，代码独立性越差）。

继承可以使用 extends 和 implements 这两个关键字来实现继承，而且所有的类都是继承于 java.lang.Object，当一个类没有继承的两个关键字，则默认继承object（这个类在 java.lang 包中，所以不需要 import）祖先类。

extends关键字

在 Java 中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类，所以 extends 只能继承一个类。

1
2
3
4
5
6
7
8
9
10
11
12

public class Animal { 
    private String name;   
    private int id; 
    public Animal(String myName, String myid) { 
        //初始化属性值
    } 
    public void eat() {  //吃东西方法的具体实现  } 
    public void sleep() { //睡觉方法的具体实现  } 
} 
 
public class Penguin  extends  Animal{ 
}

implements关键字

使用 implements 关键字可以变相的使java具有多继承的特性，使用范围为类继承接口的情况，可以同时继承多个接口（接口跟接口之间采用逗号分隔）。

1
2
3
4
5
6
7
8
9
10
11

public interface A {
    public void eat();
    public void sleep();
}
 
public interface B {
    public void show();
}
 
public class C implements A,B {
}

super 与 this 关键字

super关键字：我们可以通过super关键字来实现对父类成员的访问，用来引用当前对象的父类。

this关键字：指向自己的引用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

class Animal {
  void eat() {
    System.out.println("animal : eat");
  }
}
 
class Dog extends Animal {
  void eat() {
    System.out.println("dog : eat");
  }
  void eatTest() {
    this.eat();   // this 调用自己的方法
    super.eat();  // super 调用父类方法
  }
}
 
public class Test {
  public static void main(String[] args) {
    Animal a = new Animal();
    a.eat();
    Dog d = new Dog();
    d.eatTest();
  }
}

输出结果为：

1
2
3

animal : eat
dog : eat
animal : eat

final关键字

final 关键字声明类可以把类定义为不能继承的，即最终类；或者用于修饰方法，该方法不能被子类重写：

• 声明类：

  1	final class 类名 {//类体}

• 声明方法：

  1	修饰符(public/private/default/protected) final 返回值类型 方法名(){//方法体}

注:实例变量也可以被定义为 final，被定义为 final 的变量不能被修改。被声明为 final 类的方法自动地声明为 final，但是实例变量并不是 final

构造器

子类是不继承父类的构造器（构造方法或者构造函数）的，它只是调用（隐式或显式）。如果父类的构造器带有参数，则必须在子类的构造器中显式地通过 super 关键字调用父类的构造器并配以适当的参数列表。

如果父类构造器没有参数，则在子类的构造器中不需要使用 super 关键字调用父类构造器，系统会自动调用父类的无参构造器。

实例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48

class SuperClass {
  private int n;
  SuperClass(){
    System.out.println("SuperClass()");
  }
  SuperClass(int n) {
    System.out.println("SuperClass(int n)");
    this.n = n;
  }
}
// SubClass 类继承
class SubClass extends SuperClass{
  private int n;
  
  SubClass(){ // 自动调用父类的无参数构造器
    System.out.println("SubClass");
  }  
  
  public SubClass(int n){ 
    super(300);  // 调用父类中带有参数的构造器
    System.out.println("SubClass(int n):"+n);
    this.n = n;
  }
}
// SubClass2 类继承
class SubClass2 extends SuperClass{
  private int n;
  
  SubClass2(){
    super(300);  // 调用父类中带有参数的构造器
    System.out.println("SubClass2");
  }  
  
  public SubClass2(int n){ // 自动调用父类的无参数构造器
    System.out.println("SubClass2(int n):"+n);
    this.n = n;
  }
}
public class TestSuperSub{
  public static void main (String args[]){
    System.out.println("------SubClass 类继承------");
    SubClass sc1 = new SubClass();
    SubClass sc2 = new SubClass(100); 
    System.out.println("------SubClass2 类继承------");
    SubClass2 sc3 = new SubClass2();
    SubClass2 sc4 = new SubClass2(200); 
  }
}

输出结果为：

1
2
3
4
5
6
7
8
9
10

------SubClass 类继承------
SuperClass()
SubClass
SuperClass(int n)
SubClass(int n):100
------SubClass2 类继承------
SuperClass(int n)
SubClass2
SuperClass()
SubClass2(int n):200

Java语言提供了很多修饰符，主要分为一下两类：

• 访问修饰符
• 非访问修饰符

修饰符用来定义类，方法或者变量，通常放在语句的最前端，例如：

1
2
3
4
5
6
7
8
9

public class Classname{
    //...
}
private boollean myFlag;
static final double weeks = 9.5;
pritected static final int BOXWIDTH = 42;
public static void main(String[] arguments){
    //方法体
}

访问控制修饰符

Java中，可以使用访问控制符来保护对类，变量，方法和构造方法的访问，Java支持4种不同的访问权限。

• default(即默认，什么也不写)：在同一包内可见，不使用任何修饰符，适用对象：类、接口、变量、方法。
• private：在同一类内可见，使用对象：变量，方法。注意不能修饰类（外部类）
• public：都所有类可见。使用对象：类，接口，变量，方法
• protected：对同一包内的类和所有子类可见，使用对象：变量，方法。(注意不能修饰类（外部类）)

访问控制

默认访问修饰符-不使用任何关键字

使用默认访问修饰符声明的变量和方法，对同一个包内的类是可见的，接口里的变量都隐式声明为public static final而接口里的方法默认情况下的访问权限是public如下变量和方法的声明可以不使用任何修饰符

1
2
3
4

String version = "1.5.1";
boolean processOrder(){
    return true;
}

私有访问修饰符-private

私有访问修饰符时最严格的访问级别，所以被声明为private的方法，变量和构造方法只能被所属类访问，并且类和接口不能声明为private

声明为私有访问类型的变量只能通过类中公共的getter方法被外部类访问

Private访问修饰符的使用主要用来隐藏类的实现细节和保护类的数据，如下：

1
2
3
4
5
6
7
8
9

publuic class ligger{
    private String format;
    public String getFormat(){
        return this.format;
    }
    public void setFormat(String format){
        this.format = format;
    }
}

实例中，Logger类中的format变量为私有变量，所以其他类不能直接得到和设置该变量的值，为了使其他类能够操作该变量，定义了两个public方法：getFormat()（返回format的值）和setFormat(String)（设置format的值）

公有访问修饰符-public

被声明为public的类、方法、构造方法和接口能够被任何其他类访问

如果几个相互访问的public类分布在不同的包中，则需要导入相应的public类所在的包。由于类的继承性，类所有的公有方法和变量都能被其子类继承。

以下函数使用了公有访问控制：

1
2
3

public static void main(String[] arguments) {
   // ...
}

Java 程序的 main() 方法必须设置成公有的，否则，Java 解释器将不能运行该类。

受保护的访问修饰符-protected

protected 需要从以下两个点来分析说明：

• 子类与基类在同一包中：被声明为 protected 的变量、方法和构造器能被同一个包中的任何其他类访问；
• 子类与基类不在同一包中：那么在子类中，子类实例可以访问其从基类继承而来的 protected 方法，而不能访问基类实例的protected方法。

protected 可以修饰数据成员，构造方法，方法成员，不能修饰类（内部类除外）。

接口及接口的成员变量和成员方法不能声明为 protected。 可以看看下图演示：

子类能访问 protected 修饰符声明的方法和变量，这样就能保护不相关的类使用这些方法和变量。

下面的父类使用了 protected 访问修饰符，子类重写了父类的 openSpeaker() 方法:

1
2
3
4
5
6
7
8
9
10
11

class AudioPlayer {
   protected boolean openSpeaker(Speaker sp) {
      // 实现细节
   }
}
 
class StreamingAudioPlayer extends AudioPlayer {
   protected boolean openSpeaker(Speaker sp) {
      // 实现细节
   }
}

如果把 openSpeaker() 方法声明为 private，那么除了 AudioPlayer 之外的类将不能访问该方法。

如果把 openSpeaker() 声明为 public，那么所有的类都能够访问该方法。

如果我们只想让该方法对其所在类的子类可见，则将该方法声明为 protected。

访问控制和继承

请注意以下方法继承的规则：

• 父类中声明为 public 的方法在子类中也必须为 public。
• 父类中声明为 protected 的方法在子类中要么声明为 protected，要么声明为 public，不能声明为 private。
• 父类中声明为 private 的方法，不能够被继承。

非访问修饰符

为了实现一些其他的功能，Java 也提供了许多非访问修饰符。

static 修饰符，用来修饰类方法和类变量。

final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。

abstract 修饰符，用来创建抽象类和抽象方法。

synchronized 和 volatile 修饰符，主要用于线程的编程。

static 修饰符

• 静态变量：

  static 关键字用来声明独立于对象的静态变量，无论一个类实例化多少对象，它的静态变量只有一份拷贝。 静态变量也被称为类变量。局部变量不能被声明为 static 变量。

• 静态方法：

  static 关键字用来声明独立于对象的静态方法。静态方法不能使用类的非静态变量。静态方法从参数列表得到数据，然后计算这些数据。

对类变量和方法的访问可以直接使用 classname.variablename 和 classname.methodname 的方式访问。

如下例所示，static修饰符用来创建类方法和类变量。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

public class InstanceCounter {
   private static int numInstances = 0;
   protected static int getCount() {
      return numInstances;
   }
 
   private static void addInstance() {
      numInstances++;
   }
 
   InstanceCounter() {
      InstanceCounter.addInstance();
   }
 
   public static void main(String[] arguments) {
      System.out.println("Starting with " +
      InstanceCounter.getCount() + " instances");
      for (int i = 0; i < 500; ++i){
         new InstanceCounter();
          }
      System.out.println("Created " +
      InstanceCounter.getCount() + " instances");
   }
}

以上实例运行编辑结果如下:

1
2

Starting with 0 instances
Created 500 instances

final 修饰符

final 变量：

final 表示”最后的、最终的”含义，变量一旦赋值后，不能被重新赋值。被 final 修饰的实例变量必须显式指定初始值。

final 修饰符通常和 static 修饰符一起使用来创建类常量。

1
2
3
4
5
6
7
8
9
10

public class Test{
  final int value = 10;
  // 下面是声明常量的实例
  public static final int BOXWIDTH = 6;
  static final String TITLE = "Manager";
 
  public void changeValue(){
     value = 12; //将输出一个错误
  }
}

final 方法

父类中的 final 方法可以被子类继承，但是不能被子类重写。

声明 final 方法的主要目的是防止该方法的内容被修改。

如下所示，使用 final 修饰符声明方法。

1
2
3
4
5

public class Test{
    public final void changeName(){
       // 方法体
    }
}

final 类

final 类不能被继承，没有类能够继承 final 类的任何特性。

1
2
3

public final class Test {
   // 类体
}

abstract 修饰符

抽象类：

抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。

一个类不能同时被 abstract 和 final 修饰。如果一个类包含抽象方法，那么该类一定要声明为抽象类，否则将出现编译错误。

抽象类可以包含抽象方法和非抽象方法。

1
2
3
4
5
6
7

abstract class Caravan{
   private double price;
   private String model;
   private String year;
   public abstract void goFast(); //抽象方法
   public abstract void changeColor();
}

抽象方法

抽象方法是一种没有任何实现的方法，该方法的的具体实现由子类提供。

抽象方法不能被声明成 final 和 static。

任何继承抽象类的子类必须实现父类的所有抽象方法，除非该子类也是抽象类。

如果一个类包含若干个抽象方法，那么该类必须声明为抽象类。抽象类可以不包含抽象方法。

抽象方法的声明以分号结尾，例如：public abstract sample();。

1
2
3
4
5
6
7
8
9
10

public abstract class SuperClass{
    abstract void m(); //抽象方法
}
 
class SubClass extends SuperClass{
     //实现抽象方法
      void m(){
          .........
      }
}

synchronized 修饰符

synchronized 关键字声明的方法同一时间只能被一个线程访问。synchronized 修饰符可以应用于四个访问修饰

1
2
3

public synchronized void showDetails(){
.......
}

transient 修饰符

序列化的对象包含被 transient 修饰的实例变量时，java 虚拟机(JVM)跳过该特定的变量。

该修饰符包含在定义变量的语句中，用来预处理类和变量的数据类型。

1
2

public transient int limit = 55;   // 不会持久化
public int b; // 持久化

volatile 修饰符

volatile 修饰的成员变量在每次被线程访问时，都强制从共享内存中重新读取该成员变量的值。而且，当成员变量发生变化时，会强制线程将变化值回写到共享内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。

一个 volatile 对象引用可能是 null。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

public class MyRunnable implements Runnable
{
    private volatile boolean active;
    public void run()
    {
        active = true;
        while (active) // 第一行
        {
            // 代码
        }
    }
    public void stop()
    {
        active = false; // 第二行
    }
}

通常情况下，在一个线程调用 run() 方法（在 Runnable 开启的线程），在另一个线程调用 stop() 方法。 如果 第一行 中缓冲区的 active 值被使用，那么在 第二行 的 active 值为 false 时循环不会停止。

但是以上代码中我们使用了 volatile 修饰 active，所以该循环会停止

在家无聊学习java第三天

内容

java对象和类

• 类：类是一个模板，它描述一类对象的行为和状态
• 对象： 对象是类的一个实例，有状态和行为，比如，一条狗是一个对象，他的状态有：颜色，名字，品种，行为有：摇尾巴，叫，吃等

对比现实对象和软件对象，他们之间十分相似，软件对象也有状态和行为，软件对象的状态就是属性，行为就是具体的方法，在软件开发中，方法操作对象内部的状态，队形的相互调用也是通过方法来实现

Java中的类

如：

1
2
3
4
5
6
7
8
9
10
11
12
13

public class Dog{
  String breed;
  int age;
  String color;
  void barking(){
  }
 
  void hungry(){
  }
 
  void sleeping(){
  }
}

一个类可以包含以下类型变量：

• 局部变量：在方法、构造方法或者语句块中定义的变量被称为局部变量。变量声明和初始化都是在方法中，方法结束后，变量就会自动销毁。
• 成员变量：成员变量是定义在类中，方法体之外的变量。这种变量在创建对象的时候实例化。成员变量可以被类中方法、构造方法和特定类的语句块访问。
• 类变量：类变量也声明在类中，方法体之外，但必须声明为static类型。

一个类可以拥有多个方法，在上面的例子中：barking()、hungry()和sleeping()都是Dog类的方法。

构造方法

每个类都有构造方法，如果没有显式地为类定义构造方法。java编译器将会为该类提供一个默认构造方法，在创建一个对象的时候，至少要调用一个构造方法，构造方法的名称必须与类同名，一个类可以有多个构造方法如：

1
2
3
4
5
6
7

public class Puppy{
    public Puppy(){    
    }
    public Puppy(String name){
    // 这个构造器仅有一个参数：name 
    }
}

创建对象

对象是根据类创建的。在java中，使用关键字来创建一个新的对象。创建对象需要以下三步：

• 声明：声明一个对象，包括对象名称和对象类型。
• 实例化： 使用关键字new来创建一个对象
• 初始化 ：使用new创建对象时，会调用构造方法初始化对象

如：

1
2
3
4
5
6
7
8
9
10

public class Puppy{
    public Puppy(String name){
    //这个构造器仅有一个参数：name
    System.out.println("小狗的名字是："+name);
    }
    public static void main(String[] args){
        // 下面语句将创建一个Puppy对象
        Puppy myPuppy = new Puppy("tommy");
    }
}

在家无聊学习java第二天

内容

常量

• 字符串常量
• 整数常量
• 浮点数常量
• 字符常量
• 布尔常量
• 空常量：null

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

public class TwodayDemo1{
public static void main(String[] args){
    //字符串常量
    System.out.println("ABC");
    System.out.println("");
    System.out.println("XYZ");
    
    //整数常量
    System.out.println(30);
    System.out.println(-30);
    
    //浮点数常量（小数）
    System.out.println(3.14);
    System.out.println(-2.5);
    
    //字符常量
    System.out.println('A');
    System.out.println('6');
    //System.out.println('');  两个单引号中间必须有且仅有一个字符，没有就会报错 
    //System.out.println('AB')    有两个字符也不行
        
        //布尔常量
        System.out.println(true);
        System.out.println(false);
        
        //空常量，不能直接用来打印输出
        // System.out.println(null);  会报错
}
}

数据类型

java的数据类型分为两大类：

• 基本数据类型
• 引用数据类型

基本数据类型

四类八种基本数据类型

【SP】

• java中的默认类型，整形是int，浮点型是double

• 字符串不是基本类型而是引用类型

• 浮点型可能只是一个近似值，并非精确的值

• 数据范围与字节数并不一定相关，如float数据范围比long更加广泛，单float是4字节而long是8字节

• 如果使用float需加后缀F，若使用long后缀需加L，推荐使用大写字母后缀

  1 2 3 4

  System.out.println(100);//是int型 System.out.println(100L);//是long型 System.out.println(100.2);//是double型 System.out.println(100F);//是float型

变量的定义

变量定义有以下两种方式

1. 创建一个变量并且使用的格式

   • 数据类型 变量名称 //创建一个变量
   • 变量名称 = 数据值 //赋值

2. 一步到位

   • 数据类型 变量名称 = 数据值；//在创建变量同时，立刻放入指定的数据值

     1 2	public class Day02{ public static void main(String[] args){

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38

   //方式一 int num1; num1 =10; System.out.println(num1); //方式二 int num2 = 25; System.out.println(num2); System.out.println("--------------"); byte num3 = 30; //注意右侧数值不能超过左侧数据类型的数据范围 System.out.println(num3); //byte num4 = 400;// 右侧超出了byte的取值范围，错误！！ short num5 = 50; System.out.println(num5); long num6 = 3000000L; System.out.println(num6); float num7 = 2.5F; System.out.println(num7); double num8 = 1.2; System.out.println(num8); char zifu1 = 'A'; System.out.println(zifu1); zifu1 = '中'; System.out.println(zifu1); boolean var1 = true; System.out.println(var1); var1 = false; System.out.println(var1); } }

   1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

   **TIPS** * 变量之间不能重复 * 对于float和long后缀不能丢掉 * 如果用type和long注意取值范围 * 没有进行赋值的变量，不能直接使用，一定要复制之后才能进行使用（如打印输出操作） * 变量不要超出变量的定义域 # 数据类型转换 1. 自动转换 一个int类型变量和一个byte类型变量进行加法运算，结果是什么类型？ ```java int i =1; byte b = 2;

   运算结果，变量的类型将是int类型，这就是出现了数据类型的自动类型转换现象

   自动转换(隐式)：将取值范围小的类型自动提升为取值范围大的类型

   1 2 3 4 5 6 7 8

   public static void main(String[] args) { int i =1; byte =2; //byte x = b+i //报错 //int 类型和byte；类型运算，结果是int int j = b+i; System.out.println(j); }

   规则：数据范围从小到大

   1 2 3

   long num1 = 100;//左边是long，右边是int，从int--long是从小到大，自当发生数据类型转换 double num2 = 2.5F; float num3 =30L;

   强制类型转换

   代码需要进行特殊的格式处理，不能自动完成

   范围小的类型 范围小的变量名 = （范围小的类型）原本范围大的数据

   1 2 3 4

   int num = (int) 100L; //左边是int类型，右边是long类型，不一样 //long --> int ，不是从小到大，不能发生自动化类型转换 //范围小的类型 范围小的变量名 = （范围小的类型）原本范围大的数据

   Tips

   1. 强制类型转换一般不使用，因为有可能发生精度损失，数据溢出

      1 2	int num =(int) 6000000000L; 输出num为17亿数据溢出

   2. byte/short/char三种类型都可以发生数学运算

   3. byte/short/char三种类型在运算的时候，都会被首先提升为int类型然后再计算

   4. boolean 不能发生数据类型转换