萌新第一次写博客。。。
初学面向对象时，对接口和抽象方法有点搞不清楚，所以就总结一波~~
一：接口的一些基本知识
接口是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。接口不可以被实例化但是可以被继承。在我的理解中，接口就是规定了被继承类必须实现的方法，是对类所能实现的方法的扩展。（这句话好像有点不好理解，待会有例子说明）。
在接口中，所有的变量都默认为public static final（而且只能这样），所有的方法默认都是public abstract（只能这样）。
下面解释为什么变量要这么声明。首先接口是支持多继承的，用static就可以区分不同接口的同名变量。因为用了static，所以这个变量能所有实现这个接口类的类改变，这明显不合理。（ps：这只是我的个人理解）
二：接口与抽象类的区别：
抽象类是“父类子类是或不是的关系”，是对一个事物的抽象。接口是对行为的抽象，是有或没有的关系。干说没意思，上一个老师给我们说过的例子：
假设有一款游戏，每种装备都都有它的名称，价格。同时假设每种装备都有他的被动技能，但是有的装备具有攻击力加成特性，攻速加成特性等等。有的装备具有护甲特性，血量加成等等。
在游戏中。只要是装备的类，都可以继承一个父类：
public abstract class equip {
String name;
int prince;
public abstract void skill();
}
有的装备能攻击，有的装备能防守，所以我们要对行为进行抽象，就可以用接口来实现。
interface interfaceAck {
void atk();
}
interface interfacePro{
void protect();
}
现在用有一件装备是法杖吧，他只能攻击而不能防守。所以他要继承装备这个父类以及“拥有”攻击这个接口。
class wand extends equip implements interfaceAck{//注意：继承父类要写在前面，实现接口要写在后面
//首先实现父类的方法，抽象的方法是一定要实现的，非抽象的可以不用实现
public void skill() {
System.out.println("我拥有一项被动技能");
}
//然后实现接口的方法，这个是一定要实现的，而且继承的接口中有几个抽象方法，就要实现几个方法
public void atk() {
System.out.println("我是法杖，我能攻击");
}
}
另外有一件装备盔甲，它只能保护而不能攻击：
class armor extends equip implements interfacePro{
public void skill() {
System.out.println("我拥有一项被动技能");
}
public void protect() {
System.out.println("我是盔甲，我能保护");
};
三：接口与接口之间的继承，接口与抽象类之间的继承：
直接上代码：
interface A{
void funA();
}
interface B{
void funB();
}
interface C extends A,B{
void funC();
}
class D implements C{
public void funA() {}
public void funB() {}
public void funC() {}
}
abstract class E implements C{
//抽象类继承接口不需要实现接口的方法，但是继承了E这个类的子类需要实现接口中没有被父类实现的的方法
}
四：接口的作用：
方便维护，管理。还起到约束的作用。
举例：（这是一个不怎么好的例子）
class dog{
void call() {
System.out.println("旺旺");
}
}
class cat{
void call() {
System.out.println("喵喵");
}
}
//现在test类要模拟动物的叫声
class test{
public void fun(String animal) {
if(animal=="dog") {
dog dog=new dog();
dog.call();
}
if(animal=="cat"){
cat cat=new cat();
cat.call();
}
}
}
这样的代码在我初学的时候觉得很好，但现在就不是这样想了。现在开始改善代码，首先想到的是用多态来减少代码的冗余。
class animal{
void call() {}
}
class dog extends animal{
void call() {
System.out.println("旺旺");
}
}
class cat extends animal{
void call() {
System.out.println("喵喵");
}
}
//现在test类要模拟动物的叫声
class test{
animal animal;
public void fun(String a) {
switch(a) {
case "dog":
animal=new dog();break;
case "cat":
animal=new cat();break;
}
animal.call();
}
}
现在代码给了别人，别人想在此基础上加一个狮子类并加一个叫的方法，于是写成了这样
class lion extends animal{
void roar() {//吼叫
System.out.println("吼吼");
}
}
这样的话我的多态就用不了了。
再改进:在父类使用abstract修饰方法，这样子类就必须实现这个call（）方法，这样就可以用多态了。但是现在我们要新加一个类叫鱼，鱼不会叫但我们又必须实现让他叫的方法，而且知道它不会叫也不会调用这个方法。我觉得还是有点怪。
其实可以用接口来解决这个问题。代码如下：
abstract class animal{
int name;
}
interface animalcall{
void call();
}
class dog extends animal implements animalcall{
public void call() {
System.out.println("旺旺");
}
}
class cat extends animal implements animalcall{
public void call() {
System.out.println("喵喵");
}
}
class lion extends animal implements animalcall{
public void call() {//吼叫
System.out.println("吼吼");
}
}
//现在test类要模拟动物的叫声
public class interfaceTest{
animalcall animal;
public void fun(String a) {
switch(a) {
case "dog":
animal=new dog();break;
case "cat":
animal=new cat();break;
case "lion":
animal=new lion();break;
}
animal.call();
}
}
其实我我对它的作用理解的也不是很深~~