精华内容
下载资源
问答
  • 抽象类使用
    千次阅读
    2021-04-23 13:53:30

    抽象类

    抽象类的使用条件:当父类的某些方法,需要声明,但是有不确定如果实现时,可以将其声明为抽象方法那么这个类也就要声明为抽象类,那么这个类就时抽象类

    当父类的一些方法不能确定时,可以用abstract关键字来修饰该方法,这个方法就是抽象方法,用abstract来修饰该类就是抽象类

    抽象方法就是没有实现的方法

    没有实现就是指,没有方法体

    当一个类中存在抽象方法时,需要将该类声明为abstract类

    一般来说,抽象类会被继承,有其子类来实现抽象方法。

    抽象类的介绍

    1)用abstract关键字来修饰的一个类时,这个类就叫抽象类

    public abstract 类名{
    }
    

    2)用abstract关键字来修饰一个方法时,这个方法就时抽象方法访问修饰符abstract返回类型 方法名(参数列表);//没有方法体

    public abstract 类名{
    	public abstract void num();	//不可以有方法体
    }
    

    3)抽象类的价值更多作用是在于设计,使设计者设计好后,让子类继承并实现抽象类

    4)抽象类,是考官比较爱问的知识点,在框架和设计模式使用较多

    抽象类使用的注意事项:

    1)抽象类不能被实例化

    2)抽象类不一定要包含abstract方法。也就是说,抽象类可以没有abstract方法,也可以有实现的方法

    3)一旦类包含了abstract方法,则这个类必须声明为abstract

    4)abstract只能修饰类和方法,不能修饰属性和其他的

    5)抽象类可以有任意成员【抽象类还是类】,比如:非抽象方法、构造器,静态属性等等[举例]

    6)抽象方法不能有主体,即不能实现

    7)如果一个类继承了抽象类,则他必须实现抽象类的所有抽象方法,除非它自己也声明为abstract类

    8)抽象方法不能使用private、final和static来修饰,因为这些关键字都是和重写相违背的

    抽象类最佳实践—模板设计模式

    更多相关内容
  • Java 抽象类 使用方法【非常详细】

    千次阅读 2017-12-14 15:16:57
    一、抽象类的基本概念 普通类是一个完善的功能类,可以直接产生实例化对象,并且在普通类中可以包含有构造方法、普通方法、static方法、常量和变量等内容。而抽象类是指在普通类的结构里面增加抽象方法的组成部分。...

    一、抽象类的基本概念

    普通类是一个完善的功能类,可以直接产生实例化对象,并且在普通类中可以包含有构造方法、普通方法、static方法、常量和变量等内容。

    而抽象类是指在普通类的结构里面增加抽象方法的组成部分。

    那么什么叫抽象方法呢?在所有的普通方法上面都会有一个“{}”,这个表示方法体,有方法体的方法一定可以被对象直接使用。而抽象方法,是指没有方法体的方法,同时抽象方法还必须使用关键字abstract做修饰。

    而拥有抽象方法的类就是抽象类,抽象类要使用abstract关键字声明。

    范例:定义一个抽象类

    abstract class A{//定义一个抽象类
    
        public void fun(){//普通方法
            System.out.println("存在方法体的方法");
        }
    
        public abstract void print();//抽象方法,没有方法体,有abstract关键字做修饰
    
    }

    抽象类的特点:

    1,抽象方法一定在抽象类中。
    2,抽象方法和抽象类都必须被abstract关键字修饰。
    3,抽象类不可以用new创建和实例化对象。因为抽象类本身就是不完整的。
    4,抽象类中的抽象方法要被使用,必须由子类复写所有的抽象方法后,建立子类对象调用。
        如果子类只覆盖了部分抽象方法,那么该子类还是一个抽象类。  

    二、抽象类的使用

    抽象类的注意事项:

    • 抽象类不能实例化 不能造对象(抽象类中一定也有构造器,用于创建子类对象时此构造器可以被调用)
    • 抽象类中不一定有抽象方法,但是抽象方法一定存在于抽象类中
    • 若子类重写了父类中所有的抽象方法,则意味着此子类方可进行实例化
    • 若子类没有重写父类中所有的抽象方法,意味着此子类是一个抽象方法,且不能进行实例化
    • 子类重写抽象方法 不光是直接父类的抽象方法 也包括间接父类的抽象方法

    抽象方法的注意事项:

    • 抽象方法一定存在于抽象类中,抽象方法没有方法体
    • 子类如果继承了抽象类,且该子类不是一个抽象类,一定要重写抽象类中的所有方法


    范例:直接实例化抽象类的对象

    package com.wz.abstractdemo;
    
    abstract class A{//定义一个抽象类
    
        public void fun(){//普通方法
            System.out.println("存在方法体的方法");
        }
    
        public abstract void print();//抽象方法,没有方法体,有abstract关键字做修饰
    
    }
    
    public class TestDemo {
    
        public static void main(String[] args) {
            A a = new A();
        }
    }

    运行:

    Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
        Cannot instantiate the type A
    
        at com.wz.abstractdemo.TestDemo.main(TestDemo.java:15)
    

    从上可知,A是抽象的,无法直接进行实例化操作。为什么不能直接实例化呢?当一个类实例化之后,就意味着这个对象可以调用类中的属性或者放过了,但在抽象类里存在抽象方法,而抽象方法没有方法体,没有方法体就无法进行调用。既然无法进行方法调用的话,又怎么去产生实例化对象呢。

    抽象类的使用原则如下: 

    (1)抽象方法必须为public或者protected(因为如果为private,则不能被子类继承,子类便无法实现该方法),缺省情况下默认为public; 
    (2)抽象类不能直接实例化,需要依靠子类采用向上转型的方式处理; 
    (3)抽象类必须有子类,使用extends继承,一个子类只能继承一个抽象类; 
    (4)子类(如果不是抽象类)则必须覆写抽象类之中的全部抽象方法(如果子类没有实现父类的抽象方法,则必须将子类也定义为为abstract类。);

    范例:

    package com.wz.abstractdemo;
    
    abstract class A{//定义一个抽象类
    
        public void fun(){//普通方法
            System.out.println("存在方法体的方法");
        }
    
        public abstract void print();//抽象方法,没有方法体,有abstract关键字做修饰
    
    }
    //单继承
    class B extends A{//B类是抽象类的子类,是一个普通类
    
        @Override
        public void print() {//强制要求覆写
            System.out.println("Hello World !");
        }
    
    }
    public class TestDemo {
    
        public static void main(String[] args) {
            A a = new B();//向上转型
    
            a.fun();//被子类所覆写的过的方法
        }
    }
    

    运行结果:

    Hello World !
    

    现在就可以清楚的发现: 

    (1)抽象类继承子类里面有明确的方法覆写要求,而普通类可以有选择性的来决定是否需要覆写; 
    (2)抽象类实际上就比普通类多了一些抽象方法而已,其他组成部分和普通类完全一样; 
    (3)普通类对象可以直接实例化,但抽象类的对象必须经过向上转型之后才可以得到。

    虽然一个类的子类可以去继承任意的一个普通类,可是从开发的实际要求来讲,普通类尽量不要去继承另外一个普通类,而是去继承抽象类。

    三、抽象类的使用限制

    (1)抽象类中有构造方法么? 
    由于抽象类里会存在一些属性,那么抽象类中一定存在构造方法,其存在目的是为了属性的初始化。 
    并且子类对象实例化的时候,依然满足先执行父类构造,再执行子类构造的顺序。

    范例如下:

    package com.wz.abstractdemo;
    
    abstract class A{//定义一个抽象类
    
        public A(){
            System.out.println("*****A类构造方法*****");
        }
    
        public abstract void print();//抽象方法,没有方法体,有abstract关键字做修饰
    
    }
    //单继承
    class B extends A{//B类是抽象类的子类,是一个普通类
    
        public B(){
            System.out.println("*****B类构造方法*****");
        }
    
        @Override
        public void print() {//强制要求覆写
            System.out.println("Hello World !");
        }
    
    }
    public class TestDemo {
    
        public static void main(String[] args) {
            A a = new B();//向上转型
        }
    
    }
    

    执行结果:

    *****A类构造方法*****
    *****B类构造方法*****

    (2)抽象类可以用final声明么? 
    不能,因为抽象类必须有子类,而final定义的类不能有子类;

    (3)抽象类能否使用static声明? 
    先看一个关于外部抽象类的范例:

    package com.wz.abstractdemo;
    
    static abstract class A{//定义一个抽象类
    
        public abstract void print();
    
    }
    
    class B extends A{
    
        public void print(){
            System.out.println("**********");
        }
    }
    public class TestDemo {
    
        public static void main(String[] args) {
            A a = new B();//向上转型
            a.print();
        }
    
    }
    

    执行结果

    Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
        Illegal modifier for the class A; only public, abstract & final are permitted
    
        at com.wz.abstractdemo.A.<init>(TestDemo.java:3)
        at com.wz.abstractdemo.B.<init>(TestDemo.java:9)
        at com.wz.abstractdemo.TestDemo.main(TestDemo.java:18)
    

    再看一个关于内部抽象类:

    package com.wz.abstractdemo;
    
    abstract class A{//定义一个抽象类
    
        static abstract class B{//static定义的内部类属于外部类
            public abstract void print();
        }
    
    }
    
    class C extends A.B{
    
        public void print(){
            System.out.println("**********");
        }
    }
    public class TestDemo {
    
        public static void main(String[] args) {
            A.B ab = new C();//向上转型
            ab.print();
        }
    
    }
    

    执行结果:

    **********

    由此可见,外部抽象类不允许使用static声明,而内部的抽象类运行使用static声明。使用static声明的内部抽象类相当于一个外部抽象类,继承的时候使用“外部类.内部类”的形式表示类名称。

    (4)可以直接调用抽象类中用static声明的方法么? 
    任何时候,如果要执行类中的static方法的时候,都可以在没有对象的情况下直接调用,对于抽象类也一样。 
    范例如下:

    package com.wz.abstractdemo;
    
    abstract class A{//定义一个抽象类
    
        public static void print(){
            System.out.println("Hello World !");
        }
    
    }
    
    public class TestDemo {
    
        public static void main(String[] args) {
            A.print();
        }
    
    }
    

    运行结果:

    Hello World !
    

    (5)有时候由于抽象类中只需要一个特定的系统子类操作,所以可以忽略掉外部子类。这样的设计在系统类库中会比较常见,目的是对用户隐藏不需要知道的子类。 
    范例如下:

    package com.wz.abstractdemo;
    
    abstract class A{//定义一个抽象类
        public abstract void print();
    
        private static class B extends A{//内部抽象类子类
    
            public void print(){//覆写抽象类的方法
                System.out.println("Hello World !");
            }
        }
    
        //这个方法不受实例化对象的控制
        public static A getInstance(){
            return new B();
        }
    
    }
    
    public class TestDemo {
    
        public static void main(String[] args) {
    
            //此时取得抽象类对象的时候完全不需要知道B类这个子类的存在
            A a = A.getInstance();
            a.print();
        }
    }
    

    运行结果:

    Hello World !

    四、抽象类的应用——模板设计模式

    例如,现在有三类事物: 
    (1)机器人:充电,工作; 
    (2)人:吃饭,工作,睡觉; 
    (3)猪:进食,睡觉。 
    现要求实现一个程序,可以实现三种不同事物的行为。

    先定义一个抽象行为类:

    package com.wz.abstractdemo;
    
    public abstract class Action{
    
        public static final int EAT = 1 ;
        public static final int SLEEP = 3 ;
        public static final int WORK = 5 ;
    
        public abstract void eat();
        public abstract void sleep();
        public abstract void work();
    
        public void commond(int flags){
          switch(flags){
            case EAT:
                this.eat();
                break;
            case SLEEP:
                this.sleep();
                break;
            case WORK:
                this.work();
                break;
            case EAT + SLEEP:
                this.eat();
                this.sleep();
                break;
            case SLEEP + WORK:
                this.sleep();
                this.work();
                break;
            default:
                break;
            }
        }
    }
    

    定义一个机器人的类:

    package com.wz.abstractdemo;
    
    public class Robot extends Action{
    
        @Override
        public void eat() {
            System.out.println("机器人充电");
    
        }
    
        @Override
        public void sleep() {
    
        }
    
        @Override
        public void work() {
            System.out.println("机器人工作");
    
        }
    
    }
    
    

    定义一个人的类:

    package com.wz.abstractdemo;
    
    public class Human extends Action{
    
        @Override
        public void eat() {
            System.out.println("人吃饭");
    
        }
    
        @Override
        public void sleep() {
            System.out.println("人睡觉");
    
        }
    
        @Override
        public void work() {
            System.out.println("人工作");
    
        }
    
    }

    定义一个猪的类:

    package com.wz.abstractdemo;
    
    public class Pig extends Action{
    
        @Override
        public void eat() {
            System.out.println("猪进食");
    
        }
    
        @Override
        public void sleep() {
            System.out.println("猪睡觉");
    
        }
    
        @Override
        public void work() {
    
    
        }
    
    }
    

    测试主类:

    package com.wz.abstractdemo;
    
    public class AbstractDemo {
    
        public static void main(String[] args) {
    
            fun(new Robot());
    
            fun(new Human());
    
            fun(new Pig());
    
        }
    
        public static void fun(Action act){
            act.commond(Action.EAT);
            act.commond(Action.SLEEP);
            act.commond(Action.WORK);
        }
    
    }
    

    运行结果:

    机器人充电
    机器人工作
    人吃饭
    人睡觉
    人工作
    猪进食
    猪睡觉
    

    所有的子类如果要想正常的完成操作,必须按照指定的方法进行覆写才可以,而这个时候抽象类所起的功能就是一个类定义模板的功能。

    四、抽象类相关的设计模式

    定义模板

    这里写图片描述

    abstract class Person{
        private String name ;       // 定义name属性
        private int age ;           // 定义age属性
        public Person(String name,int age){
            this.name = name ;
            this.age = age ;
        }
        public String getName(){
            return this.name ;
        }
        public int getAge(){
            return this.age ;
        }
        public void say(){      // 人说话是一个具体的功能
            System.out.println(this.getContent()) ; // 输出内容
        }
        public abstract String getContent() ;   // 说话的内容由子类决定
    };
    class Student extends Person{
        private float score ;
        public Student(String name,int age,float score){
            super(name,age) ;   // 调用父类中的构造方法
            this.score = score ;
        }
        public String getContent(){
            return  "学生信息 --> 姓名:" + super.getName() + 
                    ";年龄:" + super.getAge() + 
                    ";成绩:" + this.score ;
        }
    };
    class Worker extends Person{
        private float salary ;
        public Worker(String name,int age,float salary){
            super(name,age) ;   // 调用父类中的构造方法
            this.salary = salary ;
        }
        public String getContent(){
            return  "工人信息 --> 姓名:" + super.getName() + 
                    ";年龄:" + super.getAge() + 
                    ";工资:" + this.salary ;
        }
    };
    public class AbstractCaseDemo02{
        public static void main(String args[]){
            Person per1 = null ;    // 声明Person对象
            Person per2 = null ;    // 声明Person对象
            per1 = new Student("张三",20,99.0f) ; // 学生是一个人
            per2 = new Worker("李四",30,3000.0f) ;    // 工人是一个人
            per1.say() ;    // 学生说学生的话
            per2.say() ;    // 工人说工人的话
        }
    };

    分析:
    1,说话这个功能,正常的是个人都有这个功能,所以可以抽取出来,在Person这个类中,定义一个say()方法,但是说话的内容,不同的类型的人讨论的话题不同,这个话题,不能写成具体的,需要定义成一个抽象的方法,在不同的子类中实现不同的内容。
    2,一个人,无论是工人还是学生或者其他什么人,想说话么,想说话,就覆写我的getContent()方法,就是这样规定好了,这就是模板,

     

    关注我们,更多技术干货:

    2000多G的计算机各行业电子资源分享(持续更新)

    2020年微信小程序全栈项目之喵喵交友【附课件和源码】

    Spring Boot开发小而美的个人博客【附课件和源码】

    Java微服务实战296集大型视频-谷粒商城【附代码和课件】

    Java开发微服务畅购商城实战【全357集大项目】-附代码和课件

    最全最详细数据结构与算法视频-【附课件和源码】

    在这里插入图片描述

    2021年JAVA 精心整理的常见面试题-附详细答案

    https://mikejun.blog.csdn.net/article/details/114488339

    2021年- 精心整理的 SpringMVC 常见面试题-【附详细答案】

    https://mikejun.blog.csdn.net/article/details/114992529

    2021年JAVA 面试题之--数据结构篇【附详细答案】

    https://mikejun.blog.csdn.net/article/details/114647742

    精心整理的计算机各类别的电子书籍【超全】

    https://mikejun.blog.csdn.net/article/details/115442555

    三天刷完《剑指OFFER编程题》--Java版本实现(第一天)

    https://mikejun.blog.csdn.net/article/details/106996017

    三天刷完《剑指OFFER编程题》--Java版本实现(第二天)

    https://mikejun.blog.csdn.net/article/details/108098502

    三天刷完《剑指OFFER编程题》--Java版本实现(第三天)

    https://mikejun.blog.csdn.net/article/details/108253489
    展开全文
  • 抽象类使用@Autowired

    千次阅读 2021-03-16 18:28:05
    抽象类使用@Autowired1.简介在本快速教程中,我们将说明如何在抽象类使用 @Autowired 自动装配注解。我们将 @Autowired 应用于 abstract 抽象类,并关注此时要考虑的重点。2.Setter 方式注入我们可以在设置...

    在抽象类中使用@Autowired

    1.简介

    在本快速教程中,我们将说明如何在抽象类中使用 @Autowired 自动装配注解。

    我们将 @Autowired 应用于 abstract 抽象类,并关注此时要考虑的重点。

    2.Setter 方式注入

    我们可以在设置方法上使用_@Autowired_:public abstract class BallService {

    private LogRepository logRepository;

    @Autowired

    public final void setLogRepository(LogRepository logRepository) {

    this.logRepository = logRepository;

    }

    }

    当我们使用_@Autowired_上setter方法,我们应该用final 关键字,这样子类便不能覆盖setter方法。否则,注解将无法正常运行。

    3.构造函数注入

    我们不能在抽象类的构造函数上使用_@Autowired_。

    Spring 不会在抽象类的构造函数上解析 @Autowired 注解。子类应为 super 构造函数提供必要的参数。

    相反,我们应该在子类的构造函数上使用_@Autowired_:public abstract class BallService {

    private RuleRepository ruleRepository;

    public BallService(RuleRepository ruleRepository) {

    this.ruleRepository = ruleRepository;

    }

    }@Component

    public class BasketballService extends BallService {

    @Autowired

    public BasketballService(RuleRepository ruleRepository) {

    super(ruleRepository);

    }

    }

    4.备忘单

    让我们总结一些要记住的规则。

    首先,抽象类不会进行组件扫描,因为没有具体的子类就无法实例化。

    其次,在抽象类中可以进行setter注入,但是如果不对setter方法使用_final_关键字,因而存在一定误用的风险。如果子类覆盖 setter 方法,则应用程序可能不能正常运行。

    第三,由于 Spring 在抽象类中不支持构造函数注入,因此通常应该让具体的子类提供构造函数参数。这意味着我们需要在具体子类中依赖构造函数注入。

    最后,将构造函数注入用于必需的依赖项,并将setter注入用于可选的依赖项是一个很好的经验法则。但是,正如我们可以从抽象类的一些细微差别中看到的那样,通常在这里构造函数注入更为有利。

    因此,实际上我们可以说具体的子类控制着它的抽象父类如何获得其依赖项。 Spring 在装配子类时, 会对其依赖进行注入。

    5.结论

    在本文中,我们练习了在抽象类中使用_@Autowired_,并解释了一些关键点。

    可以在Github项目中找到本教程的源代码 。

    b739ec46bb5c46d9c0aa4ce35ba1ea56.png

    关于找一找教程网

    本站文章仅代表作者观点,不代表本站立场,所有文章非营利性免费分享。

    本站提供了软件编程、网站开发技术、服务器运维、人工智能等等IT技术文章,希望广大程序员努力学习,让我们用科技改变世界。

    [在抽象类中使用@Autowired]http://www.zyiz.net/tech/detail-151190.html

    展开全文
  • 抽象类和接口的区别以及抽象类和接口的使用场景

    万次阅读 多人点赞 2019-05-30 18:15:44
    一、抽象类 在面向对象的概念中,所有的对象都是通过类来描绘的,但是反过来,并不是所有的类都是用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就可以称之为抽象类。 1.抽象方法...

    一、抽象类

    在面向对象的概念中,所有的对象都是通过类来描绘的,但是反过来,并不是所有的类都是用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就可以称之为抽象类。

    1.抽象方法:使用abstract修饰且没有方法体的方法。

    特点:

    ① 抽象方法没有方法体,交给子类实现

    ② 抽象方法修饰符不能是private final static

    ③ 抽象方法必须定义在抽象类或者接口中

    2.抽象类:包含抽象方法的类,即使用abstract修饰的类。

    特点:

    ① 抽象类不能被实例化,只能被继承

    ② 抽象类中可以不包含抽象方法(不包含抽象方法就没有太大意义,可以作为工具类防止被实例化)

    ③ 抽象类的子类可以不实现该类所有的抽象方法,但也必须作为抽象类(抽象派生类)

    ④ 抽象类的构造方法不能定义成私有(子类构造方法会调用父类构造方法)

    ⑤ 抽象类不能使用final修饰,final修饰的类不能被继承

    实例:武器作为一个抽象类具备攻击行为(attack方法),具体如何攻击(how2Attack方法)需要子类实现。如:机关枪可以射击敌人,手榴弹可以丢向敌人。

    public class Test3 {
        public static void main(String[] args) {
            Gun gun = new Gun("机关枪");
            Grenade grenade = new Grenade("手榴弹");
            gun.attack();
            grenade.attack();
            gun.how2Attack();
            grenade.how2Attack();
        }
    }
    
    abstract class Weapon{
        String name;
        public void attack(){
            System.out.println(name+"具有攻击行为");
        }
    
        abstract void how2Attack();
    
    }
    class Gun extends Weapon{
        public Gun(String name) {
            this.name = name;
        }
    
        @Override
        void how2Attack() {
            System.out.println(name+"射击敌人");
        }
    }
    class Grenade extends Weapon{
        public Grenade(String name){
            this.name = name;
        }
        @Override
        void how2Attack() {
            System.out.println(name+"丢向敌人");
        }
    }

    二、接口

    1.什么是接口

    ① 硬件接口:是指同一计算机不同功能层之间的通信规则称为接口。

    ② 软件接口:是指对协定进行定义的引用类型。其他类型实现接口,以保证它们支持某些操作。

    2.Java中的接口:在JAVA编程语言中是接口一个抽象类型,是抽象方法的集合,接口通常以interface来声明。一个类通过继承接口的方式,从而来继承接口的抽象方法。

    特点:

    ① 接口中没有构造器,不能被实例化

    ② 接口只能继承接口,不能继承类,接口支持多继承

    ③ 接口中的定义的成员变量,默认是public static final修饰的静态常量

    ④ 接口中定义的方法,默认是public abstract修饰的抽象方法

    ⑤ 接口中定义的内部类,默认是public static修饰的静态内部类

    标志接口:仅仅作为一个定义,就是一个标志

    常量接口:用来封装多个常量信息

    注意在JDK8中,接口也可以定义静态方法和默认非静态方法,可以直接用接口名调用静态方法,实现类可以调用默认非静态方法。如果同时实现两个接口,接口中定义了一样的默认方法,则实现类必须重写默认方法,不然会报错

    实例:走路和游泳作为两个抽象的行为,青蛙可以实现两个行为接口来具体实现行为的内容

    public class Test4 {
        public static void main(String[] args) {
            Frog frog = new Frog("青蛙");
            frog.getName();
            frog.work();
            frog.swim();
        }
    }
    class Animal {
        String name;
    
        public String getName() {
            System.out.println("Animal:"+name);
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    }
    interface IWalk{
        void work();
    }
    interface ISwim{
        void swim();
    }
    class Frog extends Animal implements IWalk,ISwim{
    
        public Frog(String name) {
            this.name = name;
        }
    
        @Override
        public void work() {
            System.out.println(this.name+":蹦蹦跳跳地走路");
        }
    
        @Override
        public void swim() {
            System.out.println(this.name+":在水里蛙泳");
        }
    }

    三、抽象类和接口的异同点

    1.语法层面

    相同点:

    ① 抽象类和接口都不能被实例化

    ② 抽象类和接口都可以定义抽象方法,子类/实现类必须覆写这些抽象方法

    不同点:

    ① 抽象类有构造方法,接口没有构造方法

    ② 抽象类可以包含普通方法,接口中只能是public abstract修饰抽象方法(Java8之后可以)

    ③ 抽象类只能单继承,接口可以多继承

    ④ 抽象类可以定义各种类型的成员变量,接口中只能是public static final修饰的静态常量

    2.设计层面

    抽象类是对一种事物的抽象,即对类抽象,而接口是对行为的抽象。抽象类是对整个类整体进行抽象,包括属性、行为,但是接口却是对类局部(行为)进行抽象。举个简单的例子,飞机和鸟是不同类的事物,但是它们都有一个共性,就是都会飞。那么在设计的时候,可以将飞机设计为一个类Airplane,将鸟设计为一个类Bird,但是不能将 飞行 这个特性也设计为类,因此它只是一个行为特性,并不是对一类事物的抽象描述。此时可以将 飞行 设计为一个接口Fly,包含方法fly( ),然后Airplane和Bird分别根据自己的需要实现Fly这个接口。然后至于有不同种类的飞机,比如战斗机、民用飞机等直接继承Airplane即可,对于鸟也是类似的,不同种类的鸟直接继承Bird类即可。从这里可以看出,继承是一个 "是不是"的关系,而 接口 实现则是 "有没有"的关系。如果一个类继承了某个抽象类,则子类必定是抽象类的种类,而接口实现则是有没有、具备不具备的关系,比如鸟是否能飞(或者是否具备飞行这个特点),能飞行则可以实现这个接口,不能飞行就不实现这个接口。

    设计层面不同,抽象类作为很多子类的父类,它是一种模板式设计。而接口是一种行为规范,它是一种辐射式设计。什么是模板式设计?最简单例子,大家都用过ppt里面的模板,如果用模板A设计了ppt B和ppt C,ppt B和ppt C公共的部分就是模板A了,如果它们的公共部分需要改动,则只需要改动模板A就可以了,不需要重新对ppt B和ppt C进行改动。而辐射式设计,比如某个电梯都装了某种报警器,一旦要更新报警器,就必须全部更新。也就是说对于抽象类,如果需要添加新的方法,可以直接在抽象类中添加具体的实现,子类可以不进行变更;而对于接口则不行,如果接口进行了变更,则所有实现这个接口的类都必须进行相应的改动。

     

    四、抽象类和接口的使用场景

    1.抽象类的使用场景

    既想约束子类具有共同的行为(但不再乎其如何实现),又想拥有缺省的方法,又能拥有实例变量

    如:模板方法设计模式,模板方法使得子类可以在不改变算法结构的情况下,重新定义算法中某些步骤的具体实现。

    2.接口的应用场景

    ① 约束多个实现类具有统一的行为,但是不在乎每个实现类如何具体实现

    ② 作为能够实现特定功能的标识存在,也可以是什么接口方法都没有的纯粹标识。

    ③ 实现类需要具备很多不同的功能,但各个功能之间可能没有任何联系。

    ④ 使用接口的引用调用具体实现类中实现的方法(多态)

    个人见解,若有错误请指出,谢谢!

     

    参考资料:https://www.cnblogs.com/dolphin0520/p/3811437.html

    展开全文
  • 抽象类和接口的区别及使用场景

    千次阅读 2020-01-02 15:49:00
    在面向对象的概念中,所有的对象都是通过类来描绘的,但是反过来,并不是所有的类都是用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就可以称之为抽象类。 1.抽象方法:使用...
  • 抽象类使用 final 修饰吗?

    千次阅读 2021-09-01 23:22:34
    不能,定义抽象类就是让其他类继承的,如果定义为final该类就不能被继承,这样彼此就会产生矛盾,所以final不能修饰抽象类
  • java抽象类经典实例分享

    千次阅读 2021-02-12 11:07:34
    在这之前有给大家详细的介绍过java抽象类,相信很多人应该都比较了解了,那么下面就要继续来给大家分享一个java抽象类的实例。题目:不同几何图形的面积计算公式是不一样的,可是,它们具有的特性是一样的,都具有...
  • (java基础)抽象类加泛型的理解

    千次阅读 2021-03-04 03:03:00
    今天在群里问了个基础问题,挨喷了。。这更加激起了我对知识的渴望。也在此铭记一下,将来有经验了要对刚入门的童鞋们严格点,简单的东西要自己看。... 最后自己想想这种结构的确好,抽象类+泛型生成。
  • 如何在抽象类中注入bean

    千次阅读 2021-03-16 18:28:05
    抽象类是无法实例化的,因此无法使用@Service等这种注解直接将抽象类交给ioc容器管理,但是项目中往往需要有很多子类公用抽象父类的模板方法,那么怎么实现呢?错误演示1、抽象类@Componentpublic abstract ...
  • Java抽象类 详解 一、抽象类的基本概念 普通类是一个完善的功能类,可以直接产生实例化对象,并且在普通类中可以包含有构造方法、普通方法、static方法、常量和变量等内容。而抽象类是指在普通类的结构里面...
  • 为什么使用抽象类?有什么好处?

    千次阅读 多人点赞 2019-04-27 18:11:05
    老是在想为什么要引用抽象类,一般类不就够用了吗。一般类里定义的方法,子类也可以覆盖,没必要定义成抽象的啊。 看了下面的文章,明白了一点。 其实不是说抽象类有什么用,一般类确实也能满足应用,但是现实中确实...
  • abstract抽象类不能被实例化,在抽象类中注入服务,而抽象类不能被实例化,因此spring不能实例化抽象类,达到托管的目的。 网上有通过子类注入从而达到超类中依赖服务的目的,也有说protect级别,...
  • 抽象类概述分析事物时, 发现了共性的内容,就出现向上抽取,但是如果父类 的方法功能与子类不同,那么这时就不抽取方法主体,这样抽取出来的方法 就是抽象方法 什么是抽象类有抽象方法的类 抽象类和普通的父类有什么区别...
  • 我的代码中使用了模板模式,定义了一个模板,再一个非抽象方法中使用了事务注解,但是使用之后发现模板(其实现)注入的bean都是null,我怀疑是关于动态代理的问题,但是按道理spring会自动判断适用于哪一种...
  • c#抽象类使用及注意事项

    千次阅读 2018-06-18 16:19:29
    抽象成员 抽象成员成员是指设计成为被覆写的函数成员。抽象成员具有以下特征: 1.必须是一个函数成员。也就是说字段和常量不能为抽象成员。 2.必须用abstract修饰符标记。 3.不能有实现代码块。抽象成员的代码...
  • java抽象类 继承

    千次阅读 2021-03-08 06:02:32
    关于java抽象类 继承的搜索结果回答抽象类和接口的区别:默认的方法实现抽象类可以有默认的方法实现完全是抽象的。接口根本不存在方法的实现。抽象类中可以有已经实现了的方法,也可以有被...实现 抽象类使用ex...
  • 以上博客对springboot抽象类无法注入实例化做了解决,虽然解决了抽象类注入实体为空的情况,但是不知具体解决原理是什么。 抽象类不能实例化,因此在抽象类中不能注入其他实例,因为无法被spring托管。然而...
  • 抽象类和抽象方法的使用

    千次阅读 2022-02-08 15:50:04
    有时候将一个类设计的非常抽象,以至于他没有具体的实例,这样的类叫做抽象类。 abstract关键字的使用 1、abstract可以用来修饰结构、类、方法 2、一旦父类抽象了,就不可以再实例化造对象 ps:父类还是应该提供...
  • Java中的抽象类和接口

    千次阅读 多人点赞 2022-04-08 15:17:42
    各位铁汁们大家好呀!今天让我们继续学习java,看看java中的抽象类和接口到底是什么? 里面也会讲到多态呀,一起来看看吧
  • 抽象类必须要有抽象方法吗?抽象类使用 final 修饰吗?
  • 抽象类的作用和应用场景

    千次阅读 2018-08-13 17:58:00
    描述一类事物的时候,发现该事物确实存在着某种行为,但是目前该行为是不具体的,那么这时候我们应该抽取该方法的声明,不去实现该方法,这时候我们应该使用抽象类。eg:所有的接口都默认有abstract修饰,即都是抽象...
  • 抽象类和接口

    千次阅读 2020-11-24 19:38:35
    抽象类 ​ 概述 ​ 父类当中的方法,被他的子类们重写,子类的各自实现又不一样。那么父类的方法声明和方法体,只有声明还有意义,而方法体内容则没有存在的意义。我们把这种没有方法体内容的方法称为抽象方法。...
  • JAVA——抽象类

    千次阅读 2021-03-09 00:47:50
    抽象方法和抽象类使用 abstract 修饰;2.有一个抽象方法的类必须是抽象类;3.抽象类中一定有抽象方法,反之不成立;4.抽象类不能够实例化 ,即不能创建对象;5.抽象类的成员一般使用 public 或者 protected修饰;6....
  • 抽象类的定义与使用

    千次阅读 2019-04-06 16:16:48
    抽象类定义:抽象类只是在普通类的基础上多了抽象方法。抽象方法用abstract修饰,只有方法声明而没有方法体。 定义一个抽象类: abstract class Main { private int num; //普通方法 public void setNum(int ...
  • java学习笔记(12-继承、抽象类

    千次阅读 2021-03-15 17:45:41
    1.继承关键字extendsjava中继承特点:在Java中,只支持单继承,不允许多继承,也就是说一个只能有一个直接父类多个可以继承一个父类在Java中,多层继承是可以的,即一个的父类可以再去继承另外的父类,例如C...
  • 回想前面我们的猫狗案例,...而是一个抽象的事物。只有真正的猫,狗才是具体的动物。同理,我们也可以推想,不同的动物吃的东西应该是不一样的,所以,我们不应该在动物中给出具体体现,而是给出一个声明即可。 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,462,584
精华内容 585,033
关键字:

抽象类使用

友情链接: LogUtils.zip