java抽象类与接口
抽象类
- 抽象类的概念和形式
- 多态的模板
- 抽象类的应用
接口
- 接口的概念和形式
- 类实现多个接口--打破单继承的限制
- 多态的模板
- 接口的应用
抽象类的概念和形式
抽象类正如其名是一种抽象形式的类，表现为类中必须定义抽象方法而且不允许实例化，他的意义在于被继承，比如new Animal()，我们都知道这个是产生一个动物Animal对象，但是这个Animal具体长成什么样子我们并不知道，它没有一个具体动物的概念，所以他就是一个抽象类，需要一个具体的动物，如狗、猫来对它进行特定的描述，我们才知道它长成啥样。
- 抽象类不允许被实例化，他的意义在于被继承
，抽象方法高度抽象，如果抽象方法可以被实例化，访问抽象方法则没有意义 - 包含抽象方法的类为抽象类(但发现没有抽象方法的类也可以定义成抽象类，如果一个类没有抽象方法为什么定义成抽象类，这里不必钻牛角尖，记住就好)
- 子类必须重写抽象父类所有的抽象方法或者将自身定义成抽象类(抽象类 可以继承抽象类)
- final static private不能修饰抽象方法
final修饰的抽象方法可以被继承但被重写,static方法属于类无法被重写，private方法访问权限限制无法被重写 - final不能修饰抽象类，final修饰的类不能被继承
多态的模板
多态的构成条件为继承 方法覆写 向上转型，而抽象类正好都符合这一点，所有说抽象类是多态的一个运用模板
抽象类的使用必须继承，抽象类的抽象方法必须被子类覆写
抽象类的应用---模板设计
抽象类的实际运用之一为模板设计，利用抽象类设计模板，利用多态具体的由子类决定，抽象类提供统一的接口
案例 学生和工人都可以说话，但说话的内容不一样
定义一个抽象类为模板，为说话这个行为提供一个统一的对外接口，根据对象的多态性，对象一样其行为的具体表现形式不一样
//设计抽象类模板Person
abstract class Person{
private String name;//姓名
private int age;//年龄
//提供构造方法
public Person(String name,int age){
this.name=name;
this.age=age;
}
public String getName(){
return this.name;
}
public int getAge(){
return this.age;
}
//人有说话这个行为
public String say(){
return this.getContent();
}
//具体的行为由子类决定
public abstract String getContent();
}
class Worker extends Person{
private double salary;//薪资
public Worker(String name,int age,double salary){
super(name,age);
this.salary=salary;
}
public double getSalary(){
return this.salary;
}
//覆写父类抽象方法
public String getContent(){
return"这年头打工太难了！";
}
}
class Student extends Person{
private float score;
public Student(String name,int age,float score){
super (name,age);
this.score=score;
}
//覆写
public String getContent(){
return"作业太难了！";
}
}
public class AbstractTest{
public static void main(String[]args){
Student st=new Student("张三",21,96.3f);//实例化学生对象
Worker wo=new Worker("小刘",34,5000.0);//实例化工人对象
Person pr=st;//学生向上转型
Person pr1=wo;//工人向上转型
System.out.println(pr.say());//学生说的话
System.out.println(pr1.say());//工人说的话
}
}
output:
作业太难了！
这年头打工太难了！
接口
接口是比抽象类更抽象的一种特殊的类，也不能实例化对象，要想使用必须被继承
接口，英文称作interface，在软件工程中，接口泛指供别人调用的方法或者函数，可以认为他是一种功能。从这里，我们可以体会到Java语言设计者的初衷，它是对行为的抽象。
对上面的话的理解
以下例子转载自：
https://www.cnblogs.com/vamei/archive/2013/03/31/2982240.html
原本有一个杯子cup，现在通过接口的继承实现成一个带有刻度的杯子
interface Cup {
void addWater(int w);
void drinkWater(int w);
}
我们在继承Cup的基础上，定义一个新的有刻度的杯子的接口，MetricCup
interface MetricCup extends Cup
{
int WaterContent();
}
现在这个杯子是一个带有刻度的杯子了
-
接口用interface关键字注明，实现一个接口用implements表示
-
接口里面只能定义常量和抽象方法
-
子类必须覆写接口中的所有抽象方法
-
接口里的变量和方法只能定义成常量和抽象方法
-
接口里的变量和方法被隐式定义成常量和抽象方法，所有可以省略其修饰符（但不建议省略）
接口--打破java单继承的限制
java无法实现多继承（c++可以）,这样的设计更符合现实生活，但必定会存在多继承的情况，java定义了接口的概念，让多继承成为可能
java中一个类不能继承多个父类，但可以实现多个接口，接口也可以实现一个或多个接口，抽象类可以实现接口，但接口不允许继承抽象类
接口--多态的模板
多态的构成条件为继承 方法覆写 向上转型，而接口正好都符合这一点
接口不允许被实例化，子类必须覆写接口的所有抽象方法
接口的应用----标准制定
接口里面只有抽象方法，可以利用接口里的抽象方法写出一个标准，让设备实现该接口，也就是接通了该标准，只有符合该标准才工作
打印机和u盘在电脑上使用都需要实现USB接口，以USB接口举例
//用接口定义标准
interface USB{
public abstract void start();//工作开始
public abstract void stop();//工作停止
}
//打印机实现USB接口
class Print implements USB{
public void start(){
System.out.println("打印机开始工作....");//覆写
}
public void stop(){
System.out.println("打印机停止工作....");//覆写
}
}
class Flash implements USB{
public void start(){
System.out.println("U盘开始工作.....");//覆写
}
public void stop(){
System.out.println("U盘停止工作.....");//覆写
}
}
class Computer{
//工作开始，只有符合USB接口标准的才可以工作
public void plugin(USB usb){
usb.start();//开始工作
System.out.println("工作进行中l......");
usb.stop();//工作停止中
}
}
public class InterfaceTest{
public static void main(String[]args){
new Computer().plugin(new Print());//插入打印机
new Computer().plugin(new Flash());//插入U盘
}
}
output:
打印机开始工作....
工作进行中l......
打印机停止工作....
U盘开始工作.....
工作进行中l......
U盘停止工作...
抽象类和接口的区别
参考https://www.cnblogs.com/dolphin0520/p/3811437.html
设计层面的区别
- 1）抽象类是对一种事物的抽象，即对类抽象，而接口是对行为的抽象
- 设计层面不同，抽象类作为很多子类的父类，它是一种模板式设计。而接口是一种行为规范，它是一种辐射式设计。
博客参考：
https://www.cnblogs.com/dolphin0520/p/3811437.html
https://www.cnblogs.com/vamei/archive/2013/03/31/2982240.html
https://www.cnblogs.com/chenssy/p/3376708.html
