黑马程序员_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();
}
}