抽象类和接口

抽象类和接口

一.抽象类

1.概念：

普通类是一个完善的功能类，可以直接产生实例化对象，并且在普通类中可以包含有构造方法、普通方法、static方法、常量和变量等内容。而抽象类是指在普通类的结构里面增加抽象方法的组成部分。

tip:抽象方法

在所有的普通方法上面都会有一个“{}”，这个表示方法体，有方法体的方法一定可以被对象直接使用。而抽象方法，是指没有方法体的方法，同时抽象方法还必须使用关键字abstract做修饰。

abstract class A{//定义一个抽象类
	
	public void normal(){//普通方法
		System.out.println("普通方法");
	}
	
	public abstract void abt();//抽象方法，没有方法体，有abstract关键字做修饰
	
}

2.特征：

1. 拥有抽象方法的类就是抽象类，抽象类要使用abstract关键字声明。
2. 抽象类中不一定有抽象方法,但是有抽象方法的类一定是抽象类。
3. 抽象类的子类可能是抽象类，也可能是普通类（这个类必须重写抽象类中的所有抽象方法）。

3.抽象类的使用

抽象类的使用原则如下：
（1）抽象方法必须为public或者protected（因为如果为private，则不能被子类继承，子类便无法实现该方法），缺省情况下默认为public；
（2）抽象类不能直接实例化，需要依靠子类采用向上转型的方式处理；
（3）抽象类必须有子类，使用extends继承，一个子类只能继承一个抽象类；
（4）子类（如果不是抽象类）则必须覆写抽象类之中的全部抽象方法（如果子类没有实现父类的抽象方法，则必须将子类也定义为为abstract类。）

eg:直接运行抽象类，如下

package test;
abstract class A{//定义一个抽象类
    public void fun(){//普通方法
        System.out.println("存在方法体的方法");
    }
    public abstract void abt();//抽象方法，没有方法体，有abstract关键字做修饰
}
public class jiekou {
    public static void main(String[] args) {
        A a = new A();
    }
}

结果并不美妙，

因为在抽象类里存在抽象方法，而抽象方法没有方法体，没有方法体就无法进行调用。

根据上文的使用原则，应如下：

eg：

abstract class A{//定义一个抽象类
    public void fun(){//普通方法
        System.out.println("普通方法");
    }
    public abstract void abt();//抽象方法，没有方法体，有abstract关键字做修饰
}

/*单继承*/
class B extends A{//B类是抽象类的子类
    public void abt() {//强制要求覆写
        System.out.println("Hello World !");
}
    
public class jiekou {
    public static void main(String[] args) {
        A a = new B();//向上转型
        a.abt();//被子类所覆写的过的方法
    }
}

得到结果：

4.抽象类使用限制

（1）抽象类中存在构造方法，其存在目的是为了属性的初始化。并且子类对象实例化的时候，依然满足先执行父类构造，再执行子类构造的顺序。

eg:

package test;
abstract class A{//定义一个抽象类

    public A(){
        System.out.println("*****A类构造方法*****");
    }
    public abstract void abt();//抽象方法，没有方法体，有abstract关键字做修饰
}
//单继承
class B extends A{//B类是抽象类的子类，是一个普通类
    public B(){
        System.out.println("*****B类构造*****");
    }
    public void abt() {//强制要求覆写
        System.out.println("Hello World !");
    }
}
public class jiekou {
    public static void main(String[] args) {
        A a = new B();//向上转型
        a.abt();
    }
}

结果如下：

（2）抽象类不能用final声明（抽象类必须有子类，而final定义的类不能有子类）

（3）外部抽象类不允许使用static声明，而内部的抽象类运行使用static声明。使用static声明的内部抽象类相当于一个外部抽象类，继承的时候使用“外部类.内部类”的形式表示类名称。

eg：

static abstract class A{//定义一个抽象类
	public abstract void abt();	
}

class B extends A{	
	public void abt(){
		System.out.println("rng nb");
	}
}

public class jiekou {
	public static void main(String[] args) {
		A a = new B();//向上转型
		a.abt();
	}
}

结果如下：

abstract class A{//定义一个抽象类
	static abstract class B{//static定义的内部类属于外部类
		public abstract void abt();
	}
}

class C extends A.B{	
	public void abt(){
		System.out.println("rng nb");
	}
}

public class jiekou {
	public static void main(String[] args) {
		A.B ab = new C();//向上转型
		ab.abt();
	}

}

结果如下：

（4）可以直接调用抽象类中用static声明的方法

（5）有时候由于抽象类中只需要一个特定的系统子类操作，所以可以忽略掉外部子类。这样的设计在系统类库中会比较常见，目的是对用户隐藏不需要知道的子类。

5.抽象类的应用

抽象化就是抽象一些有着共同相似行为的对象成为一个抽象类，然后再对不同的对象进行实例化，这样减少了很多的代码量，过程会更加简洁明了。

比如：“大鱼”和“小鱼”都是“鱼类”这个类的实体，比如鱼类都有eat() 这个方法，但是大鱼吃小鱼，小鱼吃虾米。所以每种鱼关于具体吃的方式是需要在子类中重写的，不然是没法区分大鱼和小鱼的。

package test;
abstract class Fish{//定义一个Fish类
    public void move(){
        System.out.println("我在水里游");
    }
    public abstract void eat();//创建抽象方法
}

class SmallFish extends Fish{//定义继承Fish类的子类SmallFish
    public void eat(){
        System.out.println("我是小鱼，我吃虾米。");
    }
}

class BigFish extends Fish{//定义继承Fish类的子类BigFish
    public void eat(){
        System.out.println("我是大鱼，我吃小鱼。");
    }
}

public class jiekou {
    public static void main(String[] args) {
        Fish f1 = new SmallFish();
        f1.eat();
        f1.move();
        Fish f2 = new BigFish();
        f2.eat();
        f2.move();
    }
}

运行结果：

二.接口

出现前提：见上文3.抽象类的使用中的（4）。每个子类都需覆写抽象父类中的抽象方法，但是倘若有大量的子类仅仅使用抽象父类中的一小部分方法，却仍被要求覆写父类全部的抽象方法，这会导致大量冗余代码的产生，于是接口应运而生:

我们可以将接口理解为可以抽象类型的小零件，他们无论是单拎出来，还是组装在一起，都可以视作大大小小的抽象类。有一些子类有继承许多抽象类的诉求，却苦于规则不允许（Java中规定类不能继承多个父类），就只能选择继承接口（子类可以继承多个接口，结构为：class+ 类名+ implements+ 接口1,接口2···接口n）

1.概念：

Java接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征，却没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。接口可以理解为一种特殊的类，里面全部是由全局常量和公共的抽象方法所组成。

2.特征：

1. 接口指明了一个类必须要做什么和不能做什么，相当于类的蓝图。
2. 一个接口就是描述一种能力，比如“运动员”也可以作为一个接口，并且任何实现“运动员”接口的类都必须有能力实现奔跑这个动作（或者implement move()方法），所以接口的作用就是告诉类，你要实现我这种接口代表的功能，你就必须实现某些方法，我才能承认你确实拥有该接口代表的某种能力。
3. 如果一个类实现了一个接口中要求的所有的方法，然而没有提供方法体而仅仅只有方法标识，那么这个类一定是一个抽象类。（抽象方法只能存在于抽象类或者接口中，但抽象类中却能存在非抽象方法，即有方法体的方法。接口是百分之百的抽象类）
4. 一个JAVA库中接口的例子是：Comparator 接口，这个接口代表了“能够进行比较”这种能力，任何类只要实现了这个Comparator接口的话，这个类也具备了“比较”这种能力，那么就可以用来进行排序操作了。

3.接口与抽象类的区别：

抽象类内部可能包含非final的变量，但是在接口中存在的变量一定是final，public,static的。

4.接口的使用

1. 接口的实现

package test;

interface in1{//用interface这个关键字声明一个接口，
    int att = 10;
    void display();//抽象方法
}

interface in2 {//用interface这个关键字声明一个接口，
    int att = 13;
    void display2();//抽象方法
}
class testClass1 implements in1{//使用implements关键词实现接口
    public void display(){//类比抽象类中的强制要求覆写
        System.out.println("kkk");
    }
    int att = 11;
}

class testClass2 implements in1{//使用implements关键词实现接口
    public void display(){//类比抽象类中的强制要求覆写
        System.out.println("kkk");
    }
}

class testClass3 implements in1,in2{//testClass3继承了接口in1和in2
    public void display(){//类比抽象类中的强制要求覆写
        System.out.println("kkk");
    }
    public void display2(){//类比抽象类中的强制要求覆写
        System.out.println("LLL");
    }
}

public class jiekou {
    public static void main(String[] args) {
        testClass1 t1 = new testClass1();
        testClass2 t2 = new testClass2();
        testClass3 t3 = new testClass3();
        t1.display();
        System.out.print(t1.att+"   ");
        System.out.println(in1.att);
        t2.display();
        System.out.print(t2.att+"   ");
        System.out.println(in1.att);
        t3.display();
        t3.display2();
        System.out.println(in2.att);//这里不能用t3.att，原因是在in1和in2中都定义了att。
    }
}

输出结果：
kkk
11   10
kkk
10   10
kkk
LLL
13

2. 接口与继承

   接口可以实现多重继承，接口也可以继承另外一个接口。

   1. 多重继承格式：class+ 类名+ implements+ 接口1,接口2···接口n

   2. interface in1{
      }
      interface in2 extends in1{
      }