抽象类及模板设计模式

最新推荐文章于 2023-10-23 22:05:04 发布

小蚂蚁0024

最新推荐文章于 2023-10-23 22:05:04 发布

阅读量129

点赞数

文章标签：设计模式 java 开发语言

本文链接：https://blog.csdn.net/m0_47916133/article/details/128754063

版权

文章介绍了Java中的抽象类概念，包括定义、作用及细节，强调抽象类不能实例化且含有抽象方法。通过模板设计模式的例子展示了如何使用抽象类作为模板，由子类重写抽象方法以实现特定功能，提高代码复用性和可读性。

摘要由CSDN通过智能技术生成

7.抽象类

1.定义：

1.abstract +class+类名

2.作用：

1.当父类的方法需要声明，但具体的实现通过子类重写完成时，可以将父类声明为抽象类

3.细节：

	1.当一个类中有抽象方法时，其必须声明为抽象类

			2.抽象类不能实例化对象

			3.当子类继承父类时，子类必须重写父类的所以抽象方法，否则将子类定义为抽象类

			4.abstract不能和static private final 一起使用，违背了重写原则

package review07;

public class AbstarctUse {
    public static void main(String[] args) {
        //抽象类不能实例化对象
//        Animal animal = new Animal(); 'Animal' is abstract; cannot be instantiated
        //父类的speak（）让不同的子类进行不同的实现，通过多态的动态绑定机制进行不同的调用！
        Animal temp01 = new Cat();
        temp01.speak();
        Animal temp02 = new Dog();
        temp02.speak();
    }
}

abstract class Animal {
    public String name;
    public int age;

    abstract public void speak();
}

class Cat extends Animal {
    @Override
    public void speak() {
        System.out.println("小猫喵喵叫！");
    }
}

class Dog extends Animal {
    @Override
    public void speak() {
        System.out.println("小狗汪汪叫！");
    }
}
//将子类修饰为抽象类则不需实现父类的抽象方法
abstract class Tiger extends Animal {
}

4.模板设计模式（抽象类的应用）

1.定义：父类作为抽象类相当于一个模板，子类继承进行各自的改造

2.实现：

			1.父类提供模板，并且将抽象方法给子类进行不同的实现

			2.父类中抽象出子类共有且逻辑功能相同的方法

package review07;
/*
* 1.不同型号的螺丝需要的打磨次数不同，统计不同型号螺丝需要的打磨时间
* */
public class TemplatePattern {
    public static void main(String[] args) {
        Screw01 screw01 = new Screw01();
        screw01.countTime();
        Screw02 screw02 = new Screw02();
        screw02.countTime();
        Screw03 screw03 = new Screw03();
        screw03.countTime();
    }
}
class Screw01{
    public void polish(){
       for (int i=0;i<200000;i++) {
           //假设i为打磨次数
       }
    }
    public void countTime(){
        long starttime=System.currentTimeMillis();
        polish();
        long endtime=System.currentTimeMillis();
        System.out.println("01号螺丝需要的打磨时间为："+(endtime-starttime));
    }
}
class Screw02{
    public void polish(){
        for (int i=0;i<1000000;i++) {
            //假设i为打磨次数
        }
    }
    public void countTime(){
        long starttime=System.currentTimeMillis();
        polish();
        long endtime=System.currentTimeMillis();
        System.out.println("02号螺丝需要的打磨时间为："+(endtime-starttime));
    }
}
class Screw03{
    public void polish(){
        for (int i=0;i<2000000;i++) {
            //假设i为打磨次数
        }
    }
    public void countTime(){
        long starttime=System.currentTimeMillis();
        polish();
        long endtime=System.currentTimeMillis();
        System.out.println("03号螺丝需要的打磨时间为："+(endtime-starttime));
    }
}
//普通的实现模式，每种型号的打磨次数，和时间计算在各自类中实现
//但可以看出代码可读性差，打磨次数是不同的，但时间统计函数逻辑功能是完全相同的

模板设计模式改进：

package review07;
/*
* 1.不同型号的螺丝需要的打磨次数不同，统计不同型号螺丝需要的打磨时间
* */
public class TemplatePattern {
    public static void main(String[] args) {
        Screw01 screw01 = new Screw01();
        screw01.countTime();
        Screw02 screw02 = new Screw02();
        screw02.countTime();
        Screw03 screw03 = new Screw03();
        screw03.countTime();
        //利用继承的查找机制，去调用父类的countTime函数
        //其中调用polish时，会根据多态的动态绑定调用不同的polish

    }
}
abstract class Screw{
    abstract public void polish();
    long times; //统计打印次数
    public void countTime(){
        long startTime=System.currentTimeMillis();
        polish();
        long endTime=System.currentTimeMillis();
        System.out.println("打磨时间: "+(endTime-startTime));
    }
}
class Screw01 extends Screw{

    public void polish(){
       for (int i=0;i<200000;i++) {
           times+=i;
           //假设i为打磨次数
       }
    }
}
class Screw02 extends Screw{

    public void polish(){
        for (int i=0;i<1000000;i++) {
            //假设i为打磨次数
            times+=i;
        }
    }
}
class Screw03 extends  Screw{

    public void polish(){
        for (int i=0;i<200000;i++) {
            times+=i;
            //假设i为打磨次数
        }
    }

}