1.1接口概念
类:具有相同属性和功能的事物集合

接口是功能的集合，同样可看做是一种数据类型，是比抽象类更为抽象的”类”。

接口只描述所应该具备的方法，并没有具体实现，具体的实现由接口的实现类(相当于接口的子类)来完成。这样将功能的定义与实现分离，优化了程序设计。
请记住：一切事物均有功能，即一切事物均有接口。

与定义类的class不同，接口定义时需要使用interface关键字。
定义接口所在的仍为.java文件，虽然声明时使用的为interface关键字的编译后仍然会产生.class文件。这点可以让我们将接口看做是一种只包含了功能声明的特殊类。

使用interface代替了原来的class，其他步骤与定义类相同：
 接口中的方法均为公共访问的抽象方法
 接口中无法定义普通的成员变量

类与接口的关系为实现关系，即类实现接口。实现的动作类似继承，只是关键字不同，实现使用implements。
其他类(实现类)实现接口后，就相当于声明：”我应该具备这个接口中的功能”。实现类仍然需要重写方法以实现具体的功能。

在类实现接口后，该类就会将接口中的抽象方法继承过来，此时该类需要重写该抽象方法，完成具体的逻辑。
 接口中定义功能，当需要具有该功能时，可以让类实现该接口，只声明了应该具备该方法，是功能的声明。
 在具体实现类中重写方法，实现功能，是方法的具体实现。
于是，通过以上两个动作将功能的声明与实现便分开了。(此时请重新思考：类是现实事物的描述，接口是功能的集合。)

1.4接口中成员的特点
1、接口中可以定义变量，但是变量必须有固定的修饰符修饰，public static final 所以接口中的变量也称之为常量，其值不能改变。后面我们会讲解static与final关键字
2、接口中可以定义方法，方法也有固定的修饰符，public abstract
3、接口不可以创建对象。
4、子类必须覆盖掉接口中所有的抽象方法后，子类才可以实例化。否则子类是一个抽象类。

1.5接口特点
 接口可以继承接口
如同类继承类后便拥有了父类的成员，可以使用父类的非私有成员。A接口继承B接口后，A接口便拥有了A、B两个接口中所有的抽象方法。
 Java支持一个类同时实现多个接口，或一个接口同时继承多个接口。
 类可以在继承一个类的同时，实现多个接口。
接口与父类的功能可以重复，均代表要具备某种功能，并不冲突。

3、通过上面的例子总结接口和抽象类的区别：
相同点:
 都位于继承的顶端,用于被其他类实现或继承;
 都不能直接实例化对象;
 都包含抽象方法,其子类都必须覆写这些抽象方法;
区别:
 抽象类为部分方法提供实现,避免子类重复实现这些方法,提高代码重用性;
 接口只能包含抽象方法;
 一个类只能继承一个直接父类(可能是抽象类),却可以实现多个接口;(接口弥补了Java的单继承)

 抽象类为继承体系中的共性内容,接口为继承体系外的扩展功能

 

二者的选用:
 优先选用接口,尽量少用抽象类;
 需要定义子类的行为,又要为子类提供共性功能时才选用抽象类;

包的特点:
A:可以有多层
B:不同包下的文件名可以

C:包的声明必须是第一行代码

不同包之间的互相访问
1.使用类的全名

2.使用关键字import 将类导入

注意:*代表得是通配符,代表导入了这个包所有的类,并没有导入子包下的类

相同包下的类可以直接访问,不需要做其他的操作

类的全名:包名.类名

权限修饰符:
public 当前类,相同包下不同的类,不同包下的类
default 当前类,相同包下不同的类,
private 当前类
protected 当前类,相同包下不同的类

default : 当前包下使用
protected:让子类对象使用

在Java中提供了四种访问权限，使用不同的访问权限时，被修饰的内容会有不同的访问权限，以下表来说明不同权限的访问能力：
public protected default private
同一类中 √ √ √ √
同一包中(子类与无关类) √ √ √
不同包的子类 √ √
不同包中的无关类 √
归纳一下：在日常开发过程中，编写的类、方法、成员变量的访问
A:要想仅能在本类中访问使用private修饰
B:要想本包中的类都可以访问除了private修饰符,其它都可以
C:要想本包中的类与其他包中的子类可以访问使用protected修饰
D:要想所有包中的所有类都可以访问使用public修饰。
注意：如果类用public修饰，则类名必须与文件名相同。一个文件中只能有一个public修饰的类。

成员内部类:
* 在类的成员位置,和成员变量以及成员方法所在的位置是一样的.
* 在内部类当中,科院直接访问外部类的成员,包括私有成员

成员内部类的修饰符:
* 可以使用权限修饰符修饰成员内部类,但是如果使用私有来修饰,则无法再其他类中被访问.
* 我们可以使用static 修饰成员内部类,不用在创建外部类的对象了
*
* 我们可以使用abstract,final修饰成员内部类

局部内部类:
* 在方法内,出了方法之后就无法使用

局部内部类:
* 在方法内,出了方法之后就无法使用
*
* 匿名内部类:
* 可以把匿名内部类看成是一个没有名字的局部内部类
* 定义在方法当中
* 必须在定义匿名内部类的时候创建他的对象
* 格式:
* new 类/接口() {
* 如果是创建了继承这个类的子类对象,我们可以重新父类的方法
* 如果是创建了实现这个接口的子类对象,我们必须要实现该接口的所有方法
* }
*
* 原理:而是创建了继承这个类的子类对象或者是创建了实现这个接口的子类对象
*
* 匿名内部类的应用场景:
* 作为参数进行传递

Object : equals , toString

Object类中的equals:
* 默认比较的是两个对象的地址,是当前对象和参数传入的对象
* 但是我们可以重写equals方法,让比较按照我们的想法比较
* 比如java中String也是重写了equals,比较了字符串的内容,而不是地址
*
* Object类中的toString方法:
* 这个方法 可以方法一个字符串,这个字符串用来表示当前对象
* 默认返回值:包名.类名@地址值
* 实际上 syso(对象名) 等价于 syso(对象名.toString())
* 但是我们也可以重写toString 打印出我们要的信息 而不是一个地址值
*
* 总结:实际开发中定义一个类 我们通常
* 1.封装
* 2.构造
* 3.重写equals
* 4.toString();//方便查看对象的信息


* 程序的异常:(程序中出现的问题)
* 根类Throwable
* |- Error(错误类)是程序很严重的问题,如果出现了 改代码
* 人:肝癌,脑袋被砍了
* |- Exception(编译时异常类)也是程序出现问题,自己可以处理的小问题
* 人:感冒,发烧,牙疼..
* |- RuntimeExcetpion(运行时异常)
*
* java中异常类的常见操作
*
* 1.先要有异常,一般来说 java的异常java自己常见对象,我们自己定义一个异常,我们自己常见对象
*
* 2.抛出异常(不管了)
*
* 3.捕获异常(自己处理)
*
* 抛出异常的关键字:throw, 抛出的动作,是真正的把异常对象抛出去


* 1.throw:抛出异常动作
*
* 2.throws:一种声明,throws是给方法做声明的,表示这个方法可能抛出异常,要求方法的调用者去处理
*
* 3.处理异常的方法:
* 3.1再声明抛出
* 3.2捕获方式:
* try{
* 可能出现异常的代码;
* }catch(Exception e){
* //如果上面的代码,真的出现了异常 那么就会被抓住
* //就是把异常对象赋值给了 e
* //自己处理
* }finally{
* //最终必须要执行的代码
* //一般放释放资源的代码
* }
* 捕获异常还有其他的方式:
* try{
* }finally{
* }
* try{
* }catch(Exception e){
* }
* 关于catch抓住异常 也有其他写法
* 处理：
* 1多个异常分别处理 我们基本不用
* 2多个异常一次捕获多次处理
* 3多个异常一次捕获一次处理 ***********
*


* 异常的分类:
* 1.编译时异常: Exception以及它的子类(RuntimeException)
* 2.运行时异常: RuntimeExcetion以及它的子类
*
* 我们如何区分哪个是编译异常 哪个是运行异常?

编译期异常抛出，将来调用者必须处理。
运行期异常抛出，将来调用可以不用处理。

javac出来的异常就是编译时异常，就是说把源代码编译成字节码（class）文件时报的异常，一般如果用Eclispe,你敲完代码保存的时候就是编译的时候。

Java出来的异常就是运行时异常

/自定义异常固定的套路
//1.必须继承Exception或者RuntimeException
//2.写两个构造,一个空参,一个带有异常信息的String类型参数
//throw new NoSuchAgeException("年龄不合法的异常");

能够辨别程序中异常(Exception)和错误(Error)的区别
* 错误:是程序出现非常严重的问题,必须修改源代码
* 异常:是程序出现的小问题,给出问题的代码加上处理方式
*
* 说出异常的分类:
* 根类:Throwable
* |-Error
* |-Exception:编译时异常
* |-RuntimeException:运行时异常
* 说出虚拟机处理异常的方式
* 终断方式:
* 1.打印异常信息
* 2.终止JVM运行
* 列举出常见的四个运行期异常
* NullPointerException
* ArrayIndexOutofBoundsException
* StringIndexOutofBoundsException
* ClassCastException;//类型转型异常,猫不能转成狗
*
* 能够使用try...catch关键字处理异常
* 标准方式: try{..可能出异常的代码..}catch(异常类型 变量名){...}finally{..释放资源的代码..}
* 奇葩的方式:
* try{....}finally{...}
* try{....}catch(异常类型 变量名){..}
* catch捕获异常的方式:
* 1.一个异常一个捕获 一次处理 (多个try 多个catch)
* 2.多个异常一次捕获 多次处理(一个try,多个catch);
* 3.多个异常一个捕获,一次处理(一个try 一个catch)
* 能够使用throws关键字处理异常
* throw:就是真正抛出一个异常
* throws:给方法用的,给方法做声明,声明这个方法可能抛出异常,要求调用者去处理
* 能够自定义异常类
* 固定套路:
* 1.定义一个Exception结尾异常类,继承Exception或者RuntimeException
* 2.两个构造:无参数,带有异常信息的String类型参数
* 能够处理自定义异常类
* 如果自定义异常继承RuntimeException 编译时不会出错,我们也不需要处理
* 如果自定义异常继承Exception,这时候我们需要处理(throws声明抛出,try..catch)
* 能够理解Object的equals方法
* equals方式定义在Object类中,默认实现判断当前对象和形式参数对象,是否地址相同
* public boolean equals(Object obj){
*
* return (this==obj);
* }
* 如果我们想改变equals判断规则,那么我们自己重写equals
*
* 能偶理解Object的toString方法
* toString方法定义在Object类中,默认实现打印下面的格式: 包名.类名@地址值
* 我们也可以重写toString打印出来我们要的对象信息
*
* syso(对象名)====>syso(对象名.toString())
*

当定义一个Animal类时,我们发现我们并没有写成员方法,但是能调用,这是因为它继承了Object类.
Object类是Java语言中的根类，即所有类的父类。它中描述的所有方法子类都可以使用。所有类在
创建对象的时候，最终找的父类就是Object。

equals方法，用于比较两个对象是否相同，它其实就是使用两个对象的内存地址在比较。Object类
中的equals方法内部使用的就是==比较运算符。

注意：在复写Object中的equals方法时，一定要注意public boolean equals(Object obj)的参数是Object类型
，在调用对象的属性时，一定要进行类型转换，在转换之前必须进行类型判断。
友情提示:需要重写的时候可以利用eclipse提供的快捷键直接生成 alt+shift + s + h

1.toString方法返回该对象的字符串表示，其实该字符串内容就是对象的类型+@+内存地址值。
2.在我们直接使用输出语句输出对象名的时候,其实通过该对象调用了其toString()方法.
但是toString返回值的地址 对我们来说没有实际价值的
3.由于toString方法返回的结果是内存地址，而在开发中，经常需要按照对象的属性得到相应的
字符串表现形式，因此也需要重写它。alt+shift + s + s

根类Throwable(异常):
Error(错误类):程序很严重的问题,无法处理的异常,如果出现了,改代码.
Exception(编译时异常类):如果出现了问题,自己处理.
RuntimeExcetpion(运行时异常):

java中异常类的常见操作:

1.先要有异常,一般来说java的异常java自己常见对象,我们自己定义一个异常,我们自己常见对象

2.抛出异常(不管了)

3.捕获异常(自己处理)

对于顶级类(外部类)来说，只有两种修饰符：public和默认(default)。因为外部类的上一单元是包，
所以外部类只有两个作用域：同包，任何位置。因此，只需要两种控制权限
：包控制权限和公开访问权限，也就对应两种控制修饰符：public和默认(default)。

既然你问的类使用了private修饰符，说明是个内部类。内部类的上一级是外部类，那么对应的有四
种访问控制修饰符：本类(private)，同包(default)，父子类(protected)，任何位置(public)。
种访问控制修饰符：本类(private)，同包(default)，父子类(protected)，任何位置(public)。
当一个内部类使用了private修饰后，只能在该类的外部类内部使用。

Object类中的equals:
* 默认比较的是两个对象的地址,是当前对象和参数传入的对象
* 但是我们可以重写equals方法,让比较按照我们的想法比较
* 比如java中String也是重写了equals,比较了字符串的内容,而不是地址
*
* Object类中的toString方法:
* 这个方法 可以方法一个字符串,这个字符串用来表示当前对象
* 默认返回值:包名.类名@地址值
* 实际上 syso(对象名) 等价于 syso(对象名.toString())
* 但是我们也可以重写toString 打印出我们要的信息 而不是一个地址值
*
* 总结:实际开发中定义一个类 我们通常
* 1.封装
* 2.构造
* 3.重写equals
* 4.toString();//方便查看对象的信息

程序的异常:(程序中出现的问题)
* 根类Throwable
* |- Error(错误类)是程序很严重的问题,如果出现了 改代码
* 人:肝癌,脑袋被砍了
* |- Exception(编译时异常类)也是程序出现问题,自己可以处理的小问题
* 人:感冒,发烧,牙疼..
* |- RuntimeExcetpion(运行时异常)
*
* java中异常类的常见操作
*
* 1.先要有异常,一般来说 java的异常java自己常见对象,我们自己定义一个异常,我们自己常见对象
*
* 2.抛出异常(不管了)
*
* 3.捕获异常(自己处理)
*
* 抛出异常的关键字:throw, 抛出的动作,是真正的把异常对象抛出去

1.throw:抛出异常动作
*
* 2.throws:一种声明,throws是给方法做声明的,表示这个方法可能抛出异常,要求方法的调用者去处理
*
* 3.处理异常的方法:
* 3.1再声明抛出
* 3.2捕获方式:
* try{
* 可能出现异常的代码;
* }catch(Exception e){
* //如果上面的代码,真的出现了异常 那么就会被抓住
* //就是把异常对象赋值给了 e
* //自己处理
* }finally{
* //最终必须要执行的代码
* //一般放释放资源的代码
* }
* 捕获异常还有其他的方式:
* try{
* }finally{
* }
* try{
* }catch(Exception e){
* }
* 关于catch抓住异常 也有其他写法
* 处理：
* 1多个异常分别处理 我们基本不用
* 2多个异常一次捕获多次处理
* 3多个异常一次捕获一次处理 ***********


* 异常的分类:
* 1.编译时异常: Exception以及它的子类(RuntimeException)
* 2.运行时异常: RuntimeExcetion以及它的子类
*
* 我们如何区分哪个是编译异常 哪个是运行异常

//自定义异常固定的套路
//1.必须继承Exception或者RuntimeException
//2.写两个构造,一个空参,一个带有异常信息的String类型参数
//throw new NoSuchAgeException("年龄不合法的异常");

public class TestDemo {
public static void main(String[] args) {
//一个try 多个catch

try{
System.out.println("try");
int[] arr = {1,2,3};
arr[10] = 10;//数组下标越界
System.out.println(10/0);//数学异常
String s = "abc";
char ch = s.charAt(10);//字符串下标越界
}catch(ArithmeticException ae){
System.out.println("数学异常");
}catch(ArrayIndexOutOfBoundsException aioe){
System.out.println("数组越界");
}catch(StringIndexOutOfBoundsException sioe){
System.out.println("字符串下标越界");
}finally {

}

}
}