【基础篇】Java的回顾总结

最新推荐文章于 2024-09-08 10:40:56 发布

南-北

最新推荐文章于 2024-09-08 10:40:56 发布

阅读量138

点赞数

文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/w_rj0824/article/details/128904870

版权

JDK：使用版本java8，是java开发工具包，其中包含了JRE和java的开发工具，比如：编译工具（javac.exe）和打包工具（jar.exe）等

JRE：java运行环境，包括java虚拟机（JVM Java Virtual Machine）和程序所需要的核心类库（JavaAPI）等

Java基础是学习JavaEE、大数据、Android开发的基石！

1. 前置概述

1.1 Java语言环境：JDK 、JRE 、JVM的关系

1.2 Java基础知识图解

注意：一个源文件中最多只能有一个public类。其它类的个数不限，如果源文件包含一个public类，则文件名必须按该类名命名

2. 知识回顾

2.1 特殊关键字的使用：break、continue、return

①.break语句用于终止某个语句块的执行，如果出现在多层嵌套的语句块中时，可以通过标签指明要终止的是哪一层语句块

{     
    ……
    break;
    ……
}
多层嵌套的语句块
label1: { ……
label2:     { ……
label3:         { ……
                    break label2;
                  ……
                }
            }
        }
举例：
public class BreakTest{
    public static void main(String args[]){
        for(int i = 0; i<10; i++){
            if(i==3)
                break;
            System.out.println("i =" + i);
        }
        System.out.println("Game Over!");
    }
}

②.continue语句只能使用在循环结构中，用于跳过其所在循环语句块的一次执行，继续下一次循环，如果出现在多层嵌套的循环语句体中时，可以通过标签指明要跳过的是哪一层循环

public class ContinueTest {
    public static void main(String args[]){
        for (int i = 0; i < 100; i++) {
            if (i%10==0)
                continue;
            System.out.println(i);
        }
    }
}

③. return语句并非专门用于结束循环的，它的功能是结束一个方法。当一个方法执行到一个return语句时，这个方法将被结束。与break和continue不同的是，return直接结束整个方法，不管这个return处于多少层循环之内

④.总结说明

break只能用于switch语句和循环语句中。
continue只能用于循环语句中。
二者功能类似，但continue是终止本次循环，break是终止本层循环。
break、continue之后不能有其他的语句，因为程序永远不会执行其后的语句。
标号语句必须紧接在循环的头部。标号语句不能用在非循环语句的前面。
很多语言都有goto语句，goto语句可以随意将控制转移到程序中的任意一条语句上，然后执行它。但使程序容易出错。Java中的break和continue是不同于goto的

2.2 数组（Array）

2.2.1 数组的概述

数组(Array)，是多个相同类型数据按一定顺序排列的集合，并使用一个名字命名，并通过编号的方式对这些数据进行统一管理
数组本身是引用数据类型，而数组中的元素可以是任何数据类型，包括基本数据类型和引用数据类型
创建数组对象会在内存中开辟一整块连续的空间，而数组名中引用的是这块连续空间的首地址
数组的长度一旦确定，就不能修改
每个数组都有一个属性length指明它的长度

2.2.2 数组的初始化

①.动态初始化：数组声明且为数组元素分配空间与赋值的操作分开进行

int[] arr = new int[3];
arr[0] = 3;
arr[1] = 9;
arr[2] = 8;

String names[];
names = new String[3];
names[0] = "张三";
names[1] = "李四";
names[2] = "王五";

②.静态初始化：在定义数组的同时就为数组元素分配空间并赋值

int[] arr = {3,9,8} 或 int arr[] = new int[]{3,9,8};
String names[] = {"张三"，"李四"，"王五"};

2.2.3 数组元素的默认初始化值

数组是引用类型，它的元素相当于类的成员变量，因此数组一经分配空间，其中的每个元素也被按照成员变量同样的方式被隐式初始化
对于基本数据类型而言，默认初始化值各有不同
对于引用数据类型而言，默认初始化值为null（注意 null与0不同！）

2.2.4 数组中涉及到的常见算法

①.二分法查找算法

//二分法查找：要求此数组必须是有序的。
int[] arr3 = new int[]{-99,-54,-2,0,2,33,43,256,999};
boolean isFlag = true;
int number = 256;
//int number = 25;
int head = 0;//首索引位置
int end = arr3.length - 1;//尾索引位置
while(head <= end){
    int middle = (head + end) / 2;
    if(arr3[middle] == number){
        System.out.println("找到指定的元素，索引为：" + middle);
        isFlag = false;
        break;
    }else if(arr3[middle] > number){
        end = middle - 1;
    }else{//arr3[middle] < number
        head = middle + 1;
    }
}
if(isFlag){
System.out.println("未找打指定的元素");
}

2.2.5 Arrays工具类的使用

java.util.Arrays类即为操作数组的工具类，包含了用来操作数组（比如排序和搜索）的各种方法

2.2.6 数组使用中的常见异常

数组脚标越界异常（ArrayIndexOutOfBoundsException）访问到了数组中的不存在的脚标时发生
空指针异常（NullPointerException）数组引用没有指向实体，却在操作实体中的元素

2.3 内存解析：栈、堆、方法区

堆（Heap），此内存区域的唯一目的就是存放对象实例，几乎所有的对象实例都在这里分配内存。这一点在Java虚拟机规范中的描述是：所有的对象实例以及数组都要在堆上分配。
通常所说的栈（Stack），是指虚拟机栈。虚拟机栈用于存储局部变量等。局部变量表存放了编译期可知长度的基本数据类型（boolean、byte、char、short、int、float、long、double）、对象引用（reference类型，不等同于对象本身，是对象在堆内存的首地址）。方法执行完，自动释放。
方法区（Method Area），用于存储已被虚拟机加载的类信息、常量、静态变量、即时编译器编译后的代码等数据

2.4 匿名对象

我们可以不定义对象的句柄，而直接调用这个对象的方法。这样的对象叫做匿名对象。如：new Person().shout()；如果对一个对象只需要进行一次方法调用，那么就可以使用匿名对象。经常将匿名对象作为实参传递给一个方法调用

2.5 类的成员：属性

2.5.1 定义以及成员变量（属性）和局部变量的区别

在方法体外，类体内声明的变量称为成员变量。
在方法体内部声明的变量称为局部变量。

2.5.2 对象属性的默认初始化赋值

2.6 类的成员：方法

2.6.1 方法的分类及书写格式

2.6.2 方法的重载

概念：在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
特点：与返回值类型无关，只看参数列表，且参数列表必须不同。(参数个数或参数类型)。调用时，根据方法参数列表的不同来区别。
示例：

//返回两个整数的和
int add(int x,int y){return x+y;}
//返回三个整数的和
int add(int x,int y,int z){return x+y+z;}
//返回两个小数的和
double add(double x,double y){return x+y;}

2.6.3 可变形参的方法

JavaSE 5.0 中提供了Varargs(variable number of arguments)机制，允许直接定义能和多个实参相匹配的形参。从而，可以用一种更简单的方式，来传递个数可变的实参。

说明：

1. 声明格式：方法名(参数的类型名 ... 参数名)
2. 可变参数：方法参数部分指定类型的参数个数是可变多个：0个，1个或多个
3. 可变个数形参的方法与同名的方法之间，彼此构成重载
4. 可变参数方法的使用与方法参数部分使用数组是一致的
5. 方法的参数部分有可变形参，需要放在形参声明的最后
6. 在一个方法的形参位置，最多只能声明一个可变个数形参

//JDK 5.0以前：采用数组形参来定义方法，传入多个同一类型变量
public static void test(int a ,String[] books);
//JDK5.0：采用可变个数形参来定义方法，传入多个同一类型变量
public static void test(int a ,String … books);

2.6.4 方法参数的值传递机制

Java里方法的参数传递方式只有一种：值传递。即将实际参数值的副本（复制品）传入方法内，而参数本身不受影响。

形参是基本数据类型：将实参基本数据类型变量的“数据值”传递给形参，而参数本身不受影响

形参是引用数据类型：将实参引用数据类型变量的“地址值”传递给形参，因为传的是地址值，所以改变之后，原来的实参受到影响

2.6.5 递归方法

递归方法：一个方法体内调用它自身。方法递归包含了一种隐式的循环，它会重复执行某段代码，但这种重复执行无须循环控制。递归一定要向已知方向递归，否则这种递归就变成了无穷递归，类似于死循环。

2.7 类的成员：构造器

2.7.1 构造器的特征

它具有与类相同的名称
它不声明返回值类型。（与声明为void不同）
不能被static、final、synchronized、abstract、native修饰，不能有return语句返回值

2.7.2 构造器的作用：构造器一般用来创建对象的同时初始化对象

如：Order o = new Order(); Person p = new Person(“Peter”,15);
如同我们规定每个“人”一出生就必须先洗澡，我们就可以在“人”的构造器中加入完成“洗澡”的程序代码，于是每个“人”一出生就会自动完成“洗澡”，程序就不必再在每个人刚出生时一个一个地告诉他们要“洗澡”了。

2.7.3 根据参数不同，构造器可以分为如下两类：

隐式无参构造器（系统默认提供）
显式定义一个或多个构造器（无参、有参）

2.7.4 注意：

Java语言中，每个类都至少有一个构造器
默认构造器的修饰符与所属类的修饰符一致
一旦显式定义了构造器，则系统不再提供默认构造器
一个类可以创建多个重载的构造器
父类的构造器不可被子类继承
构造器一般用来创建对象的同时初始化对象
构造器重载使得对象的创建更加灵活，方便创建各种不同的对象

2.8 关键字static

2.8.1 概述

当我们编写一个类时，其实就是在描述其对象的属性和行为，而并没有产生实质上的对象，只有通过new关键字才会产生出对象，这时系统才会分配内存空间给对象，其方法才可以供外部调用。我们有时候希望无论是否产生了对象或无论产生了多少对象的情况下，某些特定的数据在内存空间里只有一份，例如所有的中国人都有个国家名称，每一个中国人都共享这个国家名称，不必在每一个中国人的实例对象中都单独分配一个用于代表国家名称的变量

2.8.2 类属性、类方法的设计思想

类属性作为该类各个对象之间共享的变量。在设计类时, 分析哪些属性不因对象的不同而改变，将这些属性设置为类属性。相应的方法设置为类方法。
如果方法与调用者无关，则这样的方法通常被声明为类方法，由于不需要创建对象就可以调用类方法，从而简化了方法的调用

2.8.3 使用static

①. 使用范围：在java类中，可用static修饰属性、方法、代码块、内部类

②. 被修饰后的成员具备以下的特点：

随着类的加载而加载
优先于对象存在
修饰的成员，被所有对象共享
访问权限允许时，可不创建对象，直接被类调用
没有对象的实例时，可以用类名. 方法名()的形式访问由static修饰的类方法。
在static方法内部只能访问类的static修饰的属性或方法，不能访问类的非static的结构
因为不需要实例就可以访问static方法，因此static方法内部不能有this，也不能有super
static修饰的方法不能被重写

2.9 类的成员：代码块

2.9.1 代码块（或初始化块）的作用：对java类或对象进行初始化

2.9.2 分类：一个类中代码块若有修饰符，则只能被static修饰，称为静态代码块（static block），static代码块通常用于初始化static的属性；没有使用static修饰的，为非静态代码块

①.静态代码块：用static 修饰的代码块

1. 可以有输出语句。
2. 可以对类的属性、类的声明进行初始化操作。
3. 不可以对非静态的属性初始化。即：不可以调用非静态的属性和方法。
4. 若有多个静态的代码块，那么按照从上到下的顺序依次执行。
5. 静态代码块的执行要先于非静态代码块。
6. 静态代码块随着类的加载而加载，且只执行一次。

②.非静态代码块：没有static 修饰的代码块

1. 可以有输出语句。
2. 可以对类的属性、类的声明进行初始化操作。
3. 除了调用非静态的结构外，还可以调用静态的变量或方法。
4. 若有多个非静态的代码块，那么按照从上到下的顺序依次执行。
5. 每次创建对象的时候，都会执行一次。且先于构造器执行。

2.10 类的成员：内部类

①. 当一个事物的内部，还有一个部分需要一个完整的结构进行描述，而这个内部的完整的结构又只为外部事物提供服务，那么整个内部的完整结构最好使用内部类。

在Java中，允许一个类的定义位于另一个类的内部，前者称为内部类，后者称为外部类。
内部类一般用在定义它的类或语句块之内，在外部引用它时必须给出完整的名称。
内部类的的名字不能与包含它的外部类类名相同；
分类：成员内部类（static成员内部类和非static成员内部类）、局部内部类（不谈修饰符）、匿名内部类

②. 成员内部类作为类的成员的角色：

和外部类不同，内部类还可以声明为private或protected；
可以调用外部类的结构，包括私有的数据
内部类可以声明为static的，但此时就不能再使用外层类的非static的成员变量

③. 成员内部类作为类的角色：

可以在内部定义属性、方法、构造器等结构
可以声明为abstract类，因此可以被其它的内部类继承
可以声明为final的
编译以后生成OuterClass$InnerClass.class字节码文件（也适用于局部内部类）

④.内部类举例

class Outer {
    private int s;
    public class Inner {
        public void mb() {
            s = 100;
            System.out.println("在内部类Inner中s=" + s);
        }
    }
    public void ma() {
        Inner i = new Inner();
        i.mb();
    }
}

public class InnerTest {
    public static void main(String args[]) {
        Outer o = new Outer();
        o.ma();
    }
}

public class Outer {
    private int s = 111;
    public class Inner {
        private int s = 222;
        public void mb(int s) {
            System.out.println(s); // 局部变量s
            System.out.println(this.s); // 内部类对象的属性s
            System.out.println(Outer.this.s); // 外部类对象属性s
        }
    }
    public static void main(String args[]) {
        Outer a = new Outer();
        Outer.Inner b = a.new Inner();
        b.mb(333);
    }
}

2.11 总结属性赋值的先后顺序

2.11.1 赋值的位置：

① 默认初始化
② 显式初始化
③ 构造器中赋值
④ 通过“对象.属性“或“对象.方法”的方式赋值
⑤.代码块中赋值

2.11.2 赋值的先后顺序：

① - ②/⑤ - ③ - ④这里2和5之间的关系是前后顺序关系，也就是谁放前面谁就先赋值

2.12 关键字：this、package、super、final

2.12.1 this

它在方法内部使用，即这个方法所属对象的引用
它在构造器内部使用，表示该构造器正在初始化的对象
this可以调用类的属性、方法和构造器
当在方法内需要用到调用该方法的对象时，就用this
可以用this来区分同名的属性和局部变量，如：this.name=name
使用this访问属性和方法时，如果在本类中未找到，会从父类中查找
this可以作为一个类中构造器相互调用的特殊格式
可以在类的构造器中使用"this(形参列表)"的方式，调用本类中重载的其他的构造器
明确：构造器中不能通过"this(形参列表)"的方式调用自身构造器
如果一个类中声明了n个构造器，则最多有 n - 1个构造器中使用了"this(形参列表)"
"this(形参列表)"必须声明在类的构造器的首行！
在类的一个构造器中，最多只能声明一个"this(形参列表)"

2.12.2 package

2.12.3 super

①. 在java类中使用super来调用父类中的指定操作

super可用于访问父类中定义的属性
super可用于调用父类中定义的成员方法
super可用于在子类构造器中调用父类的构造器
尤其当子父类出现同名成员时，可以用super表明调用的是父类中的成员
super的追溯不仅限于直接父类
super和this的用法相像，this代表本类对象的引用，super代表父类的内存空间的标识

②. 调用父类的构造器

子类中所有的构造器默认都会访问父类中的空参构造器
当父类中没有空参数构造器时，子类的构造器必须通过this(参数列表)或者super(参数列表)语句指定调用本类或者父类中相应的构造器，同时，二者不能同时出现，且必须放在构造器的首行
如果子类构造器既未显示调用父类或本类的构造器，且父类中又没有无参构造器，则编译出错

③. this和super的区别

2.12.4 final

在Java中声明类、变量和方法时，可使用关键字final来修饰，表示“最终的”。
final标记的类不能被继承。提高安全性，提高程序的可读性。
- 如String类、System类、StringBuffer类
final标记的方法不能被子类重写。
- 如：Object类中的getClass()。
final标记的变量(成员变量或局部变量)即称为常量。名称大写，且只能被赋值一次。
- final标记的成员变量必须在声明时或在每个构造器中或代码块中显式赋值，然后才能使用
- final double MY_PI = 3.14;
不管是常量还是静态常量，一旦初始化赋值，就不能修改

2.13 面向对象的特征一：封装性

2.13.1 为什么需要封装

使用者对类内部定义的属性(对象的成员变量)直接操作会导致数据的错误、混乱或安全性问题
程序设计追求“高内聚，低耦合”。
- 高内聚：类的内部数据操作细节自己完成，不允许外部干涉；
- 低耦合：仅对外暴露少量的方法用于使用

2.13.2 封装的设计思想

隐藏对象内部的复杂性，只对外公开简单的接口。便于外界调用，从而提高系统的可扩展性、可维护性。通俗的说，把该隐藏的隐藏起来，该暴露的暴露出来。这就是封装性的设计思想。

2.13.3 信息的封装与隐藏

Java中通过将数据声明为私有的(private)，再提供公共的（public）方法：getXxx()和setXxx()实现对该属性的操作，以实现下述目的：

隐藏一个类中不需要对外提供的实现细节；
使用者只能通过事先定制好的方法来访问数据，可以方便地加入控制逻辑，限制对属性的不合理操作；
便于修改，增强代码的可维护性；

2.13.4 四种权限修饰符

2.14 面向对象的特征二：继承性

2.14.1 为什么要有继承

多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。
此处的多个类称为子类（派生类），单独的这个类称为父类（基类或超类）
类继承的语法规则：class SubClass extends SuperClass{ }

2.14.2 继承的作用

继承的出现减少了代码冗余，提高了代码的复用性
继承的出现，更有利于功能的扩展
继承的出现让类与类之间产生了关系，提供了多态的前提
注意：不要仅为了获取其他类中某个功能而去继承

2.14.3 继承的效果

子类继承了父类，就继承了父类的属性和方法
在子类中，可以使用父类中定义的属性和方法，也可以创建新的数据和方法
在java中，继承的关键字用的是“extends”，即子类不是父类的子集，而是对父类的“扩展”

2.14.4 继承的规则

子类不能直接访问父类中私有的（private）成员变量和方法
java只支持单继承和多层继承，不允许多重继承：即一个子类只能有一个父类，一个父类可以派生出多个子类

2.15 方法的重写（override/overwrite）

2.15.1 定义

在子类中可以根据需要对从父类中继承来的方法进行改造，也称为方法的重置、覆盖。在程序执行时，子类的方法将覆盖父类的方法。

2.15.2 要求

1. 子类重写的方法必须和父类被重写的方法具有相同的方法名称、参数列表
2. 子类重写的方法的返回值类型不能大于父类被重写的方法的返回值类型
3. 子类重写的方法使用的访问权限不能小于父类被重写的方法的访问权限
- 子类不能重写父类中声明为private权限的方法
4. 子类方法抛出的异常不能大于父类被重写方法的异常

2.15.3 注意

子类与父类中同名同参数的方法必须同时声明为非static的（即为重写），或者同时声明为static的（不是重写）。因为static方法是属于类的，子类无法覆盖父类的方法

2.15.4 方法的重载与重写

从编译和运行的角度看：

对于重载而言，在方法调用之前，编译器就已经确定了所要调用的方法，这称为“早绑定”或“静态绑定”；
而对于多态，只有等到方法调用的那一刻，解释运行器才会确定所要调用的具体方法，这称为“晚绑定”或“动态绑定”

2.16 子类对象的实例化过程

2.17 面向对象的特征三：多态性

2.17.1 多态的定义

对象的多态性：父类的引用指向子类的对象（也就是子类的对象可以替代父类的对象使用），可以直接应用在抽象类和接口上
子类可以看做是特殊的父类，所以父类类型的引用可以指向子类的对象：向上转型

2.17.2 java引用变量

java引用变量有两个类型：编译时类型和运行时类型。编译时类型由声明该变量时使用的类型决定，运行时类型由实际赋给该变量的对象决定。简称：编译时，看左边；运行时，看右边
若编译时类型和运行时类型不一致，就出现了对象的多态性（Polymorphism）
多态情况下，“看左边”：看的是父类的引用（父类中不具备子类特有的方法）；“看右边”：看的是子类的对象（实际运行的是子类重写父类的方法）
一个引用类型变量如果声明为父类的类型，但实际引用的是子类对象，那么该变量就不能再访问子类中添加的属性和方法。因为属性是在编译时确定的

2.17.3 多态情况下的虚拟方法调用：

子类中定义了与父类同名同参数的方法，在多态情况下，将此时父类的方法称为虚拟方法，父类根据赋给它的不同子类对象，动态调用属于子类的该方法。这样的方法调用在编译期是无法确定的。

2.17.4 多态小结

多态作用：提高了代码的通用性，常称作接口重用
前提：需要存在继承或者实现关系；有方法的重写
成员方法：
- 编译时：要查看引用变量所声明的类中是否有所调用的方法。
- 运行时：调用实际new的对象所属的类中的重写方法。
成员变量：不具备多态性，只看引用变量所声明的类
继承成员变量和继承方法的区别
- 若子类重写了父类方法，就意味着子类里定义的方法彻底覆盖了父类里的同名方法，系统将不可能把父类里的方法转移到子类中。
- 对于实例变量则不存在这样的现象，即使子类里定义了与父类完全相同的实例变量，这个实例变量依然不可能覆盖父类中定义的实例变量

2.17.5 关于多态的其他知识：instanceof操作符、对象类型转换

①. x instanceof A：检验x 是否为类A 的对象，返回值为boolean型。

要求x所属的类与类A必须是子类和父类的关系，否则编译错误。
如果x属于类A的子类B，x instanceof A值也为true。

②. 对象类型转换（Casting）

基本数据类型的Casting
- 自动类型转换：小的数据类型可以自动转换成大的数据类型
- 强制类型转换：可以把大的数据类型强制转换成小的数据类型，使用强转符：()
对Java对象的强制类型转换称为造型
- 从子类到父类的类型转换可以自动进行（多态）
- 从父类到子类的类型转换必须通过强制类型转换实现
- 无继承关系的引用类型间的转换是非法的
- 在造型前可以使用instanceof操作符测试一个对象的类型

2.18 抽象类与抽象方法

随着继承层次中一个个新子类的定义，类变得越来越具体，而父类则更一般，更通用。类的设计应该保证父类和子类能够共享特征。有时将一个父类设计得非常抽象，以至于它没有具体的实例，这样的类叫做抽象类。

2.18.1 抽象类和抽象方法的定义

用abstract关键字来修饰一个类，这个类叫做抽象类。
用abstract来修饰一个方法，该方法叫做抽象方法。
抽象方法：只有方法的声明，没有方法的实现。以分号结束：比如：public abstract void talk();
含有抽象方法的类必须被声明为抽象类。
抽象类不能被实例化。抽象类是用来被继承的，抽象类的子类必须重写父类的抽象方法，并提供方法体。若没有重写全部的抽象方法，仍为抽象类。
不能用abstract修饰变量、代码块、构造器；
不能用abstract修饰私有方法、静态方法、final的方法、final的类

2.18.2 抽象类能解决的问题

当功能内部一部分实现是确定的，一部分实现是不确定的。这时可以把不确定的部分暴露出去，让子类去实现。

2.19 接口（interface）

2.19.1 接口产生的原因

一方面，有时必须从几个类中派生出一个子类，继承它们所有的属性和方法。但是，Java不支持多重继承。有了接口，就可以得到多重继承的效果。
另一方面，有时必须从几个类中抽取出一些共同的行为特征，而它们之间又没有is-a的关系，仅仅是具有相同的行为特征而已。例如：鼠标、键盘、打印机、扫描仪、摄像头、充电器、MP3机、手机、数码相机、移动硬盘等都支持USB连接。
接口就是规范，定义的是一组规则，体现了现实世界中“如果你是/要...则必须能...”的思想。继承是一个"是不是"的关系，而接口实现则是 "能不能"的关系。
接口的本质是契约，标准，规范，就像我们的法律一样。制定好后大家都要遵守。

2.19.2 接口的概念

①. 定义：接口是抽象方法和常量值定义的集合

②. 特点

用interface来定义
接口中的所有成员变量都默认是由public static final修饰的。
接口中的所有抽象方法都默认是由public abstract修饰的。
接口中没有构造器。
接口采用多继承机制

③. 语法格式及说明

语法格式：先写extends，后写implements：class SubClass extends SuperClass implements InterfaceA{ }
一个类可以实现多个接口，接口也可以继承其它接口。
实现接口的类中必须提供接口中所有方法的具体实现内容，方可实例化。否则，仍为抽象类。
接口的主要用途就是被实现类实现。（面向接口编程）
与继承关系类似，接口与实现类之间存在多态性
接口和类是并列关系，或者可以理解为一种特殊的类。从本质上讲，接口是一种特殊的抽象类，这种抽象类中只包含常量和方法的定义(JDK7.0及之前)，而没有变量和方法的实现。

2.19.3 接口和抽象类之间的对比

2.19.4 Java8中关于接口的改进

若一个接口中定义了一个默认方法，而另外一个接口中也定义了一个同名同参数的方法（不管此方法是否是默认方法），在实现类同时实现了这两个接口时，会出现： 接口冲突。解决办法：实现类必须覆盖接口中同名同参数的方法，来解决冲突。

若一个接口中定义了一个默认方法，而父类中也定义了一个同名同参数的非抽象方法，则不会出现冲突问题。因为此时遵守：类优先原则。接口中具有相同名称和参数的默认方法会被忽略。

public interface AA {
    double PI = 3.14;
    public default void method() {
        System.out.println(" 北京");
    }
    default String method1() {
        return " 上海";
    }
    public static void method2() {
        System.out.println(“hello lambda!");
    }
}

2.20 Object类以及==操作符与equals方法

2.20.1 Object类中的主要结构

Object类是所有Java类的根父类

2.20.2 ==操作符与equals方法

①. ==操作符

基本类型比较值：只要两个变量的值相等，即为true
引用类型比较引用（是否指向同一个对象）：只有指向同一个对象时，==才返回true
用“==”进行比较时，符号两边的数据类型必须兼容（可自动转换的基本数据类型除外），否则编译出错

②. equals方法

所有类都继承了Object，也就获得了equals()方法。不重写的equals()方法的作用和“==”一样，都是比较是否指向同一个对象
当自定义使用equals()时，可以重写。用于比较两个对象的“内容”是否都相等

2.21 ==和equals的区别

2.22 包装类（Wrapper）

2.22.1 包装类的使用

针对八种基本数据类型定义相对应的引用类型——包装类（封装类），有了类的特点，就可以调用类中的方法

2.22.2 基本数据类型和包装类之间的转换

①. 装箱：基本数据类型包装成包装类的实例

1. 通过包装类的构造器实现
int i = 500; Integer t = new Integer(i);
2. 通过字符串参数构造包装类对象
Float f = new Float("4.56");
Long l = new Long("asdf"); // NumberFormatException

②. 拆箱：获得包装类对象中包装的基本类型变量

调用包装类的.XXXValue()方法
boolean b = bObj.booleanValue();

③. JDK1.5之后，支持自动装箱，自动拆箱。但类型必须匹配

2.22.3 字符串和基本数据类型之间的转换

①. 字符串转换成基本数据类型

1. 通过包装类的构造器实现
int i = new Integer("12");
2. 通过包装类的parseXxx(String s)静态方法
float f = Float.parseFloat("12.1");

②. 基本数据类型转换成字符串

1. 调用字符串重载的valueOf()方法
String str = String.valueOf(2.34f); 
2. 更直接的方式：字符串拼接 + 
String str = 2.34 + "";

2.22.4 总结：基本数据类型、包装类以及String类之间的转换

2.23 异常处理

2.23.1 异常处理机制一：try-catch-finally

①. 原理说明

java提供的异常处理机制是抓抛模型
java程序的执行过程中如出现异常，会生成一个异常类对象，该异常对象将被提交给java运行时系统，这个过程称为抛出（throw）异常
异常对象的生成
- 由虚拟机自动生成：程序运行过程中，虚拟机检测到程序发生了问题，如果在当前代码中没有找到相应的处理程序，就会在后台自动创建一个对应异常类的实例对象并抛出——自动抛出
- 由开发人员手动创建：Exception exception = new ClassCastException();——创建好的异常对象不抛出对程序没有任何影响，和创建一个普通对象一样
如果一个方法内抛出异常，该异常对象会被抛给调用者方法中处理。如果异常没有在调用者方法中处理，它继续被抛给这个调用方法的上层方法。这个过程将一直继续下去，直到异常被处理。这一过程称为捕获(catch)异常。
如果一个异常回到main()方法，并且main()也不处理，则程序运行终止。程序员通常只能处理Exception，而对Error无能为力

②. 处理方法：try-catch-finally

try{
    // 捕获异常的第一步是用try{…}语句块选定捕获异常的范围，将可能出现异常的代码放在try语句块中。
}catch( ExceptionName1 e ){
    // 在catch语句块中是对异常对象进行处理的代码。每个try语句块可以伴随一个或多个catch语句，用于处理可能产生的不同类型的异常对象。
}catch( ExceptionName2 e ){
    // 当产生ExceptionName2型异常时的处置措施，比如捕获异常的有关信息
    getMessage() 获取异常信息，返回字符串
    printStackTrace() 获取异常类名和异常信息，以及异常出现在程序中的位置。返回值void。
}finally{
    // 无论是否发生异常，都无条件执行的语句
    不论在try代码块中是否发生了异常事件，catch语句是否执行，catch语句是否有异常，catch语句中是否有return，finally块中的语句都会被执行
}

public class IndexOutExp {
    public static void main(String[] args) {
        String friends[] = { "lisa", "bily", "kessy" };
        try {
            for (int i = 0; i < 5; i++) {
                System.out.println(friends[i]);
            }
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("index err");
        }
        System.out.println("\nthis is the end");
    }
}
程序IndexOutExp.java运行结果：java IndexOutExp
    lisa
    bily
    kessy
    index err
    this is the end

③. 不捕获异常时的情况

前面使用的异常都是RuntimeException类或是它的子类，这些类的异常的特点是：即使没有使用try和catch捕获，Java自己也能捕获，并且编译通过(但运行时会发生异常使得程序运行终止)。
如果抛出的异常是IOException等类型的非运行时异常，则必须捕获，否则编译错误。也就是说，我们必须处理编译时异常，将异常进行捕捉，转化为运行时异常

2.23.2 异常处理机制二：throws + 异常类型（声明抛出异常）

①. 原理说明

如果一个方法(中的语句执行时)可能生成某种异常，但是并不能确定如何处理这种异常，则此方法应显示地声明抛出异常，表明该方法将不对这些异常进行处理，而由该方法的调用者负责处理。
在方法声明中用throws语句可以声明抛出异常的列表，throws后面的异常类型可以是方法中产生的异常类型，也可以是它的父类。

②. 代码演示