抽象类与接口以及抽象类与接口的区别

 

目录

抽象类

1.什么是抽象类

2.抽象类是什么数据类型？

 3.抽象类是怎么定义？

 4.抽象类的用途？

 5.继承抽象类的子类可以是抽象类吗？

 6.为什么抽象类必须有构造方法

7. 抽象方法

9.面向抽象编程！

接口

1.接口的基础语法

2.接口在开发中的作用

---

抽象类

1.什么是抽象类

         类与类之间具有共同的特征，将这些共同特征抽取出来形成的就是抽象类。抽象类还可以提取共同特征形成抽象类。抽象类无法实例化。 (而接口就是一种完全抽象的类，无法再提取抽象特征，因此换了一种定义方式)

                                                
2.抽象类是什么数据类型？

         抽象类属于引用数据类型。

 3.抽象类是怎么定义？

         语法：
             修饰符列表         abstract    class    类名{}
         for example：
             abstract    class    account{}====创建银行账户类

 4.抽象类的用途？

抽象类是无法实例化，无法创建对象。在我们印象中类无非就是用来实例化来调用类中方法及其属性，或者用来被子类继承，
     现在抽象类无法被实例化，因此抽象类就是用来被子类继承。

 5.继承抽象类的子类可以是抽象类吗？

     可以，抽象类子类也可以是非抽象类

 6.为什么抽象类必须有构造方法

抽象类虽然不能实例化对象，但是必须有构造方法（供子类使用），因为子类如果是非抽象类，那么子类就可以实例化对象，子类实例化对象的时候，
 必先把父类构造完成，因为没有父就没有子，在子类的内存空间必有一个super指向父类型属性特征。

7. 抽象方法

           1.没有实现的方法，也就是没有方法体的方法
            2.抽象方法一定属于抽象类，抽象类中可以有抽象方法也可以非抽象方法（即普通方法）

/*抽象类中可以有抽象方法，也可以有非抽象方法*/
abstract class A{
	public abstract void move();//抽象方法
	public void fly() {//非抽象方法
		
	}
}
class b extends A{
	public void move() {
		
	}
}
/*下面这段会报错*/
class A{
    abstract void fly();//抽象方法只能在抽象类中
}

非抽象类继承抽象类必须将抽象方法实现|重写|覆盖：因为非抽象类继承抽象类的抽象方法，而抽象方法只出现在抽象类中，因为子类是非抽象类，所以必须将父类抽象方法重写为普通方法。在非抽象子类中实现抽象方法，叫做对抽象方法的实现。

实现：将抽象方法没有方法体的方法用普通方法重写时才可以用implements

实现分为两种

                       抽象类中方法的实现：对抽象类中的抽象方法在子类非抽象方法中的重写。

                       接口（完全抽象类）的实现： 一种是接口中所有抽象方法，在子类中非抽象方法的实现

/*子类是非抽象，必须将抽象方法重写*/
abstract class A{
    public abstract void move();//抽象方法没有方法体
}
class b extends A{
    public void move() {
        
    }
}
/*子类是抽象，则无所谓，可以不对抽象方法重写|覆盖|实现。*/
abstract class a{ 
    public abstract void move();
}
abstract class c extends a{
    
}

9.面向抽象编程！

 面向抽象编程，应该是对抽象类中的类的实现，然后用抽象类调非抽象类中实现的方法。（能用多态就用多态，尽量让程序功能升级时，不用改动过多代码），其实也是面向父类编程

/*要面向抽象编程不要面向具体编程，减低程序的耦合度，提高程序扩展力，思想符合ocp原则*/
public class Abstractclasstest {
	public static void main(String[] args) {
		animal a = new bird();//这里animal a并不是创建对象，而是定义了一个animal的类a。
		a.move();
	}

}
abstract class animal{
	public abstract void move();
}
class bird extends animal{
	public void move() {
		System.out.println("鸟儿在飞翔");
	}
}

接口

1.接口的基础语法

1.接口也是一种引用数据类型，编译之后也是.class文件。接口是一种特殊的类，一种完全抽象的类，定义时候改成interface来代表完全抽象的类。

2.接口完全抽象，抽象类是半抽象。

3.接口怎么定义？

能插拔的就是接口。

修饰符列表      interface       接口名{}

4.接口可以继承，接口支持单继承，多继承，一个类可以实现多个接口（接口这种机制其实就是弥补Java中不能多继承这种缺点而诞生，于是有了接口与接口之间可以多继承，类与接口之间可以多实现。实现可以看作继承，但是并不是继承）

//接口的单继承
interface A{
    
}
interface B extends A{
    
}

//接口的多继承
interface A{
	
}
interface B{
	
}
interface C extends A,B{
	
}
//一个普通的类实现多个接口，类似于多继承
public class Test{
    public static void main(String[] args) {
        A a = new D();
        B b = new D();
        C c = new D();    
        B b1 = (B)a;
        b1.m2();
        
        Y y = new Z();
        X x = (X)y;//这是接口的一个骚操作，虽然，xy之间没有关系，但是可以这样写编译无错，但是运行阶段会抛classcastException类转换异常。
    }
}

interface X{

}
interface Y{

}
class Z implements Y{

}
interface A{
    public abstract void m1();
}
interface B {
    public abstract void m2();
}
interface C{
    public abstract void m3();
}
class D implements A,B,C{
    @Override
    public void m1() {//这里的publc不能省，重写方法的访问权限不能比父类的访问权限低只能高
        
    }
    public void m2(){
        
    }
    public void m3(){
        
    }
}
//类与接口的区别
class A{

}
class B extends A{
 
}
class C extends A{

}

                                                                                                                          

                                                                                                

                                                                               

只有继承关系才能有多态的向上转型向下转型。因此A能转B：D继承了A，D继承了B。相对于A而言，B是D的干爹。相对B而言，A是D的干爹。

但是X不能转Y。X，Y无关系。类A和类B和类C是单继承的关系。因此B，C无任何关系。

5.接口只包含两部分，一部分常量，一部分是抽象方法，其他的不能有。既然接口中都是抽象方法那么接口方法时可以省public abstract，常量定义可以省public static double。

为什么抽象类中一定要有构造方法而接口中没有构造方法？

构造方法是用来初始化类中的变量（属性），而接口中不需要初始化变量（属性），因为接口中只有常量和抽象方法。

interface math{
	public static final double P = 3.123;//可以省public static final
	int sum(int a,int b);//省了public abstract
	int sub(int a,int b);
}

6.接口中所有的都是public修饰的

7.类与类之间，接口与接口之间叫做继承extends，类与接口之间叫做实现implements，当类要实现接口时候在类中要实现/重写/覆盖所有的接口中的抽象方法。如果实现的类是抽象类时可以不实现接口中的抽象方法，因为而抽象方法只出现在抽象类中，因为子类是非抽象方法，所以必须将父类抽象方法重写为普通方法。

interface math{
	public static final double P = 3.123;//可以省public static final
	int sum(int a,int b);//省了public abstract
	int sub(int a,int b);
}
class mathimp implements math{
	public int sum(int a,int b) {
		return a+b;
	}
	public int sub(int a,int b) {
		return a-b;
	}
}
abstract class mathimps implements math{}//抽象类继承接口。他们当中方法都是抽象方法，因此不需要重写方法。

8.extends和implements同时出现。

public class Test{
    public static void main(String[] args) {
        flyable f = new cat();
        f.fly();
    }
}

class Animal{

}
//可飞翔的接口（其实是一对翅膀）
//接口可插拔
interface flyable{
    void fly();
}
class cat extends Animal implements flyable{
    public void fly(){
        System.out.println("cat会飞");
    }

}

2.接口在开发中的作用

接口在开发的作用类似于多态在开发中的作用。

多态在开发中的作用：面向抽象编程不要面向具体编程，降低程序的耦合度，提升程序的扩展力。

//主人喂养宠物的一个类
public class Master{
    publc void feed(dag d){
        
    }
    public void feed(cat c){

    }    
    //如果此时又要喂养1其他宠物，那么这个时候需要加一个代码，这样扩展力太差
}
//可以改成面向父类编程，那么就无论以后是想喂养那种宠物都行
public class Master{
    publc void feed(Animal d){
    }
}

接口在开发中的作用？

接口是一种完全抽象类，面向抽象编程以后可以改为面向接口编程，有了接口就有了可插拔，可插拔表示扩展力强，不是焊接死的。

分析中午去饭馆吃饭，这个过程有接口吗？

接口是抽象的。

菜单是一个接口。（菜单上有一个抽象的照片：西红柿炒鸡蛋）

谁面向接口调用（顾客面向菜单点餐，调用接口）

谁负责实现接口（后台厨师负责把西红柿鸡蛋做好）