Java——接口篇

一、接口
（一）概述及其特点
为了体现事物功能的扩展性，Java中就提供了接口来定义这些额外功能，并不给出具体实现，将来哪些猫狗需要被培训，只需要这部分猫狗把这些额外功能实现即可。（例如前文提到的猫狗，猫钻火圈，狗看门，并不是一开始就会的，而是经过训练而来的）
特点：
1.接口用关键字interface表示 格式: interface 接口名 {}
2.类实现接口用implements表示 格式: class 类名 implements 接口名 { }
3.接口不能实例化
那么，接口如何实例化呢?
按照多态的方式来实例化。
4.接口的子类
1)可以是抽象类。但是意义不大。
2)可以是具体类。要重写接口中的所有抽象方法。
成员特点：
A:接口成员特点
成员变量；只能是常量，并且是静态的。
默认修饰符：public static final
建议：自己手动给出。
构造方法：接口没有构造方法。
成员方法：只能是抽象方法。
默认修饰符：public abstract
建议：自己手动给出。
二、类与类,类与接口,接口与接口的关系
(一）
1.类与类：
继承关系,只能单继承,可以多层继承。
2.类与接口：
实现关系,可以单实现,也可以多实现。
并且还可以在继承一个类的同时实现多个接口。
3.接口与接口：
继承关系,可以单继承,也可以多继承。
（二）抽象类和接口的区别
1.成员区别
抽象类：
成员变量：可以变量，也可以常量
构造方法：有
成员方法：可以抽象，也可以非抽象
接口：
成员变量：只可以常量
成员方法：只可以抽象
2.关系区别
类与类
继承，单继承
类与接口
实现，单实现，多实现
接口与接口
继承，单继承，多继承
3.设计理念区别
抽象类 被继承体现的是：”is a”的关系。 抽象类中定义的是该继承体系的共性功能。
接口 被实现体现的是：”like a”的关系。 接口中定义的是该继承体系的扩展功能。
接口举例（猫狗案例）：
分析：
动物类：姓名，年龄，吃饭，睡觉。
动物培训接口：跳高
猫继承动物类
狗继承动物类
部分猫继承猫类并实现跳高接口
部分狗继承狗类并实现跳高接口
通过抽象类测试基本功能。
通过接口测试扩展功能。

//动物类：
public abstract class Animal {
    public String name;
    public int age;
    public abstract void eat();
    public abstract void sleep();
}
//猫类：
public class Cat extends Animal {
    public void eat() {
        System.out.println("吃鱼");
    }
    public void sleep() {
        System.out.println("猫白天睡觉");
    }
}

public class KittyCat extends Cat implements JumpInterface{
    public void eat() {
        System.out.println("hello kitty猫喜欢吃奶油");
    }
    public void sleep() {
        System.out.println("kitty 猫不喜欢睡觉");
    }
    public void jump() {
        System.out.println("kitty猫 经过自己的学习 学会了跳高这个功能");
    }
}

public class TomCat extends Cat{
    public void eat() {
        System.out.println("tom猫喜欢吃猫粮");
    }
    public void sleep() {
        System.out.println("tom猫喜欢晚上睡觉");
    }
}
//跳高接口：
public interface JumpInterface {
    public abstract void jump();
}

三、关于参数传递和返回值类型的实例
（一）类名作为形参——传一个该类的对象

public class MyTest {
    public static void main(String[] args) {
        Student student = new Student();
        //如果你以后看到一个方法的形参，要一个 类 类型，你就传一个该类的对象
        setStudent(new Student(),100);
        student.set(1000);
        student.show();
    }
    public static void setStudent(Student student,int num){
        student.age=num;
    }
}
class Student{
    int age;
    public void set(int num){
        this.age=num;
    }
    public void show(){
        System.out.println(age);
    }
}

（二）抽象类名作为形参——传一个该抽象类的子类对象

public class MyTest {
    public static void main(String[] args) {
    //如果你以后看到一个方法的形参，要一个 抽象类 类型，
        MyClass myClass = new MyClass();
        set(myClass,108);
        myClass.show(106); //
    }
    public static void set(AA aa,int num){
        aa.num=num;
        aa.show2();
    }
}
abstract class AA{
    int num=10;
    public abstract void show(int num);
    public void show2(){
        System.out.println("父类的"+num);
    }
}
class MyClass extends AA{
    int num=20;
    public void show(int num) {
        System.out.println(num+this.num);
    }
}

（三）抽象类名作为返回值类型——返回一个该抽象类的子类对象

public class MyTest {
    public static void main(String[] args) {
    //如果以后你看到一个方法的返回值类型，要一个抽象类类型
        AA a = set(new BB(), 12);
        a.show(16);
    }
    public static AA set(AA aa,int num){
        BB bb = new BB();
        bb.num=num;
       return bb;
    }
}
abstract class AA{
    int num=10;
    public abstract void show(int num);
}
class BB extends AA{
    int num = 1;
    public void show(int num) {
        System.out.println(this.num);
        System.out.println(num+this.num+super.num);//38 27 27 38 27
    }
}

（四）接口名作为形参——传一个该接口的子类对象

public class MyTest {
    public static void main(String[] args) {
    //如果你以后看到一个方法的形参，要一个接口类型
        MyB myB = new MyB();
        set(new MyB(),108);
    }
    public static void set(B b,int num){
        b.show(num);
    }
}
interface B{
    int num=10;
    public abstract void show(int num);
}
class MyB implements B{
    int a=10;
    public void show(int num) {
        System.out.println(num+a);
    }
}

（五）接口名作为返回值类型——返回该接口的子类对象

public class MyTest {
    public static void main(String[] args) {
     //如果你以后看到一个方法的返回值类型 要一个接口类型
        A a = set(new B(), 10);
        a.show(1);
    }
    public static A set(A a, int num) {
        B b = new B();
        b.num2 = num;
        return b;
    }
}
interface A {
    int num = 106;
    void show(int num);
}
class B implements A {
    int num2 = 20;
    public void show(int num) {
        System.out.println(num + this.num);
    }
}

（六）链式编程——当你调用完一个方法后,这个方法的返回值是一个对象，那么就可以继续打点，再去调用这个对象中的方法

public class MyTest {
    public static void main(String[] args) {
        //Dog dog = new Dog();
        //Dog dog1 = dog.getDog(new Dog(), 2);
        //dog1.show();
        new Dog().getDog(new Dog(), 2).show();
    }
}
class Dog {
    int num = 1;
    public Dog getDog(Dog dog, int num) {
        dog.num = num;
        return this;//this 本类的一个对象 谁调用我方法，方法中的this就代表谁
    }
    public void show() {
        System.out.println(num);
    }
}

四、import关键字的概述和使用和包下四种权限修饰符
（一）
导包概述：不同包下的类之间的访问，我们发现，每次使用不同包下的类的时候，都需要加包的全路径。比较麻烦。这个时候，java就提供了导包的功能。
导包格式
import 包名;
注意：
这种方式导入是到类的名称。
（二）四种权限修饰符的测试
四种权限修饰符: private(私有的) , 默认 , protected(受保护的) , public(公共的)

				本类	同一个包下(子类和无关类)  不同包下(子类) 不同包下(无关类)
	private    	 Y		
	默认		     Y	           Y
	protected	 Y		       Y		          Y
	public		 Y		       Y		          Y		          Y

（三）类及其组成所使用的常见修饰符
A:修饰符：
权限修饰符：private，默认的，protected，public
状态修饰符：static，final
抽象修饰符：abstract
B:类：
权限修饰符：默认修饰符，public
状态修饰符：final
抽象修饰符：abstract

用的最多的就是：public

C:成员变量：
权限修饰符：private，默认的，protected，public
状态修饰符：static，final

用的最多的就是：private

D:构造方法：
权限修饰符：private，默认的，protected，public

用的最多的就是：public

E:成员方法：
权限修饰符：private，默认的，protected，public
状态修饰符：static，final
抽象修饰符：abstract
F:除此以外的组合规则：
成员变量：public static final
成员方法：public static
public abstract
public final