java之抽象类精选

Posted 2022-08-23 磊哥的Java历险记

前言：

我们上一篇聊完了多态性，接着我们聊一下抽象类，我还是循序渐进，给大家持续更新更多简单易学的文章出来，一步一步聊到我做的真实项目，前提是我们必须把基础打好~

但愿每次回忆，对生活都不感到负疚，在谷底时，那正表示，你只能往上，不能往下~

一．介绍

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

    抽象类往往用来表征对问题领域进行分析、设计中得出的抽象概念，是对一系列看上去不同，但是本质上相同的具体概念的抽象。

    通常在编程语句中用 abstract 修饰的类是抽象类。在java中，含有抽象方法的类称为抽象类，同样不能生成对象。

    抽象类是不完整的，它只能用作基类。在面向对象方法中，抽象类主要用来进行类型隐藏和充当全局变量的角色。

二．知识点介绍

1、抽象类的基本概念

2、抽象类的使用

3、抽象类的使用限制

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

三．知识点详解

1、抽象类的基本概念

     普通类是一个完善的功能类，可以直接产生实例化对象，并且在普通类中可以包含有构造方法、普通方法、static方法、常量和变量等内容。而抽象类是指在普通类的结构里面增加抽象方法的组成部分。

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

    （1）抽象类必须使用abstract关键字声明

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

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

2、抽象类的使用

代码演示（错误示范）：

package com.Test;

//定义一个抽象类
//abstract关键字声明
abstract class A//定义一个抽象类
    public void fun()//普通方法
        System.out.println("存在方法体的方法");
    

    public abstract void print();//抽象方法，没有方法体，有abstract关键字做修饰

//磊哥的java历险记
public class TestDemo 
    public static void main(String[] args) 
        A a = new A();
    

（注：A是抽象的，无法直接进行实例化操作）  

抽象类的使用原则如下：

（1）抽象方法必须为public或者protected（因为如果为private，则不能被子类继承，子类便无法实现该方法），缺省情况下默认为public；

（2）抽象类不能直接实例化，需要依靠子类采用向上转型的方式处理；

（3）抽象类必须有子类，使用extends继承，一个子类只能继承一个抽象类；

（4）子类（如果不是抽象类）则必须覆写抽象类之中的全部抽象方法（如果子类没有实现父类的抽象方法，则必须将子类也定义为为abstract类。）；

package com.Test;


        abstract class A//定义一个抽象类

            //普通方法
            public void fun()
                System.out.println("存在方法体的方法");

            

            //抽象方法，没有方法体，有abstract关键字做修饰
            public abstract void print();

        
        //单继承
        //B类是抽象类的子类，是一个普通类
        class B extends A

            //强制要求覆写
            @Override
            public void print() 
                System.out.println("磊哥的java历险记");

            
        
         class Test 

            public static void main(String[] args) 
                //向上转型
                A a = new B();
                //被子类所覆写的过的方法
                a.fun();
                a.print();

            
        

3、抽象类的使用限制

（1）抽象类中有构造方法么？

    由于抽象类里会存在一些属性，那么抽象类中一定存在构造方法，其存在目的是为了属性的初始化。

    并且子类对象实例化的时候，依然满足先执行父类构造，再执行子类构造的顺序。

package com.Test;


        //定义一个抽象类
        abstract class A

            public A()
                System.out.println("*****A类构造方法*****");

            
            //抽象方法，没有方法体，有abstract关键字做修饰
            public abstract void print();

        
        //单继承
        // B类是抽象类的子类，是一个普通类

        class B extends A

            public B()
                System.out.println("*****B类构造方法*****");

            

            @Override
            public void print() //强制要求覆写
                System.out.println("Hello World !");

            
        

        class Test 
            private  final  static  String name = "磊哥的java历险记-@51博客";

            public static void main(String[] args) 
                A a = new B();//向上转型
                System.out.println("============="+name+"=============");
            
        

（2）抽象类可以用final声明么？

    不能，因为抽象类必须有子类，而final定义的类不能有子类；

（3）抽象类能否使用static声明？ 不能

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();
   

（4）可以直接调用抽象类中用static声明的方法么？可以

    任何时候，如果要执行类中的static方法的时候，都可以在没有对象的情况下直接调用，对于抽象类也一样。

package com.Test;

        //定义一个抽象类
        abstract class A
            //定义一个静态方法
            public static void print()
                System.out.println("磊哥的java历险记-@51博客");

            
        

         class TestDemo 

            public static void main(String[] args) 
                //没有创建对象，直接调用static修饰的方法
                A.print();

            
        

（5）忽略掉外部子类

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

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();
   

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

      例如，现在有三类事物：

    （1）机器人：充电，待机状态，工作；

    （2）人：吃饭，工作，睡觉；

    （3）狗子：吃饭，拆家。

    现要求实现一个程序，可以实现三种不同事物的行为，直接上代码。​

定义一个抽象行为类：

//定义 抽象行为类
     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;
            
        
    

定义一个机器人的类：

//定义机器人继承动作类
    class Robot extends Action
         //重写一下
        @Override
        public void eat() 
            System.out.println("机器人充电");
        
        @Override
        public void sleep() 
            System.out.println("机器人待机状态");
        
        @Override
        public void work() 
            System.out.println("机器人工作");
        
    

定义一个人的类：

//定义人继承动作类
     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("人工作");
        
    

定义狗子类：

//定义一个狗子继承动作类
     class Dog extends Action
         //重写动作类中方法
        @Override
        public void eat() 
            System.out.println("狗子吃饭");
        
        @Override
        public void sleep() 
            System.out.println("狗子睡觉");

        
        @Override
        public void work() 
            System.out.println("狗子拆家");
        
    

测试主类：

//测试主类：
class Abstract 
         private final static String name = "磊哥的java历险记-@51博客";
        public static void main(String[] args) 
            fun(new Robot());
            fun(new Human());
            fun(new Dog());
        
        public static void fun(Action act)

            //调用Action中的属性
            act.commond(Action.EAT);
            act.commond(Action.SLEEP);
            act.commond(Action.WORK);
            System.out.println("============="+name+"=============");
        

结语：

经常看我博客的兄弟们，应该能看出来，我每次的代码截图都很全，本来可以不用上这么多截图的，因为我每一步的代码片段都上传了，贴在博客里，但是我又想到每位兄弟的基础能力不一样，所以在代码理解上也会有不一样的观点，我每次贴出来就证明一件事，这些代码都是我自己手动敲出来的，只要按照我的流程来，自己也试试，我敢保证，大家都能理解学会。

没有博客文章的时候，我们会迷茫谁来给自己一些帮助；博客文章多的时候，我们也迷茫，因为我们不知道对或者错，我愿意做最简单最易懂，能学会的文章，不为别的，因为我也迷茫过。

感谢兄弟们持续关注！