JavaSE笔记

2018.7.24 周二 JavaSE入门
scala（函数式编程）/kotlin

用JAVA编写一段代码：
swing+数据挖掘的一个小型应用。

下载安装：JAVASE和JDK

心得：JDK安装和极域安装连接

下午：
java特性之平台无关性(基于JVM)
java源代码.java 编译> 字节码文件.class 执行> 汇编（机器指令）
****其要慢于传统编译型语言，但与平台无光的特性出众。但要快于解释型语言eg:js/php/vbscrpt/python(脚本快，类型库基于C++，os)。

编译型语言、半编译语言、脚本语言（现解析、现执行）

JVM:负责加载并执行编译后的字节码文件
JRE：运行JAVA程序所必须的环境集合，JVM+Java核心类库
JDK：JAVA开发使用，包括了JVM+JAVA核心类库+JAVA开发工具等

DOS段命令：
reneme [drive:][path]filename1 filename2…
[可选项]
<必选项>

dir -/
dir ?/

dir |more （逐条分屏输出）
tab键可以补全

***********************************************************文件下载共享
地址：\10.0.14.56
帐号：BG204 密码：7758521

---

java 垃圾回收机制(GC)
策略：
class www｛
int val =100;
｝当class类结束后，val就自动释放
system.gc()方法，建议执行垃圾回收工作。至于回收与否不知道。只是建议

//!

---

第一天完****
****************************************************************************************************************************//

2018.7.25 周三 Eclipse 安装
第一次启动会选择项目存储路径，或者可以在file==>swich Workspace更改
ide 工具主要可方便完成：
快速开发（智能提示）
工程管理
程序调试（重点）
语法检查

eclipse开发步骤：
1、创建项目JavaProject
2、创建Java源程序
3、编译Java源程序
4、运行java程序

查看文件所在位置：右击文件选择Properties Resource下有个Location
source >> src
package概念：
1、套文件夹
2、一般以组织域名命名（一般组织名倒置）（唯一性）

三个常用视图浏览方式：
1、Project Explorer//正常做项目（包资源管理器）
2、Navigator//bin文件和目录？？？？？不知道（以目录方式管理项目）
3、Package Explorer
打开方式：Windows==>Show View==>(如果找不到，other)

域名、备注
可以申请域名，后期做个网站
https://wanwang.aliyun.com/

？？？？快捷键？？搬代码？？？？ 解决方案：ant +上下键

编写代码要点：1、一个Java源文件中只能有一个public的class类，该类名必须与Java源文件名同名
2、main方法是Java应用程序的入口方法，由static关键词修饰
3、字节码文件的个数与类的个数有关

第一个实例：

运行程序的方式：
1、右击代码，run as ==> java application
2、多个程序会出错，会经常出现不是当前正在编写的程序

如运行的程序需要程序提供 入口参数，可进行运行配置:
	run as==>run configurations ==>

优化eclipse

1、UTF-8 （windows->Preferences->General->Workspace、Content Types）
2、显示行号（windows->Preferences->General->Editors->Text Editors、、Show line numbers)
3、智能提示增强优化（windows->Preferences->Java->Editor->Content Assist、、Auto Activation    +++.abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ )
4自动补全包

下载：要与当前eclipse的plugins包中的org.eclipse.jface.text.版本号对应。下载：ooxygen自动补全 luna自动补全

？？？？回车自动生成？？？？ 解决方案：优化，下载一个包

---

scanner输入
控制台输入问题：
package com.tyut;

	import java.util.Scanner;

	public class Test2 {
			public static void main(String[] args) {
					@SuppressWarnings("resource")
					Scanner scanner=new Scanner(System.in);
					System.out.println("请输入用户名：");
					String name = scanner.next();
					System.out.println(name+"你真牛X......");
			}
	}

Scanner sc = new Scanner(System.In);
System.out.println(“输入数字：”+sc.nextInt());
System.out.println(“输入字符串:”+sc.next());
System.out.println(“输入长整形:”+sc.nextLong());
if(sc.nextBoolean()){
System.out.println(“输入布尔:真的:”);
}else{
System.out.println(“输入布尔:假的”);
}

//要求输入一个整数值
int i = scanner.nextInt();

---

下午：
注释、分隔符、变量、标识符、关键字

注释
快捷键：
ctrl+shift+/ 加注释
ctrl+shift+\ 去掉注释

单行注释
	//
多行注释
	/*
	*/
//只能应用于class、interface、方法之上、注解
/**
文档化注释
*/

???文档化注释，可以通过Eclipse可以修改生成的注释模版？？？？？？怎么改

分隔符： 作用:
1、分号； 称结束标记，标记一句Java语句的结束位置。
2、花括号｛｝ Java允许用｛｝将一组语句括起来，形成一个语句快（block）。
3、空白：空格、Tab制表符、回车 Java源程序源代码中各组成部分之间可以插入任意数量的空白，主要用于排版，增强代码可读性。
空格：在代码中遇到运算符时，例如 = 等，两端流出空格，增强代码可读性、可分隔关键词。
Tab制表符：一般在语句前，来进行语句缩进。
回车换行：代码之间，可以根据逻辑关系加空白行，增加可读性。
eg:php、js、python:解析行（源代码） -->混淆（将空白删除、将变量名置换）
常量
！！！！常量标识名，一帮要求全部大写
常量：代表程序运行过程中不能改变的值
用于：1、表示固定不变的常数。2、增强程序的可读性
final关键字：
可以修饰类、方法、成员变量（常量）
final修饰成员变量（类属性）
作用：即初始化后，值不可改变。
final修饰类方法
作用：可以被继承，但不允许被重写。
final修饰类
作用：类不可以被继承。
eg:public static final double PI = 3.14159

变量
变量由三部分构成：
变量名 内存存储单元地址（0x3F0A)
变量类型 int
变量值 1000
eg:int money = 1000;
注意事项：
1、同一作用域内，变量名不可重复
2、Java语言区分大小写，所以变量名也区分大小写
3、Java中变量必须先定义，再使用。
4、变量名应符合标识符命名规则

标识符
Java语言中类名、方法名、变量名等名称统称标识符。
Java标识符命名规则：
1、由字母、数字、下划线、美元符组成，不能以数字开头。
2、Java标识符大小写敏感，长度无限制
命名规范
编程中经常使用到的命名法：
Pascal(也有说/Camel)命名法：单词为单位，每单词首字母大写
int StudentScore;
camel命名法：单词为单位，首单词字母小写，其他单词首字母大写
int studentScore;
匈牙利命名法：（c、c++使用、影响广泛）
int m_iStdScr
int* m_pStdScr指针

		Java使用了哪种命名法?:（混搭）
			类、接口、注释:pascal
			变量名、方法名：camel命名法
			常量：全大写
			包名：全小写

关键字
两大类：关键字和保留关键字

---

数据类型与封装类
数据类型
基本类型：数值型（整数类型、浮点类型）、字符型（char)、布尔类型（boolean)
引用类型：类（class)、接口（interface）、数组

		基本类型，又称值类型
		引用类型，又称
	
	字面量（常量值）：在程序代码中直接写出来的数据。
		字面量也是有数据类型的。
		
	boolean类型用于罗技运算，用于程序流程控制
	boolean类型只允许取值true或false，不可以用非0.0来代替true、false

	char型数据可用以表示一个字符
	字符类型与整数类型可完成字符编码互换

？？？？string和 char的区别？？？？ 解决情况：char是字符型数据，存放一个字符！ String是字符串型数据，存放多个字符！ char’ ’ /string" "
引用类型

？？？？基本类型和引用类的区别？？？？ 解决情况： 未解决

基本数据类型优点：
速度快
封装类型的优点：
面向对象方式使用基本类型，封装了各自类型的常量值、工具方法。

基本类型都有一个封装类：
int ->Integer
long ->Long
shot ->Shot
byte ->Byte
char ->Char
float ->Float
double ->Double
boolean ->Boolean

通过封装类的使用，可以使用面向对象的方式
eg:Integer score1=10;
int score2=10;
score1.会弹出提示
score2.什么都没有

//!

---

第二天完****
****************************************************************************************************************************//

2018.7.26 周四

不是基本数据类型需要初始化，不然调用会出错
基本类型自动生成初始化=0

引用类型变量如未初始化：默认值为null,空间都没有开辟
String title
System.out.println(title);

Syntax error 语法错误
duplicate 重复

运算符、表达式、类型转换

运算符

作分页时，要有几个关键词：
1、总数据记录数 101
2、页大小 20
3、你要显示第三页的数据 3

就可以计算出一个数据行的起始位置和结束位置

++与–中的困扰
y = ++x 先++后赋值
z = x++ 先赋值后++

//以下代码得不到1.5，double xxx=3;/2->2.0;可以得到
int xxx = 3;
double result = xxx/2;
System.out.println(result);

两种类型转换
1、隐式转换（自动类型转换）
double = double + int (int隐式转换为double)
2、显式转换（强制类型转换）

char 与int兼容 可以强制转换
eg: char c= ‘a’;
int i = (int)c;
eg: int i = 65;
char c = (char)i;

&&短路与 ||短路或？？？？？？
&:boolean 表达式，如果有多个表达式时，所有表达式都要进行计算
&&：boolean 表达式，如果有多个表达式时，以此计算，如果有一个结果为false，既不在计算后续表达式
|：boolean 表达式，如果有多个表达式时，所有表达式都要进行计算
||：boolean 表达式，如果有多个表达式时，以此计算，如果有一个结果为ture，既不在计算后续表达式

表达式
~取反 二进制按位取反，0->1,1->0
&按位与
|按位或
^按位异或
0:false
1:true

求补码：
正数：
1、先求补码：原码 + 1
2、再求反码：符号位取反
负数：
原码 - 1 ，符号位取反

位移运算：二进制位移

右移 则/2
<<左移 则*2

---

---

		程序控制

程序有三种结构
1、顺序结构
2、选择结构
3、循环结构

整理格式：ctrl+shift+f

循环while与do while
while 先判断后执行
do while 先执行后判断

程序调试
日常编程有两类错误：
1、语法性的错误（eclipse通过JVM来发现错误）
2、业务性的错误（必须通过调试来解决）
⑴观察数据是否正常，进而发现语句是否合理
⑵
打断点 f5 一句一句执行
f6 一句一句执行，如是方法则进入

//!

---

第三天完****
****************************************************************************************************************************//

2018.7.27 周五

怎么调试？Debug，断点后f6看
表达式，右击，work可以得到表达式的值

调试：让程序一步一步运行
1、设置断点
2、Debug运行
3、通过F5、F6执行观察变量值是否合理

如何进行调试：
1、分析错误，打断点。//可以右击打断点//双击执行单元，不要双击管理单元。断点要打到指令上。
2、启动调试
3、单步运行F6，观察程序运行过程。或者单机按钮(在Debug栏)
4、观察变量，单步运行时可以在“变量”视图中看到变量当前的值
5、发现问题
6、修正代码，重新运行
7、问题解决

for 循环
当你已经确定了循环次数的时候，使用for就很简单。
for是while的缩写
for([初始化代码];[循环条件];[循环变量修改]）｛｝

break可用于两类循环
1、switch；代表语句快结束
2、while、do while、for、for each ：代表终止循环

continue 只能用于循环语句 while、do while、for、for增强
结束本次循环（后续语句不会执行），开始下次循环

for each ：for增强
编程中，经常需要对数组、集合进行遍历操作，如使用for、while、do while
代码也有点多啊，自从有了for增强，就感觉好多了。
int[] a = { 1, 20, 35, 44, 5 };
for (int i = 0; i < a.length; i++) {
System.out.println(a[i]);
}
for (int i : a) {
System.out.println(i);
}

eclipse快捷键：
ctrl+shift+b 添加或取消断点
F8 resume 继续执行至下个断点
F5 step into 单步进入
F6 step over 单步执行
F7 step return 单步返回
****************最重要
代码编写快捷键：
Alt + / 内容提示
Alt + ↑↓ 将当前行语句上移或下移
ctrl+Alt+↓ 复制当前行语句至下一行（复制增加）
ctrl+Alt+↑ 复制当前行语句至上一行（复制增加）
ctrl+1： 问题修复建议
ctrl+/ 说明：添加/消除 单行注释
ctrl+shift+/ 添加多行注释
ctrl+shift+\ 消除多行注释
ctrl+shift+F 格式化代码
ctrl+D 删除当前行
shift+enter 在当前行下创建一个空白行
ctrl+shift+enter 在当前行上创建一个空白行
*****************次要
ctrl+shift+x 转换成大写
ctrl+shift+y 转换成小写
ctrl+shift+L 显示快捷键帮助
shift+alt+L Extract local variable
shift+alt+Z 快速try catch
shift+alt+S source菜单
ctrl+shift+M 包查找
ctrl+shift+O 引入当前语句所需要包
ctrl+shift+R 查找文件
ctrl+shift+T 类型查找
ctrl+m 编辑器窗口最大/最小化
ctrl+t 查看类继承关系树

数组：是引用类型 有length属性，没有length方法，有其他方法
数组声明的不同格式，四种
格式一：
int[] a1 = new int [3];
格式二：
int[] a2 ;
a = new int [30];
格式三：
int [] a3 = {1,2,3,4};
格式四：
int [] a4= new int []{1,2,3,4}

		声明的时候没有批量初始化，后边不可以再次批量初始化
		
数组排序：
	！！都可以使用前人写的代码
	java.util.Arrays
	//默认升序：Arrays.oort()
	
冒泡排序：精髓，前一个和后一个比较，如果大于后一个，换位。直到最后一个比完，再次从头开始比。

字符逆序输出：将String字符转换为char类型的字符数组，然后倒序输出

插入算法：先排序（降序），比大小找到插入点，然后将插入点后的数组向后移一位。最后插入数组

求素数：两种1、设置触发器。2、将if条件分开

斐波那契数列：a[1]=1;a[2]=1;for(int i = 1; i < 1111 ;i ++) a[i+2] = a[i] + a[i + 1] ;

杨辉三角：把直三角改为斜三角看。用二维数组int a[i][j] 。 a[1][1] = 1; a[2][1] = 1; a[2][3] = 1 ;
for(int i =1 ; i <100 ;i++){for(int j = 1 ;j <= i ; j++){if(j = 1 || j = i){a[i][j] = 1;}else{a[i][j] = a[i-1][j-1] + a[i-1][j];} } }

2018.7.30 第五天 周一

冒泡排序：外层循环n-1,内层循环n-1-i（n代表数组长度），算法：两两比较小在前

加密算法：RSA 、md5（单项）

//自动类型转换
String.substring()

//变量（局部变量、全局变量（成员变量））
//值类型8个基本类型：基于栈存储，一般用局部变量使用
//全局变量，一般用包装类型
怎么自动生成get/set方法？？？

---

赋值、==、equals

1、关于equals问题：在String中的equals方法被改写了除了比较地址还比较位数，比较对应字符是否相等。Object中的equals只比较地址
栈中：基本类型地址和引用类型的虚地址
堆：引用类型实地址
方法区：有常量池

String 特殊，用new/或者不用直接赋值常量。都会在常量池内找相同的匹配。
不用new,先在常量池内找：如果没有找到对应值，则先创建常量。栈存放地址。如果在常量池内找到，则不在常量池创建常量，但在栈中存放地址。
用new，先在常量池内找：如果池内有找到对应值，则先创建常量，然后复制到堆中建立常量值副本。如果在常量池内找到，则直接复制常量到堆中建立副本。

new/不用new，都在栈中有地址。但new会指向堆中的副本，不用new只会在常量池内找。

---

String将queals方法重写了，equals本来比较的是地址，但是在String中，不仅比较地址还比较值

Object中equals比较地址。Object为所有类的父类。

String str1 = new String (“hello”) 创建了2个对象：常量池和堆
String str2 = "hello"创建了1个对象：常量池
String str3 = “he”+"llo"创建了1个对象：常量池
String str4 = “he”+str2 创建了2个对象：常量池（st4和st2）

2、重写了equals方法（string视频3中）

3、引用类型和基本类型的区别
基本数据类型：变量；存储在栈中；直接赋值
引用数据类型：对象；寻处在堆中，栈中引用；new，String类和包装器类可以直接赋值

4、字符串的不可变性
string和stringBuffer/stringBuilder

5、Java引用类型
基本类型和引用类型的区别：主要在存储地方的却别。全局变量和局部变量的区别
基本类型，一般放在局部变量。

6、基本类型和引用类型原理。

7、类型转换

8、数组：
int [] a//建议用这个，int定义的是数组中存放数据的类型
int a []
数组在声明后还只是一个空指针，不能使用，要想使用必须创建。

a.length是length属性不是方法
对象.length（）是方法

创建数组必须指定数组长度，且一经定义则不允许改变。
数组定义的长度会+1。这个1存放的是数组的length属性，数组长度值

例题：数组=数组，给的是栈地址。在堆中共用空间
数组new= 数组 会开辟新的空间，是复制后的堆。两个数组值相等但独立存在的。

int [] a = new int [5]
a[1]==0; true 开辟了空间但Int默认值是0；开辟了5+1个空间。5为0的数据，1为存放a数组length属性值的数据

9、包装类
除了Boolean类和Character类以外，其他的包装类都有静态的方法。用于将字符转换成相对应的基本数据类型值
valueOf
√√ parsexxx

字符串转基本类型和字符串转包装类型：
将（符合）数字字符串转换为数字 基本类型√√√√√
String mm = “123”;
int n = Integer.parseInt(mm);
将（符合）数字字符串转换为包装类型 引用类型
Integer nn = Integer.valueOf(mm);

拆箱:将包装类型（引用类型）转为基本类型
装箱：将基本类型转为包装类型（引用类型）

---

第六天******

---

2018.7.31 第六天 周二

回顾：StringBuffer、StringBuilder
基本类型和引用类型
堆：存储对象的数据
栈：存储变量地址

引用拷贝：
对象拷贝：1、浅拷贝2、深拷贝

1、java面向对象
java类的声明
属性：对象的描述
方法：对象的行为
构造方法：用于实例化对象
内部类：在类体中声明的类。。一个包中只有一个public class
块：分为静态块，实例块。。区别：静态块：static{}类加载的时候调用，只调用一次 实例块：{}实例加载的时候调用

方法有返回值void
构造方法没有返回值，没有void
构造方法重载。
构造方法和类名一样

1、类的声明形式
[访问权限修饰符public,default(默认，不写)][修饰符final（最终类，不能被继承）,synchronized（线程同步锁）,abstract(抽象类)]class 类名｛类体｝
属性：属性既对象应有的数据
属性声明：【访问权限修饰符public/protected(不同包的子类，要继承的)/默认(同包不同类)/private/】【修饰符static final…】数据类型 属性名 【=初始值】
private String name;
private double salary;
private static int count = 0;

//静态属于类，也属于对象，但是静态成员属于对象共享

2、方法声明：【访问权限修饰符】【修饰符】【返回值类型】方法名【 参数类型】 【形参】
单一职责：一个方法就作一件事就好了、一个类就完成一类事就好了。一个项目就完成相似功能就好了。
//导包建议写类的全路径 com.cn.cha.Student
//可以通配符*
//Java方法不能嵌套

方法调用：在同一个类中：“方法名（）”调用
在不同类中：首先创建对象，再调用。“对象名.方法名（）”来调用

3、方法重载：在同一个类中
1、方法名必须相同，
2、参数列表不同：参数类型、参数个数、参数顺序必须有一个以上不同
3、重载与方法的返回值类型无关

下午：

生成javaDoc文档注释的方法：看老师笔记
1、javadoc命令行生成
2、eclipse工具生成：三方法

注释以“/**”开头，以“*/”结尾

javadoc标记：
@author对类说明开发作者信息
@version对类说明版本信息
@see对类、属性、方法的说明参考转向，即相关主题
@param对方法中参数列表的进行作用说明
@return对方法返回值的进行说明
@exception对方法可能抛出的异常进行说明

???
常用的Java API包???
???

重载：解决方法重名问题（参数列表不同：个数不同或类型不同）
返回值和重载没关系

2018.8.1 第七天 周三

1、创建网络驱动

2、批判昨晚的作业

3、修饰符（modifier）
修饰符的具体权限？？
private 本类
default 本类、同包
protectde 本类、同包、子类
public 本来、同包、子类、任何

注：类修饰：public default
方法修饰：private、default、protected、public

4、PowerDdsigner数据库的简单应用

5、认识类图

uml关系图：
+public
-private

uml类图中常见几种关系：
	Generallization:继承关系，表示一般与特殊的关系，即子类继承父类特征和行为的关系。
	Realization:实现关系，接口与实现类间的关系，表示类实现了接口所有特征和行为。
	Dependency:依赖关系，又称使用关系，即A类使用B类的关系。分单向、双向依赖，依赖将加重耦合度。
	Association:关联关系，又称拥有关系，即拥有者体内有被拥有者的关系（代码体现:成员变量）
	Agregation:聚集关系，整体与部分的关系，部分可脱离整体存在，即组件式编程的一种关系表达。如车与轮胎、发动机之间的关系。
	Composition:组织关系，整体与部分的关系，部分不能离开整体而存在，即组件式编程的一种关系表达式。如公司与部门的关系。

eclipse:
shift+alt+a纵向选择

6、数组扩展问题？？？

2018.8.2 第八天 周四

封装（面向对象的三大特征、封装、this)

1、封装、继承、多态

封装： 所谓封装，也就是把客观事物封装成抽象的类，
并且类可以把自己的数据和方法只让可信的类或
者对象操作，对不可信的进行信息隐藏。
继承： 所谓继承是指可以让某个类型的对象获得另一个
类型的对象的属性的方法。
多态： 所谓多态就是指一个类实例的相同方法在不同情形
有不同表现形式。多态机制使具有不同内部结构的
对象可以共享相同的外部接口。

封装：即抽象一个类的过程

继承：通过继承，可以获取父类中的属性或方法，进而使用父类代码

多态：
	重载：类内部问题、
      	重写：父子类直接的问题，如，父类有smoke()，子类可以改写。
      	向上转型、向下转型

2、封装：（有大封装、小封装)
代码封装、
数据封装

概念：
	将类的某些信息隐藏在类内部，不允许外部程序直接访问，
	而是通过该类提供的方法来实现对隐藏信息的操作和访问

shift+alt+s 代码生成的快捷菜单
+R 快捷生成get/set方法

封装（小封装）：get、set来实现     是一个良好的开发规范

	get方法:用于获取成员变量数据、外界使用成员变量必须通过get方法，get方法可以格式化数据。
	set方法:用于设置成员变量数据、外界使用成员变量必须通过set方法，set方法中，可以数据进行过滤和验证。


	成员变量通常设置为private
	get、set方法通常设置为public

优点：
	1、只能通过规定方法访问数据
	2、隐藏类的实现细节
	3、方便加入控制语句
	4、方便修改实现



以后成员变量必须做成私有的，用get/set来访问


封装的步骤：
	1、修改属性的可见性      			 设置为private
	2、创建共有的get/set方法     		 用于属性的读写
	3、在get/set中加入属性控制语句    	 对属性值的合法性进行判断

3、this关键字作用：就是在类体内使用，我自己。当前类的类实例。
1、调用属性
this.health = 100;
this.name = “大黄”;
2、调用方法
this.print();
3、调用构造：如果使用必须放在狗仔方法中的第一条语句
this();//无参构造方法
this(“小黑”，100，100，“雄”);//有参的构造方法

  *********
使用有参构造方法必须有无参构造方法！！！！！

封装总结：
封装指的是将对象的状态信息（属性）和行为
（方法）捆绑为一个逻辑单元的机制。
Java中通过将数据封装、声明为私有的(private)，
再提供一个或多个公开的(public)方法实现对该属性
的操作，以实现下述目标；
1、隐藏一个类的实现细节。
2、防止对封装数据的未经授权的访问。使用者只能通过事先定制
好的方法来访问数据，可以方便地加入控制逻辑，限制对属性的不合
理操作。
3.有利于保证数据的完整性。
4、便于修改，增强代码的可维护性。

信息的隐藏：
隐藏：指的是对象的一种保护机制，使得它的属性
或方法不被外部的程序直接访问
使用者对类内部定义的数据（对象的成员变量）的直接
操作，有可能会导致数据的错误。混乱或安全性问题。


方法重载的规则：
	方法名相同
	参数项不同
	与访问修饰符和返回值无关

3、static可以修饰类成员变量（属性）、类成员方法、静态块

---

继承 、super、重写override、final、is-A

1、继承
多个子类抽象成父类，然后通过父类继承子类
修饰符：extends

优点：
可以简化代码，代码重复问题。方便修改代码，减少代码量

1、继承的过程
	编写父类：
		class Pet{ //公共的属性和方法 }
	编写子类，继承父类：（只能继承一个父类）
		class Dog extends Pet{ //子类特有的属性和方法 }
		class Penguin extends Pet{  }
2、向上转型：10.52。。丧失子类特征	即 is-A

		//子类
		Dog dog = new Dog();
		dog.setName("小乖");
		dog.setStrain("");
		
		//父类，虽然构造函数是子类的，但是类型是父类的。pet调用不到Dog里的个性方法strain;
		//向上转型(会丧失子类特征)     即Dog is A;
		Pet pet = new Dog();
		pet.setName("小瓜");

2、子类访问父类成员（super）
访问父类构造方法
super();
super(name); 在子类构造方法中调用且必须是第一句
访问父类属性
super.name;
访问父类方法
super.print(); 父类代表父类对象，this代表本来对象

		super作用:
	  1、在子类当中，使用父类成员。super.成员变量（方法）
	  2、调用父类构造时，只能是第一句

		访问父类成员的时候用  super关键字.
		访问本类成员用   this

	//调用父类构造方法
	super("二狗", 99, 120);
	this .strain = "狗啊你是";

小结：super关键字来访问父类的成员
super只能出现在子类的方法和构造方法中
super调用构造方法时，只能是第一句
super不能访问父类的private成员

构造函数可以大量的精简代码
	

子类可以继承父类的所有资源吗？
	不能被继承的父类：private成员
	子类与父类不在同包时，default成员
	构造方法


多重继承关系的初始化顺序是怎样的：  ( 自上向下 )
	父类成员->父类构造->子类成员->子类构造

	
继承的好处：
	可以简化代码，代码重复问题。方便修改代码，减少代码量

3、重写override
重载：解决同一类方法同名问题。overload
重写：解决父类与子类的方法继承问题，如不喜欢父类方法，可在子类中重写父类方法。override
作用：
子类可以主动拒绝（改写）父类行为。即重写父类的资源即可。

区别： 
			位置		方法名	参数表	返回值			访问修饰符
方法重载	同类或子类	相同	不相同	无关			无关
方法重写	子类		相同	相同	相同或是其子类	不能比父类更严格

小结：构造方法不能被继承，顾不能被重写
方法重写规则：
方法名相同
参数列表相同
返回值类型相同或者是其子类
访问权限不能严于父类方法

@Override：保证继承中，一定有父类的这个方法

4、final修饰符
修饰变量：声明该变量不可变，常量
修饰方法：子类可以继承，但是不可以重写
修饰类：类不允许被其它类继承

总结：final修饰后----> class不可被继承、继承后的方法不可被重写、属性值不可改变


【final】int ...args
final参数设计可防止分那个发内部修改参数内容

可变参数：
int[]args   =   int ... args
int ...args   可变参数，数量可以++++ 

5、深入讨论 is-A
处理复杂关系，如类关系、继承关系的方法
instanceof关键字,用来判断对象是否是类的实例
isInstance()方法，用来判断对象是否属于某个类型的实例
isAssignableFrom()方法，用来判断类型间是否存在派生关系

	out(dog instanceof Pet);
	out(Pet.class.isInstance(dog));
	out(Pet.class.isAssignableFrom(Dog.class));

下午

//向下转型，回复原样     前提：必须是子类的实例
instanceof关键字  if else 搭配。用来保障
isInstance()
isAssignableFrom()

			//向上转型后，个性化代码都没有
		
			//向下转型后，恢复原样


多态：一个父类的类型可以代表好多类型，之后在用向下转型

***********************************************8

1、多态、向上转型、向下转型
多态：重载和重写就是多态
为什么使用多态：
未使用多态的代码 多
使用了多态的代码 少

多态可以减少类中代码量，可以提高代码的可扩展性和可维护性

调用无区别：同上


（继承和）多态技术，当处理更多子类时，更方便

使用多态的两个常见应用场景：
将父类作为方法参数。即使用父类作为方法形参实现多态
将父类作为方法返回类型。即使用父类作为方法返回值实现多态

多态的作用：
向上转型：子类转父类，自动进行类型转换
协变、向上造型、类型提升
向下转型：父类转子类，先使用instanceof关键字判断，再进行强制类型转换
逆变、抗变、向下造型

2、抽象类、抽象方法

抽象类、接口是彻底的抽象类：包含有抽象方法的类，即为抽象类。（abstract修饰)
抽象方法：只有声明，没有实现体的方法
两者关系：抽象类中可以没有抽象方法，但抽象方法必须在抽象类中


抽象类不能实例化！！！！！
抽象类的第一个作用：
	1、修饰一些不允许实例化的类，防止他人实例化该类
	2、封装抽象方法，让其他人去实现。


抽象方法是个方法。 

抽象方法：
	1、不用许再写方法体，方法体由子类实现。。。
	2、也是某种形式的重写，他的子类必须重写。

总结：抽象类
1、抽象类具备普通类的特点，即可有具体实现，也可由为实现
2、如子类未实现抽象父类的抽象方法，则子类必须是抽象子类
3、抽象类不能被实例化，但可以有构造函数，实例化子类时被调用
4、抽象类一般作为基类存在，表示一种抽象概念。如抽象类不是没有子类语法上可以，但无意义
5、抽象类的构造分方法和静态方法不可以修饰为abstract

************************************************8

接口、面向接口编程、组件式编程

类：全部实现
抽象类(abstract)：部分实现、全部实现、什么都不实现
接口(interface)：彻底不实现

写接口的名字：I+名字
接口实现类：DogImp（有部分公司这么用）

1、接口：极致的抽象即为接口。
接口只能有方法声明、常量、不能有成员变量、不能具体实现。可以有方法、final常量、static常量

接口使用规则：
	接口不可以被实例化
	实现类必须实现接口的所有方法
	实现类可以实现多个接口
	接口中还可以定义常量，且是Static、public

Java类中，一个类只能有一个直接父类（继承自另一个类），但可以实现多个接口
注：当一个类需要实现多个规范时，使用抽象类较有局限性。


实现了某一接口，即多了一种能力

面向接口编程！做设计：只关心有什么功能，不关心怎么实现

2、组件式编程：观察的角度不同
组件式编程两种方式，导致不同代码结果：
方式一：一个类实现一个接口，体内包含另外多个接口的实例
has a关系：代表的是对象和它的成员的从属关系。
方式二：一个类实现多个接口
is A 关系：代表的是类直接的继承关系

接口是一个约定

接口的特点：
接口是一种特殊到极致的抽象类
接口中没有变量，只能有公开的静态常量。默认（最终）修饰符为public static final
接口中所有方法都是抽象方法。默认(最终)修饰符 public abstract
接口是不能被直接实例化，故没有构造函数
Java中的接口：
属性全都是全局静态常量
方法都是全局抽象分那个发
无构造函数

一个类可以实现多个接口，普通(非抽象)类实现接口时必须实现接口中的全部方法

2018.8.3 周五 第九天

小知识：
1、System.out.println(1.01+2.02)
输出的值大于3.03…002… java的机制小数不是确定值，会有后边的小数
2、浮点计算不应使用float与double可以用BigDecimal

3、BigDecimal的初始化不应基于浮点字面量，而应基于String或整数

				BigDecimal b1  = new BigDecimal("1.01");
				BigDecimal b2  = new BigDecimal(5);
				
				System.out.println(b1+"   "+b2);
			
4、BigDecimal中封装有几个特殊值	
				BigDecimal zero = BigDecimal.ZERO;
				BigDecimal one = BigDecimal.ONE;
				BigDecimal ten = BigDecimal.TEN;
				
				System.out.println(zero);
				System.out.println(one);
				System.out.println(ten);
5、BigDecimal的加减乘除运算			
				System.out.println(b1.add(b2));// +
				System.out.println(b1.subtract(b2));// -
				System.out.println(b1.multiply(b2));// *
				System.out.println(b1.divide(b2));// /

6、BigDecimal两值比较
		使用==与equals都不对，应使用compareTo
		-1	小于比较值
		0	等于比较值
		1	大于比较值
				System.out.println(b1.compareTo(b2));

1、Object 超类、基类

1、所有Java类的祖先。每个类都使用Object作为基类，故所有对象（包括数组）都继承了该类的方法。
2、在未给出父类的情况下，Java会自动把Object类作为类的基类。故Object对象又可指向任意类型对象。
3、Object类定义于java.lang包中

所有的数据对象，都可以赋值给Object对象，此称为父类引用。//向上转型

Object超类的重要方法：
1、String toString():返回一个“以文本方式表示”此对象的字符串。
一般而言，可重写override
其Objcet.toSrtring的计算过程为：
getClass().getName()+’@’+Integer.toHexString(hashCode())

2、boolean equlals(Object obj):指示某个对象是否与此对象“相等”。
		Object类的equals（）比较特殊，比较的仅为栈内存（虚地址），效果等效于 == 比较
		Java中大部分官方类都重写了Object的equals()方法。效果和==  不一样

		自定义类型，要用equals()方法比较，一定以要重写equals()方法。
		
3、int hashCode() 返回该对象的哈希码值。
	
	为了解决自我保证协定的稳定性：
		自定义类equals用hashcode重写！！    可以自己编写，但是建议用eclipse自动生成代码功能！

	hashCode常被用于数据检索、去重、比较
	hashcode的常规协定。
	
	哪里需要用到hashCode
		equals用、集合：hashSet、hashMap

4、protected Object clone() 创建并返回此对象的一个副本。
	自定义类Clone条件：
		子类必须实现Cloneable接口，否则抛出CloneNotSupportedException
		重写clone方法
		
	浅拷贝（拷贝虚地址）
			=
	深拷贝（栈内存和堆内存全新开辟空间）
			new
			Cloneable接口实现   clone()  //标识接口，没有任何东西


5、Class getClass() 返回此 Object的运行时类
	运行时类:
		在运行中，动态获取一个类的定义信息，该类称运行时类。一般
		借助反射技术，可访问该类信息（字段、方法等），动态实例化对象
		、动态的调用对象的方法等操作。
	获取运行时类：
		getClass() 方法取得一个对象的运行时类
		Class clazz = user.getClass();
		Object user = clazz.newInstance();
6、protected void finalize() GC自动调用、完成资源释放功能（类似析构）

理解接口是一种能力的概念 ，了解Comparable接口
2、Comparable 与Comparator 接口
如一个类 Comparable 或Comparator 代表，其对象可比较，可排序。

1、Comparable接口：可比较的能力。
	该接口中声明了一个比较方法：compareTo(o)
	int compareTo(Object o) ：返回值说明
		排序结果	当前对象<比较对象	当前对象>比较对象	当前对象 == 比较对象
		升序				-1					1					0
		降序				1					-1					0
	
2、Java中很多类都实现了Comparable接口，借助该接口可以通过使用：
	Arrays.sort(Object[])、Collections.sort(Object[])、TreeSet集合支持（唯一性结合都要求） 
	来对 数组、集合 进行排序   进而可以认为支持Comparable接口，获得了排序能力

	
3、Comparator接口定义于java.util包下：
	Comparable、Comparator都是一种规范结合元素比较排序的接口。
	两者的区别：
		Comparable在待排序类的内部实现比较顺序支持（第一人称视角）
		Comparator在待排序类的外部实现比较排序支持（第三人称视角）

	调用compataror或者comparable需要重写。compare方法  eg31  compareTo方法  eg30
	comparable接口，声明有public int compareTo(T,O);抽象方法
	comparator接口，声明有public int compare(T 1O，T o2);抽象方法
	实际其即可，拥有该能力。

小知识：
比大小三目运算符： System.out.println((result < 0 )? “dog1小于dog3”:(result > 0 )? “dog1大于dog3”:“相等” );
比大小后排序输出：
Arrays.sort(dogs,new SmallDogComparator());;
for (SmallDog bigDog : dogs)
{System.out.println(bigDog);}

3、 常量池：
学习Java，常量池是个特殊的存在。
常量池，是为了方便某些对象快速存储而开发的一种技术。
常量池是一段连续的内存空间，其中的数据在项目加载时，初始化完毕。

常量池技术的应用：
	Byte,Short,Integer,Long,Character,Boolean 使用了常量池技术
	Byte,Short,Integer,Long,Character泛整型变量值（-128至127）初始化于常量池。
	Float、Double未使用常量池技术
	常量池中存储着高频字符串，即字符串也支持常量池操作。
	
常量池中常量的开辟过程；
	1、先在常量池中查找是否存在该值
	2、如不存在，则在常量池中添加该值，并将该值地址引用至变量
	3、如果存在，则直接将该值地址引用至变量

4、 内部类
即定义在类或方法体内部的类，经常被使用于GUI、Android编程中的事件处理、测试外部类等。
用在窗体

	内部类实例化原则：应该先实例化外部类，再实例化内部类
			//实例化内部类方法一
			Outher outher = new Outher();
			Outher.Inner inner = outher.new Inner();
			inner.test();
			
			//实例化内部类方法二
			Outher.Inner inner2 = new Outher().new Inner();
			
			//实例化内部类方法三(外部类中通过getter获取)
			Outher outher2 = new Outher();
			outher2.getInner();
			在外部类中->private Inner inner3;
						public Inner getInner() {
							return new Inner();
							}

小结 内部类：
	1、编译时特点，其一旦编译成功，会成为两个完全不同的类。对于一个名为Outher的外部类和其内部定义的名为Inner的内部类。
	编译完成后将形成Outher。class/Outher$Inner.class两个独立的字节码文件。
	2、内部类中可以直接调用外部类的所有成员（包括私有）
	3、实例化内部类时，应先实例化外部类。

小结 方法中的内部类：
	1、方法中的内部类，仅限于方法内部使用，其类成员不可使用static修饰，且应在使用前定义。
	2、方法中final类型的局部常量，可被Inner类的方法访问，且应在内部类定义前定义。
			注：但是方法中的内部类访问方法中变量，需要在内部类之前创建，且在内部类内进行赋值，才能在方法中的内部类中的方法调用。
			public class Outer{
				private int x ;
				class Inner{
					int j = i;
					public static void main(String [] args){
						j++;
					}
				}
			}
	3、内部类可定义在方法体内，但尽量不要使用，会导致代码复杂化。

5、 静态内部类：
通常static仅能修饰类成员、此处第一次对类进行修饰，即static还可修饰内部类
public class Outer{
final int x ;
static class Inner{
int j = i;
public static void main(String [] args){
j++;
Outer outer = new Outer();
System.out.println(outer.x);
}
}
}

	一个类中可以有内部类，一个方法中可以由内部类
	
	
	Java中static 不能修饰外部类。。只能修饰变量、方法、内部类

小结：
	静态内部类一般配合静态成员使用，否则需要实例化后使用类成员。
	静态内部类不能定义到方法体内。
	静态内部类不能使用外部类的非static的成隐患变量
	普通内部类成员不能声明为static，但可声明静态常量。只有外部类或静态内部类中才可声明static成员。

作业：
1、提供类图(PowerDesigner作的)pdm格式文件
2、提供可运行项目

**浅拷贝：只拷贝栈内地址
深拷贝：拷贝栈地址、堆数据

深拷贝方法三种：
直接new，开辟新空间，创造新对象
cloneI()方法，直接将对象复制
用工具类
**

2018.8.4 周六 上午
高级类特性阶段复习：
1、static变量、方法和初始化器（静态块、自由块）、内部类
2、final类、方法和变量
3、abstract类和abstract方法
4、接口、
5、多态、
6、虚方法调用
7、instanceof运算符
8、对象的造型（cast）
9、内部类
10、修饰符的适用范围

1、static关键字：
1、static关键字用来修饰变量、类语句块、方法和内部类，依次称为静态变量、静态块、静态方法和静态内部类。
2、static关键字声明一个属性或方法是和类相关的，而不是和类的某个特定的实例相关。
3、如果访问控制权限允许，可通过类对象或类名加“.”的方式来调用，仅能使用静态变量、静态方法、静态内部类
4、静态块不能直接调用
5、static 不可用于修饰构造器
public class Test{
static int i = 100;
public static void main(){
Test.i = 100;
}
}

小知识：1、父类static最先调用->子类static->父类普通代码块->父类构造方法->子类普通代码块->子类构造方法
		2、static 修饰全局变量或方法后，可直接在方法体内用:类名.变量名	  来调用。不需要实例化new。

代码块（语句快）：
		将{}直接写于class体内，其在当前类被实例化时，最先被调用，构造后调用。
		经常被用于完成：当前类实例的初始化工作。		
		
static+代码块、语句快：静态代码块、静态块：

static代码块：当类加载时时，即执行。一般用于初始化项目环境、外部环境。

静态代码块：当类加载时，即执行。一般用于初始化项目外部环境。
		//初始化工作，初始化的是全局变量，初始化整个工程
		//连接oracle,执行初始化脚本    客户如果没有数据 这里就起很大作用了
		//创建N表，N个视图,N个存储过程
		//以上类似的代码，写在这里都很完美

static当类加载的时候就执行！！！！！！！！！！！！

static静态（自由）块：
	所谓类的“自由块”，就是在类中用{}包含起来的不属于任何方法或构造器的代码段
	使用static来修饰的自由块只在类加载的时候执行一次，通常用于初始化静态变量。





学习设计模式，要理解，这个设计模式是为什么而生。？？？

单例(Singleton)设计模式：
	设计模式是在大量的实践总结后，优选的代码结构、编程风格以及解决问题的最佳实践(设计模式就是一些优秀的编程经验)。
	
	主要目标：保证一个类只能被实例化一次
	
	在实际开发中常用到，比如数据库的连接。
			使用Singleton模式可以节省内存，因为它限制了实例的个数。

	使用Singleton模式可以节省内存，因为他限制了连接实例的个数


	
	单例模式：
	创建一个类时，应满足：
		1、构造器私有避免用new操作符在类的外部产生类的对象，但在类内部仍可以产生该类的对象
		2、用一个私有、静态变量引用实例
		3、提供一个共有、静态方法获取得实例用该类的静态方法返回类内部创建的对象，静态方法只能访问类中的静态成员变量。
	分为：
		懒汉单例：别人获取实例化，再创建。
		饿汉单例：先创建好，别人用时，直接获取。
	作业练习：
		请根据自己的语法知识，完成单例模式块的一个类，上述使用的是饿汉单例，大家自己完成一个懒汉单例。
	在时间开发中常用到，比如数据库的连接。
		使用Singleton模式可以节省内存，因为它限制了实例的个数。

2、filna关键字：
final可以用于类、方法。变量定以前。
final修饰的类：可不被继承，如java.lang.Math就是一个final类，不可被继承
final修饰的变量：在初始化后不可改变变量值，这种变量可称为常量。如果final变量是引用类型变量，则不可以改变它的引用对象，但可以改变对象属性。如：char[]。可以改变数组内容
final修饰的变量在定义的时候必须赋初值
final修饰的方法：不可被重写(override)

3、abstract关键字
用abstract修饰的类表示这个类是一个抽象类
用abstract修饰的方法表示这个分那个发是一个抽象方法
抽象分那个发是只有方法声明，而没有方法实现的方法。虚方法。

4、抽象类
定义：只定义类的一个框架，并不具体实现，具体实现交给子类去完成，此时可将该类定义为抽象类。
抽象原则：
抽象类里面并非一定需要抽象方法，但是没有抽象方法，抽象类就没有存在的必要。

	抽象类不能被实例化。
	
	在以下任一条件成立时，类必须定义成抽象类：
			1、类中有至少一个抽象方法
			2、类继承了父类中的抽象方法，但是至少有一个抽象方法没有实现。
			3、类实现了某个接口，但没有全部实现接口中的方法。

5、接口
定义：接口是方法声明和常量值的定义的集合
原则：接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义（抽象方法），而没有变量和方法的实现
抽象类和接口区别：
抽象类：有抽象方法和非抽象方法，抽象类是被继承的
接口：所有分那个发都是抽象的，接口是被实现的
接口定义格式：
interface[extends<super_interface>]{
[<attribute_dedarations>]
[]
}
接口的常量默认都是public static final 修饰的
接口的方法默认都是public abstract 修饰的

6、接口的继承
接口和类都可以从一个父接口中派生。接口的继承也是使用"extends"关键字来完成。
就扣继承的基本语法如下：
interface[extends<super_interface>,{super_interface}]
{
[<attribute_dedarations>]
[<abstract_method_declaration>]
}
和类不同的是，一个接口可以继承自多个父接口，各个接口使用逗号"," 隔开

实现接口：
	多个无关的类可以实现同一个接口。
	一个类可实现多个无关的接口
		语法如下：
			<modifier>class<name>[extends<superclass>][implements<interface>[<interface>*]]
				{
					<declrations>*
				}
	在Java中，可以通过接口来模拟"多继承"。

7、未实现方法和空方法的区别
未实现方法：
public int method A();
可出现在接口或抽象类中，使用abstract修饰
空方法：
public void method B(){}
不可以用abstract来修饰

8、多态
在Java中，类的对象是多态的。一个类型为Aclass的对象既可以指向类型为Aclass的对象，又可以指向Aclass的任何子类的对象。
类Aclass则可以将子类Bclass的对象赋给父类变量。
Aclass a = new Bclass();
Bclass b = new Aclass();//此时要强制转换

在日常开发中，以多态的形式来传递参数，可以增强了参数类型的灵活性。

多态中的方法调用：
	正常的方法调用
		Person p = new Person();
		p.showName();
		Student s = new Student();
		s.showName();
	虚拟方法调用（多态情况下）
		Person p = new Student();
		p.showName();

9、对象造型（Casting）
所谓造型就是Java对象间的类型转换
Java的对象造型可以分为两种情况：
自动造型、隐匿转换（子类转父类）（男人转人）
强制造型、强制类型转换（父类转子类）（人转男人）
在造型去前可以使用instanceof运算符测试一个对象的类型
对象的造型只用在有继承关系的对象之间

10、修饰符适用表速查

---

2018.8.4 第十天 周六 下午 未完
1、Java String字符串
String字符串不可变性
String类封装了字符串处理的常用方法，并可使用”+“号操作符来连接字符串
String类构造共有13种重载：
String()
…

String的主要方法：
	length()
	trim()
	startsWith(String prefix)、endsWith(...)
	char At(int indes)
	indexOf(String str)、contains(...)
	concat(String str)
	replace(char oldChar,char newChar)
	subString(int beginindex)
	toLowerCase()
	toUpperCase()
	String[] split(Strign regex)

方法传值
形参 引用类型（除了String之外，不可变性）（除了封装类）
实参 基本类型

异常：

解决一下代码的输入性或其他异常问题，可以通过代码增强，来加强
代码的健壮性
什么是异常：
异常是指在程序的运行过程中所发生的不正常事件，它会中断程序运行
Java编程语言使用异常处理机制为程序提供了错误处理的能力

使用异常处理机制，可以达到，让程序出错后，继续执行。

java异常处理是通过5个关键字来实现：
try–catch()–finally
throw Exception

当捕获到错误时，通过Exception来接收
Exception中封装的两个方法，保证有异常信息
pringStackTrace();
String exInfo = ex.getMassage;

宽泛的catch方最后

finally块不管是否有异常都会执行。
只有在cath块有system.exit(1)    退出程序，不执行

---

第十天完****
****************************************************************************************************************************//

2018.8.6 第十一天 周一 上午

1、log4j:
1、了解Log4j
2、掌握log4j在入场开发中的使用
3、张默log4j配置

loj4j概念：
	Apache的一个开源项目，通过使用loj4j，我们可以控制日志信息
	输送的目的地是控制台、文件、数据库，甚至是套接字服务器、NT事件记录器、
	UNIX守护进程等。我们可以通过log4j方便的充值日志的输出格式；
	定义日志的记录级别，能够更加细致地控制日志的生成过程。
	通过配置文件的修改可灵活的配置日志输出目标日子格式，而不需要修改一行代码。

2、写日志的需求：
文本、文件数据库、xml、mysql、大数据平台。

3、日志分类：
日志：
主要用来记录系统运行
日志分类:
SQL日志、异常日志、业务日志
log4j是一个非常优秀的开源日志记录工具：
控制日志的输出级别
控制日志信息输送的目的地是控制台、文件等

4、开发步骤：
1、导入log4j的jar包
2、创建log4j.properties文件
3、配置日志信息
4、编写日志输出代码
5、使用log4j记录日志信息

5、Log4j输出级别：[level]
fatal(最高)-> error -> warn -> ifno -> debug(最低)

6、配置信息

	# 设置Log4j的日志输出级别、目的地
	log4j.rootLogger=debug, stdout, logfile
	# 输出至控制台
	log4j.appender.stdout=org.apache.log4j.ConsoleAppender
	log4j.appender.stdout.Target=System.err/System.out
	log4j.appender.stdout.layout=org.apache.log4j.SimpleLayout

	# 输出至文本文件： 
	log4j.appender.logfile=org.apache.log4j.FileAppender
	log4j.appender.logfile.File=logs/garysu.log
	log4j.appender.logfile.layout=org.apache.log4j.PatternLayout
	log4j.appender.logfile.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %l %F %p %m%n

7、配置详解：
配置Logger根：
log4j.rootLogger = [level] , appenderName1 , appenderName2,…

	配置日志信息输出目的地Appender
		log4j.appender.appenderName = fully.qualified.name.of.appender.class
		log4j.appender.appenderName.option1 = value1
		其他属性配置...
		log4j.appender.appenderName.optionN = valueN

	配置日志信息的格式（布局）
		log4j.appender.appenderName.layout = fully.qualified.name.of.layout.class
		log4j.appender.appenderName.layout.option1 = value1
		其他布局配置
		log4j.appender.appenderName.layout.optionN = valueN

8、Appender为日志输出目的地，Log4j提供了一下几种主要的输出目标：
org.apache.log4j.ConsoleAppender(控制台)
org.apache.log4j.FileAppender(文件)
org.apache.log4j.DailyRollingFileAppender(每天产生一个日志文件)
org.apache.log4j.RollingFileAppender(按文件大小产生一个新的文件)
org.apache.log4j.WriterAppender(将日志信息以流格式发送到任意指定的地方)
org.apache.log4j.jdbc.JDBCAppender(将日志信息发送至数据库中)

9、Layout日志输出格式，Log4j提供一下几种：
org.apache.log4j.HTMLLayout(使用HTML表格布局)
org.apache.log4j.SimpleLayout(仅输出日志级别和信息字符串)
org.apache.log4j.TTCCLayout(包含日志产生的时间、线程、类别等信息)
org.apache.log4j.PatternLayout(自定义布局)

10、log4j自定义布局中的格式化字符：
%m 输出代码中指定的消息
%p 输出优先级，即DEBUG，INFO，WARN，ERROR，FATAL
%r 输出自应用启动到输出该log信息耗费的时间，毫秒数
%c 输出所属的类名，通常就是所在类的全名
%t 输出产生该日志事件的线程名
%n 输出一个回车换行符，Windows平台为“\r\n”，Unix平台为“/n”
%d 输出日志发生的日期时间，默认格式为ISO8601，可在其后指定格式，比如：%d{yyy MMM dd HH:mm:ss , SSS}，输出类似：2017年2月28日 22 ： 10 ： 28 ， 921
%l 输出日志发生的位置信息，包括类全名、发生的线程，以及代码行号。举例：cn.garysu.javase.Testlog4.main(TestLog4.java: 10 )

11、为特定的输出 配置项，设置输出级别：
log4j.appender.appenderName.Threshld = DEBUG ##输出DEBUG级别以上的日志

2018.8.6 第十一天 周一 下午

集合
数组是集合
数组有缺点，所以要学习集合
1、定长,初始化后，不能呢个再修改长度
2、相同类型的数据才能放在一起

集合就完美的解决了数组的问题！

1、Java提供了一套性能优良、使用方便的集合处理接口和类：
Collection：
List:ArrayList、LinkedList
Set:HashSet、TreeSet
Map:
HashMap、TreeMap

		List接口在Conllection实现集合：顺序存储
		Set接口在Conllection实现集合：唯一性（）
		Map接口集合：ksy/value，key不重复，根据key取value

*注意：List集合，添加时很方便，任意都可添加，但取出时，就不知什么类型数据所以返回一个object

2、List接口声明的主要方法：
boolean add(Object o) 在列表的末尾顺序添加元素
void add(int index,Object o) 在指定的索引位置添加元素
void clear() 移除所有元素
boolean contains(Object o) 判断列表中是否存在指定元素
Object get(int,index) 返回指定索引位置处的元素
E set(int index,E element) 替换列表中指定位置的元素
int indexOf(Object o) 返回此集合中第一次出现的指定元素的索引；如不包含该元素，返回-1
boolean isEmpty() 如果列表不包含元素，则返回true
Iterator itreator 返回集合的迭代器
boolean remove(Object o) 从列表中删除指定元素，重复数据，依次删除最后一个
E remove(int index ) 从列表中删除指定索引位置的元素，向左移动所有后续元素
int size() 返回列表中的元素个数
Object[] toArray 返回按适当顺序包含列表中的所有元素的数组

3、求集合长度：
String的长度.length()
Array的长度.length
set的长度：size()

4、List的子类：
ArrayList实现了长度可变的数组，在内存中分配连续的空间。（遍历元素和随机访问元素的效率比较高）

	使用ArrayList存储元素:
		List dogs = new ArrayList();
	 	dogs.add(qqq);

5、ArrayList的扩容机制：
首次扩容10个
下次扩容5个 10/2 =5
下次扩容7可 15/2 =7
每次集合使用完毕后，集合将自动扩容：现有空间个数 /2 取整

6、ArrayList与Array比较，有没有缺点？：
1、 读取数据的时候，不知道原始数据类型通过泛型版本的ArrayList来解决这一问题。
Java所有集合在Java1.5版本中，都进行了升级，提供了泛型版本的集合
eg: ArrayList list2 = new ArrayList();
list2.add(“大明”);
list2.add(new Dog());
list2.add(String.valueOf(1));

	注；泛型集合，有效的解决了读取数据时，经常要作的类型转换的问题。
	有效的减少了拆箱的性能消耗

7、泛型集合的优缺点：
自Java5.0引入，其实质是将数据类型参数化。
减少代码量，可有效增强项目的可维护性
增强可靠性，解决集合框架中频繁的数据转型问题

作业练习
需求说明：
在上机3的基础上，改写为泛型版本，存储、修改企鹅信息等功能。
分别使用for、foreach语句进行遍历输出

8、泛型方法与泛型类

泛型不支持基本类型处理。

泛型方法：
		public <T> T add(T a, T b){
			
			if(a instanceof Integer && b instanceof Integer){
				Integer i = Integer.valueOf(a.toString());
				Integer j = Integer.valueOf(b.toString());
				Integer result = i + j;
				return (T)result;
			}
			
			if(a instanceof Double && b instanceof Double){
				Double i = Double.valueOf(a.toString());
				Double j = Double.valueOf(b.toString());
				Double result = i + j;
				return (T)result;
			}
			
			if(a instanceof String && b instanceof String){
				String i = a.toString();
				String j = b.toString();
				String result = i + j;
				return (T)result;
			}
			
			
			return (T)null;
		}



泛型类：
		package cn.gary2;

		public class Test011 {

			public static void main(String[] args) {

				Calculator2<String> calculator2 = new Calculator2<String>();
				String r1 = calculator2.add("我是小明", "小明");
				
				System.out.println(r1);
				
				String r2 = calculator2.substract("我是小明", "小明");
				System.out.println(r2);
				
			}

		}

		class Calculator2<T> {

			public T add(T a, T b) {

				if (a instanceof Integer && b instanceof Integer) {
					Integer i = Integer.valueOf(a.toString());
					Integer j = Integer.valueOf(b.toString());
					Integer result = i + j;
					return (T) result;
				}

				if (a instanceof Double && b instanceof Double) {
					Double i = Double.valueOf(a.toString());
					Double j = Double.valueOf(b.toString());
					Double result = i + j;
					return (T) result;
				}

				if (a instanceof String && b instanceof String) {
					String i = a.toString();
					String j = b.toString();
					String result = i + j;
					return (T) result;
				}

				return (T) null;
			}

			public T substract(T a, T b) {

				if (a instanceof Integer && b instanceof Integer) {
					Integer i = Integer.valueOf(a.toString());
					Integer j = Integer.valueOf(b.toString());
					Integer result = i - j;
					return (T) result;
				}

				if (a instanceof Double && b instanceof Double) {
					Double i = Double.valueOf(a.toString());
					Double j = Double.valueOf(b.toString());
					Double result = i - j;
					return (T) result;
				}

				if (a instanceof String && b instanceof String) {
					String i = a.toString();
					String j = b.toString();
					String result = i.replace(j, "");
					return (T) result;
				}

				return (T) null;
			}

		}

9、泛型接口：就是拥有一个或多个类型参数的接口
语法：
public interface 接口名<类型形参>{
方法名(类型形参 类型形参实例);
}
示例：
public interface Test{
public T print(T x);
public T show (T x);
}

小结：
泛型要求处理的类型，必须是引用类型对象。不允许使用基本类型变量。
故此，泛型集合不支持基本类型定义。

class<T>、class<?>  T:表示Java  ?:表示不确定类型
class<K,V>、class<E> K,V代表k\Key/Value   E代表Element
?号的其他使用：<? extends Collection>  <? supper Collection>



ArrayList：数组的特点，遍历有优势

LinkedList:链表的特点,插入、删除具有优势

11、LinkedList类：
void addFirst(Object o) 在列表的首部添加元素
void addLast(Object o) 在列表的末尾添加元素
Object getFirst() 返回列表中的第一个元素
Objetc getLast() 返回列表中的最后一个元素
E remove()
remove(int index) 获取并移除此列表的头
remove(Object o)
Object removeFirst() 删除并返回列表中的第一个元素
Object removeLast() 删除并返回列表中的最后一个元素

12、set
HashSet TreeSet

set集合特点:
	不允许有重复元素（允许有NULL）
	不保证元素顺序（添加顺序）
注:以上特点，对于自定义类成立的基础，是重写hashCode和equals方法。
	排序方式，是根据哈希值排序(不提供有序存储)

13、使用HashSet集合时的主义事项：
1、应保证元素已经重写hashCode()方法和equals()
2、如未重写，将会存入重复数据

HashSet
	数据无序（hash字节顺序）
TreeSet
	不允许有重复元素、数据有序（自然顺序）

14、Map集合
Map
HashMap TreeMap

Map接口常用方法
	Object put(Object key, Object val)	以“键-值对”的方式进行存储
	Object get(Object key)				根据键返回相关联的值，如果不存在指定的键，返回null
	Object remove(Object key)			删除由指定的键映射的“键-值对”的方式进行存储
	int size()							返回元素个数
	Set keySet()						返回键的集合
	Set<Map.Entry<K,V>>entrySet()		返回此集合由Map.Entry集合
	Collection values()					返回值的集合
	boolean containsKey(Object key)		如果存在由指定的键映射的“键-值对”，返回true

金典面试题：
set或list集合的添加元素方法是什么 add()
map集合添加元素的方法是什么 put()

Map集合中的key,不能存储重复的key
如果使用自定义类型，作为key,要记得重复其的hashCode()和equals（）方法

---

第十一天完****
****************************************************************************************************************************//

2018.8.7 第十二天 周二 上午

集合总结：

	String	

	数组

	List

	Set

	Map



掌握集合，主要是了解的接口

1、Java中的集合如此之多，是否存在着一种统一、且快速的遍历手段呢？

Iterator迭代其（设计模式）、游标
只能往前走，遍历
迭代器(Iterator)模式，又称游标模式。GOF给出的定义为：提供一种方法访问一个容器对象中的各个元素，
	而又不需要暴露该对象的内部细节。
即使用一种统一的方法来访问集合，而不需要了解其的内部细节。

特点：
	1、Intertor遍历集合的过程中不允许其他线程对集合元素修改，否则会抛异常
	2、Intertor遍历集合元素的过程中，可以通过remove方法来移除原集合中的元素
	3、Intertor必须依附某个Collection对象而存在，Iterator本身不具备数据存储能力。
			即：3只存地址，不存储数据

2、Iterator接口的三个方法
boolean hasNext() 判断是否有可访问的元素
E next() 读取元素，并指向下一个元素（游标下移）
void remove() 移除当前元素（当前游标指向的元素）

3、Itertor遍历方式：2种
方法一：
while(iterator.hasNext()){
String str = (String)iterator.next();
//…
}
方法二：
for(;iterator.hasNext()?{
String str = (String)interator.next();
//…
}
eg://迭代器
//Set
Set set = new TreeSet();
set.add(“11”);
set.add(“12”);
set.add(“13”);
set.add(“14”);

					Iterator<String> iset =  set.iterator();
					while(iset.hasNext()) {
						String str = iset.next();
						System.out.println(str);
						System.out.println(iset.hasNext());
					}
					
					System.out.println("================================");
					
					//List
					List<String> list = new ArrayList<String>();
					list.add("asd");
					list.add("fgh");
					list.add("eeh");
					list.add("vh");
					
					Iterator<String> ilist =  list.iterator();
					while(ilist.hasNext()) {
						String str = ilist.next();
						System.out.println(str);
						System.out.println(ilist.hasNext());
					}

4、迭代其Iterator示例：
List集合地带遍历
Set集合迭代遍历
Map集合迭代遍历

Set keys = dogMap.KeySet();  //取出所有key的集合
Iterator it = keys.iterator(); //获取Iterator对象
while(it.hasNext()){
	String key = (String)it.next();   //取出key
	Dog dog = (Dog)dogMap.get(key);   //根据key取出对应的值
	System.out.println(key+"\t"+dog.getStrain());
}

5、Collection接口：
List接口：存储数据可重复，有序（插入顺序）对象集合。
Set接口：存储数据不重复，HashSet无序、TreeSst有序。

6、Map
存储键值对的对象集合，提供key/value的数据对，可以根据key快速获取value。

7、集合类对比
面试常见：
Vector ArrayList
HashTable HashMap

操作数组时的工具类：Array
操作集合时的工具类：Collections

2018.8.7 第十二天 周二 上午
IO编程

1、文件和目录操作都是使用：
java.io.File类

2、File类的常用方法：
boolean exists() 判断文件或目录是否存在
boolean isFile() 判断是否是文件
boolean isDirectory() 判断是否是目录
boolean isHidden() 判断是否是隐藏文件
String getPath() 返回此对象表示的文件的相对路径
String getAbsolutePath() 返回此对象表示的文件的绝对路径
String getName() 返回此对象表示的文件或目录的名称
boolean delete() 删除指定文件或空目录，不能删除非空的文件夹
boolean creatrNewFile 创建名称的文件夹，不创建文件夹
long length() 返回文件的长度，单位为字节
boolean mkdir() 只能创建一级的目录，需要父目录已存在
boolean mkdirs() 可以创建多级目录，无论是否存在父目录
String[] list() 返回文件夹中的文件信息（文件、目录）

3、路径的计算
./ 当前目录
…/ 上级目录
/ 根目录

4:文件中的 路径概念
路径：就是文件或文件夹所在的位置。
路径分隔符：上下级文件夹之间使用分隔符分开
a.
b.
c.
绝对路径与相对路径：
a.
b.
c.
d.

作业：写病毒:熊猫烧香

2018.8.7 第十二天 周二 下午

多线程、进程与线程、创建线程、声明周期
1、概念
进程：应用程序的运行实例，是资源分配调度的基本单位。
线程：进程中的执行单位，是cup时间片的调度使用单位。
多线程：在同一时间执行多个任务的功能，即多线程
时间片：即对CPU资源按时间切片，每个线程轮流执行。

2、进程与线程间关系：
进程是操作系统分配资源的最小单元，线程是操作系统调度的最小单元。
线程是进程的组成部分，一个进程拥有1-N个线程，至少一个线程。
倒戈线程可以并发同步执行。

3、多线程的优缺点
优势：
1、可以同时完成多个任务，提高CPU利用率
2、多任务并发执行，速度更快
3、可以随时停止任务，并设置任务优先级以优化程序性能
缺点：
1、多线程间存在着竞争资源，比如文件、表中的一行数据、内存空间，
对资源的并发访问可能造成程序紊乱。（应对共享资源访问应进行同步或控制）
2、特殊情况下，程序的整体运行速度会减慢
3、代码复杂度较高

3、多线程在Java中的两种实现手段
1、继承Java.lang.Thread类，并重写run()方法
class TestThread extends Thread｛
public void run(){
//覆盖该方法
}
｝
2、实现Java.lang.Runnable接口，并实现run()方法
class TestRunnable immplements Runnable｛
public void run(){
//覆盖该方法
}
｝

4、创建并启动线程：新键的线程不会自动运行，必须通过start()方法来启动
1、启动继承Thread的线程：
TestRunnable t = new TestRunnable();
t.start();
2、启动实现Runnable接口的线程
TestRunnable tr = new TestRunnable();
Thread r = new Thread(tr);
r.start();

5、Thread类的主要方法：
static Thread currentThread() 得到当前线程
final String getName() 返回线程的名称
final void setName(String name) 设置线程的名称
int getPriority()、setPriotity() 更改线程的优先级
void start() 调用run()方法启动线程，开始线程的执行
boolean isAlive() 测试线程是否处于活动状态
void join() 等待该线程终止。（强行介入）
static void sleep(long millis) 使当前正在执行的线程休眠（暂停执行）
static void yield() 让出时间片
void run() 线程代码（不能主动调用）

6、如要多线程间的协调，控制，就需要更多的线程方法
Thread.currentThread();

7、线程的声明周期如图
1、初级版本
2、强化版本

8、线程优先级：
线程优先级：
1、多个线程处于可运行状态时，将对cpu时间片进行竞争，优先级高的，获取的可能性则高
2、线程优先级有1-10表示，1的优先级最高，默认值是5或继承其父线程优先级
更改优先级：
setPriority(int grade)方法：
相关静态整形 常量：
Thread.MIN_PRIORITY=1
Thread.Max_PRIORITY=10
Thread.NORM_PRIORITY=5

9、线程调度的方法
join()方法 tempjt.join(); 等待该线程终止。（强行介入），强行别的线程终止等待
sleep()方法 tempjt.sleep()； 该线程睡一会儿
yield()方法 Thread.yield(); 在线程内调用，当线程停止运行后，可以继续和别的进程竞争cpu资源

*****************************************8
线程同步、同步块、同步方法
1、线程同步
当多个线程，都在操作同一个共同资源时，就会出现资源竞争问题。
就要给统统资源加把锁（代码锁）

当两个或两个以上线程访问同一资源时，需要某种方式来确保资源在某一时刻只被一个线程使用

解决方案：
	同步块
		在类下定义一把锁标记：  static Object lock = new Object();
		对操作公共资源的代码，添加同步块：synchronized(lock){// 同步块代码  }
	同步方法
		访问修饰符synchronized返回类型 方法名{}
		可以把操作公共资源的代码，封装成一个方法，为该方法添加synchronized，其方法一次只能有一个线程进入执行

2、总结：
线程同步的好处
解决了线程安全问题、对公共资源的使用有序化
线程同步的缺点
性能下降
会带来死锁
线程同步的注意点：
同步代码块的锁对象，同步方法都要求是唯一的。
一般都使用static来修饰，当然也可不使用static。
核心要求是同步代码块的锁对象，同步方法是唯一的。
所有的非静态同步方法用的都是同一把锁—实例对象本身。

3、死锁问题
当两个线程相互等待对方释放“锁”时，将会发生死锁。

---

第十二天完****
****************************************************************************************************************************//

2018.8.8 第十三天 周三 上午 未完

IO编程

2018.8.8 第十三天 周三 下午 李老师 未完

网络编程

---

第十三天完****
****************************************************************************************************************************//

2018.8.9 第十四天 周四 上午

2018.8.7 第十二天 周二 上午
IO编程

1、文件和目录操作都是使用：
java.io.File类

2、File类的常用方法：
boolean exists() 判断文件或目录是否存在
boolean isFile() 判断是否是文件
boolean isDirectory() 判断是否是目录
boolean isHidden() 判断是否是隐藏文件
String getPath() 返回此对象表示的文件的相对路径
String getAbsolutePath() 返回此对象表示的文件的绝对路径
String getName() 返回此对象表示的文件或目录的名称
boolean delete() 删除指定文件或空目录，不能删除非空的文件夹
boolean creatrNewFile 创建名称的文件夹，不创建文件夹
long length() 返回文件的长度，单位为字节
boolean mkdir() 只能创建一级的目录，需要父目录已存在
boolean mkdirs() 可以创建多级目录，无论是否存在父目录
String[] list() 返回文件夹中的文件信息（文件、目录）

3、路径的计算
./ 当前目录
…/ 上级目录
/ 根目录

4:文件中的 路径概念
路径：就是文件或文件夹所在的位置。
路径分隔符：上下级文件夹之间使用分隔符分开
a.
b.
c.
绝对路径与相对路径：
a.
b.
c.
d.

作业：写病毒:熊猫烧香

2018.8.7 第十二天 周二 下午

多线程、进程与线程、创建线程、声明周期
1、概念
进程：应用程序的运行实例，是资源分配调度的基本单位。
线程：进程中的执行单位，是cup时间片的调度使用单位。
多线程：在同一时间执行多个任务的功能，即多线程
时间片：即对CPU资源按时间切片，每个线程轮流执行。

2、进程与线程间关系：
进程是操作系统分配资源的最小单元，线程是操作系统调度的最小单元。
线程是进程的组成部分，一个进程拥有1-N个线程，至少一个线程。
倒戈线程可以并发同步执行。

3、多线程的优缺点
优势：
1、可以同时完成多个任务，提高CPU利用率
2、多任务并发执行，速度更快
3、可以随时停止任务，并设置任务优先级以优化程序性能
缺点：
1、多线程间存在着竞争资源，比如文件、表中的一行数据、内存空间，
对资源的并发访问可能造成程序紊乱。（应对共享资源访问应进行同步或控制）
2、特殊情况下，程序的整体运行速度会减慢
3、代码复杂度较高

3、多线程在Java中的两种实现手段
1、继承Java.lang.Thread类，并重写run()方法
class TestThread extends Thread｛
public void run(){
//覆盖该方法
}
｝
2、实现Java.lang.Runnable接口，并实现run()方法
class TestRunnable immplements Runnable｛
public void run(){
//覆盖该方法
}
｝

4、创建并启动线程：新键的线程不会自动运行，必须通过start()方法来启动
1、启动继承Thread的线程：
TestRunnable t = new TestRunnable();
t.start();
2、启动实现Runnable接口的线程
TestRunnable tr = new TestRunnable();
Thread r = new Thread(tr);
r.start();

5、Thread类的主要方法：
static Thread currentThread() 得到当前线程
final String getName() 返回线程的名称
final void setName(String name) 设置线程的名称
int getPriority()、setPriotity() 更改线程的优先级
void start() 调用run()方法启动线程，开始线程的执行
boolean isAlive() 测试线程是否处于活动状态
void join() 等待该线程终止。（强行介入）
static void sleep(long millis) 使当前正在执行的线程休眠（暂停执行）
static void yield() 让出时间片
void run() 线程代码（不能主动调用）

6、如要多线程间的协调，控制，就需要更多的线程方法
Thread.currentThread();

7、线程的声明周期如图
1、初级版本
2、强化版本

8、线程优先级：
线程优先级：
1、多个线程处于可运行状态时，将对cpu时间片进行竞争，优先级高的，获取的可能性则高
2、线程优先级有1-10表示，1的优先级最高，默认值是5或继承其父线程优先级
更改优先级：
setPriority(int grade)方法：
相关静态整形 常量：
Thread.MIN_PRIORITY=1
Thread.Max_PRIORITY=10
Thread.NORM_PRIORITY=5

9、线程调度的方法
join()方法 tempjt.join(); 等待该线程终止。（强行介入），强行别的线程终止等待
sleep()方法 tempjt.sleep()； 该线程睡一会儿
yield()方法 Thread.yield(); 在线程内调用，当线程停止运行后，可以继续和别的进程竞争cpu资源

*****************************************8
线程同步、同步块、同步方法
1、线程同步
当多个线程，都在操作同一个共同资源时，就会出现资源竞争问题。
就要给统统资源加把锁（代码锁）

当两个或两个以上线程访问同一资源时，需要某种方式来确保资源在某一时刻只被一个线程使用

解决方案：
	同步块
		在类下定义一把锁标记：  static Object lock = new Object();
		对操作公共资源的代码，添加同步块：synchronized(lock){// 同步块代码  }
	同步方法
		访问修饰符synchronized返回类型 方法名{}
		可以把操作公共资源的代码，封装成一个方法，为该方法添加synchronized，其方法一次只能有一个线程进入执行

2、总结：
线程同步的好处
解决了线程安全问题、对公共资源的使用有序化
线程同步的缺点
性能下降
会带来死锁
线程同步的注意点：
同步代码块的锁对象，同步方法都要求是唯一的。
一般都使用static来修饰，当然也可不使用static。
核心要求是同步代码块的锁对象，同步方法是唯一的。
所有的非静态同步方法用的都是同一把锁—实例对象本身。

3、死锁问题
当两个线程相互等待对方释放“锁”时，将会发生死锁。

1、XML技术 可扩展标记语言（Extensible Markup Language）
一种有格式的文本文件或字符串。（使用IO文件流也能读写，但有格式要求，所以使用IO较复杂）

认识xml格式：
	两部分构成：
		XML 声明--定义 XML 版本和编码信息
		  <?xml version="1.0" encoding="UTF-8"?>
		XML体：
		  元素--由开始标签、元素内容和结束标签组成

HTML语言 及派生自XML

XML格式规则：
1、必须有xml声明语句
2、必须有且仅有一个元素
3、标签大小写敏感
4、属性值用双引号包裹
5、标签成对
6、元素正确嵌套


XML的优势与作用：
	XML基于文本格式，具有简单性、可扩展性、交互性和灵活性等优点。
	
	主要应用场景（作用）：
		数据持久化			当需要将数据存储起来时，可使用
		数据交换				A系统向B系统传递数据。
		参数配置				存储软件的配置信息片段（小）

业界最通用的两种格式：XML、JSON

完成学生成绩信息的序列化：反序列化


xml注释：
	<!-- 注释内容 -->

2、DOM4J：
一款优秀的XML JavaAPI，具有性能优异、功能强大、简单易用的特点，性能超越官方的DOM操作技术，
同时它也是一个开源软件，Hibernate框架使用其解析配置文件（XML）。

DOM4J开发步骤：
	1、导入jar包、add to build path
	2、编写代码、实现功能

dom4j存储xml时需要考滤的问题：
将文档写入XML文件：
	OutputFormat format=OutputFormat.createPrettyPrint();
	format.setEncoding("GBK"); //指定XML编码
		
		//字节流输出
		FileOutputStream outputStream = new FileOutputStream(xmlFile);
			XMLWriter writer=new XMLWriter(outputStream ,format);
		
		//字符流输出
		//FileWriter fileWriter = new FileWriter(xmlFile);
		//XMLWriter writer=new XMLWriter(fileWriter, format);
		writer.write(document);
		writer.close();

存节点构成
节点格式


uuid?

xml格式校验技术
1、DTD
2、Schema

Struts框架（xml配置）
Spring(application.xml)

下午
枚举、可变参数、静态导入、

枚举（enum)

1、枚举类型，关键字enum:jdk1.5以上
枚举enum本质上为一个类，即具备典型的class，interface特性，但又有所限制。
枚举enum被设计用来代表一类事物，可使代码具备更好的编码特性。

2、枚举设计目标：
规范化编程，限制变量值的选择，减少代码错误。
拓展性变成后，可使枚举常量有意义(需自我实现)

3、枚举语法规则：
枚举常量没有任何修饰符
各常量以",“逗号分隔，以”;"分号结束整个枚举常量定义（可省略）

4、枚举定义：
public enum 枚举名称｛
枚举常量1，枚举常量2，枚举常量3，；
｝

5、常量与枚举的应用对比：
public static final String RED = 1;
public static final String WHITE = 2;

public enum Color{Red,While,Blue}


枚举可一定程度上替代常量的作用

6、枚举拓展
枚举的应用增强（具备储值能力）
public enum Color{
Red,Blue,While,;
static String getColor(Color color){
String value = “” ;
switch(color){
case Red:
value = “红”;break;……
}
}
return value;
}

7、总结：枚举特性
枚举通常可用于完成类似常量的功能，但可有效规范化值选择，进而提高代码质量。

1、可变参数：
规则
1、优先匹配固定参数的方法
2、方法定义存在二意性
3、一个方法只能拥有一个可变长参数，且可变长参数必须是最后一个参数

1、静态导入
import static
使用静态成员（方法和变量）必须给出提供这个方法的类。使用静态导入可以使被导入类的所有静态变量和静态方法在当前类直接可见，使用这些静态成员无无需再给出他们的类名。

import static java.lang.System.out;

public class HelloWorld{
public static void main(String[] args){
out.print(“Hello World!”);
}
}

1、Properties文件：
有格式的文本文件，经常用来作配置文件格式。（通用性不高，没有层级关系）
key=value

注：yml文件（有层级关系）

2、Properties类
Properties类是HashTable类的子类，间接实现自Map接口，封装于java.util包中。
日常开发中，常使用Properties类对属性文件进行读写操作。

void load(InputStream inStream)		加载文件
Object setProperty(String key,String value)	写入数据
getProperty(String key)		读取数据
getProperty(String key,String defaluValue)	读取数据，如key不存在，则返回默认值
void store(OutputStream out,String comments)	回写文件（保存）

3、字节流、字符流写入properties

File file = new File("./src/config.properties");
if (!file.exists()) {
file.createNewFile();
}
//数入流
InputStream inputstream = new FileInputStream(file);

	Properties properties = new Properties();
	properties.load(inputstream);  									//加载文件
	
	System.out.println(properties.getProperty("千山万水总是情3"));
	
	/*//写入（修改）
	properties.setProperty("千山万水总是情1", "毛毛爱你行不行");

File file = new File("./src/configFile.properties");
if (!file.exists()) {
file.createNewFile();
}
FileReader fileReader = new FileReader(file);
Properties properties = new Properties();
properties.load(fileReader);

	//写入数据
	properties.store(new FileWriter(file), "爱你啊");

4、小结：
Properties类间接的实现了Map接口，但在写入数据时不要使用put和putAll方法，因为这些
方法允许插入任意类型的数据，但属性文件key/value只能接收String类型
主要用于生产配置文件与读取配置文件的信息。Properties要注意的细节：
1、如果配置文件信息一旦使用了中文，那么在使用store方法生成配置文件的时候只能使用字符流解决，如果使用字节流生成配置文件的话，默认使用的是iso8859-1码表进行编码存储，这时候会出现乱码。
2、如果properties中的内容发生了变化，一定要重新使用properties生成配置文件，否则配置文件信息不会发生变化

JVM中的运行参数（系统中的配置文件），也是通过Properties来

获取OS系统变量：
Map<String, String> maps = System.getenv();
for (Map.Entry<String, String> item : maps.entrySet()) {
System.out.println(“key:”+item.getKey()+"\tvalue:"+item.getValue());
}

5、小玩具

6、加载属性文件的三种方式：
方式一:
p.load(Thread.currentThread().getContextClassLoader().getResourceASStream(“HanLP.properties”));
Webapp/WEB-INF/lib
Webapp/WEB-INF/class
Appserver/lib
JRE/lib
方式二:
p.load(getServletContext().getResourceAsStream("/WEB-INF/filename.properties"));
方式三:
properties.load(new FileInpultStream("/absoulte/path/to/filename.properties"));

1、正则表达式

2018.8.14 第十六天 周二 上午

正则表达式
数据抓去

正则表达式 字符规则：

String(少量方法支持)、Pattern类(提供正则支持)

汉字的边界：[\u4e00-\u9fa5]

正则表达式三个模式:规则
Greedy数量词"贪婪模式"(默认模式)
匹配器第一次匹配时，即读入整个字符串，如匹配失败，则

Reluctant数量词"勉强模式"?

Possessive数量词"独占模式"+

正则分组：
正则表达式，可使用()进行分组，分组匹配后，可以按组的方式来访问匹配信息，进而完成按钮提取、按组替换…等操作
语法规则：
():分组
$n:按分组序号提取匹配字符串，起始为1

非捕获组：
（？=where）
以（？）开头的组是纯的非捕获组，它不捕获文本，也不针对组合进行计数。非捕获组可有效提高效率。

使用序号，可提取分组内容

下午：
数据抓取
网络爬虫又称网页蜘蛛，又称spider:
是一种按照一定规则编写的软件应用，可自动、持续的抓许互联网中的数据信息。
google、百度发家之前，都在抓取

get/post/
response

基于Java的Http数据获取方法一（java api）
HttpURLConnection抽象类
是Java的标准类，封装于java.net包中，HttpURLConnetcion继承自
URLConnection抽象类，可用于向指定网站发送GET、POST请求，并获取响应数据。

主要方法：
int getResponseCode() 获取服务器的响应代码
String getResponseMessage() 获取服务器的响应消息
void setRequestMethod(String method)设置发送请求的方式

注：一般情况下，只处理简单的数据获取，HttpURLConnection已可以满足需求但如要同时获取更多信息，如Session、Cookie等信息，则可能导致编码过于复杂。

Java网络代理配置：
方案一：
System.setProperty("http.proxyHost","10.0.0.1");
System.setProperty("http.proxyPort","8080");
方案二：
InetSocketAddress inetSocketAddress = new InetSocketAddress(host,port);
Proxy proxy = new Proxy(Proxy.Type.HTTP,inetSocketAddress);
URLConnect com = url.openConnection(proxy);

抓取全站的过程分析：（有迭代过程）
1、先抓首页
2、获取首页中的所有超链接地址urls
3、分区urls哪些是站内的
4、对该url再次抓取

基于Java的http数据获取方式二（apache 第三方插件jar包）

HttpClient
HttpClient是Apache下的开源项目，用来提供高效的、最新的 、功能丰富的基于HTTP协议的编程工具包

简单来说，HttpClient就是增强版的HttpURLConnection,HttpURLConnection可以做的事情HttpClient
全部可以做，并封装了更多的方法，来增强功能。

HttpClient主要类：
HttpClient 核心类
HttpGet 请求对象
HttpPost 请求对象
HttpResponse 响应对象
HttpEntity 响应正文结果
HttpUtils 结果分析工具类

2018.8.15 周三 上午
1、SVM、GIT两种工作环境的搭建
2、反射机制

2018.8.15 周三 下午
1、反射机制
2、类加载器

3、循环抓取、抓取文件
https://www.cnblogs.com/
1、抓取列表页
2、分析列表页中的url
3、再依次抓取每页 url
4、抓取下一个列表页

2018.8.16 下午（上午没课） 周四

数据挖掘的项目开发
1、可行性分析
2、需求分析（需求采集、需求分析书）为了签合同
文字、图标（流程图、时序图、用例图其它）
主要作用：与客户交流、法定的依据、报价基础
客户有可能会自己选型
3、概要设计（概要设计书）
技术选型、数据建模
文字、图标（模块图、E-R图、开发计划书、其它）
4、详细设计（详细设计书）
界面制作、代码开发、单元测试
5、项目测试
集成测试、压力测试（项目测试报告）
6、项目发布（用户手册、安装部署手册）

今天任务：
1、完成立项（半小时之内）（大名）项目宗旨
2、开发计划书office project写
尽最大的可能性去挖掘项目功能（每个人员，负责3项需求）
swing
找有意义的行业去挖掘……

3、项目开发
4、最后半天，进行项目PK（奖罚制度，明天班长给）
5、匿名打分小系统打分