培训日记10

接口

概述
接口，是java语言中一种引用类型，是方法的集合。如果说类的内部封装了成员变量、构造方法和成员方法，那么接口的内部主要是封装了方法，包含抽象方法（JDK7及以前），默认方法和静态方法（JDK8），私有方法（JDK9）。

接口的定义，它与定义类方式相似，但是使用interface关键字。它也会被编译成.class文件，但一定要明确它并不是类，而是另外一种引用数据类型。

引用数据类型：数组，类，接口。

接口的使用，它不能创建对象，但是可以被实现（ implements ，类似于被继承）。一个实现接口的类（可以看做 是接口的子类），需要实现接口中所有的抽象方法，创建该类对象，就可以调用方法了，否则它必须是一个抽象类。

定义格式：
public interface 接口的名称{
//抽象方法
//默认方法
//静态方法
//私有方法
}

抽象方法：
抽象方法：使用abstract关键字去修改，可以省略，没有方法，该方法子类实现使用。

public interface InterfaceName {
	//抽象方法：
	public abstract void method();
}

默认方法和静态方法：
默认方法：使用default修改，不可省略，供子类调用或者子类重写
静态方法：使用static修饰，供接口直接调用

public interface InterfaceName {
	//抽象方法：
	public abstract void method();
	//默认方法
	public default void method1(){
		//执行语句
	}
	//静态方法：
	public static void method2(){
		//执行语句
	}
}

含有私有方法和私有静态方法：
私有方法：使用private修饰，供接口中的默认方法或者静态方法调用（1.9特性)

public interface InterfaceName {
	//私有方法
    private void method3(){
		//执行语句
    }

	//私有静态方法
    private static void method4(){
        //执行语句
    }
}

基本实现：
类和接口的关系就是实现关系，我们类称为接口的实现类，也可以称为接口的子类，用到的关键字implements 非抽象类实现接口：

1、必须重写接口中所有的抽象方法
2、继承接口的默认方法，可以直接调用，也可以重写

抽象方法的使用

接口：

public interface Person {
    //定义抽象方法
    public abstract void eat();
    public abstract void sleep();
}

实现类

public class Student implements Person{

    @Override
    public void eat() {
        System.out.println("吃得饱");
    }

    @Override
    public void sleep() {
        System.out.println("睡得香");
    }
}

测试类

public class TestDemo {
    public static void main(String[] args) {
        //创建对象，直接调用
        Student student = new Student();
        //调用实现过的方法
        student.eat();
        student.sleep();
    }
}

结果

默认方法的使用
可以继承，也可以重写，但是只能通过我们实现类的对象去调用：
1.继承默认方法：

public interface Person {
    //默认方法
    public default void add(){
        System.out.println("我是接口中的默认方法！");
    };
}

public class Student implements Person{
    //不重写接口中的默认方法
}

public class TestDemo {
    public static void main(String[] args) {
        //创建对象，直接调用
        Student student = new Student();
        student.add();
    }
}

结果：

2、重写默认方法：

public interface Person {
    //默认方法
    public default void add(){
        System.out.println("我是接口中的默认方法！");
    };
}

public class Student implements Person{
    @Override
    public void add() {
        System.out.println("我是实现类中的方法add");
    }
}

public class TestDemo {
    public static void main(String[] args) {
        //创建对象，直接调用
        Student student = new Student();
        student.add();
    }
}

结果：

静态方法的使用
静态和.class文件相关，只能是用我们的接口的名字去调用，不可以通过我们实现类的类名或者实现类的对象去调用。

public interface Person {
    public static void add(){
        System.out.println("我是接口中的静态方法！");
    };
}

public class Student implements Person{
    //无法重写接口中的静态方法

}

public class TestDemo {
    public static void main(String[] args) {
        //创建对象，直接调用
        Student student = new Student();
        Person.add();
    }
}

结果：

私有方法的使用
私有方法：只能默认方法可以调用
私有静态方法：默认方法和静态方法都可以调用

当我们在接口中定义的私有方法是静态的时候，可以在接口中的静态方法中调用。

接口的多实现：
在继承体系中，一个类只能继承一个父类，而对于接口来说，一个类可以实现多个接口，这个叫接口的多实现，同 时我们一个类，在继承父类的前提下，可以实现多个接口。

格式：
class 类名 【extends 父类名】 implements 接口1，接口2{
//重写我们接口中的抽象方法
//重写接口中默认方法【不重名的可以可选】
}

抽象方法：
接口中，有多个抽象方法，实现类必须重写接口中的所有的抽象方法，如果抽象方法有重名，只需要重写一次。



默认方法：
在接口中，有多个默认方法，实现类都可以继承使用，如果默认方法重名，必须重写一次



静态方法
多个接口中，存在同名的静态方法并不会冲突，原因就是各个接口只能通过接口名去调用静态方法

优先级的问题：
当一个类，既继承了父类，又实现了若干个接口的时候，父类中的方法和接口中的默认方法重名，子类就近原则执 行父类中的成员方法

接口的多继承
一个接口可以继承另外一个接口或者多个接口，这和类之间继承关系相似，接口继承也用那个关键字extends，子 接口继承父接口的方法，如果父接口中默认的方法有重名，子接口只重写一次。

注意点： 1、子接口重写默认方法的时候，default关键字可以保留
2、子类重写默认方法的时候，default关键字不可以保留。

其他的成员特点：
1、接口中，无法定义成员变量，但是定义常量，其值不可以改变，默认使用public static final修饰

public interface A{
	public static final int a = 0;
}

2、接口中，没有构造方法，不能创建对象。
3、接口中也没有静态代码块。

多态：

多态是我们三大特性之一，前面已经讲过我们封装，继承。比如我们动物，猫。狗。他们的叫声不一样，可见同一 个行为，通过不同事物，变现出不同 的形态，多态，就是描述的这个状态。

多态：同一个行为，具有不同的表现形式。
前提：
1、继承或者实现{二选一}
2、方法重写【重写，不重写就没啥意义了】
3、父类的引用指向子类对象【多态的格式】
格式： 父类类型 类名=new 子类类型（）；
类名.变量名
父类的类型：指子类对象继承父类的引用，或者实现父接口类型。

多态的变现形式：


多态的好处：
实际开发的时候，父类类型作为我们方法的参数，传递子类对象给方法，进行方法的申明

引用类型的转换：
多态的转型分为向上和向下转型

向上转型：
多态本身就是子类类型指向父类类型的向上转型这么一个过程， 父类类名 类名=new 子类类型();

Animal animal = new Dog();

向下转型：
父类类型向子类类型向下转化的过程，这个过程其实就是强转的一个过程
子类类型 名字=（子类类型）父类变量名

Dog dog = (Dog) animal;

为啥会有转型这么一说？
当使用多态 的方式调用方法时，首先检查父类中是否有该方法，如果没有。编译报错，不能调用子类拥有而父类没 有的方法，所以才有了多态向下转型一下。

转型的异常：
转型过程中，容易出现我们类型转换异常

public static void main(Stirng[] args){
	Animal animal = new Dog();
	Cat cat = (Cat) animal;
	cat.eat();
}

当我们使用多态定义的时候，我们用动物的父类申明，子类狗接收，但是我们后面用向下转型转为了cat，逻辑没有任何问题，编译也看不出，但是运行会报错-----ClassCastException

if(cat instatnceof Cat){
	cat.eat();
}