抽象类与接口
抽象类：
包含一个抽象方法的类称为抽象类，抽象方法只是声明而未实现的方法，所有的抽象方法必须使用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();
}
}
|
分享到：
相关推荐
java抽象类与接口实例java抽象类与接口实例java抽象类与接口实例java抽象类与接口实例java抽象类与接口实例java抽象类与接口实例java抽象类与接口实例java抽象类与接口实例java抽象类与接口实例java抽象类与接口实例...
深入浅出的说明java抽象类与接口区别，让初学者更好的理解java抽象类与接口的概念
在Java语言中，abstract class和interface 是支持抽象类定义的两种机制。正是由于这两种机制的存在，才赋予了Java强大的面向对象能力。abstract class和interface之间在对于抽象类定义的支持方面具有很大的相似性，...
Java抽象类与接口实验报告
java 抽象类与接口的练习，包括代码及注释，个人笔记
JAVA学习笔记，java知识点总结
抽象类和接口的区别 在Java语言中， abstract class 和interface 是支持抽象类定义的两种机制。正是由于这两种机制的存在，才赋予了Java强大的 面向对象能力。abstract class和interface之间在对于抽象类定义的支持...
1.继承及继承实例 2.方法重写（Overwrite） 3.super关键字 4.方法重载（Overload） 5.final修饰符 6.abstract修饰符 7.抽象类 8.接口 9.接口和抽象类对比 10.接口和抽象类使用场合实例 11.总结
Java --- 接口、抽象类、方法重写
此书对于你学习Java抽象类和接口有非常大的帮助
1.抽象类&接口的教学视频。 2.提供在线支持和教学源码 3.新手训练面向对象思维的视频
学生通过对该项目整体框架的搭建和对动物城信息管理等模块的设计与功能实现，训练了学生对项目框架的搭建、类的封装、抽象类定义与继承、接口的定义与接口的实现等Java OOP面向对象知识点的掌握。 本项目主要包括...
Java中的类、抽象类和接口的区别和联系
java 抽象类与接口的区别
面向对象程序设计与实践 第五章 Java抽象类和接口 面向对象程序设计与实践课程组 面向对象程序设计与实践-Java抽象类和接口[33页]全文共33页，当前为第1页。 教学目标 教学方式 重点知识 学习目标 1．熟悉抽象类的...
Abstractclass和interface是Java语言中对于抽象类定义进行支持的两种机制，正是由于这两种机制的存在，才赋予了Java强大的面向对象能力
Java源代码：抽象类和接口 Java源代码：抽象类和接口
在Java语言中，abstract class 和interface 是支持抽象类定义的两种机制区别
实验5：Java抽象类与接口.doc
Java实验7抽象类和接口.pdf