java------抽象类和接口【详解】
目录
一.抽象类
1.1抽象类的定义：
1.2抽象类的语法：
1.3 抽象类的特性：
二.接口
2.1接口概念：
2.2 接口的语法：
2.3接口的使用：
2.4接口的特性：
2.5多个接口的实现：
2.6抽象类和接口的区别
一.抽象类
1.1抽象类的定义：
在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的， 如果 一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类 。 比如：
说明：
- 矩形，圆形，三角形都是图形，因此和Graph类的惯性应该是继承关系
- 虽然图形中Graph也存在draw()的方法，但由于Graph类并不是具体的图形，因此其内部的draw()方法实际是没有办法实现的
- 由于Graph类没有办法描述一个具体的图形，导致其draw()方法无法具体实现，因此可以将Graph类设计为“抽象类”
在上述图形例子中 , 我们发现 , 父类 Graph 中的 draw 方法好像并没有什么实际工作 , 主要的绘制图形都是由 Graph的各种子类的 draw () 方法来完成的 . 像这种没有实际工作的方法 , 我们可以把它设计成一个 抽象方法 (abstract method) , 包含抽象方法的类我们称为 抽象类 (abstract class)
1.2抽象类的语法：
- 在Java中一个类如果被 abstract 修饰称为抽象类，抽象类中被 abstract 修饰的方法称为抽象方法，抽象方法不用给出具体的实现体
// 抽象类：被abstract修饰的类
abstract class Graph {
// 抽象方法：被abstract修饰的方法，没有方法体
abstract public void draw();
abstract void calcArea();
// 抽象类也是类，也可以增加普通方法和属性
public double getArea(){
return area;
}
protected double area; // 面积
}注意：抽象类也是类，内部可以包含普通方法和属性，甚至构造方法
1.3 抽象类的特性：
代码示例：
//抽象类的创立
abstract class Graph{
abstract public void draw();//抽象方法
abstract public void calArea();
double area;//抽象类也是类，也可以增加普通方法和属性
public double getArea(){
return area;
}
}
//抽象类必须被继承，并且继承后子类要重写父类中的抽象方法,以完成子类的特有属性
class Rect extends Graph{
public double length;//子类中也能定义除了抽象类以外的方法和属性
public double width;
public Rect(double length,double width){
this.length=length;
this.width=width;
}
public void draw(){//子类的方法
System.out.println("矩形：length="+length+" "+"width="+width);
}
public void calArea(){
area=length*width;
System.out.println("areaRect="+area);
}
}
//抽象类必须被继承，并且继承后子类要重写父类中的抽象方法,以完成子类的特有属性
class Circle extends Graph{
public double r;
public static double PI=3.14;
public Circle(double r){
this.r=r;
}
public void draw(){//抽象类的方法必须重写
System.out.println("圆：r="+r);
}
public void calArea(){
area=PI*r*r;
System.out.println("areaCircle="+area);
}
}
public class Main {
public static void main(String[] args){
//Graph Graph = new Graph(); 抽象类虽然不能直接实例化
//但可以把一个普通类对象传给一个抽象类的引用呀，即父类引用指向子类对象
Rect rect=new Rect(20,30);
rect.draw();
rect.calArea();
System.out.println("");//打印换行
Circle circle=new Circle(5);
circle.draw();
circle.calArea();
}
}
二.接口
2.1接口概念：
- 官方解释：Java接口是一系列方法的声明，是一些方法特征的集合，一个接口只有方法的特征没有方法的实现，因此这些方法可以在不同的地方被不同的类实现，而这些实现可以具有不同的行为（功能）。
- 通俗的讲：接口可以理解为一种特殊的类，里面全部是由全局常量和公共的抽象方法所组成。接口是解决Java无法使用多继承的一种手段，但是接口在实际中更多的作用是制定标准的。或者我们可以直接把接口理解为100%的抽象类，既接口中的方法必须全部是抽象方法。（JDK1.8之前可以这样理解）
2.2 接口的语法：
上面提到，接口可以理解为一种特殊的类，接口的定义格式与定义类的格式基本相同，将class关键字换成 interface 关键字，就定义了一个接口。
interface 接口名称{
//抽象方法
void method1()；
void method2();
void method3();
……
}说明：
1. 创建接口时, 接口的命名一般以大写字母 I 开头.2. 接口的命名一般使用 "形容词" 词性的单词.3. 阿里编码规范中约定, 接口中的方法和属性不要加任何修饰符号, 保持代码的简洁性.
2.3接口的使用：
接口不能直接使用，必须要有一个"实现类"来"实现"该接口，实现接口中的所有抽象方法。
class 类名称 implements 接口名称{
//接口方法的实现
……
}注意：子类和父类之间是extends 继承关系，类与接口之间是 implements 实现关系。
代码示例：
interface USB{//定义一个USB接口
void openDevice();//里面包含两个待实现的方法，分别是打开和关闭设备
void closeDevice();
}
// 鼠标类，实现USB接口
class Mouse implements USB{
public void openDevice(){//接口方法的重写
System.out.println("打开鼠标");
}
public void closeDevice(){
System.out.println("关闭鼠标");
}
public void click(){//除了接口以外自身的方法
System.out.println("点击鼠标");
}
}
// 键盘类，实现USB接口
class keyBoard implements USB{
public void openDevice(){
System.out.println("打开键盘");
}
public void closeDevice(){
System.out.println("关闭键盘");
}
public void input(){
System.out.println("键盘输入");
}
}
// 笔记本类：使用USB设备
class Computer{
public void powerOff(){
System.out.println("关闭笔记本");
}
public void powerOn(){
System.out.println("打开笔记本");
}
//instanceof判断前面的对象是否属于后面的类，或者属于其子类
public void useDevice(USB usb){
usb.openDevice();//打开设备
if(usb instanceof Mouse){
Mouse mouse=(Mouse)usb;
mouse.click();
}else if(usb instanceof keyBoard){
keyBoard keyboard=(keyBoard)usb;
keyboard.input();
}
usb.closeDevice();//关闭设备
}
}
public class Main{
public static void main(String[] args){
omputer computer=new Computer();//创建一个computer实例
computer.powerOn();//执行开机
computer.useDevice(new Mouse());//使用鼠标
computer.useDevice(new keyBoard());//使用键盘
computer.powerOff();//执行关机
}
} 
2.4接口的特性：
- 接口中的方法是不能在接口中实现的，只能由实现接口的类来实现
- 重写接口中方法时，不能使用默认的访问权限
- 接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量
- 接口中不能有静态代码块和构造方法
2.5多个接口的实现：
在 Java 中，类和类之间是单继承的，一个类只能有一个父类，即 Java 中不支持多继承 ，但是 一个类可以实现多个接 口 。
代码示例：
class Animal{
public String name;//定义一个动物类
public Animal(String name){
this.name=name;
}
}
//定义多个接口
interface IFlying{
void fly();
}
interface IRunning{
void run();
}
interface ISwimming{
void swim();
}
//在Cat中实现IRunning接口
class Cat extends Animal implements IRunning{
public Cat(String name){
super(name);
}
public void run(){
System.out.println(this.name+"正在跑步~");
}
}
//在Fish中实现ISwimming接口
class Fish extends Animal implements ISwimming{
public Fish(String name){
super(name);
}
public void swim(){
System.out.println(this.name+"正在游泳~");
}
}
//在Duck中实现ISwimming,IRunning,IFlying接口
class Duck extends Animal implements ISwimming,IRunning,IFlying{
public Duck(String name){
super(name);
}
public void swim(){
System.out.println(name+"正在游泳~");
}
public void run(){
System.out.println(name+"正在跑步~");
}
public void fly(){
System.out.println(name+"正在飞~");
}
}
public class Main{
public static void main(String[] args){
Cat cat=new Cat("xiaobao");//实现各个接口
cat.run();
Fish fish=new Fish("xioa");
fish.swim();
Duck duck=new Duck("yazi");
duck.swim();
duck.fly();
duck.run();
}
}
2.6抽象类和接口的区别
核心区别 : 抽象类中可以包含普通方法和普通字段 , 这样的普通方法和字段可以被子类直接使用 ( 不必重写 ), 而接口中不能包含普通方法, 子类必须重写所有的抽象方法。
*相同点：
- 都不能被实例化 ，接口的实现类或抽象类的子类都只有实现了接口或抽象类中的方法后才能实例化。
*不同点：
- 抽象类中的抽象方法的修饰符只能为public或者protected，默认为public；接口中的方法默认使用public修饰
- 接口成员变量默认为public static final，必须赋初值，不能被修改。抽象类中成员变量默认default，可在子类中被重新定义，也可被重新赋值；
- 实现接口的关键字为implements，继承抽象类的关键字为extends。一个类可以实现多个接口，但一个类只能继承一个抽象类。所以，使用接口可以间接地实现多重继承。
- 接口强调特定功能的实现，而抽象类强调所属关系。
- 抽象类可以包含方法、构造方法，方法可以实现，但是构造方法不能用于实例化，主要用途是被子类调用。接口只有定义，不能有方法的实现，java 1.8中可以定义default方法体
博客到这里也是结束了，制作不易，喜欢的小伙伴可以点赞加关注支持下博主，这对我真的很重要~~