Java-抽象类与接口

抽象类与接口

抽象类：

包含一个抽象方法的类称为抽象类，抽象方法只是声明而未实现的方法，所有的抽象方法必须使用abstract声明，所有的抽象类也需要使用abstract关键字声明。抽象类不能被实例化。

抽象类的特点：

Ø  抽象类的属性和方法都是他的子类的公共属性和方法的集合。

Ø  改变他的属性和方法一定会改变他所有子类的该属性和方法。

Ø  以abstract修饰的方法称为抽象方法，所有的抽象方法都必须在抽象类中

Ø  抽象类中既存在抽象方法，也存在一般方法

Ø  对于父类中的抽象方法是通过覆盖的形式来继承的，子类必须实现父类中所有的抽象方法，否则该子类必须仍然定义为抽象类

Ø  继承不涉及构造函数的继承

抽象类的声明：abstract  class 类名{}

抽象方法的声明：abstract  方法名（）;  //方法名的括号后直接加“;”结束，不可再加“{}”

下面看一个简单的抽象类的定义：

abstract class A

{public abstract void fun1();  //抽象方法

 public void fun2()

         {System.out.println("普通方法");}

}

class B extends A

{public void fun1()

         {System.out.println("覆写A类的抽象方法fun1()");}

}

public class Demo01

{public static void main(String[] args)

         {B b=new B();

     b.fun1();

          b.fun2();

    }

}

抽象类中允许有构造方法，但此构造方法是不能直接调用的，要交给子类去调用的，子类对象实例化过程中，永远都是先调用父类中的构造方法。

abstract class A

{ A()

    {System.out.println("**********");}

 public abstract void fun1();  //抽象方法

}

class B extends A

{ B()

         {super();

          System.out.println("__________");

         }

 public void fun1()

    {System.out.println("复写A类的抽象方法fun1()");}

}

public class Demo02

{

 public static void main(String[] args)

         {new B();

    }

}

允许后输出：

**********

__________

 

 

 

abstract class A{

         private String name ;

         public A(String name){     // 构造方法

                   this.name = name ;

                   System.out.println("*******");

         }

         public String getName(){

                   return this.name ;

         }

         public abstract void fun() ;  //抽象方法

}

class B extends A{   // 继承抽象类

         public B(String name){

                   super(name) ;

         }

         public void fun(){       // 覆写方法时需要注意访问控制权限

                   System.out.println(super.getName()) ;

         }

}

public class Demo03

{        public static void main(String args[]){

                   B b = new B("张三") ;

                   b.fun() ;

         }

}

输出：

*******

张三

接口：

接口是若干完成某一特定功能的没有方法体的方法（抽象方法）和常量的集合。

Java语言使用接口来实现类间多重继承的功能，从而弥补了Java语言只支持类间单重继承，描述复杂实际问题处理不方便的不足。

接口的定义格式：

[修饰符]  interface  接口名 [extends  父接口名表] {接口体}

接口体同抽象类相似，为变量和抽象方法的集合，但没有构造方法和静态初始化代码。接口体中定义的变量均为终极（final）的、静态（static）的和公共（public）的。接口体中定义的方法均为抽象的和公共的。由于接口所有成员均具有这些特性，相关的修饰符可以省略。

例如以下程序段就是一个接口的定义：

interface A

{int a=10;

 void fun();   //抽象方法

}

此接口中定义了一个常量和一个抽象方法，与抽象类一样接口也需要有子类。只是子类此时不再称为继承类，而是实现接口，通过implements关键字完成。

interface A

{int a=10;

 void fun();   //抽象方法

}

class B implements A  //实现接口A

{public void fun()   //实现接口方法时，访问权限应为public

         {System.out.println(a);}

}

public class Demo04

{public static void main(String[] args)

         {B b=new B();

          b.fun();

         }

}

 

一个类只可继承一个父类，但可以实现多个接口，实现多重继承的功能。

interface A

{int a=10;

 void fun1();

}

interface B

{String b="接口B";

 void fun2();

}

class C implements A,B

{public void fun1()

         {System.out.println(a);}

 public void fun2()

         {System.out.println(b);}

 

}

public class Demo05

{public static void main(String[] args)

         {C c=new C();

          c.fun1();

          c.fun2();

         }

}

 

一个类亦可同时继承一个类和实现多个接口。

interface A

{int a=10;

 void fun1();

}

interface B

{String b="接口B";

 void fun2();

}

abstract class C

{public abstract void fun3();

}

class D extends C implements A,B

{public void fun1()

         {System.out.println(a);}

 public void fun2()

         {System.out.println(b);}

 public void fun3()

         {System.out.println("抽象类C");}

 

}

public class Demo06

{public static void main(String[] args)

         {D d=new D();

          d.fun1();

          d.fun2();

          d.fun3();

         }

}

 

 

 

一个类可以实现多个接口，但一个接口不能继承一个类。不过却可以继承多个接口。

interface A

{int a=10;

 void fun1();   //抽象方法

}

interface B

{String b="接口B";

 void fun2();

}

interface C extends A,B

{void fun3();

}

class D implements C

{public void fun1()   //实现接口方法时，访问权限应为public

         {System.out.println(a);}

 public void fun2()

         {System.out.println(b);}

 public void fun3()

         {System.out.println("抽象类C");}

 

}

public class Demo07

{public static void main(String[] args)

         {D d=new D();

          d.fun1();

          d.fun2();

          d.fun3();

         }

}

 

接口也可以像抽象类那样通过对象的多态性进行对象的实例化操作。

interface A

{void fun();

}

class B implements A

{public void fun()

         {System.out.println("Hello");}

}

public class Demo08

{public static void main(String[] args)

         {A a=new B();

          a.fun();

         }

}

抽象类与接口的区别：

No.	比较点	抽象类	接口
1	组成	抽象方法、普通方法、常量、构造方法、全局常量	抽象方法、全局常量
2	定义	abstract	interface
3	子类	通过extends继承抽象类	通过implements实现接口
4	限制	一个子类只能继承一个抽象类	一个子类可以实现多个接口
5	关系	一个抽象类可以实现多个接口	一个接口不能继承抽象类 但可以继承多个接口
一个抽象类中可以包含多个接口	一个接口中可以包含多个抽象类
6	设计模式	模板设计	工厂设计、代理设计
二个一起可以完成适配器设计
7	实例化	都对通过对象的多态性，通过子类进行对象的实例化操作。
8	实现限制	存在单继承局限	不存在单继承局限
9			表示一种标准、一种能力

 

一个抽象类中可包含多个接口。

abstract class A{

         public abstract void fun1() ;

         interface B{      // 内部接口

                   public void fun2() ;

         }

}

class X extends A{

         public void fun1(){

                   System.out.println("******") ;

         }

         class Y implements B{

                   public void fun2(){

                            System.out.println("======") ;

                   }

         }

}

public class Demo09{

         public static void main(String args[]){

                   A a = new X() ;

                   a.fun1() ;

                   A.B b = new X().new Y() ;

                   b.fun2() ;

         }

}

 

 

 

同样一个接口亦可包含多个抽象类。

interface A

{void fun1();

 abstract class B

 {abstract void fun2();

 }

}

class X implements A

{public void fun1()

         {System.out.println("******");}

 class Y extends B

 {public void fun2()

          {System.out.println("======");}

 }

}

public class Demo10

{public static void main(String[] args)

         {A a=new X();

          a.fun1();

          A.B b=new X().new Y();

          b.fun2();

         }

}