抽象类
抽象类的概述
抽象就是从多个事物中将共性的、本质的内容抽取出来。例如:狼和狗共性都是犬科,犬科就是抽象出来的概念。
- 抽象类:Java中可以定义没有方法体的方法,该方法的具体实现由子类完成,该方法称为抽象方法,包含抽象方法的类就是抽象类;
- 抽象方法的由来:多个对象都具备相同的功能,但是功能具体内容有所不同,那么在抽取过程中,只抽取了功能定义,并未抽取功能主体,那么只有功能声明,没有功能主体的方法称为抽象方法。例如,狼和狗都有吼叫的方法,可是吼叫内容是不一样的,所以抽象出来的犬科虽然有吼叫功能,但是并不明确吼叫的细节。
抽象类的特点
- 抽象方法一定定义在抽象类中;
- 抽象方法和抽象类都必须被abstract关键字修饰;
- 抽象类不可以用new创建对象,因为调用抽象方法没意义;
- 抽象类中的抽象方法要被使用,必须由子类覆写其所有的抽象方法后,建立子类对象调用,如果子类只覆盖了部分抽象方法,那么该子类还是一个抽象类。
抽象类的一些细节
- 抽象类中有构造函数吗?
有。抽象类的构造函数虽然不能给抽象类对象实例化,因为抽象类不能创建对象,但是抽象类有子类,它的构造函数可以给子类的对象实例化。 - 抽象类一定是个父类吗?
是的。必须需要子类覆盖抽象方法后,才可以实例化,使用这些方法。 - 抽象类中可以不定义抽象方法吗?
可以的。仅仅是让该类不能创建对象。 - 抽象关键字abstract和哪些关键字不能共存呢?
- final:非法的修饰符组合,abstract和final;
- private:private的方法不能被覆盖;
- static
- 抽象类和一般类的异同点?
抽象类和一般类没有太大的不同,该如何描述事物就如何描述事物,只不过该事物出现了一些看不懂的东西。这些不确定的部分,也是该事物的功能,需要明确出现,但是无法定义主体,通过抽象方法表示。抽象类和一般类的异同点,总结起来就是:
- 相同点:都是用来描述事物,都可以进行属性和行为的描述;
- 不同点:抽象类描述事物的信息不具体,一般类描述事物的信息具体;
- 代码的不同之处:抽象类中可以定义抽象方法,一般类不行(也即抽象类比一般类多了个抽象函数,就是在类中可以定义抽象方法,也可以不定义抽象方法);抽象类不可以实例化,一般类可以。
抽象类的练习
练习一,假如我们在开发一个系统时需要对员工进行建模,员工包含3个属性:姓名、工号以及工资。经理也是员工,除了含有员工的属性外,另外还有一个奖金属性。请使用继承的思想设计出员工类和经理类,要求类中提供必要的方法进行属性访问。
abstract class Employee {
private String name;
private String id;
private double pay;
Employee(String name, String id, double pay) {
this.name = name;
this.id = id;
this.pay = pay;
}
public abstract void work();
}
class Pro extends Employee {
Pro(String name, String id, double pay) {
super(name, id, pay);
}
public void work() {
System.out.println("pro work");
}
}
class Manager extends Employee {
private int bonus;
Manager(String name, String id, double pay, int bonus) {
super(name, id, pay);
this.bonus = bonus;
}
public void work() {
System.out.println("manager work");
}
}
练习二,获取一段程序运行的时间。
分析:一段程序运行时间的原理——获取程序开始和结束的时间并相减即可。获取时间:System.currentTimeMillis();
。
abstract class GetTime {
public final void getTime() {
long start = System.currentTimeMillis();
runCode();
long end = System.currentTimeMillis();
System.out.println("毫秒:"+(end-start));
}
public abstract void runCode();
}
class SubTime extends GetTime {
public void runCode() {
for(int x = 0; x < 4000; x++) {
System.out.print(x);
}
}
}
class TemplateDemo {
public static void main(String[] args) {
// GetTime gt = new GetTime();
SubTime gt = new SubTime();
gt.getTime();
}
}
从上述程序代码中,我们可以学到一个模板方法设计模式。什么是模板方法设计模式呢?在定义功能时,功能的一部分是确定的,但是有一部分是不确定的,而确定的部分在使用不确定的部分,那么这时就将不确定的部分暴露出去,由该类的子类去完成,这样可以提高功能扩展性和代码复用性。
接口
接口的概述
初期理解,可以认为是一个特殊的抽象类,当抽象类中的方法都是抽象的,那么该类可以通过接口的形式来表示。接口定义时,格式特点有:
- 接口中常见定义:常量、抽象方法;
- 接口中的成员都有固定修饰符——常量:
public static final
、方法:public abstract
。记住:接口中的成员都是public的。
接口是不可以创建对象的,因为有抽象方法,需要被子类实现,子类对接口中的抽象方法全都覆盖后,子类才可以实例化,否则子类仍是一个抽象类。
接口的特点
- 接口不可以实例化;
- 需要覆盖了接口中的所有的抽象方法的子类,才可以实例化,否则该子类还是一个抽象类;
- 接口是用来被实现的。
接口的好处
接口的多实现
接口可以被多实现,也是对多继承不支持的转换形式,Java是支持多实现的。
interface Inter {
public static final int NUM = 3;
public abstract void show();
}
interface InterA {
public abstract void show();
}
class Demo {
public void function() {}
}
class Test extends Demo implements Inter, InterA {
public void show() {}
}
class InterfaceDemo {
public static void main(String[] args) {
Test t = new Test();
System.out.println(t.NUM); // 3
System.out.println(Test.NUM); // 3
System.out.println(Inter.NUM); // 3
}
}
避免了单继承的局限性
亦可从上述程序代码中知道接口的第二个好处:一个类继承一个类的同时,还可以实现多个接口,这样就避免了单继承的局限性。这也说明了继承是为了获取体系中的基本功能,想要扩展功能,可以通过实现接口来完成。
类与类之间是继承关系(is a),类与接口之间是实现关系(like a),那么接口与接口之间是什么关系呢?是继承关系,而且是多继承的。
interface A {
void methodA();
}
interface B {
void methodB();
}
interface C extends B, A {
void methodC();
}
class D implements C {
public void methodA() {}
public void methodB() {}
public void methodC() {}
}
没有抽象方法的抽象类
还记得我们在讲抽象类的时候,说过抽象类中可以不定义抽象方法。肯定有人会对此有疑问,没关系,我们现在用一个例子来释疑。
interface Inter
{
void show1();
void show2();
void show3();
void show4();
}
// 为了方便创建Inter接口的子类对象,可以用一个类先把接口中的所有方法都空实现。
// 该类创建对象没有意义,所以可以将该类抽象。
// 这就是传说中的没有抽象方法的抽象类。
abstract class Demo implements Inter
{
public void show1() {}
public void show2() {}
public void show3() {}
public void show4() {}
}
// DemoA需要使用接口中的部分方法,比如使用show1。
class DemoA extends Demo //implements Inter
{
public void show1()
{
System.out.println("DemoA show1");
}
/*
public void show2() {}
public void show3() {}
public void show4() {}
*/
}
// DemoB也需要接口的部分功能,需要show3();
class DemoB extends Demo // implements Inter
{
public void show3()
{
System.out.println("DemoB show3");
}
/*
public void show2() {}
public void show1() {}
public void show4() {}
*/
}
// 问题:只需要部分功能,但是为了实例化,必须要全部覆盖。代码的复用性很差。
class InterfaceDemo4
{
public static void main(String[] args)
{
DemoA a = new DemoA();
a.show1();
}
}
接口的思想
- 接口的出现扩展了功能;
- 接口其实就是暴露出来的规则;
- 接口的出现降低了耦合性(事物之间的紧密联系程度),接口的出现更多的是为了解耦。
接口的出现,一方在使用接口,一方在实现接口,所以我们要知道如何弄清楚双方。
抽象类和接口的区别
- 类与类之间是继承关系,is a;类与接口之间是实现关系,like a;
- 抽象类中可以定义抽象和非抽象方法,子类可以直接使用,或者覆盖使用;接口中定义的都是抽象方法,必须实现才能用;
- 类用于描述的是事物的共性基本功能;接口用于定义的都是事物的额外功能。(这个是最重要的!!!!!)