1. 什么是抽象类?
随着继承层次中一个个新子类的定义,类变得越来越具体,而父类则更一般,更通用。类的设计应该保证父类和子类能够共享特征。有时将一个父类设计得非常抽象,以至于它没有具体的实例,这样的类叫做抽象类
。
抽象类的出现使面向对象更加规范,比如人是一个抽象的概念,没有具体的对象,我们应该将其抽象成一个类,它无法生成对象实例,却拥有一些人通用的属性和方法。有些方法人类都是一样的行为,比如说都是用嘴吃饭,用耳朵听声音等;但有些则不是,比如工作,不同的岗位人们有不同的工作行为,那么这些行为的具体实现在子类完成,Person父类只负责定义。
2. 抽象类与抽象方法的特点
- 用abstract关键字来修饰一个类,这个类叫做抽象类。
- 抽象类可以有构造器,可以使用this关键字,子类可以使用super关键字
- 用abstract来修饰一个方法,该方法叫做抽象方法。抽象方法只能声明,具体实现应该交给子类完成
抽象方法:只有方法的声明,没有方法的实现。以分号结束:
比如:public abstract void talk(); - 抽象类中不一定包含抽象方法,但是含有抽象方法的类必须被声明为抽象类。
- 抽象类不能被实例化。抽象类是用来被继承的,抽象类的子类必须定义父类的抽象方法,并提供方法体。若没有定义全部的抽象方法,仍为抽象类。
- 不能用abstract修饰变量、代码块、构造器;
- 不能用abstract修饰私有(private)方法、静态(static)方法、final的方法、final的类
- 抽象类可以引用非抽象类的子类对象,并调用子类实现抽象类定义的方法和抽象类本身不是抽象的方法。
package Random_name.sgm.abstract_interface;
/**
* @Program: JavaSE
* @ClassName: TestMain
* @Author: Mr.BitHachi
* @CreateTime: 2020-08-08 12:07
* @Version: V1.0
* @Description:
**/
abstract class A {
private int aa=10;
static final String str="可以有static属性";
static{
System.out.println("可以有代码块");
}
A(int aa){
this.aa=aa;
}
public abstract void m1();
public void m2() {
System.out.println("A类中定义的m2方法");
System.out.println("A类中的属性a="+this.aa);
}
}
class B extends A {
private int bb=10;
B(int aa,int bb){
super(aa);
this.bb=20;
}
public void m1() {
System.out.println("B类中定义的m1方法");
}
public void m2() {
System.out.println("B类中重写的的m2方法");
}
void m3(){
super.m2();
}
}
class Test {
public static void main(String args[]) {
A a = new B(20,20);
a.m1();
a.m2();
B b=new B(30,30);
b.m3();
}
}
运行结果:
可以有代码块
B类中定义的m1方法
B类中重写的的m2方法
A类中定义的m2方法
A类中的属性a=30
3. 抽象类的应用
抽象类的应用与多态应用相关联。
抽象类体现的是一种模板模式的设计,抽象类作为多个子类的通用模板,子类在抽象类的基础上进行扩展、改造,但子类总体上会保留抽象类的行为方式。
抽象类解决的问题:
- 当功能内部一部分实现是确定的,一部分实现是不确定的。这时可以把不确定的部分暴露出去,让子类去实现。
- 在软件开发中实现一个算法时,整体步骤很固定、通用,这些步骤已经在父类中写好了。但是某些部分易变,易变部分可以抽象出来,供不同子类实现。这就是一种
模板模式
。
模板方法设计模式是编程中经常用得到的模式。各个框架、类库中都有他的影子,比如常见的有:
- 数据库访问的封装
- Junit单元测试
- JavaWeb的Servlet中关于doGet/doPost方法调用
- Hibernate中模板程序
- Spring中JDBCTemlate、HibernateTemplate等
4. 什么是接口?
- 接口(英文:Interface),在JAVA编程语言中是一个抽象类型,是抽象方法的集合,接口通常以interface来声明。
- 有时必须从几个类中派生出一个子类,继承它们所有的属性和方法。但是,Java不支持多重继承。有了接口,就可以得到多重继承的效果。
- 有时必须从几个类中抽取出一些共同的行为特征,而它们之间又没有is-a的关系,仅仅是具有相同的行为特征而已。
- 接口就是规范,定义的是一组规则,体现了现实世界中“如果你是/要…则必须能…”的思想。继承是一个"是不是"的关系,而接口实现则是 "能不能"的关系。
5.接口的特点
- 接口(interface)是抽象方法和全局常量值定义的集合(jdk8之前)。jdk8之后可以定义static和default的方法和方法体
- 接口的特点:
- 用interface来定义。
接口中没有构造器
。- 接口不能用于实例化对象。
接口中不能拥有代码块
- 接口中的所有成员变量都默认是由
public static final
修饰的。 - 接口中的所有抽象方法都默认是由
public abstract
修饰的。 - 一个类可以实现多个接口,接口也可以继承(extends)其它一个或多个接口。
- 定义Java类的语法格式:先写extends,后写implements
class SubClassextends
SuperClassimplements
InterfaceA{ } - 实现接口的类中必须提供接口中所有方法的具体实现内容,方可实例化。否则,仍为抽象类。
- 接口的主要用途就是被实现类实现。(面向接口编程)
- 与继承关系类似,接口与实现类之间存在多态性
- 接口和类是并列关系,或者可以理解为一种特殊的类。从本质上讲,接口是一种特殊的抽象类,这种抽象类中只包含常量和方法的定义(JDK7.0及之前),而没有变量和方法的实现。
接口的定义举例:
JDK8中关于接口的改进:
-
Java 8中,你可以为接口添加静态方法和默认方法。从技术角度来说,这是完全合法的,只是它看起来违反了接口作为一个抽象定义的理念。
-
静态方法
:使用 static 关键字修饰。可以通过接口直接调用静态方法,并执行其方法体。我们经常在相互一起使用的类中使用静态方法。可以在标准库中找到像Collection/Collections或者Path/Paths这样成对的接口和类。 -
默认方法
:默认方法使用 default 关键字修饰。可以通过实现类对象来调用。我们在已有的接口中提供新方法的同时,还保持了与旧版本代码的兼容性。比如:java 8 API中对Collection、List、Comparator等接口提供了丰富的默认方法。- 若一个接口中定义了一个默认方法,而另外一个接口中也定义了一个同名同参数的方法(不管此方法是否是默认方法),在实现类同时实现了这两个接口时,会出现: ·接口冲突·。
解决办法
:实现类必须覆盖接口中同名同参数的方法,来解决冲突。 - 若一个接口中定义了一个默认方法,实现其接口的类的父类中也定义了一个同名同参数的非抽象方法,则不会出现冲突问题。因为此时遵守:
类优先原则
。接口中具有相同名称和参数的默认方法会被忽略。
- 若一个接口中定义了一个默认方法,而另外一个接口中也定义了一个同名同参数的方法(不管此方法是否是默认方法),在实现类同时实现了这两个接口时,会出现: ·接口冲突·。
-
接口中静态方法和默认方法必须给出方法体,不能只定义
根据接口的特点,综合举例:
/************ 一个类可以实现多个无关的接口 ************/
interface Runner {
int a=10;
public void run();//jdk8之前只能声明非static和defult的方法
static void fun2() {//jdk8之后可以定义static和defult的方法,不能声明,必须给出方法体
System.out.println("interface Runner static fun2");
}
default void fun3(){
System.out.println(this.a);//可以使用this,但是不能更改其值,因为默认缺省public static final
System.out.println("interface Runner default fun3");
}
}
interface Swimmer {
public double swim();
default void fun3(){
System.out.println("interface Swimmer default fun3");
}
default void skip(){
System.out.println("interface Swimmer default skip");
}
}
class Creator{
public void eat() {
System.out.println("eat");
}
public void skip(){
System.out.println("class Creator skip");
}
}
class Man extends Creator implements Runner ,Swimmer{
public void run() {
System.out.println("run");
}
public double swim() {
System.out.println("swim");
return 1.1d;
}
public void fun3(){
System.out.println("class Man fun3");//类覆盖两个接口中默认的方法fun3()
Runner.super.fun3();//调用原接口中默认的方法
Swimmer.super.fun3();
}
}
class Test{
public static void main(String args[]){
Test t = new Test();
Man m = new Man();
t.m1(m);//接口多态引用,与继承关系类似,接口与实现类之间存在多态性
t.m2(m);
t.m3(m);
System.out.println("-----------");
Runner.fun2();
System.out.println("-----------");
System.out.println(Runner.a);
System.out.println("-----------");
m.fun3();
System.out.println("-----------");
m.skip();
}
public void m1(Runner f) {//接口多态引用
f.run();
}
public void m2(Swimmer s) {//接口多态引用
s.swim();
}
public void m3(Creator a) {//接口多态引用
a.eat();
}
}
运行结果:
run
swim
eat
-----------
interface Runner static fun2
-----------
10
-----------
class Man fun3
10
interface Runner default fun3
interface Swimmer default fun3
-----------
class Creator skip
6.接口面试题
题一:
interface A {
int x = 0;
}
class B {
int x = 1;
}
class C extends B implements A {
public void pX() {
System.out.println(x);//Error
System.out.println(super.x);//1
System.out.println(A.x);//0
}
public static void main(String[] args) {
new C().pX();
}
}