java学习笔记（六）-- （抽象类与接口上）（抽象类&模板设计模式）

最新推荐文章于 2024-02-22 23:37:19 发布
最新推荐文章于 2024-02-22 23:37:19 发布
阅读量289 收藏 1
点赞数 2
分类专栏： javaSE学习笔记 java 文章标签： 抽象类与接口上 模板设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ds19980228/article/details/83244177
版权

抽象类的定义和使用

  • 抽象类的定义：抽象类只是比普通方法多了一些抽象方法而已。
  • 抽象方法：只声明而未实现的方法（没有方法体），抽象方法所在的类也一定要使用abstract来定义只声明而未实现的方法不一定为抽象方法，也可能为本地方法（调用c/c++库函数）

抽象类的使用原则

        1.所有抽象类必须有子类（final（没有子类）与abstract不能同时出现，矛盾）

        2.抽象类的子类必须覆写抽象类的所有抽象方法（private（不允许覆写）与abstract不能同时出现）

        3.抽象类无法直接创建实例化对象，需要通过子类向上转型为实例化 

举例：

abstract class Person{
    private String name;
    public String getName(){
        return name;
    }
    public abstract void test();
}
class Student extends Person{
    public void test(){
        System.out.println("子类覆写抽象方法！");
    }
}
public class Test{
    public static void main(String[] args) {
        Person per=new Student();
        per.test();
    }
}

 

抽象类相关规定

  • 抽象类一定存在构造方法，子类也一定遵循对象实例化流程。先调用父类构造再调用子类构造

举例：

abstract class Person{
    private String name;
    //构造方法
    public Person(){
        System.out.println("**********");
    }
    public String getName(){
        return this.name;
    }
    //普通方法
    public void setName(String name){
        this.name=name;
    }
    //抽象方法
    public abstract void getPersonInfo();
}
class Student extends Person{
    //构造方法
    public Student(){
        System.out.println("###########");
    }
    public void getPersonInfo(){
        //空实现
    }
}
public class Test{
    public static void main(String[] args) {
        new Student();
    }
}
//打印结果如下
// **********
// ###########

 

如果父类没有无参构造，那么子类构造必须使用super明确指出使用父类哪个构造方法

范例：  ****重要****

abstract class A{
    //4.调用父类构造
    public A(){
        //5.调用被子类覆写的方法
        this.print();
    }
    public abstract void print();
}
class B extends A{
    private int num=100;
    //2.调用子类实例化对象
    public B(int num){
        //3.隐含的super语句，实际要先调用父类构造
        super();
        //8.为类中属性初始化
        this.num=num;
    }
    //6.此时子类对象的属性还没有被初始化
    public void print(){
    //7.对应其数据类型的默认值
        System.out.println(this.num);
    }
}
public class Test{
    public static void main(String[] args) {
        //1.实例化子类对象
        new B(30);        
        new B(30).print();
    }
}
//打印结果如下：
//0

// 0
// 30
如果构造方法，那么对象中的属性一定都是其对应数据类型的默认值
对象实例化过程：
进行类加载
进行类对象的空间开辟
进行类对象的属性初始化（构造方法）
  • 抽象类可以没有任何抽象方法，但此时仍然不能创建实例化对象
  •  final与abstract不能同时出现；private与abstract也不能同时出现      具体原因：抽象类一定不能使用final声明，因为使用final声明的类不允许有子类；而抽象类必须有子类；相应的，抽象方 法也不能使用private定义，因为抽象方法必须要被覆写。

关于内部抽象类：子类只需要覆写外部抽象类的直接抽象方法。内部抽象类的抽象方法可不覆写。外部抽象类中不能使用static修饰，但是内部抽象类允许使用static

举例：

abstract class A{
    public abstract void printA();
    //内部类使用static修饰
    static abstract class B{
        public abstract void printB();
    }
}
class X extends A{
    public void printA(){}
}

 

 

**** 重点****

模板设计模式

设计模式：精髓解耦，引入第三方解耦（高内聚，低耦合）

开闭原则（OCP）：一个软件实体如类。模块或函数应该对扩展开放，对修改关闭。

模板方法仅仅使用了Java的继承机制，但它是应用非常广泛的模式，抽象类的实际应用

模板方法定义了一个算法的步骤，并允许子类为一个或者多个步骤提供具体实现。

模板（模板方法）设计模式：基于抽象类

核心在一个方法定义一个算法的骨架，而将一些步骤延迟到子类中。模板模式可以使得子类在不改变算法的前提下，重新定义算法中的某些步骤。

注意：为了防止恶意操作，一般模板方法都加上final关键字， 不允许被覆写

模板方法的优点：
● 封装不变部分，扩展可变部分
● 提取公共部分代码，便于维护
● 行为由父类控制，子类实现

模板模式就是在模板方法中对基本方法的调用。

模板方法通用代码：

抽象模板类：

public abstract class AbstractClass {
     //基本方法
     protected abstract void doSomething();
     //基本方法
     protected abstract void doAnything();
     //模板方法
     public void templateMethod(){
             /*
              * 调用基本方法，完成相关的逻辑
              */
             this.doAnything();
             this.doSomething();
     }
}

具体模板类：注意：抽象模板中的基本方法尽量设计为protected类型，符合迪米特法则，不需要暴露的属性或方法尽量不要设置为protected类型

public class ConcreteClass1 extends AbstractClass {
     //实现基本方法
     protected void doAnything() {
             //业务逻辑处理
     }
     protected void doSomething() {
             //业务逻辑处理
     }
}
public class ConcreteClass2 extends AbstractClass {
     //实现基本方法
     protected void doAnything() {
             //业务逻辑处理
     }
     protected void doSomething() {
             //业务逻辑处理
     }
}

场景类：

public class Client {
     public static void main(String[] args) {
             AbstractClass class1 = new ConcreteClass1();
             AbstractClass class2 = new ConcreteClass2();               
             //调用模板方法
             class1.templateMethod();
             class2.templateMethod();
     }
}

模板模式举例·：

星巴克咖啡冲泡法

  1. 将水煮沸 
  2. 用沸水冲泡咖啡
  3. 将咖啡倒进杯子 
  4.  加糖和牛奶

星巴克茶冲泡法

  1. 将水煮沸 
  2. 用沸水浸泡茶叶 
  3. 把茶倒进杯子
  4. 加柠檬

根据冲泡步骤使用代码实现咖啡和茶的类：
 

class Coffee{
    //咖啡冲泡法（算法）
    void prepareRecipe(){
        boilWater();
        brewCoffeeGrings();
        pourInCup();
        addSugarAndMilk();
    }
    public void boilWater(){
        System.out.println("将水煮沸");
    }
    public void brewCoffeeGrings(){
        System.out.println("冲泡咖啡");
    }
    public void pourInCup(){
        System.out.println("将咖啡倒进杯子中");
    }
    public void addSugarAndMilk(){
        System.out.println("加糖和牛奶");
    }
}
class Tea{
    void prepareRecipe(){
        boilWater();
        steepTeaBag();
        pourInCup();
        addLemon();
    }
    public void boilWater(){
        System.out.println("将水煮沸");
    }
    public void steepTeaBag(){
        System.out.println("浸泡茶");
    }
    public void pourInCup(){
        System.out.println("将茶倒进杯子中");
    }
    public void addLemon(){
        System.out.println("加柠檬");
    }
}
public class Test{
    public static void main(String[] args) {
        Coffee coffee=new Coffee();
        coffee.prepareRecipe();
        Tea tea=new Tea();
        tea.prepareRecipe();
    }
}

我们可以发现茶和咖啡非常相似，因此可以将二者相同的部分抽取出来，放进一个基类（父类）当中。

我们可以把“将水煮沸”和“将饮料倒进杯子中”放到一个基类中。

我们在可以从冲泡法和往饮料中加调料着手，将二者的冲泡算法合并成

  1. 将水煮沸
  2. 用热水泡饮料
  3. 将饮料倒进杯子
  4. 在饮料内加入适当的调料

抽象基类代码实现：


//咖啡因饮料是一个抽象类
//抽象模板类
abstract class CaffeineBeverage{
    //使用同一个prepareBeverage()方法处理茶和咖啡
    //使用final关键字来防止子类覆盖这个方法
    //模板方法
    final void prepareRecipe(){
        boilWater();
        //冲饮料的方法
        brew();
        pourInCup();
        //往饮料中加的调料
        addCondiments();
    }
    //基本方法
    public void boilWater(){
        System.out.println("将水烧开");
    }
    //基本方法
    public void pourInCup(){
        System.out.println("将饮料倒进杯子");
    }
    //将咖啡和茶不同的处理方法声明为抽象，留给子类实现
    //基本方法
    public abstract void brew();
    //基本方法
    public abstract void addCondiments();
}
//具体模板类
class Coffee extends CaffeineBeverage{
    public void brew(){
        System.out.println("冲泡咖啡");
    }
    public void addCondiments(){
        System.out.println("加糖和牛奶");
    }
}
//具体模板类
class Tea extends CaffeineBeverage{
    public void brew(){
        System.out.println("冲泡茶");
    }
    public void addCondiments(){
        System.out.println("加柠檬");
    }
}
//场景类
public class Test{
    public static void main(String[] args) {
        //向上转型
        CaffeineBeverage coffee=new Coffee();
        coffee.prepareRecipe();
        //向上转型
        CaffeineBeverage tea=new Tea();
        tea.prepareRecipe();
    }
}

此时的类图：

模板方法定义了一个算法的步骤，并允许子类为一个或者多个步骤提供具体方法

使用模块方法所带来的优势

不好的茶或咖啡实现

模板方法提供的咖啡因饮料

Coffee或Tea主导一切，控制算法

由超类主导一切，它拥有算法，并且保护这个算法

Coffee与Tea之间存在重复代

有超类的存在，因此可以将代码复用最大化

对于算法所做的代码改变，需要打开各个子类修改很多地方

算法只存在一个地方，容易修改

弹性差，新种类的饮料加入需要做很多工作

弹性高，新饮料的加入只需要实现自己的冲泡和加料方 法即可

算法的知识和它的实现分散在许多类中

超类专注于算法本身，而由子类提供完整的实现。

钩子方法：是一类“默认不做事的方法”，子类可以选择性的覆盖他们

范例：扩展上述类，引入钩子方法

//咖啡因饮料是一个抽象类
abstract class CaffeineBeverage{
    //使用同一个prepareBeverage()方法处理茶和咖啡
    //使用final关键字来防止子类覆盖这个方法
    final void prepareRecipe(){
        boilWater();
        //冲饮料的方法
        brew();
        pourInCup();
        //判断顾客是否需要加入调料
        if(customerWantCondiments()){
            //往饮料中加的调料
            addCondiments();
        }
    }
    public void boilWater(){
        System.out.println("将水烧开");
    }
    public void pourInCup(){
        System.out.println("将饮料倒进杯子");
    }
    //将咖啡和茶不同的处理方法声明为抽象，留给子类实现
    public abstract void brew();
    public abstract void addCondiments();
    //钩子方法
    boolean customerWantCondiments(){
        return true;
    }
}
class Coffee extends CaffeineBeverage{
    public void brew(){
        System.out.println("冲泡咖啡");
    }
    public void addCondiments(){
        System.out.println("加糖和牛奶");
    }
}
class Tea extends CaffeineBeverage{
    public void brew(){
        System.out.println("冲泡茶");
    }
    public void addCondiments(){
        System.out.println("加柠檬");
    }
    public boolean customerWantCondiments(){
        String answer=getUserInput();
        if(answer.equals("y")){
            return true;
        }else{
            return false;
        }
    }
    //私有方法，获取用户的意愿
    private String getUserInput(){
        String answer=null;
        System.out.println("您想要在茶中加入柠檬吗(y/n)？");
        //写入用户的选择
        Scanner scanner=new Scanner(System.in);
        answer=scanner.nextLine();
        return answer;
    }
}
public class Test{
    public static void main(String[] args) {
        //向上转型
        CaffeineBeverage coffee=new Coffee();
        coffee.prepareRecipe();
        //向上转型
        CaffeineBeverage tea=new Tea();
        tea.prepareRecipe();
    }
}

 

Dyson~
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
面向对象（下）章节练习题及面试题
qq_41048982的博客
11-02 1784
main()方法 选择题 class Test { public static void main(String[] args) { String foo = args[1]; String bar = args[2]; String baz = args[3]; } } d:\>java Test Red Green Blue what is the value of baz? A. baz has value of "" B. baz has value o
Java学习笔记 --- 抽象类
乌云的博客
10-17 798
当父类的某些方法，需要声明，但是又不确定如何实现时，可以将其声明为抽象方法，那么这个类就是抽象类}}//抽象类}//父类方法不确定性的问题//考虑将其设计为抽象方法，抽象方法就是没有实现的方法//没有实现就是值没有方法体//当一个类中存在抽象方法时，需要将该类声明为抽象类//一般来说，抽象类会被继续，由其子类继承来实现抽象方法}1、用abstrac关键字来修饰一个类时，这个类就叫抽象类访问修饰符 abstract 类名 { }
简单的接口和抽象类实现模板设计模式
zaoanmiao的博客
07-13 1841
一、先使用接口实现模板设计模式 1、先写模板模式中大家公共的方法，将该方法放到一个接口里： public interface MyPublic { public void step02(); } 2、写模板类（step01和step03是公共的不变的方法，step02是公共各自需要实现改变的方法，也就需要传入一个实现类对象） public class MyTemplate { ...
JavaOO总结2
xiaozhang___的博客
05-14 232
Java总结21、Java中一个类能同时继承多个类吗？所有类的父类是什么？不能   object2、构造方法能继承吗？构造方法能重载吗？构造方法不能继承，但是子类对象创建时需要调用父类的构造方法，产生父类对象构造方法能重载，通过重载方法完成属性的初始化操作3、final、finally、finalize的区别是什么？final是修饰符表示该类不能被继承方法，不能被i子类重写，修饰变量，表示该变量的...
JavaSE之面向对象编程—抽象类与接口—— 2（模板设计模式——抽象类的实际应用）
ZhuiZhuDream5的博客
11-20 178
                  &amp
来一杯java_初级java笔试题
weixin_39766109的博客
02-13 178
1.public static void main(String[] args){short s1 = 1;s1 = s1 + 1;System.out.println(s1);}。判断是否错误？s1 + 1 运算结果是int型，赋值给s1的时候需要强制转换类型。public static void main(String[] args) {short s1 = 1;s1 += 1;System....
设计模式学习笔记 - 面向对象 - 5.接口和抽象类的区别
最新发布
chenjian723122704的专栏
02-22 1413
在面向对象编程中，抽象类和接口是常被用到的语法概念，是面向对象四大特性，以及很多设计模式、设计思想、设计原则实现的基础。它们之间的区别是什么？什么时候用接口？什么时候用抽象类？抽象类和接口存在的意义是什么？
java学习笔记7--抽象类与抽象方法
GarfieldEr007的专栏
03-21 1325
接着前面的学习: java学习笔记6--类的继承、Object类 java学习笔记5--类的方法  java学习笔记4--类与对象的基本概念（2） java学习笔记3--类与对象的基本概念（1） java学习笔记2--数据类型、数组 java学习笔记1--开发环境平台总结 本文地址：http://www.cnblogs.com/archimedes/p/java-study-note
java学习笔记----抽象类
cn_leeyiru_static的博客
01-28 341
java学习笔记（高琪版）面向对象OOP抽象类抽象类必须要被继承才有意义，他的结构能给子类一个模板，限制子类的设计。注意： 只能定义抽象方法（类也要被定义为抽象类） only public, protected, private, static, final, transient & volatile are permitted抽象类不能被实例化，只能定义子类 Car mycar1 = ne
抽象类与接口（学习笔记）
12-21
抽象类 什么是抽象类： 类和类之间具有共同特征，讲这些共同特征抽取出来，就形成了抽象类。因为类本身是不存在的，所以抽象类无法创建对象（无法实例化）。 以下借用视频中总结的思维层次图： 抽象类属于什么类型...
Java-抽象类和接口--学习笔记.docx
07-05
JAVA学习笔记，java知识点总结
java学习笔记接口和抽象类
08-23
java学习笔记接口和抽象类
PHP 面向对象程序设计（oop）学习笔记(一) - 抽象类、对象接口、instanceof 和契约式编程
10-25
面向对象程序设计（OOP）是一种计算机编程架构。OOP的一条基本原则是计算机程序是由单个能够起到子程序作用的单元或对象组合而成。OOP达到了软件工程的三个主要目标：重用性、灵活性和扩展性。为了实现整体运算，每...
java中的CAS操作以及锁机制详解
【Dyson】的博客
11-17 8158
关于CAS操作 CAS：Compare And Swap   --  乐观锁策略 CAS（无锁操作）：使用CAS叫做比较交换来判断是否出现冲突，出现冲突就重试当前操作直到不冲突为止。 悲观锁（JDK1.6之前的内建锁）：假设每一次执行同步代码块均会产生冲突，所以当线程获取锁成功，会阻塞其他尝试获取该锁的线程。 乐观锁（Lock机制）：假设所有线程访问共享资源时不会出现冲突，既然不会出现冲突...
定义一个抽象的"Role"类，有姓名，年龄，性别等成员变量
【Dyson】的博客
10-24 3914
定义一个抽象的"Role"类，有姓名，年龄，性别等成员变量  要求尽可能隐藏所有变量(能够私有就私有,能够保护就不要公有)， 再通过GetXXX()和SetXXX()方法对各变量进行读写。具有一个抽象的play()方法， 该方法不返回任何值，同时至少定义两个构造方法。Role类中要体现出this的几种用法。  从Role类派生出一个"Employee"类，该类具有Role类的所有成员（构造方法...
java异常练习题：定义一个MulException类继承Exception类，要求两数相乘等于100报错，在主类中定义一个方法，在方法中抛出此异常，在主方法观察结果
【Dyson】的博客
11-01 1517
题目描述： 定义一个MulException类继承Exception类，要求两数相乘等于100报错，在主类中定义一个方法，在方法中抛出此异常，在主方法观察结果。  定义一个DivException类继承RuntimeException类，要求两数相除等于2报错，在主类中定义一个方法，在方法中抛出此异常，在主方法观察结果 代码如下： package www.Dyson.java; //继承受...
java--Fibonacc由数字1、1、2、3...组成的，从第三个数字起每一个数字为前两个数字的和。创建一个方法，接受一个整数参数，显示从第一个元素开始总共由该参数指定的个数所构成的所有斐波那契数
【Dyson】的博客
10-14 1502
题目完整描述：一个斐波那契数列是由数字1、1、2、3、5、8、13、21、34等等组成的，其中每一个数字(从第三个数字起)都是前两个数字的和。创建一个方法，接受一个整数参数，并显示从第一个元素开始总共由该参数指定的个数所构成的所有斐波那契数字。例如，如果运行 java Fibonacci 5(Fibonacci为类名)，那么输出应该是1、1、2、3、5。 public class Fibona...
java--创建一个Test类，包含有一个public权限的int型成员变量与一个char类型的成员变量，观察在main方法中的初始值。
【Dyson】的博客
10-14 1263
//创建一个Test类 class Test1{ //包含有一个public权限的int型成员变量与一个char类型的成员变量 public int a; public char c; } //主类 public class Test{ //主函数 public static void main(String[] args){ //声明与实...
思维导图 --- 继承，封装，多态
【Dyson】的博客
11-15 1115
思维导图 — 继承，封装，多态 传送门: 继承、封装、多态.
学习笔记--如何使用Comparable接口里compareTo 方法进行排序
05-30
这个接口是 Java 中的一个接口，它只有一个方法 `compareTo()`。这个方法的作用是定义类的自然排序顺序。 如果我们要对一个对象集合进行排序，只需要让这个类实现 `Comparable` 接口，并且重写 `compareTo()` 方法...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值