第二阶段java源码测试
- 课程内容
a) Javase:java 基础部分
i. Javase
b) Javaee:java高级部分（java企业级技术）
i. Servlet,jsp……
c) 最后会对一个项目进行源码测试（白盒测试）
i. 电商项目
计算机基础知识
- 软件开发：
a) 什么是软件：是由一系列特定顺序组织的计算机数据和指令的集合
i. 软件的组成：
- 程序：用计算机来解决问题的方法和步骤
- 数据：就是程序加工和处理的对象
- 文档：软件在生产过程中所产生一系列图文资料
b) 软件的分类：
i. 系统软件：就是一些操作系统
- Dos（disk operating system），unix，windows，andriod，ios，linux
ii. 支撑软件：支撑一些软件的开发
- C-free，eclipse,oracle,tomcat……
iii. 应用软件：
- Qq，qq影音，亿图……
人机交互方式
- 命令行交互模式：就是一行一行命令
- 界面交互模式：可以在界面上点的
- 多媒体的交互方式：声音等
- 脑电波交互方式：脑电波等
一些简单的dos命令的使用
- Dir
a) md
b) cd
c) rd
d) cd
e) cd ..
f) cd \
g) cls
h) exit
- 一些快捷键和组合键的使用
a) Tab-制表符
b) Shift-上档键
c) Windows键
d) Ctrl
i. A：全选
ii. C：复制
iii. V：粘贴
iv. X：剪切
v. Z：撤销
vi. S：保存(不离手)
e) Win
i. D：显示桌面
ii. R：打开运行程序
iii. E：打开我的电脑
iv. L：锁屏
f) 一些程序的打开：
i. calc：计算器
ii. mspaint：打开画板
iii. mstsc：打开远程连接
iv. services.msc : 打开windows服务
v. regedit：打开注册表
vi. Winword : 打开word程序
vii. iexplore.exe ： 打开IE浏览器
viii. notepad : 打开记事本
java语言概述
- java语言的发展史
a) 詹姆斯高斯林
b) Java V1.0 1996-01-23发行 (代号Oak)
c) Java V1.5 2004-09-30发行 (代号Tiger)
d) Java V1.6 2006-12-11发行 (代号Mustang)
e) Java V1.7 2011-07-28发行 (代号Dolphin)
f) Java V1.8 2014-03-18发行(代号Spider)
g) Java V1.9 2017-9-21发布
- Java语言的平台
a) 三大体系
i. Javase（java standard edition）
- 是学其他两种的基础
- 可以开发一些桌面应用程序
ii. Javaee (java enterprise edition)
- 可以开发web应用程序，比如百度网站
iii. Javame (java micro edition)
- 可以开发手机端应用程序
- Java语言的特点
a) 面向对象：其实就是将任务分配给对象来做
b) 开源：源代码对外进行开放
c) 跨平台：java程序可以在window,linux，mac操作系统上运行着就实现了跨品台
i. 这个过程依赖与jvm(java virtual machine):java虚拟机
ii. 一次书写，处处运行。
- Jre 和JDK
a) Jre（java runtime enviroment java运行环境）：如果用户只需要运行java程序，只需要安装jre即可。
b) Jdk（java development kit java 开发工具包）：包含了开发人员所需的开发的工具也包含了jre
- Jdk的下载和安装
a) 下载网址：
i. Java.sun.com
ii. www.oracle.com
b) 安装
i. 安装的路径：不要有中文和空格
ii. 配置环境变量：
- 将jdk的安装的根目录复制，比如：D:\ProgramFiles\Java\jdk1.7.0_80
- 打开环境变量
a) 在系统变量里新建一个，变量名为java_home,变量值为刚才复制的地址
b) 将java_home引入到path里
i. 在path的最前面添加一行：%java_home%\bin；
- 验证：打开dos窗口，输入java或者javac 若出现多行即可
- Java的编程工具
a) Notepad:记事本
i. 后缀名隐藏导致的编译失败
ii. 关键字书写错误导致的编译失败
- 因为java程序是严格区分大小写的。
b) Editplus
i. Editplus的一些配置
ii. Javac（编译工具）的配置：
-
iii. Java的配置
-
c) Notepad++\ue
d) 重量级编程工具
i. Eclipse:免费的
ii. Myeclipse：收费的，但是破解工具
iii. Intellij IDEA:收费的
iv. Jbuilder : 收费的
- Java程序的执行过程
a)
b) 首先有javac这个编译工具将.java文件编译成机器可识别的字节码文件，然后用java这个工具启动jvm加载.class文件并执行里面的程序
关键字
- 什么是关键字?
a) 被java语言赋予了特殊含义
b) 所有字母全部小写
c) 在editplus里显示为蓝色字体是关键字
- 但是有两个关键字不去使用
a) goto
b) const
注释
- 单行注释
a) // 注释的内容
- 多行注释
a) / 注释内容 /
- 文档注释
a) /* 注释内容 /
b) 这是java独有的注释
c) 这种注释可以被javadoc所解析，解析的结果就是一套以网页形式的说明文档
i. Javadoc -d [存储的目录名称] [java类]
d) 什么作用?
i. 给其他人帮助阅读的
- 所有的注释jvm是不执行的。
标识符
- 什么是标识符？
a) 就是给java程序中的接口、类、方法、变量等命令的字符序列
- 命名规则
a) 26个英文字母大小写【52个】
b) 数字字符【0~9】
c) $和_
d) 总共64个，之外一律不能用
- 注意事项：
a) 数字不能开头
b) 不能使用java已经定义好的关键字
c) 严格区分大小写
- 变量命名规范
a) 若变量是一个单词组成时，所有字母全部小写
b) 若多个单词组成，首个单词全部小写，后面每个单词首字母大写。
c) 驼峰命名法
- 乱码
a) 产生的原因：保存的编码集与打开的编码集不一致导致乱码
b) 解决：将打开的编码集与保存的编码集一致即可
常量与变量
- 什么是常量
a) 其值不可改变
b) 常量的分类
i. 整型常量：15 2 36
ii. 浮点型常量：3.5 3.1415926
iii. 字符常量：‘a’ ‘h’ ‘我’
- 单引号引起来
iv. 布尔常量：true false(布尔常量只有这两个)
v. 字符串常量：”jason” “杨占孟” “a”
- 双引号引起来的
- 变量：可以改变的量
- 转义字符“\”
a) “\n”:换行
b) “\t”：一个tab键，四个空格
c) “\”：一个双引号
d) “\”：一个斜杠
Java数据类型
- 基本数据类型
a) 数值类型
i. 整型类型
- Byte,short,int,long
- 1byte = 8bit
- 1short = 16bit
- 1int = 32 bit
- 1long = 64bit
ii. 浮点类型
- Float
- double
b) 字符类型
i. char
c) 布尔类型
i. Boolean
d) Boolean = 8bit
e) Char = 16bit
f) Float = 32bit
g) Double = 64bit
- 引用数据类型
a) 类：class
b) 接口：interface
c) 数组：[ ]
- “+”号的两种用法
a) 作为加法运算：System.out.println(5 + 6);//结果是11
i.
b) 作为连接符连接前后：System.out.println(“jason” + 6); // 结果是jason6
i.
数据类型转换
- 隐式转换
a) 其实就是编译器做的一系列类型转换：就是将表示空间低的向空间高的转换
b)
- 强制类型转换
a) 就是编译器不确定你是否要转换，所以会报一个可能会损失精度错误。
b) 如果非要赋值给一个低位变量可以强制类型转换
i.
c) 在结果前面加（[要转换的类型]）
- += 与展开的区别
a)
进制
- 有哪些进制？
a) 二进制
i. 只有1或者0组成，逢2进1.
ii. 表现形式：0b
iii. 比如：0b010101
b) 八进制
i. 0~7,逢8进1
ii. 表现形式：0开头
iii. 比如：04532
c) 十进制
d) 十六进制
i. 0~9 ,a~f，逢16 进1
ii. 表现形式：0x
iii. 比如：0xd42c
- 进制之间的转换
a) 比如将二进制转换为八进制
i. 先转换为十进制，然后在转换为八进制
ii. 比如将0b010111转换为八进制
原码、反码、补码
- 正数
a) 对于正数而言，它的原码、反码、补码都是一样的。
- 负数
a) 对于负数而言，它的补码就是在原码的基础上取反（不包括符号位）加1
- 练习
a)
5:
0000 0101 首个0是符号位
0000 0101
0000 0101
-5：
1000 0101
1111 1010
1111 1011
运算符
- 算术运算符
a) + - * / % ++ --
b)
c)
- 逻辑运算符
a) 与：&非短路与，&&短路与
b)
c) 对于这两种运算符，我们一般都用短路的。因为效率高。
d) 非运算符：！
i. 对于运算结果为布尔类型的进行取反运算。
ii. 比如：System.out.println(!(4>5));这个结果就是true.
- 关系运算符
a) > < >= <= == !=
b)
c) 比较等于用==，一个=表示赋值的意思。
- 位运算符
a) &(与) |（或） ^（异或） ~（按位取反）
b) &：
i. 运算规则：同一为1，其他为0
c) |
i. 运算规则：见1为1，其他为0.
d) ^
i. 运算规则：相同为0，不同为1.
e) 按位取反
i. 对一个数的补码进行按位取反
ii.
f) 小插曲：
i. 位移运算符
- 右移、左移
- 右移：>>
a) 其实就是对数据的补码进行右移
i. 正数：对于正数右移左边空缺位补0
ii. 负数：对于负数右移后左边空缺位补1
iii.
b) 无符号右移：>>>
i. 不管正数还是负数：右移一律补0
ii.
- 左移：<<
a) 对于正数和负数，空缺为全部补0
- 三元运算符
a) 格式： (条件表达式)？(表达式1)：(表达式2);
b)
c) 三个数求最大值：
i.
数据的录入
- 第一步：先导包用import关键字来导入所需要的包
a) import java.util.Scanner;
b) 创建数据录入对象：Scanner sc = new Scanner(System.in);
c) 调用相对应的方法来输入
i. Int num = Sc.nextInt();
d)
- 三个数求最大值，最小值，中间值
a)
b)
-
程序的流程
- 顺序结构
- 选择结构
a) 单分支
i.
b) 双分支
i.
c) 多分支：
i. 格式：if …… else if ……else if …nnnnnn ……else
ii.
iii. Switch ……case
- 相对于if …else 来说只能匹配具体的某几个数值
-
iv. 注意
- 这里的break的作用是跳出swtich…case语句ss
- Switch 能接受的几种数据类型
a) 整型（byte short int long） String char
- 循环结构
a) While
i. 当型循环
- 格式：while(//条件){ // 循环体 }
-
-
ii. 直到型循环
- 格式：do{ //循环体 }while(//条件);
-
b) for
i. 次数型循环：可以规定一些循环次数
ii. 格式：for ( //变量的定义和初始化 ;//条件表达式 ; 变量的自增和自减 ){ //循环体 }
iii. 打印等腰三角形
-
c) 猜字游戏：
i.
方法
- 什么是方法
1). 是一个代码块，有固定的组织规则，实际上描述的是 一个行为、一种功能，提高代码块的复用性，其决定了一 个对象能够接收什么样的消息做出什么样的反应.
- 格式
修饰符 返回值类型 方法的名称（【参数序列】）{
//具体的程序
return [数据];
}
修饰符：private ，默认，protected ，public
返回值类型：void 或者 11种类型
方法的名称的命名规范：一个单词组成全部小写，多个单词组成第二个单词开始首字母大写（驼峰命名法）
参数序列：可以传入多个参数。格式：数据类型 【标识符】
- 方法的重载关系
a) 什么是方法的重载？
i. 方法的名称一样
ii. 但是方法的参数列表不一样，像这样的方法之间的关系叫重载关系
iii. 参数列表的不一样指的是：
- 类型不一样
- 类型的位置不一样
- 参数的个数不一样
iv. 始终与返回值类型无关
v. 始终在一个类的的方法之间才有这种关系
b)
数组（very important）
- 什么是数组？
a) 简单来讲就是存储数据的一种容器
b) 特点：只能存储同种类型的数据
c) 存储类型：11种数据类型
- 一维数组
a) 申明的格式
i. 数据类型 [ ] 数组名称 = new 数据类型[ 数组的长度 ];
ii.
b) 特点
i. 只能存储某一类型的数据
ii. 数组里的元素有序，依赖与索引或者说角标来确定数组的某一个空间的
c) 数组的默认初始化
i. 对于byte,short,int,long数组：默认初始化为0
ii. 对于char数组,默认初始化为\u0000(空字符)
iii. 对于boolean数组，默认初始化为false
iv. 对于float ，double ，默认初始化为0.0
d) 数组角标越界异常：ArrayIndexOutOfBoundsException
e) 数组的申明
i. 动态
- int[] arr = new int[9];
ii. 静态
- int[] arr1 = {
1,3,5,5,5,56,4,4
};
- int[] arr2 = new int[ ]{
5,3,6,9,5,4
};
f) jvm的内存的结构：
i. 堆
ii. 栈
iii. 方法区
iv. 本地方法区
v. 寄存器
g) 数组在内存里的变化
i.
ii. 首先在栈里会申明一个int类型的引用arr1,然后通过new关键字在堆内存中会真正创建一个实体对象，然后系统会经过一系列的默认初始化，最后会分配一个十六进制的地址，通过“=” 号将堆内存中的地址赋值给栈里的引用，此时栈里的引用就指向堆里的实体对象。
iii. 空指针异常：NullPointerException
- 引发的原因：栈里引用不指向堆里的对象，若强制操作会引发该异常。
iv. 数组的遍历
-
h) 数组练习的开胃小菜
i.
ii. 数组求和，数组求奇数的和，求偶数的和，将是3的倍数的元素角标打印出来。
-
iii. 数组的翻转
-
iv. 两个一维数组的比较：
-
v. 统计数组里的数字出现的次数
-
- 二维数组
a) 其实就是数组的数组
i. 其实就是高维数组里存的是低维数组里的地址（十六进制）
b) 二维数组的申明格式：
i. Int[ ][ ] arr
ii. Int[ ] arr[ ]
iii. Int arr[ ][ ]
c)
d) 二维数组的遍历
i.
e) 二维数组的小练习：统计城市人口
面向对象
- 什么是面向对象？
a) 其实就是一种思想，同时又是一种技术 ，用客观 的自然语言描述现实世界，使分析、设 计和实现系统的方 法同认识客观世界的过程尽可 能一致。
- 面向对象的有点
a) 更符合人们的思考习惯
- 作为开发语言，提供一阵套解决方案
a) OOA：面向对象分析
b) OOD：面向对象设计
c) OOP：面向对象编程
- 面向对象的特点：
a) 抽象性：就是对现实的实体的抽象
b) 继承性：提高代码的复用性，和可扩展性
c) 封装性：提高了代码的安全性
d) 多态性：基于继承
类与对象
- 类
a) 什么是类？
i. 是构造对象的模板或者蓝图或者说图纸，其实就是某一个具体事务的抽象，决定了构造后对象的行为和属性
b) 类的申明格式
i. 用class关键字类申明这是一个类
- class [类名称]{
//封装的代码
}
ii. 类里可以写哪些内容？
- 属性：成员变量
- 行为：成员方法
iii. 对象的创建
- 通过new关键字来真正的创建实体对象：这个对象在内存空间的堆内存中
-
iv. 对象的内存演示
-
- 过程：
a) 在栈内存中申明了一个car类型bm引用（null），等号的右边通过new关键字在堆内存真正创建了一片空间（属性），并且会对属性进行系统的默认初始化。然后系统会给该对象分配一个十六进制的地址，然后通过“=”号将地址赋值给栈里bm引用。此时bm引用就指向堆里的实体对象
v. 练习：
-
vi. 成员变量和局部变量
- 成员变量：作用在整个类中
- 局部变量：作用在方法内
- 变长参数
a) 可以变化的接受传入的参数
b) 格式：参数类型… 参数名称
c) 原理：将传入的参数分割开来并放到数组里传进来
i.
d) 注意
i. 一个方法只能有一个变长参数。
ii. 一个方法如果不仅有变长参数还有其他，变长参数必须放在最后面
封装
- 将类的内部属性或者方法用private 关键字进行修饰
- 是面向对象的重要特性，是指隐藏类的实现细节，仅仅对外公共访问接口
a)
- 怎么做的？
a) 将属性用private关键字进行修饰
b) 然后对外提供一个get/set方法，在让外界间接的访问内部属性
- 好处：
a) 防止误操作
b) 降低各个子系统的、模块、组件之间的耦合性
c) 方便给使用进行使用
- 封装的原则
a) 将要封装的属性隐藏起来
b) 然后对外提供公共访问接口
构造方法
- 什么是构造方法？
a) 方法名称与类名一样，并且没有返回值
b) 作用：用来初始化对象的，避免了调用setxxx方法的麻烦
c)
- 注意事项:
a) 若不写任何构造方法，那么系统会自动提供一个无参构造方法
i.
b) 若我们手动写了一个或者多个构造方法，那么系统就不会在提供无参的构造方法。
i.
对象的初始化的三种方式
- 拿对象.属性进行赋值
a)
- 用private 将属性进行封装，然后提供公共访问接口公外界访问呢
a)
- 用构造方法的方式进行构造对象
a)
- 一般是第二种和第三种结合在一起使用比较多
a) 提供set/get方法还有构造方法
匿名对象
- 没有名字的对象
a) new Car();
b) 其实在底层指的就是没有引用指向堆里的实体对象
c) 用处：在程序中，若一些方法只需要执行一次，可以用匿名对象的方式来用。
i.
d) 在使用后，因为没有引用指向该对象，所以这个堆内存中的对象就变成了垃圾
i. 然后java有个定时程序,GC垃圾回收器会不定时的来清理垃圾。
This指针
This:是一个指针
- 当方法进栈的时候，都会有一个this（每个方法都有），用于指向当前所属对象
static 关键字
- Static关键字用于数据共享
a) 用static修饰成员变量后就变成了静态变量
b) 用static修饰后的变量可以被所有的实体的对象所共享。
c) 对于静态变量
i. 可以用对象调用
ii. 也可以用类名称直接调用（用类名调用比较多）
d) 对于静态方法
i. 即可以用对象调用也可以用类名调用
ii. 好处：省去创建对象的过程
e) 静态变量和成员变量的区别
i. 静态变量：即可以用对象有可以用类名调用
ii. 成员变量：只能用对象调用
iii. 静态变量是随着类的加载而加载，随着类的释放而释放，与对象的创建无关，但是对象可以用
iv. 成员变量是随着对象的创建而产生，随着对象的清理而消失
f) 注意：static修饰的方法是无法使用this的。
g) 静态方法的用途：
i.
- 静态代码块 , 构造代码块, 构造函数
a)
一些系统类的使用
- System
- Scanner
- Date:java.util包下
a) 第一步导包：Import java.util.Date
b) 第二步创建对象：Date date = new Date();
c) Date 时间日期提取：
i.
- Math
a)
继承
- 什么是继承？
a) 描述的是类与类之间的关系（is-a）,意在表达一个类是另一个类的一种
- 继承的格式
a) 通过extends关键字来申明一个类是另一个类的一种
b) 格式：class [子类的名称] extends [父类的名称]{
//代码
}
c) 好处
i. 提高了代码的复用性
ii. 让类与类之间产生了关系（子类和父类）
d) 子类无法从父类里继承私有成员
- 继承里的注意事项
a) 一个类不能有多个父类（不能有多继承）：因为在调用父类重复的方法时会产生歧义
b) 多层继承：其实就是类一层一层往下继承
c) 继承体系：子类继承父类，父类继承祖类，……这个整个的继承，叫继承体系
继承中的变量和方法的访问特点
- 对子类与父类有相同的变量时，父类的变量就相当于隐藏了。如果非要访问父类的变量，可以用super关键字类访问。（super其实代表就是父类的一片空间，this代表的是本类的空间）
a)
- 构造函数
a) 无论new多少个子类对象，首先要将父类加载并初始化，然后在加载子类并初始化。因为子类构造函数的第一行有个隐藏的super();,其代表的就是父类的构造函数
i. 注意:
ii. Super();可以不写。
iii. 但是如果要写，必须写在第一行。否则报错。
iv.
方法的重写
- 发生在两个类之间（基于继承），覆盖父类的方法。
a) 子类出现与父类一样的方法时，这种操作叫方法的重写。
- 若父类的一些方法随着时间的变化功能落后或者满足不了希需求，就需要子类来继承并重写父类的方法，依靠子类添加一些新的功能
- 子类若想重写父类的方法，则权限必须大于或者等于原来的权限即可
a) 注意：若原来的权限为private,子类如果在写，这不叫重写。因为子类不知道父类原来有那个方法。
b) Private ? 默认 ? protected ? public(从小到大)
- 静态代码块、构造代码块、构造函数在继承中的访问顺序
a)
b)
c)
d) new Zi();
final关键字
- final修饰方法：这是方法就是最终态的方法
a) 不允许被子类重写，或者子类无法重写
i.
- Final修饰变量：
a) 这个变量就变成了常量
i. 常量的命名一定要按照命名的规范来写：
ii. 一个单词组成时，全部大写，多个单词组成时，全部大写并且用下划线连接
iii. final static STUDENT_NUMBER = 9;
b) 后期无法再改变其中的值
- Final修饰类：
a) Final修饰的类子类无法继承
b)
c)
- Final修饰引用
a) 修饰后，无法再为这个引用分配地址
b)
c)
抽象类
- 被abstract关键字修饰的类叫抽象类
- 一般来讲，子类的共有的属性可以继续往上抽取，形成一个父类。但是发现子类也有一些共有的方法可以往上抽取，但是思考，在向上抽取的过程中，发现每一个子类的实现各不相同，因此在子类向上抽取的过程将，方法体省略掉，让后用分号代替，然后再用abstract关键字修饰即可。那么称为这个方法就是一个抽象方法。还需要用abstract关键字来修饰这个类，这个类就叫做抽象类。
a)
- Abstract抽象
a) Abstract 修饰方法：抽象方法
b) Abstract 修饰类：抽象类
c) Abstract 无法修饰变量或者常量。
- Abstract类的特点：
a) 若子类想创建对象则，必须要完全实现父类的抽象方法。
b) 若子类没有实现抽象方法，那么这个子类也必须成为抽象类。
c) 抽象类无法完成实例化（无法创建对象）
- 抽象类与普通类的区别
a) 普通类可以创建对象可以实例化
i. 抽象类不能创建对象。
b) 普通类足够的信息来描述一类事物
i. 抽象类就没有足够的信息来描述一类事物
c) 普通类不能写抽象方法
i. 抽象类可以没有抽象方法（那么这个抽象类的作用就是避免该类的实例化）
- Abstract 不能与其他哪些关键共存
a) final
b) static
c) privat
接口
- 什么是接口？
a) 其实就是规范的更加的明显体现，就是抽象类的更加抽象
- 格式：用interface关键字来申明这是一个接口
a) Interface 【接口的名称】{
//常量和抽象方法
}
b) 在接口里只允许存在常量，若只写变量的形式，那么依然是常量，因为系统会自动加public static final 前缀，因此依然是个常量
c) 对于方法而言，若只写方法的申明格式，那么依然是个抽象方法，因为系统会自动加public abstract前缀，因此依然是个抽象方法。
- 接口不能创建对象：
- 接口的实现特点：
a) 若子类没有完全实现接口里抽象方法，则这个类依然是一个抽象类
b) 若子类想创建对象，则必须实现接口里的全部抽象方法。
c) 一个类是存在实现多个接口的关系的
i.
d) 多实现就解决了多继承问题
i.
e) 类，接口之间是什么关系
i. 类与类
- 继承关系(extends)，只允许单继承，不允许有多继承
ii. 类与接口
- 实现关系（implements）,可以有多实现，也可以有单实现
iii. 接口与接口
- 继承关系，可以有多继承关系
f) 抽象类与接口的区别
i. 成员变量：抽象类即可以有常量也可以有变量，接口只能有常量
ii. 构造方法：抽象类可以有构造方法，接口没有构造方法
iii. 成员方法：抽象类即可以有非抽象方法，也可以有抽象方法，而接口只能有抽象方法。
多态
- 一种事物多种形态
a)
- 本质
a) 父类类型的引用指向子类的实体对象
- 前提
a) 基于继承
- 多态的好处
a) 前期的代码依然可以后期新增的内容
-
弊端：无法调用子类自己独有的方法
比如：Animal cat = new Cat();
但是这个cat就无法调用自己特有的方法了catchMouse();
因此我们需要引入强制类型转换，将类型向下转换才能调用特有方法
Cat cat1 = (Cat)cat;
cat1.catchMouse();
- 类型转换
a) 自动类型提升
i. Animal cat = new Cat();
ii. 系统会将cat的类型自动提升为Animal
b) 强制类型转换（向下转换）
i. 如果想让这个引用调用子类特有的方法，则必须要转换
ii. Cat cat1 = (Cat)cat();
iii. int l = (int)3.14;
iv. 将Animal类型的cat转换为为Cat类型，这个时候就可以调用自己特有的方法了。
v. 注意：
- 向下类型转换只能转换为原来的类型，不能转换为其他的类型，否则会出现异常:ClassCastException(类型转换异常)
-
- Instanceof关键字
a) 专门用来进行类型判断
b) 格式:<引用> instanceof <要判断的类型>
c) 返回值类型为boolean
d)
e) 一些基本数据类型对应的封装类
i.
- 多态的一些成员的访问特点
a) 变量
i. 编译和运行都取父类的
ii. 编译和运行都看左边
b) 成员方法
i. 编译看左边，运行看右边
c) 静态方法
i. 编译和运行都看左边
ii.
多态与接口的使用：
Package
- 就是将类进行管理，避免凌乱
- 格式：package 路径;
a) 路径的规范：一般是网址的倒过来
b) 比如www.baidu.com,那么package com.baidu.user;
c) 注意事项：
i. Package语句必须方法在文件的第一行
ii. 并且每个文件只能有一个package语句
Import 导包
- 格式：import <类的路径>;
- 注意
a) Import放在package和class之间
b) Import 语句可以写多个。可以导多个类进来
- 特殊的格式
a) 全部导包：import java.util.*;将java.util包下的所有类全部导进来。
b) 静态导包：import static com.baidu.user.Person.show;将Person类里的show静态导入，这是jdk1.5后的新特性
c)
d)
Jar包
- 打包
a) class ? jar包
b) jar -cvf 【目标.jar】 【包路径】
- 解包
a) Jar –> 解压出来
b) Jar -xvf 【要解压.jar】
jar,war,ear
- package
- import
- class
a) Package :一个类文件只允许有一个该语句，并在文件的第一行。
b) Import在package与class 之间，可以写任意个import语句。
c) Class一个类文件可以写多个。
http 状态码
2:
3:
4:
5:
内部类
-
- 在一个类内部还有一个类，那么B类相对于A类而言，就是一个内部来，A相对B而言就是外部类。
- 分析：
- 内部类的对象的创建
a) 对于普通内部来对象的创建方式
i. 外部类名称.内部类名称 <引用> = new 外部类名称().new 内部类名称();
b) 对于静态内部类的对象创建方式
i. 外部类名称.内部类名称 <引用> = new 外部类.内部类名称();
ii.
- 内部类与外部类成员访问特点
a) 内部类可以访问外部类的所有成员，包括私有成员
-
- 若内部类有成员是静态的，那么这个内部类也必须是静态的
a)
对象创建的设计模式
- 懒汉式和饿汉式
a)
Object类
- 什么是Object?
? 在java里默认是所有类的父类。，是所有类继续向上抽取的结果
? Object是所有的类的基类，父类，超类。Object是上帝。
- 子类与Object的关系
? 子类要么是直接要么是间接的成为Object的子类。
?
? toString方法
- 若直接打印对象，子类没有重写toString，则会调用Object类的toString方法，但是这种打印的内容是：getClass().getName() + ”@” + Integer.toHexString(hasCode());
- 因为这种打印基本上没有重要性可言，所有若子类想打印一些类的基本信息，可重写toString方法
- 一般重写的内容为：类名 + 属性名和值
a)
? equals方法
- 若子类调用equals 方法，则是直接调用的是父类的equals方法，这种比较是比较两个对象的地址是否一样。因此没有太大意义
- 子类重写equals方法
a) 意义在于子类可以实现自己的比较的方式
b)
String 类
a) String类内存机制
a) 当第二次创建对象的时候，先到常量池（字符串的缓冲区）里去看有没有该对象，若有就直接将引用指向他即可，没有则创建。
b) String类重写了Object类的equals方法
i. 因此若想比较两个字符串数据，调用equals即可，因为String重写Object的equals方法。
ii.
b) String 创建对象的第二种方式
a)
String 类的一些构造方法的使用
一些成员方法的使用
UUID类
随机生成的一个36位字母和数字随机组合的一个UUID对象
用途：可以用于标识人的唯一号或者其他需要唯一标识的数据。
异常
- 什么是异常
a) 程序在执行的过程中，出现不正常的情况，就叫异常
- 异常类
a) 封装了异常信息的类叫异常类
b) Exception和error(异常和错误)
i. Exception是Throwable的子类
- Exception我们可以解决的
ii. Error是Throwable的子类
- Error问题一般是解决不了的
iii.
c) 异常的调用栈
i.
ii. 异常的处理：
- 第一种方式：
a) 通过throws 关键字对外申明我有可能抛异常，让调用者知道我在处理的过程中有可能抛异常。
iii. 手动抛出异常
- 通过throw关键字手动抛出
- 格式:Throw new <异常类>；
iv. Throws与throw的区别
- Throws是写在方法后面
a) Throw是写在方法体里
- 抛出的异常没人解决
- Throw 会真正抛出个异常出去
- Throws 只是申明有可能抛出异常
v. 第二种异常处理方式
- Try{ //要监控的代码 } catch( //匹配的异常 ){ //异常的处理的代码 }
-
- Try和Throws
a) Try是可以解决这个异常的。
b) Throws没有解决这个异常
- 注意：
a) try与catch代码块之间不能有其他代码块
i.
b) 一个try代码块可以有多个catch代码块
c) Finally代码块里面写系统关闭等资源的重要代码：与try一样只能有一个，在catch里结束的时候，先到finally把代码执行完才执行结束代码
i.
vi. 对于出现的异常有两种处理方式
- 继续向外申明异常，让外界知道我也有可能出现异常
- 中途自己用try catch代码将异常拦截并解决。
- 自定义异常类
a) 直接或者间接成为异常体系的中的一员。
b) 这个时候我们自定义的异常类才具有可抛性。
c) 格式就是继承Exception
d) 重载构造方法
e)
IO流
- 什么是IO(input,Output)流？
a) 是两个设备之间的数据的写入和写出，这种过程叫做IO流。
b) 内存 硬盘
c)
d) 流的分类
i. 按照流的方向来分
- 输入流Input
- 输出流Output
ii. 按照流的类型来分
- 字节流
- 字符流
-
e) 字符流
i. 文本里写入内容
- 第一步：创建文件的写入对象并指定要写入的文件
- 第二步：调用写入方法往文件里写入数据
- 第三步：关闭写入资源
-
ii. 文本的读取
- 第一步：创建文件读取对象并指定要读取文件
- 第二步：调用文件的读取方法来读取文件
- 关闭文件读取资源
-
iii. 练习：文件的拷贝
-
f) 总结：
i. 适用于操作一些纯文本数据
- 字节流
a) 计算机上的一切数据都可以用字节流来操作
b)
多线程
- 什么是进程？
a) 正在进行的程序叫做进程。
- 何为线程？
a) 是进程里的一个执行路径或者执行单元，比如电脑管家里的垃圾清理就是属于电脑管家里的一个子线程
b) 一个进程里至少要有一个线程
- 软件开多了，电脑会卡
a) 线程一多，cpu处理某个线程的频率就降低。
b) 买多核电脑
- 多线程的实现
a) 第一步：让类称为Thread的子类
b) 第二步：重写run方法。
c) 第三步：启动这个线程 start();
d)
e)
- Thread类的一些方法的使用
a)
- 实现线程的第二种方式
a) 第一步：子类来实现Runnable接口
b) 第二步：实现run方法。
c) 第三步：创建Thread对象并将子类的实例当做参数传入
d) 第四步：通过Thread对象的start方法来创建并启动该线程
e)
f)
线程的状态
-
线程的安全性问题
- Synchronized 同步
- 把共享的数据用synchronized关键字来封锁上
? 解决思路：就是将多条操作共享数据的线程代码封装起来，当有线程在执行这些代码的时候，其他线程就不能参与运算了（因为其他线程会判断这个锁是否被拿走了）。
- 那么这个时候只有当前线程执行完后，其他线程才能继续进来执行
? 将要同步的代码用synchronized关键字来锁定
? 引用格式：
synchronized(对象){
//需要被同步的代码块
}
? synchronized 还可以修饰方法，那么这个方法就叫做同步函数或者同步方法。
?
多线程的练习
- 生产者和消费者实例
a)
- 消费者javabean
a)
- 生产者javabean
a)
- 面包javabean
a)
- 面包测试类
a)
- 同步的好处与弊端
a) 好处：解决了线程的安全性问题
b) 弊端：其他线程会对当前的锁进行无限判断，所以可能会造成执行效率上的问题
- 同步的前提
a) 必须多个线程使用的是同一把锁
集合框架
- 什么是集合？
a) 也是一种容器，来存储数据。
- 为什么要用集合？。
a) 数组在申明的时候长度就已经固定了，如果想添加一个，不行了。
b) 集合代替数组
c) 与数组区别：
i. 数组长度固定
- 集合长度可以变化的
ii. 数组能存11种数据类型（基本数据类型，引用数据类型）
- 集合只能存储引用数据类型
- ArrayList的使用
a) 其实这种集合就可以当做可变长度的数组用即可
b) 在java.util包下
c) 自动拆装箱机制
i.
d) 集合的一些方法的使用
e)
f) 集合的遍历方式
i.
ii.
iii.
泛型
- 广泛的类型
- 格式:<T>
a) 为什么要引入泛型
i. 在引入泛型之前，集合可以存储任意类型的数据，这后期在强制类型转换的时候有可能报ClassCastException异常，每次都需要进行强制类型转换，太麻烦，所以引入泛型。就规定集合在创建的时候就必须存储某一种类型。即动态的绑定传入的类型。
- 泛型修饰方法
a)
- 泛型修饰类
a)
b) 注意：泛型不能修饰变量
- 泛型解决问题
a) 解决了数据存储的安全性问题
b) 避免了强制类型转换的麻烦
小练习：申明一个集合，申明这个集合只能存储Person类型的对象，然后用迭代器方法遍历
Map映射集合
- 为什么要使用map集合？
a) 因为list可以存储重复的元素
b) 但是map不可以
- Map的格式
a) 是一种以“键--值”对的形式来存储数据。
b) 010—北京
c) 020—上海
d) 030—深圳
e) 010—广州
f)
g) 一些方法的使用
i.
Map遍历的两种方式
-
-
JDBC
- Jdbc(java database connective java 数据库连接)
a) 其实就是一种规范
- 用jdbc来操作数据库
a) 导包：mysql-connector-java-5.1.7.jar(是对mysql数据库操作的实现类：数据库驱动)
b) 第二步：写数据库的具体实现类
c)
d)
e) 插入数据的乱码问题
i. 在连接的时候指定编码格式：characterEncoding=utf8
ii. 创建数据库的时候就指定编码集为utf8;这样即可解决乱码问题
f) 对于控制台的方法的使用规范
i. 对于数据库的增删改使用：executeUpdate(String sql);
ii. 对于数据库的查询使用：executeQuery(String sql);
g) 不定列遍历
i.
ii.
- Sql注入
- Sql注入的一个解决方法（用预处理控制台）
a)
- JDBCUtils：对外提供两个静态方法
a) Update()对于数据库的增、删、改操作
i. 传入的参数：提供一个sql模本，和要填充的数据，返回值是影响的行数
b) Query(),对于数据库的查询有操作
i. 传入的参数：提供一个sql查询模板，和填充的数据。暂且无返回值
数据库连接池技术
- 数据库连接池参数
a) 初始化池参数：10
b) 最小空闲连接数：5
c) 池增量：3
d) 最大空闲连接数：12
e) 最大连接数：50
f) 最大连接时间：1000
g) 四大参数
i. Mysql驱动类
ii. url地址
iii. 用户名
iv. 密码
- DBCP连接池的使用
a) 导入jar包：
i. Common-dbcp.jar
ii. Common-pool.jar
iii. Mysql-connector-java-5.1.7-bin.jar
b) 创建连接池对象
i.
C3p0连接池
- 导入c3p0连接池jar包
a) C3p0-0.9.2.-per1.jar
b) Mchange-commons-0.2.jar
c) Mysql-connector-java-5.1.7-bin.jar
d) 导入配置文件
i. c3p0-config.xml(必须这么写)
ii. 必须放在src目录下
e) 创建数据库连接池对象
i. ComboPooledDataSource
ii.
iii.
数据库总结
- 导入数据库相关操作jar包
a)
b)
c) 5大结果集处理器
- 总结：
a) 后期若想操作数据库，只需要导入5个jar包
b) C3p0两个
c) Mysql驱动包
d) hkr工具包
e) commons-dbutils
f) 一个配置文件：c3p0-config.xml
g) 注意TxQueryRunner对象即可
软件体系结构
- 常用的软件分类
a) B/S(browser/server)
i. 基于浏览器和服务器端
ii. 弊端：不安全，或者安全性不够高.我们可以通过抓包工具（wireshark和fiddle）来抓取数据包，进行分析里面的数据。因此现在的网站做的好一点的都会对访问的过程进行加密（http://到现在的https://(ssl加密套接字层)）。
b) C/S (client/server)
i. 基于客户端和服务器端
ii. 相比于b/s模式安全性就高了很多。
iii. 缺点：在升级的过程，客户端和服务器端都要升级
Web资源
- 静态资源：浏览器能直接能看懂的
a) html 或者htm
- 动态资源
a) 浏览器无法直接看懂的，jsp,php,asp。若访问动态资源，我们的服务器会将动态资源转换为静态资源然后返回给浏览器。
b)
Web资源的访问
- 打开浏览器：在浏览器的地址栏输入url（统一资源定位器）
- 服务器端
a) Web服务器
i. Tomcat：是apache提供的免费，开源的服务器
ii. JBoss:（red hat组织）支持javaee
- 这几天最热门的新闻之一，就是 Linux龙头厂商 Redhat决定以三亿五千万美金，并购也算是龙头级的自由软件厂商 JBoss。JBoss的 Java应用软件服务器目前可以算是全世界最受欢迎的自由软件之一。包括美国的大陆航空、梦工厂电影公司、法国国税局、西门子等等企业都是它的客户。
-
- 尴尬的是，JBoss现任的老板 Marc Fleury过去批评 Redhat的嘉言录，可能会让他以后在 Redhat的日子不太好过。以下节录其中的几则：
-
- 「Redhat根本是一家只会搞封闭私有技术的厂商。他们用封闭私有的技术，重新包装开放原始码的 Linux，然后靠这个来赚钱。」
-
- 「Redhat只能算是一家包装公司，他们把 Linux用封闭私有的狗屎包装起来。他们对 Linux的发展根本没有贡献。」
-
- 「Redhat根本不愿意把赚到的钱分享给自由软件的发展者，他们把赚到的钱全部占为己有。所以我只好自己出来创立 JBoss这家公司。」
-
- 「Redhat从来没有作过任何创新的事情。它只是一家冒牌的自由软件公司。」
-
- 虽然批评了那么多，相信 Marc Fleury在拿到上亿美金的支票时，应该还是会笑到合不拢嘴，完全忘记自己即将加入这一家冒牌的自由软件公司吧。（个人猜测他应该不会留在 Redhat太久。）
iii. Weblogic：（oracle公司）收费的，支持javaee，使用与大型项目
iv. Websphere:（IBM公司）收费
Tomcat的下载和安装
- 网址：https://tomcat.apache.org
- 配置
i. 新建catalina_home，将复制的路径粘贴进去。
ii. 引到path变量里：%catalina_home%\bin;%catalina_home%\lib;
iii. 用命令安装服务：用管理员权限打开dos窗口,在里面输入service.bat install(将tomcat的服务安装到windows上)
iv. 启动tomcat:在dos窗口输入startup
v. 验证：在浏览器的地址栏里输入:localhost:8080
静态网站
- 在tomcat的webapps目录下新建一个目录。这个目录叫项目目录
- 开发的静态页面全部放在里面
- 修改tomcat的访问端口
a) 在tomcat的conf目录有个server.xml文件
b) 在71行的connector标签有个port属性，可以修改端口
动态网站
a) 在eclipse里创建一个动态网络项目：（dynamic web project）
a) 新建一个dynamic项目，然后点击下一步，下一步，把create web.xml选项勾选上。最后点击finish 。
b) 在eclipse配置tomcat服务器：
i. 在window?preferences—>server—>runtime enviroments--> add tomcat
ii. 选择tomcat的目录即可。最后点击finish。
c) 注意：在web-content目录下有一个WEB-INF目录，外部无法直接访问WEB-INF这个目录的。
- Web请求的访问过程
a)
i. 通过浏览器的地址提交到项目里，tomcat会与web.xml文件进行匹配（通过servlet映射来完成），找到相关处理类来进行java程序处理。
ii. 直接在浏览器输入地址访问和点击超链接访问都是属于get提交方式
iii. 表单：method=”get” ,post
b) 创建一个servlet
i. 在doGet方法内或者doPost方法内写相对应的处理程序
ii. 还需要在web.xml配置文件配置访问的转载
c) 加载tomcat运行库，选中项目，右键configure bulid path ,add library –->server runtime ，选择一个Tomcat然后点击确定。
d) 然后在浏览器访问http://localhost:[端口]/[项目名称]/解析后缀
e) 请求和响应
i. HttpServletRequest request请求：浏览器向服务器请求的内容全部放在这里
ii. httpServletResponse响应：服务器向浏览器返回的数据全部封装在这个响应对象里。
iii. 通过request对象可以将请求的参数取出：getParameter(String params);
iv. 通过response响应体向浏览器里写入数据。
- Response.getWriter().print(“数据”);通过响应对象来得到写入对象来向前端写入数据
v. 如果直接拿response对象往前端写数据会显得非常麻烦。
Jsp（java server page）
i. Sun公司推出jsp1.0技术之前，所有web程序的开发都是用servlet(java+html)来做的。
a) servlet的缺点：html代码与java代码全部参合在一起，导致后期维护非常麻烦。
b) 所以sun公司推出jsp1.0
i. Jsp注重将html和java彻底分离开来
ii. 分离的程度
-
- Jsp ? servlet程序
- Jsp语法
a) 不在用jsp脚本的方式往外输入
b) El(expression languange)表达式：
i. 导入jar包：jstl-1.2.jar
ii. 在jsp文件申明导入标签：<%@ taglib prefix=”c” uri=http://java.sun.com/jsp/jstl/core %>
iii. 后期在前端显示的数据一律用c标签来做
iii. Servlet的方法调用的升级
- 因为前期一个访问就对应一个servlet这样代码可复用行太差
- 让一个servlet可以解决很多个请求
- 解决方法：
a) 提供了一个BaseServlet
b) 我们自己写的servlet继承BaseServlet
c) 提供方法的格式：public String xxxx(){ //程序体 return “页面显示路径;” }
d)
ii. 四个包
a) cn.com.hkr.servlet:处理前端的请求的。初步接触前端
b) cn.com.hkr.service:业务逻辑处理层，主要处理业务逻辑。
c) cn.com.hkr.domain：存放的javabean
d) cn.com.hkr.dao:存放是与数据库打交道的类：用户持久层
iii. 在cn.com.hkr.web.servlet里新建一个servlet用来封装数据
a) 用Commons和hkr的工具来封装的：CommonUtils.toBean(Map map,Class clazz);
Junit
- 什么是单元测试?
a) 用main方法可以吗？
i. 可以。
ii. 不好
iii. 不能一起运行。
iv. 大多数情况下，需要测试员用眼来动态的观察结果，从而判断结果是否正确。
- Junit测试框架
a) 新建junit test case(junit测试用例)
b) 命名：xxx(要测试的类型)Test表示这是一个测试类
i.
断言：
- AssertTrue();
ii. @Test：标识这是一个测试方法
iii. @BeforeClass:标识这个是类加载完成后第一个执行的程序
- 一些对象的初始化
iv. @AfterClass:标识在所有test执行完成后执行的程序
- 一些对象置空，和资源的关闭
- 上述的BeforeClass和AfterClass在类里只执行一次
v. @Before
- 在每个方法执行前执行
vi. @After
- 在每个方法执行之后执行
vii. 执行顺序:@BeforeClass ? @Before ? @Test ?@After ………………… @AfterClass
Junit给我们提供了哪些测试方法
- @Test:测试方法
- @Ignore:忽略测试
- 性能超时测试@Test(timeout=2000)
- 异常测试：@Test（expected=xxxxxxException.class）
- 参数化测试
a) 将类用@RunWith(Parameterized.class)注解
b) 将所有的数据全部先放到一个集合里，每次作为一维数组的形式取出
i. 提供一个方法，返回值是一维数组
ii. ，需要拿@Parameters注解这个方法
c)
- 组合测试
a) 就是将测试类按照各种组合的方式进行测试
b)
白盒的测试方法
- 是否关注程序具体结果的内部实现测试来划分
a) 黑盒
b) 白盒
- 从是否执行角度来看
a) 静态测试
b) 动态测试
- 白盒测试的注重点：
a) 主要测试的是业务逻辑处理层里面的哪些方法
b) 在src新建一个test包专门来装测试类的
c) 写完之后将用例写到一个excel表内
- 判定路径覆盖和边界值测试
a) 边界值测试
i. 比如一个输入框只能输入3位。
ii. 2 3 4
iii. String user = “abc”;
iv. String user = “ab”;
v. String user = “abcd”；
b) If elseif ……………………else
i.
c) 判定路径覆盖测试的原则：设计足够多的测试用例来覆盖这些路径
package cn.com.hkr.test;
import static org.junit.Assert.*;
import org.junit.Test;
import cn.com.hkr.goods.user.domain.User;
import cn.com.hkr.goods.user.service.UserService;
public class UserTest {br/>@Test
public void loginTest(){
/*
- 用户传入用户名密码
- 1、用户名和密码都正确
- 返回的user不为空
- 2、用户名和密码都错、用户名正确密码错误、用户名错误密码正确返回user为空
-
*/
//模拟前端传入的正确的数据
String username = "jason";
String password = "admin";
User foruser = new User();
foruser.setLoginname(username);
foruser.setLoginpass(password);
//将对象传入业务逻辑处理层，然后观察返回的数据是否空即可
UserService service = new UserService();
User user = service.login(foruser);
assertNotNull(user);
}
@Test
public void loginTest1(){
/*
- 用户传入用户名密码
- 1、用户名和密码都正确
- 返回的user不为空
- 2、用户名和密码都错、用户名正确密码错误、用户名错误密码正确返回user为空
-
-
-
*/
//模拟前端传入的正确的数据
String username = "jason";
String password = "root";
User foruser = new User();
foruser.setLoginname(username);
foruser.setLoginpass(password);
//将对象传入业务逻辑处理层，然后观察返回的数据是否空即可
UserService service = new UserService();
User user = service.login(foruser);
assertNull(user);
}
@Test(timeout=2000)
public void run(){
String username = "def";
String password = "def";
User formuser = new User();
formuser.setLoginname(username);
formuser.setLoginpass(password);
UserService service = new UserService();
User login = service.login(formuser);
assertFalse(login.isStatus());
}
}
- 代码覆盖率统计工具（EclEmma）
a) Coverage as运行
b) 红色：后面的代码没有运行完
c) ×××：代码没有运行到
d) 绿色：代码运行过
javaSE笔记
原文：http://blog.51cto.com/lyinginsun/2154808
