目录
一、基础
1.命名规范
2.位运算符
二、数组
1.一维数组
- 静态初始化（指定内容）
数据类型[] 数组名 = new 数据类型[]{元素1,元素2,元素3…};
int[] arr = new int[]{1,2,3,4,5};
// 可以拆分
int[] arr;
arr = new int[]{1,2,3,4,5};
静态初始化省略格式（不能拆分）
数据类型[] 数组名 = {元素1,元素2,元素3…};
int[] arr = {1,2,3,4,5};
- 动态初始化（指定长度）
数据类型[ ] 数组名字 = new 数据类型[数组长度];
数据类型 数组名字[ ] = new 数据类型[数组长度];
int[] arr = new int[3];
int arr[] = new int[3];
// 可以拆分
int[] arr;
arr = new int[3];
2.二维数组
二维数组初始化
同一维数组一样，共有4总不同形式的定义方法：
int[][] array1 = new int[10][10];
int array2[][] = new int[10][10];
int[][] array4 = new int[][] { { 1, 1, 1 }, { 2, 2, 2 } };
int[][] array3 = { { 1, 1, 1 }, { 2, 2, 2 } };
不定长二维数组
int[][] array = new int[3][];
array[0] = new int[1];
array[1] = new int[2];
array[2] = new int[3];
3.Java虚拟机的内存划分
4.数组在内存中的存储
public static void main(String[] args) {
int[] arr = new int[3];
System.out.println(arr); // [I@5f150435
}
以上方法执行，输出的结果是[I@5f150435，这个是什么呢？是数组在内存中的地址。new出来的内容，都是在堆内存中存储的，而方法中的变量arr保存的是数组的地址。
数组作为方法参数传递，传递的参数是数组内存的地址。
数组作为方法的返回值，返回的是数组的内存地址
三、类和对象
Java 类及类的成员：属性、方法、构造器、代码块、内部类
面向对象的三大特征：封装、继承、多态性、(抽象性)
类的语法格式：
修饰符 class 类名{
属性声明;
方法声明;
}
说明：修饰符 public：类可以被任意访问类的正文要用{ }括起来
1.对象数组的内存解析
/*引用类型的变量，只可能存储量两类值：null或地址值（含变量类型）*/
Student[] stus= newStudent[5];
stus[0] = new Student();
sysout(stus[0].state);//1
sysout(stus[1]);//null
sysout(stus[1].number);//异常
stus[1] = new Student();
sysout(stus[1].number);//0
class Student{
int number;//学号
int state = 1;//年级
int score;//成绩
}
2.匿名对象的使用
1.理解:我们创建的对象，没有显示的赋值给一个变量名。即为匿名对象。
2.特征：匿名对象只能调用一次。
3.方法的重载
方法的重载(overload) loading…
1.定义:在同一个类中，允许存在一个以上的同名方法，只要它们的参数个数或者参数类型不同即可。
“两同一不同”:同一个类、相同方法名
参数列表不同：参数个数不同，参数类型不同
2.举例:Arrays类中重载的sort() / binarySearch()
3.判断是否重载
与方法的返回值类型、权限修饰符、形参变量名、方法体都无关。
4.在通过对象调用方法时，如何确定某一个指定的方法：方法名---->参数列表
可变个数形参的方法
1.jdk 5.0新增的内容
2.具体使用：
2.1 可变个数形参的格式：数据类型 ... 变量名
2.2 当调用可变个数形参的方法时，传入的参数的个数可以是：0个，1个，2个…
2.3可变个数形参的方法与本类中方法名相同，形参不同的方法之间构成重载。
2.4可变个数形参的方法与本类中方法名相同，形参类型也相同的数组之间不构成重载。即二者不可共存。
2.5可变个数形参在方法中的形参中,必须声明在末尾。public void show(int i, String... strs)
2.6可变个数形参在方法中的形参中，最多只能声明一个可变形参。
关于变量的赋值 如果变量是基本数据类型，此时赋值的是变量所保存的数据值。
如果变量是引用数据类型，此时赋值的是变量所保存的数据的地址值。
四、面向对象特征之一：封装与隐藏
对于 class 的权限修饰只可以用 public 和 default(缺省)。
- public 类可以在任意地方被访问。
- default 类只可以被同一个包内部的类访问。
4.1、构造器(构造方法)
类的结构之三:构造器(构造方法、constructor)的使用
constructor:一、构造器的作用:
1.创建对象
2.初始化对象的属性
二、说明
1.如果没有显示的定义类的构造器的话，则系统默认提供一个空参的构造器。
2.定义构造器的格式:
权限修饰符 类名(形参列表) { }
3.一个类中定义的多个构造器，彼此构成重载。
4.一旦显示的定义了类的构造器之后，系统不再提供默认的空参构造器。
5.一个类中，至少会有一个构造器
总结:属性赋值的先后顺序
① 默认初始化值
② 显式初始化
③ 构造器中赋值
④ 通过"对象.方法" 或 “对象.属性”的方式，赋值
以上操作的先后顺序:① - ② - ③ - ④
4.2、this 的使用
this 关键字的使用
1.this 用来修饰、调用：属性、方法、构造器
2.this 修饰属性和方法:
this 理解为：当前对象,或当前正在创建的对象。
2.1 在类的方法中，我们可以使用"this.属性"或"this.方法"的方式，调用当前对象属性和方法。通常情况下，我们都选择省略“this.”。特殊情况下，如果方法的形参和类的属性同名，我们必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参。
2.2在类的构造器中，我们可以使用"this.属性"或"this.方法"的方式，调用正在创建的对象属性和方法。但是，通常情况下，我们都选择省略“this.”。特殊情况下，如果构造器的形参和类的属性同名，我们必须显式的使用"this.变量"的方式，表明此变量是属性，而非形参。
3.this 调用构造器
① 我们可以在类的构造器中，显式的使用"this(形参列表)"的方式，调用本类中重载的其他的构造器！
② 构造器中不能通过"this(形参列表)“的方式调用自己。
③ 如果一个类中声明了n个构造器，则最多有n -1个构造器中使用了"this(形参列表)”。
④"this(形参列表)"必须声明在类的构造器的首行！
⑤在类的一个构造器中，最多只能声明一个"this(形参列表)"。
4.3、关键字—import
二、import关键字的使用
import:导入
1.在源文件中显式的使用import结构导入指定包下的类、接口
2.声明在包的声明和类的声明之间
3.如果需要导入多个结构，则并列写出即可
4.可以使用"xxx.*"的方式,表示可以导入xxx包下的所有结构。
5.如果导入的类或接口是java.lang包下的，或者是当前包下的，则可以省略此import语句。
6.如果在代码中使用不同包下的同名的类。那么就需要使用类的全类名的方式指明调用的是哪个类。
7.如果已经导入java.a包下的类。那么如果需要使用a包的子包下的类的话，仍然需要导入。
8.import static组合的使用：调用指定类或接口下的静态的属性或方法.
五、继承
为什么要有继承？
多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，
那么多个类无需再定义这些属性和行为，只要继承那个类即可。
一、继承性的好处
① 减少了代码的冗余，提高了代码的复用性；
② 便于功能的扩展；
③ 为之后多态性的使用，提供了前提。
二、继承性的格式
class A extends B{}
A:子类、派生类、subclass
B:父类、超类、基类、superclass
2.1 体现：一旦子类 A 继承父类以后，子类 A 中就获取了父类 B 中声明的结构：属性、方法。特别的，父类中声明为 private 的属性或方法，子类继承父类以后，仍然认为获取了父类中私有的结构。只有因为封装性的影响，使得子类不能直接调用父类的结构而已
2.2 子类继承父类以后，还可以声明自己特有的属性或方法，实现功能的拓展。
子类和父类的关系：不同于子集与集合的关系。
extends:延展、扩展
三、Java 中关于继承性的规定：
1.一个类可以被多个类继承
2.Java 中类的单继承性：一个类只能有一个父类
3.子父类是相对的概念。
4.子类直接继承的父类，称为：直接父类。间接继承的父类，称为，间接父类。
5.子类继承父类后，就获取了直接父类以及所有间接父类中声明的属性和方法。
四、
1.如果我们没有显式的声明一个类的父类的话，则此类继承于 java.lang.Object 类
2.所有的 java 类(除 java.long.Object 类之外)都直接或间接地继承于 java.lang.Object 类;
3.意味着，所有的 java 类具有 java.lang.Object 类声明的功能。
5.1、方法的重写(override/overwrite)
方法的重写(override/overwrite)
1.重写：子类继承父类以后，可以对父类中同名同参数的方法进行，覆盖操作。
2.应用：重写以后，当创建子类对象以后，通过子类对象去调用子父类中同名同参数方法时，执行的是子类重写父类的方法。
3.重写的规定：
方法的声明：权限修饰符 返回值类型 方法名(形参列表){//方法体 }
① 子类重写的方法的方法名和形参列表必须和父类被重写的方法的方法名、形参列表相同;
② 子类重写的方法使用的访问权限不能小于父类被重写的方法的访问权限,
特殊情况: 子类不能重写父类中声明为private权限的方法;
③ 返回值类型:
父类被重写的方法的返回值类型是void,则子类重写的方法的返回值类型只能是void;父类被重写的方法的返回值类型是A类型，则子类重写的方法的返回值类型可以是A类或A类的子类;父类被重写的方法的返回值类型如果是基本数据类型(比如:double)，则子类重写的方法的返回值类型必须是相同的基本数据类型(必须是:double)。④ 子类方法抛出的异常不能大于父类被重写的方法抛出的异常;
注意：子类与父类中同名同参数的方法必须同时声明为非static的(即为重写)，或者同时声明为static的（不是重写）。因为static方法是属于类的，子类无法覆盖父类的方法。
面试题：区分方法的重载与重写(有的书也叫做“覆盖”)
答：方法的重写Overriding和重载Overloading是Java多态性的不同表现。重写Overriding是父类与子类之间多态性的一种表现，重载Overloading是一个类中多态性的一种表现。如果在子类中定义某方法与其父类有相同的名称和参数，我们说该方法被重写 (Overriding)。子类的对象使用这个方法时，将调用子类中的定义，对它而言，父类中的定义如同被"屏蔽"了。如果在一个类中定义了多个同名的方法，它们或有不同的参数个数或有不同的参数类型，则称为方法的重载(Overloading)。
5.2、关键字：super
super关键字的使用
1.super理解为:父类的
2.super可以用来调用:属性、方法、构造器
3.super的使用
3.1 我们可以在子类的方法或构造器中,通过"super.属性"或"super.方法"的方式，显式的调用父类中声明的属性或方法。但是，通常情况下，我们习惯去省略这个"super."
3.2 特殊情况:当子类和父类中定义了同名的属性时，我们要想在子类中调用父类中声明的属性，则必须显式的使用"super.属性"的方式，表明调用的是父类中声明的属性
3.3 特殊情况:当子类重写了父类中的方法后，我们想在子类的方法中调用父类中被重写的方法时，必须显式的使用"super.方法"的方式，表明调用的是父类中被重写的方法。
4.super调用构造器
4.1 我们可以在子类的构造器中显式的使用"super(形参列表)"的方式,调用父类中声明的指定的构造器
4.2"super(形参列表)"的使用，必须声明在子类构造器的首行！
4.3 我们在类的构造器中，针对于"this(形参列表)"或"super(形参列表)"只能二选一，不能同时出现。
4.4在构造器的首行，既没有显式的声明"this(形参列表)"或"super(形参列表)",则默认的调用的是父类中的空参构造器。super()
4.5在类的多个构造器中，至少有一个类的构造器使用了"super(形参列表)",调用父类中的构造器。
子类对象实例化过程
子类对象实例化的全过程
1.从结果上看:
子类继承父类以后，就获取了父类中声明的属性或方法。创建子类的对象中，在堆空间中，就会加载所有父类中声明的属性。
2.从过程上看:
当我们通过子类的构造器创建子类对象时,我们一定会直接或间接的调用其父类构造器,直到调用java.lang.Object类中空参的构造器为止。正因为加载过所有的父类结构，所以才可以看到内存中有父类中的结构，子类对象可以考虑进行调用。
明确:虽然创建子类对象时，调用了父类的构造器，但自始至终就创建过一个对象，即为new的子类对象。
六、多态
面向对象之三:多态性
1.理解多态性:可以理解为一个事物的多种态性。
2.何为多态性:
对象的多态性:父类的引用指向子类的对象(或子类的对象赋值给父类的引用)
3.多态的使用：虚拟方法调用
有了对象多态性以后，我们在编译期，只能调用父类声明的方法，但在执行期实际执行的是子类重写父类的方法
简称：编译时，看左边；运行时，看右边。
若编译时类型和运行时类型不一致，就出现了对象的多态性(Polymorphism)
多态情况下，
看左边”：看的是父类的引用（父类中不具备子类特有的方法）
“看右边”：看的是子类的对象（实际运行的是子类重写父类的方法）
4.多态性的使用前提：
① 类的继承关系
② 方法的重写
5.对象的多态性:只适用于方法，不适用于属性(编译和运行都看左边)
6.1、==操作符与equals方法
一、回顾 ==的使用(运算符)
1.可以使用在基本数据类型变量和引用数据类型变量中
2.如果比较的是基本数据类型变量：比较两个变量保存的数据是否相等。(不一定类型要相同)如果比较的是引用数据类型变量：比较两个对象的地址值是否相同,即两个引用是否指向同一个对象实体
补充: == 符号使用时，必须保证符号左右两边的变量类型一致。
二、equals()方法的使用
1.是一个方法，而非运算符
2.只能适用于引用数据类型。
说明：Object类中定义的equals()和 ==的作用是相同的，比较两个对象的地址值是否相同，即两个引用是否指向同一个对象实体。
4.像String、Date、File、包装类等都重写了Object类中的equals()方法.重写以后，比较的就不是两个引用的地址是否相同，而是比较两个对象的“实体内容”是否相同。
5.通常情况下，我们自定义的类如果使用equals()的话，也通常是比较两个对象的"实体内容"是否相同。那么，我们就需要对Object类中的equals()进行重写。
重写的原则:比较两个对象的实体内容是否相同。
6.2、toString的使用
/*
* Object类中toString()的使用
*
* 1.当我们输出一个引用对象时，实际上就是调用当前对象的toString()
* 2.Object类中toString的定义方法
* public String toString() {
* return getClass().getName() + "@" + Integer.toHexString(hashCode());
* }
*
* 3.像String、Date、File、包装类等都重写了Object类中的toString()方法。
* 使得在调用toString()时，返回"实体内容"信息.
*
* 4.自定义类如果重写toString()方法，当调用此方法时，返回对象的"实体内容".
*/
6.3、包装类(Wrapper)的使用
/*
* 包装类的使用
* 1.java提供了8种基本数据类型对应的包装类，使得基本数据类型的变量具有类的特征
* 基本数据类型 包装类
* byte Byte
* short Short
* int Integer
* long Long
* float Float
* double Double
* boolean Boolean
* char Character
* 注意:其中Byte、Short、Integer、Long、Float、Double的父类是:Number
* /
包装类的自动拆装箱机
进行基本类型数据和包装类对象之间的互转时：
//创建包装类对象有两种方式：new关键字、valueOf()方法。
Integer num1 = new Integer(1); //基本数据类型转为包装类
Integer integer = Integer.valueOf(10);//基本数据类型转为包装类
int num2 = num1.intValue(); //包装类型转为基本数据类型
System.out.println(num1 +" "+ num2);
为了方便使用和性能优化，提供了自动拆装箱机制
//1、包装类中的自动装箱拆箱机制
Integer num1 = 1; //自动装箱
int num2 = num1; //自动拆箱
System.out.println(num1 +" "+ num2);
import org.junit.Test;
/*
* 2.基本数据类型、包装类、String三者之间的相互转换。
*
*/
public class WrapperTest {
//String类型---> 基本数据类型、包装类,调用包装类的parseXxx()
@Test
public void test5(){
String str1 = "123";
// String str1 = "123a";
//错误的情况，可能会报错
// int num1 = (int)str1;
// Integer in1 = (Integer)str1;
int num2 = Integer.parseInt(str1);
System.out.println(num2 + 1); //124
String str2 = "true";
Boolean b1 = Boolean.parseBoolean(str2);
System.out.println(b1); //true
}
//基本数据类型、包装类---》String类型，调用String重载的valueOf(Xxx xxx)
@Test
public void test4(){
int num1 = 10;
//方式1:连接运算
String str1 = num1 + "";
//方式2:调用String的valueOf(Xxx xxx)
float f1 = 12.3f;
String str2 = String.valueOf(f1); //"12.3"
Double d1 = new Double(12.4);
String str3 = String.valueOf(d1);
System.out.println(str2);
System.out.println(str3); //"12.4"
}
/*
* JDK 5.0 新特性:自动装箱与自动拆箱
*/
@Test
public void test3(){
// int num1 = 10;
// //基本数据类型 --》 包装类的对象
// method(num1); //Object obj = num1
//自动装箱:基本数据类型 --》 包装类
int num2 = 10;
Integer in1 = num2;//自动装箱
boolean b1 = true;
Boolean b2 = b1;//自动装箱
//自动拆箱：包装类 --》 基本数据类型
System.out.println(in1.toString());
int num3 = in1;
}
public void method(Object obj){
System.out.println(obj);
}
//包装类 --》 基本数据类型:调用包装类的xxxValue()
@Test
public void test2() {
Integer in1 = new Integer(12);
int i1 = in1.intValue();
System.out.println(i1 + 1);
Float f1 = new Float(12.3f);
float f2 = f1.floatValue();
System.out.println(f2 + 1);
}
//基本数据类型--》包装类,调用包装类的构造器
@Test
public void test1() {
int num1 = 10;
// System.out.println(num1.toString());
Integer in1 = new Integer(num1);
System.out.println(in1.toString());
Integer in2 = new Integer("123");
System.out.println(in2.toString());
//报异常
// Integer in3 = new Integer("123abc");
// System.out.println(in3.toString());
Float f1 = new Float(12.3f);
Float f2 = new Float("12.3");
System.out.println(f1);
System.out.println(f2);
Boolean b1 = new Boolean(true);
Boolean b2 = new Boolean("true");
Boolean b3 = new Boolean("true123");
System.out.println(b3); //false
Order order = new Order();
System.out.println(order.isMale); //false
System.out.println(order.isFemale); //null
}
}
class Order{
boolean isMale;
Boolean isFemale;
}
七、关键字 static和final
7.1、static
static 关键字的使用
1.static:静态的。
2.static 可以用来修饰:属性、方法、代码块、内部类。
3.使用 static 修饰属性:静态变量(或类变量)。
3.1 属性:是否使用 static 修饰，又分为:静态属性 VS 非静态属性(实例变量)
实例变量:我们创建了类的多个对象，每个对象都独立的拥有了一套类中的非静态属性。当修改其中一个非静态属性时，不会导致其他对象中同样的属性值的修饰。
静态变量:我们创建了类的多个对象，多个对象共享同一个静态变量。当通过静态变量去修改某一个变量时，会导致其他对象调用此静态变量时，是修改过的。
3.2 static 修饰属性的其他说明:
① 静态变量随着类的加载而加载。可以通过"类.静态变量"的方式进行调用。
② 静态变量的加载要早于对象的创建。
③ 由于类只会加载一次，则静态变量在内存中也只会存在一次。存在方法区的静态域中。
④ 类变量 实例变量
类 yes no
对象 yes yes
3.3 静态属性举例:System.out ; Math.PI;
4.使用 static 修饰方法:静态方法
① 随着类的加载而加载，可以通过"类.静态方法"的方式调用
② 方法 非静态方法
类 yes no
对象 yes yes
③静态方法中，只能调用静态的方法或属性
非静态的方法中，可以调用所有的方法或属性
5.static 注意点:
5.1在静态的方法内，不能使用 this 关键字、super 关键字
5.2 关于静态属性和静态方法的使用，大家从生命周期的角度去理解。
6.开发中，如何确定一个属性是否需要声明 static 的？
》 属性是可以被多个对象所共享的，不会随着对象的不同而不同的。
》 类中的常量也常常声明为 static
开发中，如何确定一个方法是否要声明为 static 的？
》 操作静态属性的方法，通常设置为 static 的
》 工具类中的方法，习惯上声明为 static 的。比如：Math、Arrays、Collections
7.2、final
1.final可以用来修饰的结构:类、方法、变量
2.final用来修饰一个类:此类不能被其他类所继承。比如:String类、System类、StringBuffer类
3.final修饰一个方法:final标记的方法不能被子类重写。比如：Object类中的getClass()。
4.final用来修饰变量:此时的"变量"(成员变量或局部变量)就是一个常量。名称大写，且只能被赋值一次。
4.1 final修饰属性，可以考虑赋值的位置有:显式初始化、代码块中初始化、构造器中初始化
4.2 final修饰局部变量:
尤其是使用final修饰形参时，表明此形参是一个常量。当我们调用此方法时，给常量形参赋一个实参。
一旦赋值以后，就只能在方法体内使用此形参，但不能进行重新赋值。
static final 用来修饰:全局常量
八、代码块、抽象类和抽象方法、接口
8.1、代码块
代码块（或初始化块）
1.代码块的作用：用来初始化类、对象的
2.代码块如果有修饰的话，只能使用 static
3.分类:静态代码块 vs 非静态代码块
4.静态代码块
- 内部可以有输出语句
随着类的加载而执行,而且只执行一次- 作用:初始化类的信息
- 如果一个类中，定义了多个静态代码块，则按照声明的先后顺序执行
- 静态代码块的执行，优先于非静态代码块的执行
静态代码块内只能调用静态的属性、静态的方法，不能调用非静态的结构5.非静态代码块
- 内部可以有输出语句
随着对象的创建而执行每创建一个对象，就执行一次非静态代码块。- 作用:可以在创建对象时，对对象的属性等进行初始化。
- 如果一个类中，定义了多个非静态代码块，则按照声明的先后顺序执行
非静态代码块内可以调用静态的属性、静态的方法，或非静态的属性、非静态的方法。对属性可以赋值的位置:
①默认初始化
②显式初始化
③构造器中初始化
④有了对象以后，可以通过"对象.属性"或"对象.方法"的方式，进行赋值。
⑤在代码块中赋值
8.2、抽象类和抽象方法
随着继承层次中一个个新子类的定义，类变得越来越具体，而父类则更一般，更通用。类的设计应该保证父类和子类能够共享特征。有时将一个父类设计得非常抽象，以至于它没有具体的实例，这样的类叫做抽象类
1.abstract:抽象的
2.abstract 可以用来修饰的结构:类、方法
3.abstract修饰类:抽象类
- 此类
不能实例化- 抽象类中
一定有构造器，便于子类实例化时调用(涉及:子类对象实例化全过程)- 开发中，都会提供抽象类的子类，让子类对象实例化，实现相关的操作
4.abstract
修饰方法:抽象方法
- 抽象方法，
只有方法的声明，没有方法体。- 包含抽象方法的类，一定是一个抽象类。反之，抽象类中可以没有抽象方法
- 若子类重写了父类中所有的抽象方法，此子类方可实例化；若子类吗，没有重写父类中的所有的抽象方法，则此子类也是一个抽象类，需要使用abstract修饰
abstract 使用上的注意点:
1.abstract不能用来修饰变量、代码块、构造器；
2.abstract 不能用来修饰私有方法、静态方法、final 的方法、final 的类。
8.3、接口
一方面，有时必须从几个类中派生出一个子类，继承它们所有的属性和方法。但是，Java 不支持多重继承。有了接口，就可以得到多重继承的效果。
另一方面，有时必须从几个类中抽取出一些共同的行为特征，而它们之间又没有 is-a 的关系，仅仅是具有相同的行为特征而已。例如：鼠标、键盘、打印机、扫描仪、摄像头、充电器、MP3 机、手机、数码相机、移动硬盘等都支持 USB 连接。
接口就是规范，定义的是一组规则，体现了现实世界中“如果你是/要…则必须能…”的思想。继承是一个"是不是"的关系，而接口实现则是"能不能"的关系。
接口的本质是契约，标准，规范，就像我们的法律一样。制定好后大家都要遵守。
接口(interface)是
抽象方法和常量值定义的集合。
接口的特点：
- 用 interface 来定义。
- 接口中的所有
成员变量都默认是由 public static final 修饰的。- 接口中的所有
抽象方法都默认是由 public abstract 修饰的。- 接口中
没有构造器。- 接口采用多继承机制。
标签：重写,Java,int,子类,汇总,内容,父类,方法,属性 From： https://blog.csdn.net/qq_45606619/article/details/1369883231.接口使用 interface 来定义。
2.在 Java 中:接口和类是并列的两个结构
3.如何去定义两个接口:定义接口中的成员
3.1 JDK7 及以前:只能定义全局常量和抽象方法
全局常量:public static final 的,但是书写中，可以省略不写。
抽象方法:public abstract 的
3.2 JDK8:除了全局常量和抽象方法之外，还可以定义静态方法、默认方法。
4.接口中不能定义构造器！意味着接口不可以实例化。
5.Java 开发中，接口通过让类去实现(implements)的方式来使用。如果实现类覆盖了接口中的所有方法，则此实现类就可以实例化;如果实现类没有覆盖接口中所有的抽象方法，则此实现类仍为一个抽象类
6.Java 类可以实现多个接口 -->弥补了 Java 单继承性的局限性
格式:class AA extends BB implementd CC,DD,EE
7.接口与接口之间是继承,而且可以多继承
8.接口的具体使用，体现多态性
接口的主要用途就是被实现类实现。（面向接口编程）