提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

JAVA基础

提示：这里可以添加本文要记录的大概内容：

例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。

---

提示：以下是本篇文章正文内容，下面案例可供参考

三、方法

一、数组

1 数组基础

1.1 数组初始化

静态初始化、动态初始化

//静态初始化：创建+赋值
int[] a={1,2,3,4,5,6,10};
//动态初始化:包含默认初始化即没有被赋值的元素就是0
int[] b=new int[10];
b[0]=10;

1.2 数组的四个基本特点

（1）其长度是确定的，数组一旦被创建，他的大小不可以改变
（2）其元素必须是相同类型，不允许出现混合类型
（3）数组中的元素可以是任何数据类型，包括基本类型和引用类型
（4）数组变量引用类型，数组也可以看成是对象，数组中的每个元素相当于该对象的成员变量，数组本身就是对象，java中对象是堆中的，因此数组无论保存原始类型还是其他对象类型，数组对象本身是在堆中的。

1.3 数组的使用

遍历数组、查找数组中的最大值、反转数组、打印数组

int[] array={1,2,3,4};
//遍历数组
for (int i=0;i<array.length;i++){System.out.println(array[i]);
}
//查找数组中的最大元素
public static void main(String[] args) {int[] array={1,98,78,30,50};int max=array[0];for (int i = 0; i < array.length; i++) {if(array[i]>max){max=array[i];}}System.out.println(max);}public static void main(String[] args) {int[] arrays = {1, 2, 3, 4, 6};//printArray(arrays);int[] reverse=reverse(arrays);printArray(reverse);}//反转数组public static int[] reverse(int[] arrays) {int[] result=new int[arrays.length];//反转操作for (int i = 0,j=result.length-1;i <arrays.length ; i++,j--) {result[j]=arrays[i];}return result;}//打印数组public static void printArray(int[] arrays){for (int i = 0; i <arrays.length ; i++) {System.out.print(arrays[i]+" ");}

1.4 多维数组

多维数组：可以看成是数组的数组，比如二维数组就是一个特殊的一维数组，其每一个元素都是一个一维数组。
(a) 二维数组打印某一个数
(b)二维数组打印某一行
© 二维数组的打印方式

public static void main(String[] args) {int a[][]=new int[2][5];int[][] array={{1,2},{3,4}};printArray(array[0]);//打印array第0行printArray(array[1]);//打印array第1行System.out.println(array[0][1]);//打印array的第0行第一个元素System.out.println(array[0][0]);//打印array的第0行第0个元素//打印二维数组的方式：for (int i = 0; i < array.length; i++) {for (int j = 0; j < array[i].length; j++) {System.out.println(array[i][j]);}}}//打印数组public static void printArray(int[] array){for (int i = 0; i <array.length ; i++) {System.out.print(array[i]+" ");}}

2、数组的应用

2.1 Arrays 类

数组的工具类java.util.Arrays
由于数组对象本身并没有什么方法可以供我们调用，但API中提供了一个工具类Arrays供我们使用，从而可以对数据对象进行一些基本的操作。
查看JDK帮助文档
Arrays类中的方法都是Static修饰的静态方法，在使用的时候可以直接使用类名进行调用，而“不用”使用对象来调用（注意：是“不用”而不是“不能”）
具有以下常用功能：
1、给数组赋值：通过fill方法
2、对数组排序：通过sort方法，按升序
3、比较数组：通过equals方法比较数组中元素值是否相等
4、查找数组元素：通过binarySearch方法能对排序好的数组进行二分查找法操作。

打印数组:Arrays.toString
自己仿照Arrays类进行打印数组

    public static void main(String[] args) {int[] a={1,27,3,4,566,788,4};System.out.println(a);//[I@1540e19d//打印数组元素用Arrays.toStringSystem.out.println(Arrays.toString(a));printArray(a);}//自己的方法打印public static void printArray(int[] a) {for (int i = 0; i < a.length; i++) {if(i==0){System.out.print("[");}if(i==a.length-1){System.out.print(a[i]+"]");}else {System.out.print(a[i]+", ");}}}

Arrays.sort 升序排序打印数组

      public static void main(String[] args) {int[] a={234,556,67,254,66,43};Arrays.sort(a);//数组排序System.out.println(Arrays.toString(a));//打印数组元素}

Arrays.fill 数组填充：将数组所有元素都填充成val的值：

public class Demo3_Arrayssort {public static void main(String[] args) {int[] a={234,556,67,254,66,43};Arrays.sort(a);//数组排序System.out.println(Arrays.toString(a));//打印数组元素Arrays.fill(a,0);//数组填充System.out.println(Arrays.toString(a));Arrays.fill(a,2,4,0);//第二个元素到第四个元素之间被0填充System.out.println(Arrays.toString(a));}
}
//打印结果：
// [43, 66, 67, 234, 254, 556]
//[0, 0, 0, 0, 0, 0]
//[43, 66, 0, 0, 254, 556]

2.2 排序算法（8种）

（1）冒泡排序

比较数组中两个相邻的元素，如果第一个数比第二数大就交换位置；
每一次比较都会产生出一个最大或者最小的数字；
下一轮则可以少一次排序；
依次循环，直到结束。

    public static void main(String[] args) {int[] a={2,8,9,5,74,23};int[] sorts=sorta(a);//调用完我们自己写的排序方法以后，返回一个排序后的数组System.out.println(Arrays.toString(sorts));}//冒泡排序public static int[] sorta(int[] a) {int temp=0;//外层循环，判断我们这个要走多少次for (int i = 0; i <a.length-1 ; i++) {//内层循环，比较判断2个数，第一个比第二个数大就交换位置for (int j = 0; j <a.length-1-i ; j++) {if (a[j]>a[j+1]){temp=a[j];a[j]=a[j+1];a[j+1]=temp;}}}return a;}

2.3 数据结构——稀疏数组

二、面向对象

1 面向过程思想

步骤清晰简单，第一步做什么，第二步做什么…
面对过程适合处理一些较为简单的问题

2 面向对象思想

物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。
面向对象适合处理复杂的问题，适合处理需要多人协作的问题！
总结： 对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。

3 面向对象编程（Object-Oriented Programing，OOP）

**面向对象编程的本质：**以类的方式组织代码，以对象的组织（封装)数据。
三大特性： 封装、继承、多态
从认识角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象。
从代码运行角度考虑是先有类后有对象。类是对象的模板。

4 方法

4.1 方法的定义

修饰符
返回类型
break：跳出Switch，结束循环和return的区别
方法名：注意规范就ok，驼峰命名+见名如意
参数列表：（参数类型，参数名）…
异常抛出：IOException

4.2 方法的调用

静态方法
非静态方法
形参和实参
值传递和引用传递
this关键字

方法：
修饰符 返回值类型 方法名（…）{
//方法体
return 返回值；
}

    public String sayhello(){return "hello world";}public void hello(){return;//void类型 返回是空}public int max(int a,int b){return a>b?a:b;//三元运算符：如果a大于b就返回a，否则返回b}//抛出异常//数组下标越界异常：ArrayIndexOutOfBoundsExceptionpublic void readFile(String file)throws IOException{}

方法的调用
想要调用学生类（静态方法）：直接类.方法名

public class Demo02 {public static void main(String[] args) {//静态方法:类名.方法名Student.say();}
}

//学生类
public class Student {//静态方法public static void say(){System.out.println("学生说话了");}
}

想要调用学生类（非静态）：需要new这个方法

public class Demo02 {public static void main(String[] args) {//非静态方法：//实例化这个类 new//对象类型 对象名=对象值Student student=new Student();student.say();}
}

public class Student {//非静态方法public void say(){System.out.println("学生说话了");}
}

两个方法同时是static，互相调用不出错
两个方法同时不是static，互相调用也不出错
一个方法是static，一个方法不是static时，调用会出错
原因如下：

      //和类一起加载的public static void a() {b();}//类实例化之后才存在public void b() {}

4.3 实参和形参

实际参数和形式参数的类型要对应

public class Demo03 {public static void main(String[] args) {int add=Demo03.add(1,2);//实参System.out.println(add);}public static int add(int a,int b){//形参return a+b;}
}

4.4 值传递和引用传递

1、值传递

//值传递
public class Demo03 {public static void main(String[] args) {int a=1;System.out.println(a);Demo03.change(a);System.out.println(a);//a=1}//返回值为空public static void change(int a){a=10;}
}

2、引用传递
引用传递：对象，本质还是值传递

//引用传递：对象，本质还是值传递
public class Demo04 {public static void main(String[] args) {Person person=new Person();System.out.println(person.name);//nullDemo04.change(person);System.out.println(person.name);//杨晨晨}public static void change(Person person) {//person是一个对象：指向的--->Person person=new Person()person.name="杨晨晨";}//定义一个Person类，有一个属性：name
}
class Person{String name;//null
}

5 类与对象的关系

类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一个具体的事物
例如：动物、植物、手机、电脑…
Person类、Pet类、Cat类等，这些类都是用来描述/定义某一类具体的事物应该具备的特点和行为
对象是抽象概念的具体实例
例如：张三就是人的一个具体实例，张三家里的旺财就是狗的一个具体实例
能够体现出特点，展现出功能的是具体的实例，而不是一个抽象的概念。

5.1 创建与初始化对象

使用new关键字创建对象
使用new关键字创建的时候，除了分配内存空间之外，还会给创建好的对象进行默认的初始化以及对类中构造器的调用。
类中的构造器也称为构造方法，是在进行创建对象的时候必须要调用的。并且构造器有以下2个特点：
1、必须和类的名字相同
2、必须没有返回类型，也不能写void。

5.2 类、对象、实例化

一个类中只有属性和方法
类是抽象的，需要被实例化
学生guoyu是类的对象，
创建类的对象的过程就是类的实例化：使用new关键字来实例化一个对象
以下方代码举例：
类=学生
类的对象=学生guoyu
类的实例化=创建对象的过程

//学生类
public class Student {//属性：字段String name;//nullint age;//0//方法public void study(){System.out.println(this.name+"在学习");}
}

public class Aplication {public static void main(String[] args) {//类：抽象的，实例化//guoyu是类的对象，创建类的对象的过程就是类的实例化。//类实例化后会返回一个自己的对象！//国宇对象就是一个Student类的具有实例！Student guoyu = new Student();//类的实例化=创建对象的过程Student yangchenchen = new Student();guoyu.name="国宇";guoyu.age=18;System.out.println(guoyu.name);System.out.println(guoyu.age);}
}

5.3 构造器

Alt+insert 一键生成有参无参构造器
使用new关键字，本质是调用构造器
构造器一般用来初始化值
例如：无参构造

//学生类
public class Student {
//一个类即使什么都不写，它也会存在一个方法
// 显示的定义构造器String name;//实例化初始值//使用new关键字，本质是调用构造器//无惨构造public Student(){this.name="杨晨晨";}
}

public class Aplication {public static void main(String[] args) {//new 实例化了一个对象Student student = new Student();System.out.println(student.name);//杨晨晨}
}

有参构造
（1）一旦定义了有参构造，无参构造必须要写上去，否则new实例化时会报错！

//学生类
public class Student {String name;//无参构造public Student(){}//很重要！！！//有参构造public Student(String name){this.name=name;}
}

public class Aplication {public static void main(String[] args) {//new 实例化了一个对象Student student = new Student();System.out.println(student.name);//杨晨晨}
}

（2）有参构造——new实例化传参数
传递结果只走有参的。

//学生类
public class Student {String name;//无参构造public Student(){}//有参构造public Student(String name){this.name=name;}
}

public class Aplication {public static void main(String[] args) {//new 实例化了一个对象Student student = new Student("yangchenchen");System.out.println(student.name);//杨晨晨}
}

6、创建对象内存分析

栈：方法和变量的引用
堆：存放具体创建出来的对象
下图的具体流程详解及其代码：
1、main方法在栈里的最底下，当栈结束时会被弹出。首先程序先从Application_pet类中进来,进入main函数。
2、当执行到new Pet()时会跳转到宠物Pet类，此时实例化对象dog就有了name和age这两个属性，以及shout方法；但是此时的name 和age没有值。
3、接下来定义dog的name名字叫“富贵”，dog的age是3。此时的dog这个名字是在栈里，真正的dog对象是在堆中，此时name=null，age=0，shout是空。
4、堆中的dog调用方法区的name=‘富贵“，和age=1以及Pet类中的调用的shout()，此时dog就有了名字和年龄。所有的值赋完，dog这个对象在堆中就有值了。以此类推，cat也是，但是cat在方法区中没有赋name和
5、static静态方法区和类一起加载，堆中所有对象都可以调用它。

public class Application_pet {public static void main(String[] args) {Pet dog = new Pet();//创建dog对象dog.age=3;dog.name="富贵";dog.shout();System.out.println(dog.age);System.out.println(dog.name);Pet cat = new Pet();//创建cat对象}
}

public class Pet {public String name;public int age;public void shout() {System.out.println("叫了一声");}
}

7、封装、多态、继承

7.1 封装

该露的露，该藏的藏
程序设计要追求“高内聚，低耦合”。高内聚就是类的内部数据操作细节自己完成，不允许外部干涉；低耦合：仅暴露少量的方法给外部使用
封装（数据的隐藏)
通常，应禁止直接访问一个对象中数据的实际表示，而应通过操作接口来访问，这称为信息隐藏。

(1)属性私有（private）：get/set

使用private 的属性，当实例化类后，实例化对象不能直接调用其属性，所以此时要`采用另一个方式，来操作private属性。使用get/set方法
get：获取这个数据；
set：给这个数据设置值
右键 Generate Getter and Setter自动生成get 和set

public class Application {public static void main(String[] args) {Student s1 = new Student();s1.setName("杨晨晨");s1.setAge(999);//不合法！！！System.out.println(s1.getName());System.out.println(s1.getAge());}
}

public class Student {//名字private String name;//名字private  int id;//学号private char sex;//性别private int age;//年龄//提供一些可以操作这个属性的方法！//提供一些public的get、set方法//get 获得这个数据public String getName(){return this.name;}//set 给这个数据设置值public void setName(String name){this.name=name;}public int getId() {return id;}public void setId(int id) {this.id = id;}public int getAge() {return age;}public void setAge(int age) {if(age<120&&age>0){this.age = age;}else {this.age=3;}}
}

私有化的意义：
（1）提高程序的安全性、保护数据
（2）隐藏代码的实现细节
（3）统一接口
（4）系统可维护增加了

7.2 继承

继承的本质是对某一批类的抽象，从而实现对现实世界更好的建模。
extends是扩展的意思。子类是父类的扩展。
JAVA中类只有单继承，没有多继承！ 一个儿子只能有一个爸爸；一个爸爸可以有多个儿子！
继承是类和类之间的一种关系，除此之外，类和类之间的关系还有依赖、组合、聚合等。
继承关系的两个类，一个为子类（派生类），一个为父类（基类）。子类继承父类，使用**关键字extends来表示。
子类和父类之间，从意义上讲应该具有“is a“的关系。

(1)object 类

super
方法重写
优先级从高到低
public > protected > default > private
【继承】例子如下程序：
父类：人
子类：学生
即使子类里面什么都没写，但是父类里面定义了属性，所以在new子类的实例化对象时，子类对象可以继承父类的属性。

public class Application {public static void main(String[] args) {Student student = new Student();student.say();System.out.println(student.money);}
}

public class Person {//优先级从高到低//public//protected//default//privatepublic int money=10000;public void say(){System.out.println("说了一句话");}
}

public class Student extends Person {
//ctrl+H
}

==================打印结果==================：
说了一句话
10000

在JAVA中，所有的类，都默认直接或者间接继承object类

(2)Super和 this

子类访问父类，
1、想要调用父类的name属性并输出，用super.name
输出当前类的属性值用this.name
2、想要调用父类的构造函数，用super();
super需要注意：
1、super是调用父类的构造方法，必须在构造方法的第一个
2、super必须只能出现在子类的方法或者构造方法中
3、super和this不能同时调用构造方法
super VS this：
1、super和this代表的对象不同：
this：本身调用这个对象
super：代表父类对象的应用
前提
this:没有继承也可以使用
super:只能在继承条件下才可以使用
构造方法
this():本类的构造
super()：父类的构造

public class Aplication {public static void main(String[] args) {Student student = new Student();student.test("杨");student.test1();}
}

public class Person {public Person(){System.out.println("Person无参执行了");}protected String name="ren";public void print(){System.out.println("Person");}
}

public class Student extends Person{public Student(){//隐藏代码：默认调用了父类的无参构造super();//调用父类的构造器，必须要在子类构造器的第一行System.out.println("Student无参构造执行了");System.out.println("=======1=======");}private String name="yangchenchen";public void print(){System.out.println("Student");}public void test1(){print();this.print();//当前类的public定义的函数super.print();//父类的public定义的函数System.out.println("=========3=========");}public void test(String name){System.out.println(name);//传递的参数System.out.println(this.name);//当前属于哪个类就输出类里面的东西System.out.println(super.name);//输出的事父类的东西System.out.println("=========2=========");}
}

打印结果：
Person无参执行了
Student无参构造执行了
=======1=======
杨
yangchenchen
ren
=========2=========
Student
Student
Person
=========3=========Process finished with exit code 0

(3) private、default、projected、public的优先级

public>projected>default>private
**public：**所有类均可见
**projected：**同一个包下的类，以及所有子类都可见
**default：**只有同一个包下的类可见
private只对本类可见

(4)方法的重写

重写：非静态条件下是前提，需要有继承关系，子类重写父类的方法！
1、方法名必须相同
2、参数列表必须相同
3、修饰符：范围可以扩大，但不能缩小。
4、抛出的异常：范围，可以被缩小，但不能扩大：ClassNotFoundException–>Exception(大)
口诀：方法看左边，实现看右边！
意思是：先看左边的类名，是Animal，找到Animal的类中是否有bark方法、sleep属性，有的话说明该bark函数、sleep函数可以被调用；再看右边，是Cat类，所以最后实现的结果是Cat中的bark函数里的值，和sleep函数的值，由于Cat类里面没有特殊的sleep函数，Cat是Animal的子类，Cat继承Animal类的所有方法，所以对于sleep函数也可以调用父类的值。代码如下：

    //方法看左边，实现看右边！Animal a1=new Cat();//子类重写了父类的方法a1.bark();//结果：喵喵喵~a1.sleep();//结果：Animal is sleeping

完整代码如下：

public class Application {public static void main(String[] args) {//方法看左边，实现看右边！Animal a = new Animal();a.bark();Cat b = new Cat();b.sleep();//方法看左边，实现看右边！Animal a1=new Cat();a1.bark();a1.sleep();
//        Cat c=new Animal();//错误！！！这句话的意思是：动物是猫？所以是错误的
//        c.bark();}
}

public class Animal {public void bark() {System.out.println("Animal is barking");}public  void sleep(){System.out.println("animals is sleeping");}
}

public class Cat extends Animal{@Overridepublic void bark() {System.out.println("喵喵喵~");}public void eating(){System.out.println("吃鱼！");}
}

打印结果：
Animal is barking
animals is sleeping
喵喵喵~
animals is sleepingProcess finished with exit code 0

静态方法与非静态方法的区别很大
重写的前提是在非静态的条件下，如下程序，想要实现cat的bark方法喵喵喵，在非静态的条件下，重写父类方法，达到效果；但是在静态Static条件下，
不能起到重写的效果，所以结果还是父类的bark函数里的结果。代码如下：

public class Animal {public static void S_bark() {System.out.println("静态Animal is barking");}public void bark() {System.out.println("非静态Animal is barking");}
}

public class Cat extends Animal{public static void S_bark() {System.out.println("静态喵喵喵~");}@Overridepublic void bark() {System.out.println("非静态喵喵喵~");}
}

public class Application {public static void main(String[] args) {Animal a1=new Cat();a1.barking();a1.bark();}
}

打印结果：
静态Animal is barking
非静态喵喵喵~Process finished with exit code 0

7.3多态

动态编译：类型：可扩展性
即同一方法可以根据发送对象的不同而采用多种不同的行为方式。
一个对象的实际类型是确定的，但可以指向对象的引用的类型有很多。
多态存在的条件
有继承关系
子类重写父类的方法
父类引用指向子类对象
注意：多态是方法的多态，属性没有多态性
强转类型：父类和子类之间是有的关系的前提下才可以转换。
类型转换异常：ClassCastException!
强转类型举例代码如下：

        Animal a = new Cat();//由于a是Animal类型的，父类没有eating函数，想要调用子类的eating函数//可以采用强转类型((Cat) a).eating();

多态总结：
1、多态是方法的多态，属性没有多态
2、类型转换的前提是：父类和子类，没有关系的类型之间不可以转换
3、当父类和子类的方法名字重复时，需要override进行方法重写
4、以下情况不能进行方法重写：
（1)Static 状态下的方法，它属于类不属于实例
（2）final 常量
（3）private 定义的方法

(1)instanceof关键字类型转换

可以判断两个类之间是否存在父子关系，通过bool类型返回结果如下：

public class Application {public static void main(String[] args) {//判断下面是否可以编译通过，就看下面这句话X与y是否为父子类关系，如果没有父子关系，编译就会报错//X x=new m();//System.out.println(x instanceof y);//判断True or false 就看x所指向的类型是不是y的子类型。//Object>String//Object > Person > Teacher//Object > Person > StudentObject object = new Student();System.out.println(object instanceof Object);//trueSystem.out.println(object instanceof String);//falseSystem.out.println(object instanceof Person);//trueSystem.out.println(object instanceof Teacher);//false Object和Teacher是父子关系，但是Student与teacher无关System.out.println(object instanceof Student);//trueSystem.out.println("========================");Person person = new Student();System.out.println(person instanceof Object);//true//System.out.println(person instanceof String);//报错！！Person与String不是父子关系System.out.println(person instanceof Person);//trueSystem.out.println(person instanceof Student);//trueSystem.out.println(person instanceof Teacher);//falseSystem.out.println("========================");Student student = new Student();System.out.println(student instanceof Object);//true//System.out.println(student instanceof String);//报错！！Student与String不是父子关系System.out.println(student instanceof Person);//trueSystem.out.println(student instanceof Student);//true//System.out.println(student instanceof Teacher);//报错！！Student与String不是父子关系}
}

(2)Static 总结

（1）静态属性：
（2）静态方法：
静态属性：

public class Student {private static int age;//静态变量 多线程！private double score;//非静态变量public static void main(String[] args) {Student s1 = new Student();System.out.println(Student.age);//System.out.println(Student.score);报错System.out.println(s1.score);System.out.println(s1.age);}
}

静态方法
被final修饰的类，不能被继承——断子绝孙
例如：public final class Person
静态方法举例

public class Student {public static void go(){}public void run(){}public static void main(String[] args) {Student.go();//Student.run();//报错！！！go();//run();//报错！！！}
}

代码块

public class Student{{//代码块（匿名代码块）//创建对象的时候就出现了，而且是在构造器之前System.out.println("2匿名代码块");}static {//静态代码块，类一加载就执行，永久执行System.out.println("1静态代码块");}public Student() {System.out.println("3构造器");}public static void main(String[] args) {Student student = new Student();System.out.println("======================");Student student1 = new Student();}
}

打印结果：
1静态代码块
2匿名代码块
3构造器
======================
2匿名代码块
3构造器Process finished with exit code 0

(3)抽象类——abstract*

抽象类的所有方法，继承了它的子类，都必须要实现它的方法~

public abstract class Action {//自己不想实现，找人帮我们实现//abstract，抽象方法，只有方法名字，没有方法的实现public abstract void doSomething();//1、抽象类不能new，只能靠子类去实现它；约束！//2、抽象类可以写普通方法//3、抽象方法必须在抽象类中//抽象的抽象：约束~
}

//抽象类的所有方法，继承了它的子类都必须要实现它的方法
public class A extends Action {@Overridepublic void doSomething() {}
}

(4)接口

普通类：只有具体实现
抽象类：具体实现和规范（抽象方法）都有！
接口：只有规范！自己无法写方法专业的约束！约束和实现分类：面向接口编程~
接口就是规范，定义的是一组规则，体现了现实世界中“如果你是…则必须能…"的思想。如果你是天使，则必须能飞。如果你是汽车，则必须能跑。如果你是好人，则必须干掉坏人。
接口的本质是契约，就像我们人间的法律一样。制定好后大家都遵守。
接口的精髓，是对对象的抽象，最能体现这一点的就是接口，为什么我们讨论设计模式都只针对具备了抽象能力的语言（比如C++、java、c#等），就是因为设计模式所研究的，实际上就是如何合理的去抽象。
声明类的关键字是class，声明接口的关键字是interface。
接口和类的区别：类有方法的实现，接口没有，接口只有方法的定义。

接口中所有定义的方法其实都是抽象的public abstract
接口中所有定义的属性都是常量，是public static final

//接口定义：
public interface UserService {//常量 public static finalint AGE=99;//接口中的所有定义其实都是抽象的public abstractvoid add(String name);void delete(String name);void update(String name);void query(String name);
}

//接口定义：
public interface TimeService {void timer();
}

实现多继承-不同的接口不同方法继承

public class UserServiceimpl implements UserService,TimeService{@Overridepublic void add(String name) {}@Overridepublic void delete(String name) {}@Overridepublic void update(String name) {}@Overridepublic void query(String name) {}@Overridepublic void timer() {}
}

总结
1、接口不能被实例化~接口中没有构造方法
2、接口负责定义一些方法，让不同的人去实现
3、接口可以实现多个，用implements可以实现多个接口
4、实现接口必须要重写接口中的方法

(5)内部类

内部类就是一个类的内部在定义一个类，比如，A类中定义一个B类，那么B类相对A类来说就称为内部类，而A类相对B类来说就是外部类了。
1、成员内部类
2、静态内部类
3、局部内部类
4、匿名内部类

public class Application {public static void main(String[] args) {Outer outer = new Outer();//通过外部类实例化对象内部类Outer.Inner inner = outer.new Inner();inner.in();inner.getID();}
}

public class Outer {private int id;public void out(){System.out.println("这是外部类的方法");}public class Inner{public void in(){System.out.println("这是内部类的方法");}//获得外部类的私有属性public void getID(){System.out.println(id);}}
}

局部内部类、内部类
一个java类中可以有多个class类，但只能有一个public class

public class Outer {public void method(){//局部内部类class Inner{public void in(){}}}
}
//一个java类中可以有多个class类，但只能有一个public class
class A{}

public class Outer {public static void main(String[] args) {//没有名字去初始化类new Apple();//类同样可以调用方法,不用将实例保存到变量中new Apple().eat();new UserService(){};}}
class Apple {public void eat(){System.out.println("1");}
}
interface UserService{}

8、异常

异常处理机制
·抛出异常
·捕获异常
异常处理五个关键字
try catch finally throw throws
在程序中使用自定义异常类，大体可以分为以下几个步骤：
1、创建自定义异常类
2、在方法中通过throw关键字抛出异常
3、如果在当前抛出异常的方法中处理异常，使用

public class Test {public static void main(String[] args) {int a=1;int b=0;try {//try监控区域System.out.println(a/b);}catch (ArithmeticException e){//catch 捕获异常System.out.println("程序出现异常，变量b不能为0");}finally {//处理善后工作System.out.println("finally");}}
}

主动抛出异常:
在方法里面抛出异常是throw
在方法上抛出异常是throws

public class Test {public static void main(String[] args) {new Test().test(1,0);}public void test(int a,int b){if (b==0){throw new ArithmeticException();//主动抛出异常，一般在方法中使用}}
}