JAVA基础篇
1_JAVA语言概述
1.1 JAVA的总体概述
第一部分：编程语言的核心结构
主要知识点：变量、基础语法、分支、循环、数组、流程控制、…
第二部分：JAVA面向对象的核心逻辑
主要知识点：封装、继承、多态、抽象、…
第三部分：JAVA SE 高级部分
主要知识点：集合、泛型、异常、反射、网络编程、I/O、多线程、…
1.2 JAVA语言概述
1.2.1 基础常识
软件：即一系列按照特定顺序组织的计算机数据和指令的集合。分为：系统软件 和 应用软件
系统软件：windows , mac os , linux ,unix,android,ios,…
应用软件：word ,ppt,画图板,…
人机交互方式： 图形化界面 OR 命令行方式
常用的DOS命令：
1.2.2 计算机语言的发展迭代史
1、机器语言
最初的计算机所使用的是由“0”和“1”组成的二进制数，二进制是计算机的语言的基础。计算机发明之初，计算机只能被少部分人使用，人们需要用0、1组成的指令序列交由计算机执行，对于机器语言的使用与普及都是很令人头疼的问题。对于程序的移植能力几乎没有，从而时间成本，人力成本十分昂贵。但机器语言也不是没有优势，由于这种语言是直接对计算机硬件进行操作，所以在特定型号的计算机上面，运算效率也是很高的，机器语言的出现对于未来的计算机语言发展起到了很好的推动作用，所以机器语言也是第一代计算机语言。
2、汇编语言
汇编语言是在机器语言的基础上诞生的一门语言，用一些简洁的英文字母、符号串来替代一个特定的指令的二进制串，这也提高了语言的记忆性和识别性。对于程序的开发与维护起到了积极作用。汇编语言同样也是直接对硬件进行操作，这样依然局限了它的移植性。但是使用汇编语言针对计算机特定硬件而编制的汇编语言程序，对于计算机硬件的功能和特长的发挥已有了很大进步，它精炼而质量高，所以至今仍是一种常用的程序开发语言。
3、高级语言
从最初与计算机交流的痛苦经历中，人们意识到，应该设计一种这样的语言，这种语言接近于数学语言或人的自然语言，同时又不依赖于计算机硬件，编出的程序能在所有机器上通用。经过努力，1954年，第一个完全脱离机器硬件的高级语言—FORTRAN问世了，40多年来，共有几百种高级语言出现，有重要意义的有几十种，影响较大、使用较普遍的有FORTRAN、ALGOL、COBOL、BASIC、LISP、SNOBOL、PL/1、Pascal、C、PROLOG、Ada、C++、VC、VB、Delphi、JAVA等。高级语言的发展也经历了从早期语言到结构化程序设计语言，从面向过程到非过程化程序语言的过程。相应地，软件的开发也由最初的个体手工作坊式的封闭式？生产，发展为产业化、流水线式的工业化生产。
面向对象：Java,JS,Python,Scala,…
面向过程：C,Pascal、Fortran
1.2.3 Java语言版本迭代概述
1991年 Green项目，开发语言最初命名为Oak (橡树)
1994年，开发组意识到Oak 非常适合于互联网
1996年，发布JDK 1.0，约8.3万个网页应用Java技术来制作
1997年，发布JDK 1.1，JavaOne会议召开，创当时全球同类会议规模之最
1998年，发布JDK 1.2，同年发布企业平台J2EE
1999年，Java分成J2SE、J2EE和J2ME，JSP/Servlet技术诞生
2004年，发布里程碑式版本：JDK 1.5，为突出此版本的重要性，更名为JDK 5.0
2005年，J2SE -> JavaSE，J2EE -> JavaEE，J2ME -> JavaME
2009年，Oracle公司收购SUN，交易价格74亿美元
2011年，发布JDK 7.0
2014年，发布JDK 8.0，是继JDK 5.0以来变化最大的版本
2017年，发布JDK 9.0，最大限度实现模块化
2018年3月，发布JDK 10.0，版本号也称为18.3
2018年9月，发布JDK 11.0，版本号也称为18.9
1.2.4 Java语言应用的领域
Java Web开发：后台开发
大数据开发：
Android应用程序开发：客户端开发
1.2.5 Java语言的特点
面向对象性：
两个要素：类、对象
三个特征：封装、继承、多态
健壮性：① 去除了C语言中的指针 ②自动的垃圾回收机制 -->仍然会出现内存溢出、内存泄漏
跨平台型：write once,run anywhere:一次编译，到处运行
功劳归功于：JVM
1.3 开发环境的搭建（重点）
1.3.1 JDK、JRE、JVM的关系
JDK = JRE + 集成开发工具
JRE = JVM + JAVA SE基础类库
1.3.2 JDK的下载、安装
下载：http://www.oracle.com/technetwork/java/javase/downloads/index.html
安装：傻瓜式安装：JDK 、JRE
注意问题：安装软件的路径中不能包含中文、空格。
1.3.3 path环境变量的配置
1.3.3.1 为什么配置path环境变量？
path环境变量：windows操作系统执行命令时所要搜寻的路径
为什么要配置path:希望java的开发工具（javac.exe,java.exe)在任何的文件路径下都可以执行成功。
1.3.3.2 如何配置？
找到环境变量
右键我的电脑点属性：
点击高级系统设置
选择环境变量
配置系统环境变量
新建JAVA_HOME变量，变量值是JDK安装的根目录
在Path变量中添加JAVA_HOME
Path是原有变量，只能编辑，不要新建。
添加：%JAVA_HOME%\bin.并上移到第一位
环境变量配置成功之后，需要在cmd下运行javac和java命令出现如下图像代表配置成功
1.3.4 第一个JAVA程序
新建java源文件，编译java源文件，运行字节码文件
创建一个java源文件：
HelloWorld.java
class HelloChina{
public static void main(String[] args){
System.out.println("Hello,World!");
}
}
编译源文件使用javac命令
javac HelloChina.java
编译成功后形成class文件
运行可执行文件
java HelloChina
运行结果：
1.3.5 注释与API文档等…
1.3.5.1 注释:Comment
分类：
单行注释：//
多行注释：/* */
文档注释：/** */
作用：
① 对所写的程序进行解释说明，增强可读性。方便自己，方便别人
② 调试所写的代码
特点：
①单行注释和多行注释，注释了的内容不参与编译。
②多行注释不可以嵌套使用
1.3.5.2 Java API 文档
API: application programming interface。习惯上：将语言提供的类库，都称为api.
API文档：针对于提供的类库如何使用，给的一个说明书。类似于《新华字典》
1.3.5.3 良好的编程风格
1.3.5.4 EditPlus
EditPlus是一款由韩国 Sangil Kim （ES-Computing）出品的小巧但是功能强大的可处理文本、HTML和程序语言的Windows编辑器，你甚至可以通过设置用户工具将其作为C,Java,Php等等语言的一个简单的IDE。
官网下载： https://www.editplus.com/
2_JAVA的基础语法
2.1 关键字与标识符
2.1.1 java关键字的使用
定义：被Java语言赋予了特殊含义，用做专门用途的字符串（单词）
特点：关键字中所字母都为小写
2.1.2 保留字：
现Java版本尚未使用，但以后版本可能会作为关键字使用。
具体哪些保留字：goto 、const
注意：自己命名标识符时要避免使用这些保留字
2.1.3 标识符的使用
定义：凡是自己可以起名字的地方都叫标识符。
涉及到的结构：
包名、类名、接口名、变量名、方法名、常量名
规则：(必须要遵守。否则，编译不通过)
规范：（可以不遵守，不影响编译和运行。但是要求大家遵守）
注意点：
在起名字时，为了提高阅读性，要尽量意义，“见名知意”。
2.2 变量的使用和数据类型
2.2.1 变量的分类
按数据类型分类
详细说明：
整型：
byte(1字节=8bit) \ short(2字节) \ int(4字节) \ long(8字节)
① byte范围：-128 ~ 127
② 声明long型变量，必须以"l"或"L"结尾
③ 通常，定义整型变量时，使用int型。
④整型的常量，默认类型是：int型
浮点型 :
float(4字节) \ double(8字节)
① 浮点型，表示带小数点的数值
② float表示数值的范围比long还大
③ 定义float类型变量时，变量要以"f"或"F"结尾
④ 通常，定义浮点型变量时，使用double型。
⑤浮点型的常量，默认类型为：double
字符型
char (1字符=2字节)
① 定义char型变量，通常使用一对’’,内部只能写一个字符
② 表示方式：1.声明一个字符 2.转义字符 3.直接使用 Unicode 值来表示字符型常量
布尔型
boolean
① 只能取两个值之一：true 、 false
② 常常在条件判断、循环结构中使用
按声明的位置分类(了解)
2.2.2 定义变量的格式
数据类型 变量名 = 变量值;
int one = 100;
数据类型 变量名;
变量名 = 变量值;
int one;
one = 100;
2.2.3 变量使用的注意点：
① 变量必须先声明，后使用
② 变量都定义在其作用域内。在作用域内，它是有效的。换句话说，出了作用域，就失效了
③ 同一个作用域内，不可以声明两个同名的变量
2.2.4 基本数据类型变量间运算规则
涉及到的基本数据类型：除了boolean之外的其他7种
自动类型转换(只涉及7种基本数据类型）
结论：当容量小的数据类型的变量与容量大的数据类型的变量做运算时，结果自动提升为容量大的数据类型。
byte 、char 、short --> int --> long --> float --> double
特别的：当byte、char、short三种类型的变量做运算时，结果为int型
说明：此时的容量大小指的是，表示数的范围的大和小。比如：float容量要大于long的容量
强制类型转换(只涉及7种基本数据类型）：自动类型提升运算的逆运算。
1.需要使用强转符：()
2.注意点：强制类型转换，可能导致精度损失。
2.2.5 String与8种基本数据类型间的运算
- String属于引用数据类型,翻译为：字符串
- 声明String类型变量时，使用一对""
- String可以和8种基本数据类型变量做运算，且运算只能是连接运算：+
- 运算的结果仍然是String类型
避免：
String s = 123;//编译错误
String s1 = "123";
int i = (int)s1;//编译错误
2.3 进制（只做了解）
编程中涉及的进制及表示方式：
二进制的使用说明：
计算机底层的存储方式：所有数字在计算机底层都以二进制形式存在。
二进制数据的存储方式：所有的数值，不管正负，底层都以补码的方式存储。
原码、反码、补码的说明：
正数：三码合一
负数：
2.4 运算符
算术运算符：
+ - * / % ++ –
%运算只能在整数型时使用，浮点数不适用。
++前 是变量先自加再运算，后++ 是变量先运算在自加。
赋值运算符：
= += -= *= /= %=
=运算符右侧会出现四种情况
int i = 100;// 常量值赋值，什么类型的常量值赋值给什么类型的变量。
int i = 100 + 50;// 表达式运算结果赋值。
int j = i;// 变量给变量赋值，值传递。
double d = Math.random();// 方法的返回值赋值。
one += 10 等同于 one = one + 10;
关系运算符：
< > <= >= == !=
关系运算符连接的关系表达式，关系表达式的结果是boolean。
逻辑运算符：
逻辑运算符的作用是连接多个关系表达式。& | ^ ! && ||
&符号：左右两端的关系表达式同时返回true的时候整个表达式返回true，有一端返回false则整个表达式是false。
|符号：左右两端有一端是返回true则整个表达式返回true，只有两端同时返回false整个表达式才返回false。
^符号：异或就是找不同，左右两端的表达式返回的结果不一样，则返回true。左右两端返回的结果一样则返回false。
！：反转一个boolean表达式的结果。true变false，false变true。
&&：短路与，短路与左侧关系表达式为false则右侧关系表达式将不再运算。
||：短路或，短路或左侧表达式返回为true则右侧表达式不再运算。
三目运算符：
？：。问号左侧是一个boolean表达式。当boolean表达式的结果是true 则执行：号左侧的表达式，返回false则执行：右侧的表达式。
位运算符（了解）：
& | ^ ~ << >> >>> 对于数学运算，位运算的效率更高。位运算只能操作整数。
<< 左移 ： 任何一个数左移N位，相当于这个数乘以2的N次方。 >>右移：任何一个数右移N为，相当于这个数除以2的N次方法。
2.5 流程控制（循环语句）
顺序结构：程序从上到下执行。
判断结构：if，if-else
if(条件表达式){// 条件表达式返回true，则执行if块，if块执行结束程序会向下继续。如果返回false则跳过if块执行后面的代码。
}
if(条件表达式){// if后面的表达式返回true则执行if块，返回false则执行else块。
}else{
}
分支结构：多重的if-else
if(条件1){
}else if(条件2){// 多重的else if可以写任何多个，没有个数限制
}else if(条件3){
}
.......
else{// 可选结构
}
分支结构：switch-case
switch(表达式){
case 常量1:
执行语句1;
//break;
case 常量2:
执行语句2;
//break;
default:
//可选
break;
循环结构 ：while，do-while，for
while(循环条件){// 循环条件为true则进入循环体，循环体执行完毕，则返回起点重新判断循环条件
// 循环操作
}
// while循环，先判断后执行，如果循环条件的初始值不满足则一次循环都不执行
do{
// 循环操作
}while(循环条件);
// do-while循环，先执行后判断，循环体会首先执行一次，然后判断循环条件，循环条件true则继续循环，false则退出循环。
for(循环变量的定义;循环条件;循环变量的改变){// 用于执行循环次数确定，先判断后执行。三个表达式都可以根据需求进行省略，但是两个分号不能省略。
// 循环操作
}
二重循环：嵌套的循环
// 一个循环完整的包含在另一个循环的循环体里。可以是任何一个循环结构去包含另一个循环系结构
for(){// 外层循环
for(){// 内层循环
// 外层循环执行一次，内层循环要完整的执行完所有的操作，所以内层循环的循环体执行的次数是外层循环次数*内存循环次数。
}
}
3_数组
数组的概念：数组是一个装载多个数据的容器。
数组的四个要素：数组的类型，数组名，数组元素，访问下标。
数组的声明：三种方式
int[] one = new int[5];// 数组必须在声明的时候给出长度，且这个长度不再改变。第一种声明方式，给出数组长度，但是没有给数组元素赋值。数组元素上是默认值。
int[] two = {30,50};// 数组在声明的同时给每一个元素赋值。数组的长度根据大括号中的值得数量决定。这种方式必须在一行之内完成。
int[] three
three = new int[]{30,40,50};// 数组在声明的同时给每一个元素赋值。数组的长度根据大括号中的值得数量决定。这种方式允许在两行之内完成。
数组的遍历：
// 普通for循环遍历数组
for(int i = 0;i < nums.length; i++){
System.out.println(nums[i]);// 访问数组元素的方式是数组名[下标]，下标的合法访问区间，是0到数组长度-1.访问数组元素时，如果下标在合法区间，则访问可以正常进行，如果访问下标超过了合法区间则会抛出数组越界异常。
}
二维的数组：一维的元素是另一个数组
int[][] nums = new int[5][3];// 同时给出一维和二维的数组长度。
int[][] nums = new int[5][];// 只给出一维的长度，不给二维的长度。此时一维元素为null。
nums[0] = new int[3];// 创建新数组给一维元素赋值。
int[][] nums = {{35,87,90},{35,77,20,17},{90,87,65,100,40}};// 静态声明二维数组，必须在声明数组的同时完成赋值
int[][] nums;
nums = new int[][]{{1,2,3},{1,2,3},{1,2,3}};// 静态初始化二维数组，允许在数组声明之后赋值。
二维数组的遍历
for(int i = 0;i < nums.length; i++){// 循环遍历一维数组
for(int j = 0;j < nums[i].length; j++){
System.out.println(nums[i][j]);
}
}
4_面向对象
4.1 面向对象学习的三条主线：
-
1.Java类及类的成员：属性、方法、构造器；代码块、内部类
-
2.面向对象的大特征：封装性、继承性、多态性、(抽象性)
-
3.其它关键字：this、super、static、final、abstract、interface、package、import等
4.2 面向对象中两个重要的概念：
类：对一类事物的描述，是抽象的、概念上的定义
对象：是实际存在的该类事物的每个个体，因而也称为实例
面向对象程序设计的重点是类的设计
设计类，就是设计类的成员。
4.3 面向过程和面向对象的区别
-
面向过程：考虑问题主要是分步，步骤不可逆，顺序执行。
-
面向对象：考虑问题主要是找到解决问题的类，用类创建对象，用对象调用属性或者方法。
-
类：是一个规范，是一个模板，规定了一类事物必须有的属性和方法。
-
对象：使用类创建出来的具体的客观存在的实体。使用对象调用属性，使用对象调用方法。
在java程序中定义类：
public class Student{// 定义类的时候给出若干属性和方法。类体中主要是定义属性和方法。
public String stuName;
public int stuAge;
public void sayHello(){// 定义方法，方法有五个常规部分，访问修饰符，返回类型，方法名，参数组，方法体。访问修饰符暂时记public，返回类型如果没有返回值则写void。参数组如果没有参数则小括号空着。大括号中是方法体。
}
public int methodOne(){// 当一个方法规定了返回类型，必须在方法结束前，返回一个该类型的变量。
int one = 0;
one = 100;
return one;// java语言规定返回值只能返回一个值。
}
public void methodTwo(int i,double d){// 方法有参数，参数是基础类型。一个方法定义参数，那么调用这个方法的时候必须按照要求传参。参数类型要求，参数个数要求，顺序要求。
System.out.println(i+d);
}
public void methodThree(String s){// 参数是引用类型，参数是对象，对象有属性，对象有方法。
System.out.println(s.equals("Tom"));
}
}
4.4 静态
static关键字：static关键字能修饰类的成员。被static关键字修饰的属性叫静态属性，被static关键字修饰的方法叫静态方法。
静态成员的特征：
-
1、静态成员可以不用创建对象，直接由类名调用。也可以由对象名调用，但不推荐这样做。
-
2、静态的成员只能访问静态的成员，不能访问普通成员。静态的成员初始化时间比较早，在类的加载同时初始化。普通的成员在创建对象时初始化。
-
3、静态属性是类所有对象共有属性，也被称作类变量。静态属性出现在内存的方法区中。
4.5 封装
面向对象语言的三大特性：封装，继承，多态。
封装：将类的细节隐藏起来，通过private修饰符，阻止外界访问。通过给private修饰的成员提供public的访问方法类实现访问。
JavaBean：所有的属性都是private修饰的，所有的private修饰的属性都有public修饰的get/set方法，必须拥有一个无参的构造方法，有参的构造方法可选。
public class Student {
private String stuName;
private Integer stuAge;
private String stuGender;
public Student() {
}
public Student(String stuName, Integer stuAge, String stuGender) {
this.stuName = stuName;
this.stuAge = stuAge;
this.stuGender = stuGender;
}
public String getStuName() {
return stuName;
}
public void setStuName(String stuName) {
this.stuName = stuName;
}
public Integer getStuAge() {
return stuAge;
}
public void setStuAge(Integer stuAge) {
this.stuAge = stuAge;
}
public String getStuGender() {
return stuGender;
}
public void setStuGender(String stuGender) {
this.stuGender = stuGender;
}
@Override
public String toString() {
return "Student{" +
"stuName='" + stuName + '\'' +
", stuAge=" + stuAge +
", stuGender='" + stuGender + '\'' +
'}';
}
}
4.6 继承
4.6.1 继承的语法
public class Father{
private int one;
public int getOne(){
return one;
}
public void setOne(int one){
this.one = one;
}
public void show(){
System.out.println("one="+one);
}
}
public class Son extends Father{// Son类继承自Father类，Son类是子类，Father类是父类。
// 子类可以继承到父类所有的属性和方法，但是不能继承构造方法。private的属性和方法可以被子类继承，但是不能被子类直接访问。需要通过public修饰的方法方法。
private int two;// 子类可以拥有自己的属性和方法
public int getTwo(){
return two;
}
public void setTwo(int two){
this.two = two;
}
public void getInfo(){
System.out.println("one="+this.getOne()+",two="+this.two;
}
}
4.6.2 java继承的特点：
java语言使用单继承。单继承就是一个java类只能有一个父类，一个父类可以有多个子类。
一个java类如果显示的继承自类一个类，那么它的父类就是显示继承的类。如果一个java类没有显示的继承，那么它隐示的继承自Object。所以所有的java类的父类都是Object。Object就是java继承树的根节点。
4.6.3、方法的重载和方法的重写：
方法的重载：发生在一个类中，方法名相同，参数组不同(参数类型不同，参数个数不同，参数顺序不同)。
方法的重写：发生在父子类中，子类编写一个方法名，参数组，访问修饰符，返回类型和父类方法完全一样的方法。子类重写的父类方法的修饰符只允许比父类方法更宽不能比父类方法更窄。子类重写父类 的方法时，子类重写的方法的返回类型允许是父类方法返回类型的子类型。方法重写是一个方法，一旦子类重写了父类的方法，再调用的一定是子类重写的方法。
4.7 多态
多态的概念：任何一个需要父类引用的位置，都可以传递一个子类对象。
多态的实现步骤：
1、有继承，有父子类。
2、父类定义方法，子类重写方法。
3、父类的引用，子类的对象。
class Father{
public void methodOne(){
System.out.println("父类的methodOne");
}
}
class Son extends Father{
public void methodOne(){
System.out.println("子类重写的methodOne");
}
}
class Test{
public static void main(String[] args){
Father f = new Son();// 创建对象多态
f.methodOne();// 子类一旦重写父类方法，再次调用的一定是子类重写的方法。
// Son son = new Son();
methodTwo(new Son());// 参数定义是父类类型，传递参数时传递子类对象。
Father[] nums = new Father[5];// 声明一个父类类型的对象数组
nums[0] = new Son();// 为数组元素赋值时传递子类对象。
nums[1] = new Son();
nums[2] = new Son();
nums[3] = new Son();
nums[4] = new Son();
}
public static void methodTwo(Father f){// 方法定义的参数是父类类型参数。
f.methodOne();
}
}
4.8 抽象
abstract关键字：可以修饰类，被修饰的类称作抽象类。抽象类不能被实例化。可以修饰方法，被修饰的方法称作抽象方法。抽象方法没有方法体。抽象的方法必须在抽象的类中，抽象的类中可以有抽象的方法也可以有普通的方法
abstract class Father{
public abstract void methodOne();// 抽象的方法没有方法体,抽象的方法必须在抽象的类里
public void methodTwo(){
// 抽象的类中还可以有普通的方法。
}
}
class Son extends Father{
public void methodOne(){
// 子类继承自抽象父类，必须重写父类中所有的抽象方法。
}
}
class Test{
public static void main(String[] args){
// Father f = new Father();// 抽象类不能创建对象
Father f = new Son();// 抽象类需要对象，只能创建抽象了的子类对象。
}
}
注意点：
- 1.abstract不能用来修饰：属性、构造器等结构
- 2.abstract不能用来修饰私方法、静态方法、final的方法、final的类
4.9 static:静态的
可以用来修饰的结构：主要用来修饰类的内部结构
属性、方法、代码块、内部类
静态成员的特征：
-
1、静态成员可以不用创建对象，直接由类名调用。也可以由对象名调用，但不推荐这样做。
-
2、静态的成员只能访问静态的成员，不能访问普通成员。静态的成员初始化时间比较早，在类的加载同时初始化。普通的成员在创建对象时初始化。
-
3、静态属性是类所有对象共有属性，也被称作类变量。静态属性出现在内存的方法区中。
//示例代码
class Circle{
private double radius;
private int id;//自动赋值
public Circle(){
id = init++;
total++;
}
public Circle(double radius){
this();
// id = init++;
// total++;
this.radius = radius;
}
private static int total;//记录创建的圆的个数
private static int init = 1001;//static声明的属性被所对象所共享
public double findArea(){
return 3.14 * radius * radius;
}
public double getRadius() {
return radius;
}
public void setRadius(double radius) {
this.radius = radius;
}
public int getId() {
return id;
}
public static int getTotal() {
return total;
}
}
4.10 接口
接口的语法：
public interface A{
// 接口中所有的属性默认是公开静态常量
public static final String NAME = "Tom";
// 接口中所有的方法默认是公开抽象
public abstract void methodOne();
}
*接口的特点：
-
1、接口不允许实例化。
-
2、接口必须配备实现类。
*接口的实现类：
// 使用implements关键字，类B是接口A的实现类
// 一个接口的实现类必须实现接口中所有的抽象方法
public class B implements A{
public void methodOne(){
System.out.println("hello world!");
}
}
// 一个接口可以有多个实现类
public class C implements A{
public void methodOne(){
System.out.println("bye bye!");
}
}
// 一个类可以实现多个接口，一个类实现多个接口必须，实现这些接口中的所有的抽象方法。
public class D implements A,Comparable{
}
接口可以继承，并且是多继承
interface A{
public void methodOne();
}
// 接口可以继承接口
interface B extends A{
// 子接口继承父接口，子接口将继承到父接口中的方法
public void methodTwo();
}
class C implements B{
public void methodOne(){};
public void methodTwo(){};
}
interface D{
}
// 接口可以多继承
interface E extends A,D{
}
4.11 封装类
概念：java语言为每一种基础数据类型都对应的准备了一个引用类型。这个引用类型叫做封装类。
封装类的基本操作：
// 1、创建封装类对象
Integer one = new Integer(10);
Integer two = new Integer("50");
// 2、对象转基础类型
int i = one.intValue();
// 3、基础类型转封装类型
Integer one = new Integer(i);
Integer two = Integer.valueOf(i);
// 4、String类型转封装类型
Integer one = new Integer("50");
// 5、封装类型转String
String s = one.toString();
// 6、基础类型转String
String s = Integer.toString(i);
自动装箱和自动拆箱：从jdk1.5开始，基础类型和对应引用类型可以自动转换。如果是引用类型需要进行运算，引用类型必须转成基础类型。
4.12 枚举
概念：枚举用于适应只有固定的几个值的情况，比如一年有四季，一个年有十二个月，一个星期有七天。
实现枚举：jdk1.5之前的枚举
public class Gender{
// 提供公开静态常量的该类属性
public static final Gender MAN = new Gender();
public static final Gender WEMON = new Gender();
// 构造方法私有
private Gender(){
}
}
jdk 1.5之后的枚举
public enum Gender{
// 必须在类体的第一部分声明该类属性的公开静态常量
// 除属性名外的其他修饰部分全部省略
MAN,WEMON;
// enum声明的类体中，所有的构造方法默认是private修饰
}
4.13 内部类
概念：一个类定义在另一个类的类体中，这个里面的类叫内部类，外面的类叫外部类。
分类：
- 1、静态成员内部类：声明在外部类的类体中，由static关键字修饰。
特点：可以在内部类中声明静态的成员，可以不需要创建外部类对象，直接创建内部类对象。可以访问外部类静态的成员，不能访问外部类普通的成员。
- 2、普通成员内部类：声明在外部类的类体中，没有static关键字修饰。
特点：只能在内部类类体中声明普通成员，需要先创建外部类对象，在由外部类对象创建内部类对象。可以访问外部类所有的成员。
-
3、局部内部类：声明在方法体中的内部类。不能脱离声明内部类的方法使用。
-
4、匿名内部类：匿名内部类是局部内部类的特殊形式。匿名内部类通常作为类的子类或者接口的实现类。
4.14 注解
注解从jdk1.5开始的时候出现。@注解名,注解可以出现在类的任何一个位置。注解可以实现一些功能，做出一些标注，检测一些语法，但是注解不能影响程序的运行结果。
系统注解：
@SuppressWarnings("unused") // 抑制警告注解
@Deprecated // 标注方法过时注解
@Override // 检测方法重写注解
元注解：修饰注解的注解
@Target //标注注解可以修饰那些内容
@Retention // 标注注解的生命周期
@Documented // 标注注解可以随生成文档进入API中
@Inherited // 标注注解可以在继承时被子类继承到
5_异常处理
概念：程序运行时的错误。
异常的流程：在一行代码运行时出现异常，程序会在异常产生行终止，创建并抛出一个该类异常对象。异常对象在没有被捕获的情况下会一直向上抛出。一旦异常对象抛给虚拟机，则虚拟机立即终止当前进程。
异常处理的目的：异常处理的目的是防止异常对象抛给虚拟机，防止因为异常导致程序终止。
5.1 异常
5.1.1 异常的体系结构
* java.lang.Throwable
* |-----java.lang.Error:一般不编写针对性的代码进行处理。
* |-----java.lang.Exception:可以进行异常的处理
* |------编译时异常(checked)
* |-----IOException
* |-----FileNotFoundException
* |-----ClassNotFoundException
* |------运行时异常(unchecked,RuntimeException)
* |-----NullPointerException
* |-----ArrayIndexOutOfBoundsException
* |-----ClassCastException
* |-----NumberFormatException
* |-----InputMismatchException
* |-----ArithmeticException
5.1.2 从程序的执行角度来看分为运行时异常和编译时异常
编译时异常：执行javac.exe命名时，可能出现的异常
运行时异常：执行java.exe命名时，出现的异常
5.1.3 常见的异常类型，请举例说明：
//******************以下是运行时异常***************************
//ArithmeticException
@Test
public void test6(){
int a = 10;
int b = 0;
System.out.println(a / b);
}
//InputMismatchException
@Test
public void test5(){
Scanner scanner = new Scanner(System.in);
int score = scanner.nextInt();
System.out.println(score);
scanner.close();
}
//NumberFormatException
@Test
public void test4(){
String str = "123";
str = "abc";
int num = Integer.parseInt(str);
}
//ClassCastException
@Test
public void test3(){
Object obj = new Date();
String str = (String)obj;
}
//IndexOutOfBoundsException
@Test
public void test2(){
//ArrayIndexOutOfBoundsException
// int[] arr = new int[10];
// System.out.println(arr[10]);
//StringIndexOutOfBoundsException
String str = "abc";
System.out.println(str.charAt(3));
}
//NullPointerException
@Test
public void test1(){
// int[] arr = null;
// System.out.println(arr[3]);
String str = "abc";
str = null;
System.out.println(str.charAt(0));
}
//******************以下是编译时异常***************************
@Test
public void test7(){
// File file = new File("hello.txt");
// FileInputStream fis = new FileInputStream(file);
//
// int data = fis.read();
// while(data != -1){
// System.out.print((char)data);
// data = fis.read();
// }
//
// fis.close();
}
5.2 异常的处理
java异常处理的抓抛模型：
过程一：
“抛”：程序在正常执行的过程中，一旦出现异常，就会在异常代码处生成一个对应异常类的对象。
并将此对象抛出。
一旦抛出对象以后，其后的代码就不再执行。
关于异常对象的产生：
① 系统自动生成的异常对象
② 手动的生成一个异常对象，并抛出（throw）
过程二：
“抓”：可以理解为异常的处理方式：① try-catch-finally ② throws
5.2.1 异常处理方式一：try-catch-finally
try{
// try块监控可能出现异常的代码
}catch(Exception ex){
// catch块捕获异常对象，进行异常处理
}fianlly{
// 无论出现不出现异常，finally块一定执行，用于释放自愿
}
5.2.2 异常处理方式二：throws,throw
public void methodOne()throws Exception{// throws关键字用于声明方法不处理的异常，将该类异常抛给调用点处理
throw new Excetpion();// throw关键字用于抛出手动创建的异常对象
}
throw 和 throws区别：
throw 表示抛出一个异常类的对象，生成异常对象的过程。声明在方法体内。
throws 属于异常处理的一种方式，声明在方法的声明处。
异常的分类：
Exception是所有异常类的总父类，只要是异常类必须是Exception的子类
除RuntimeException及其子类以外的所有异常类：这类异常被称作已检查异常，这类异常强制处理。
RuntimeException及其子类：这类异常被称作未检查异常，这类异常不强制处理，但是一旦爆发异常还是走异常流程。
5.2.3 自定义异常：
自定义已检查异常则继承Exception，自定义未检查异常则继承RuntimeException。
自定义异常重写getMessage()方法。或者构造方法传参调用super()将异常信息传递给父类的构造方法。
示例代码：
public class MyException extends Exception{
static final long serialVersionUID = -7034897193246939L;
public MyException(){
}
public MyException(String msg){
super(msg);
}
}