黑马程序员_JAVA抽象类和接口

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

抽象类与接口

抽象类：

包含一个抽象方法的类称为抽象类，抽象方法只是声明而未实现的方法，所有的抽象方法必须使用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();
         }
}

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

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();
         }
}

转载于:https://my.oschina.net/u/2348536/blog/401693