抽象类与接口的一些认识

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

• 抽象类
  • 什么是抽象类
  • 抽象类的注意事项
  • 抽象类的继承
  • 抽象类与多态
• 接口
  • 什么是接口
  • 接口的注意事项
  • 接口与继承
  • 接口与实现
• 接口与抽象类的区别
  • 接口与类的区别
  • 接口与抽象类的区别

---

---

一、抽象类

1.1 什么是抽象类

首先了解什么叫做抽象方法。在声明类时，没有方法体的方法叫做抽象方法，也就是说花括号里面没有内容，那么该方法就叫做抽象方法。只要一个类含有这种抽象方法，那么该类就叫做抽象类。

1.2 抽象类的注意事项

1. 抽象类可以有零至多个普通方法，也可由零至多个抽象方法
2. 不论抽象类是否含有抽象方法，都不允许被实例化
3. 若父类是抽象类，且子类不想成为抽象类，则子类必须将父类中的所有方法重写为带方法体的普通方法
4. 关于抽象类不能实例化却仍有构造方法。为实例化子类之前必须要初始化父类提供方法

1.3 抽象类的继承

      1. 子类会继承父类有public,protected修饰的属性和方法，不能继承private的属性和方法

      2. 实例化子类之前必须要初始化父类。一般调用父类的无参构造方法或者显示调用父类的有参构造方法（super()）

1.4 抽象类与多态

        正是抽象类的各种子类，让程序运行时会有多种派生类选择

1.	//父类——Shape类
2.	public abstract class Shape{  //类头加上abstract
3.	    //无参构造
4.	    public Animal(){
5.	    }
6.	//获得面积的抽象方法
7.	    public abstract double getArea();
8.	//获得周长的抽象方法
9.	    public abstract double getPerimeter();
10.	}
11.	
12.	//子类——Circle类
13.	public class Circle extends Shape{
14.	//构造方法
15.	    public Circle(double r = 1){
16.	        radius = r
17.	} 
18.	//实现父类的getArea()方法
19.	    public double getArea(){
20.	        return 3.14159 * radius * radius;
21.	}
22.	//实现父类的getPerimeter()方法
23.	    public double getPerimeter(){
24.	        return 3.14159 * 2 * radius;
25.	}
26.	    private double radius;
27.	}
28.	//子类——矩形
29.	public class Rectangle extends Shape{
30.	//构造方法
31.	    public Rectangle(double r){
32.	        radius = r
33.	} 
34.	//实现父类的getArea()方法
35.	    public double getArea(){
36.	        return width * height;
37.	}
38.	//实现父类的getPerimeter()方法
39.	    public double getPerimeter(){
40.	        return 2 * (width + height);
41.	}
42.	    private double width, height;
43.	}
44.	Shape obj1 = new Circle();
45.	//这里建了一个新对象，是Circle类，Circle类实现了父类的抽象方法。
46.	Shape obj2 = new Rectangle();
47.	//这里创建了一个新对象，是Rectangle类，该类同样实现了父类的抽象方法。
48.	//如果一个类没有全部实现父类的抽象方法，那么该子类仍然为抽象类。
49.	创建多边形类——仍然是抽象类
50.	public abstract class Polygon{
51.	    public Polygon(){
52.	}
53.	    public abstract double getArea();
54.	    public abstract double getPerimeter();
55.	    public abstract String   getName();//获取形状，比如说正方形就返回“正方形”，三角形就返回“三角形”
56.	}

 

二、接口

1.什么是接口

        1.1 有一个类，若类里的所有方法全是pubilce且是抽象方法，那么该类就叫做接口。接口除了抽象方法之外，还可以有属性，但是这些属性的修饰符必须是public, final, static(默认有这三个)

        1.2 Final：final修饰的变量就是常量，final修饰的引用在初始化后就不能再指向另一个对象了，但被指向的对象是可以变的

        1.3 static作用于成员变量意味只保留一份副本。当创建一个类对象时，static修饰的成员变量首先被初始化，随后是普通成员，最后调用Person类的构造方法完成初始化。当再次n创建该类的对象时，static修饰的类成员不会被再次初始化，在程序运行过程中，static只会在第一次new时被初始化。被static修饰的成员变量和成员方法独立于该类的任何对象

2.接口的注意事项

1. 接口和抽象类一样不能被实例化。
2. 一个接口要想使用，必须依靠子类。子类(如果并不是抽象类)要实现接口的所有抽象方法。
3. 接口没有构造方法
4. JDK1.8以后允许接口有default修饰的方法。default修饰的方法允许有方法体，且允许被重写(可以是实现类，也可以是子接口)
5. JDK1.8 以后接口中使用static修饰的方法。使用static修饰的方法允许有方法体。接口中使用static修饰的方法允许有方法体，使用接口名.方法名调用,且不能被实现类重写。接口中使用static修饰的方法不可以被子接口继承

3.接口与实现

1. 一个类要实现接口，需要在类头使用implements关键字，并且需要实现接口的所有抽象方法。
2. 一个类可以实现多个接口

 

1.	interface 接口名称{
2.	   // 全局常量，public static final，但书写时可以省略不写
3.	   // 抽象方法，ublic abstract 的
4.	}
5.	class 类名 implements 接口1, 接口2 ... {
6.	  // 重写所引用接口中所有使用的方法
7.	}
8.	
9.	interface Animal{
10.	  // 定义接口中的抽象方法
11.	  void eat(); // 省略了抽象方法前面的public abstract
12.	  void drink();
13.	  void play();
14.	}
15.	//Dog类来实现Animal接口
16.	class Dog implements Animal,Mood{
17.	    public int name;
18.	    public int age;
19.	    public void eat(){  //实现接口的方法
20.	        System.out.println("狗去吃东西了");  
21.	}
22.	     public void drink(){  //实现接口的方法
23.	        System.out.println("狗去喝水了");  
24.	}
25.	     public void play(){  //实现接口的方法
26.	        System.out.println("狗去玩了");  
27.	}
28.	}
29.	interface cat extends Animal, mood{  //cat接口多继承，继承了两个父接口
30.	   .......
31.	}
32.	
33.	class obj implements interface1, interface2{  //obj实现多个接口
34.	  ......
35.	}

三、接口与抽象类的区别

 1.首先应先明白一个概念——接口与类的区别

        

接口不能用于实例化对象，接口没有构造方法。

接口不是被类继承了，而是要被类实现。

 接口支持多继承。

2.接口与抽象类的区别

从使用方式上来看

比较点	抽象类	接口
关键字	abstract class	interface
字段	无限制	只能是public,static,final
方法	普通方法，抽象方法	只能含抽象方法，且是public.但是JDK1.8后也可以有default,static修饰的方法
继承/实现	只能被类和抽象类继承	可以被接口继承，可以被类实现
多重继承	不支持	可以继承多个父接口

从设计层面上来看

1）抽象类是对一种事物的抽象，即对类抽象，而接口是对行为的抽象。抽象类是对整个类整体进行抽象，包括属性、行为，但是接口却是对类局部（行为）进行抽象。举个简单的例子，飞机和鸟是不同类的事物，但是它们都有一个共性，就是都会飞。那么在设计的时候，可以将飞机设计为一个类Airplane，将鸟设计为一个类Bird，但是不能将 飞行 这个特性也设计为类，因此它只是一个行为特性，并不是对一类事物的抽象描述。此时可以将 飞行 设计为一个接口Fly，包含方法fly( )，然后Airplane和Bird分别根据自己的需要实现Fly这个接口。然后至于有不同种类的飞机，比如战斗机、民用飞机等直接继承Airplane即可，对于鸟也是类似的，不同种类的鸟直接继承Bird类即可。从这里可以看出，继承是一个 "是不是"的关系，而 接口 实现则是 "有没有"的关系。如果一个类继承了某个抽象类，则子类必定是抽象类的种类，而接口实现则是有没有、具备不具备的关系，比如鸟是否能飞（或者是否具备飞行这个特点），能飞行则可以实现这个接口，不能飞行就不实现这个接口。

2）对于抽象类，如果需要添加新的方法，可以直接在抽象类中添加具体的实现，子类可以不进行变更；而对于接口则不行，如果接口进行了变更，则所有实现这个接口的类都必须进行相应的改动。

详细介绍请参考百度安全验证

---