新手小白学JAVA 抽象类

柔情只为你懂 2021-09-07 17:08 567阅读 0赞

# 抽象类 #

## 1 概念 ##

Java中可以定义被abstract关键字修饰的方法,这种方法只有声明,没有方法体,叫做抽象方法.  
Java中可以定义被abstract关键字修饰的类,被abstract关键字修饰的类叫做抽象类

1.  如果一个类含有抽象方法,那么它一定是抽象类
2.  抽象类中的方法实现交给子类来完成

## 2 抽象方法的格式 ##

![在这里插入图片描述][20210511180015159.png]

## 3 特点 ##

1.  abstract 可以修饰方法或者类
2.  被abstarct修饰的类叫做抽象类,被abstract修饰的方法叫做抽象方法
3.  抽象类中可以没有抽象方法
4.  如果类中有抽象方法,那么该类必须定义为一个抽象类
5.  子类继承了抽象类以后,要么还是一个抽象类,要么就把父类的所有抽象方法都重写
6.  多用于多态中
7.  抽象类不可以被实例化

## 4 练习：抽象类入门案例 ##

创建包: cn.tedu.oop  
创建类: AbstractDemo.java

package cn.tedu.oop;
    /*本类用作抽象测试的入门案例*/
    public class AbstractDemo { 
        public static void main(String[] args) { 
            /*4.抽象类不可以实例化！！！-创建对象*/
            //5.测试抽象父类是否可以创建对象
            //Animal a = new Animal();
            //6.创建多态对象进行测试
            Animal a = new Pig();
            a.eat();//调用抽象父类的普通方法
            a.fly();//调用抽象父类的抽象方法
    
        }
    }
    //1.创建父类Animal
    /*2.被abstract修饰的类是抽象类 * 如果一个类中包含了抽象方法，那这个类必须被声明成一个抽象类*/
    //4.2添加抽象方法后，本类需要用abstract修饰
    abstract class Animal{ 
        //3.创建普通方法
        public void eat(){ 
            System.out.println("吃啥都行~");
        }
        public void play(){ 
            System.out.println("玩啥都行~");
        }
        //4.1创建抽象方法
        /*1.被abstract修饰的方法是抽象方法，抽象方法没有方法体*/
        public abstract void fly();
        public abstract void fly2();
    }
    //2.创建子类Pig,并与Animal类建立继承关系
    /*3.当一个子类继承了抽象父类以后，有两种解决方案： * 方案一：变成抽象子类，“躺平，我也不实现，继续抽象” * 方案二：实现抽象父类中的所有的抽象方法，“父债子偿”*/
    //4.3子类需要处理，继续抽象/实现父类所有抽象方法
    //abstract class Pig extends Animal{--方案一
    class Pig extends Animal{ //方案二
        @Override//注解，标识这是一个重写的方法
        public void fly() { 
            System.out.println("我爸的债我终于还清了，我家的猪终于飞起来了~");
        }
    
        @Override
        public void fly2() { 
            System.out.println("抽象父类中的所有抽象方法都需要被实现");
        }
    }

## 5 练习：抽象类构造函数测试 ##

抽象类中的构造函数通常在子类对象实例化时使用

创建包: cn.tedu.oop  
创建类: AbstractDemo2.java

package cn.tedu.oop;
    /*本类用作抽象类构造函数测试*/
    /*抽象类是否有构造方法？有 * 既然抽象类不能实例化，为什么要有构造方法呢？ * 不是为了自己使用，而是为了子类创建对象时使用super(); */
    public class AbstractDemo2 { 
        public static void main(String[] args) { 
            //4.测试抽象类是否可以创建对象？不可以！！！
            //Animal2 a = new Animal2();
            //5.创建子类对象进行测试
            Pig2 p = new Pig2();
        }
    }
    //1.创建抽象父类Animal2
    abstract class Animal2{ 
        //3.创建构造方法
        public Animal2(){ 
            System.out.println("我是Animal2的构造方法~");
        }
    }
    //2.创建子类Pig2
    class Pig2 extends Animal2{ 
        //6.创建子类的无参构造
        public Pig2(){ 
            super();//表示调用父类的无参构造
            System.out.println("我是Pig2的构造方法~");
        }
    }

## 6 练习：抽象类成员测试 ##

创建包: cn.tedu.oop  
创建类: AbstractDemo3.java

package cn.tedu.oop;
    /*本类用作抽象类中的成员测试*/
    public class AbstractDemo3 { 
    }
    //1.创建抽象父类Fruit
    abstract class Fruit{ 
        /*1.抽象类中可以定义成员变量吗？--可以！！！*/
        //3.1定义抽象父类中的成员变量
        int sum = 100;
        /*2.抽象类中可以定义成员常量吗？--可以！！！*/
        //3.2定义抽象父类中的成员常量
        final String name = "XIAOHUANGREN";
        /*3.抽象类中可以定义普通方法吗？--可以！！！ * 抽象类中可以都是普通方法吗？--也可以！！！*/
        /*4.如果一类中都是普通方法，那它为啥还要被修饰成抽象类呢？ * 因为抽象类不可以被实例化，所以如果不想让外界创建本类的对象 * 就可以把普通类声明成抽象类*/
        //4.定义抽象父类的普通方法
        public void clean(){ 
            System.out.println("水果还是要洗洗再吃哒~");
        }
        /*5.抽象类中可以定义抽象方法吗？--可以！！！*/
        /*6.如果类中添加了抽象方法，那么这个类必须被声明成抽象类*/
        //5.定义抽象父类中的抽象方法
        public abstract void grow();
        public abstract void clean2();
    }
    //2.创建子类Banana
    /*如果一个子类继承了抽象父类，有两种处理方案： * 方案一：继续抽象，也就是作为抽象子类，无需实现抽象方法-"躺平" * 方案二：不再抽象，实现继承自父类中的所有未实现的抽象方法-"父债子偿"*/
    class Banana extends Fruit{ 
        @Override
        public void grow() { 
            System.out.println("一串香蕉老沉了~");
        }
        @Override
        public void clean2() { 
            System.out.println("香蕉不用洗，香蕉喜欢被扒皮");
        }
    }

# 拓展 #

## 总结:abstract注意事项 ##

抽象方法要求子类继承后必须重写。  
那么，abstract关键字不可以和哪些关键字一起使用呢？以下关键字，在抽象类中。用是可以用的，只是没有意义了。  
1.private：被私有化后，子类无法重写，与abstract相违背。  
2.static：静态优先于对象存在，存在加载顺序问题。  
3.final：被final修饰后，无法重写，与abstract相违背。

## 程序设计: 分析老师示例—面向抽象编程 ##

具体事物: 培优班老师 高手班老师  
共性: 讲课 备课

创建包: cn.tedu.design  
创建类:DesignTeacher.java

package cn.tedu.design;
    /**本类用于设计老师类,面向抽象编程*/
    public class DesignTeacher { 
    	public static void main(String[] args) { 
    		CGBTeacher ct = new CGBTeacher();
    		SCDTeacher st = new SCDTeacher();
    		ct.ready();
    		ct.teach();
    		st.ready();
    		st.teach();
    	}
    
    }
    //生活中的事物--类
    //特征--属性 & 行为--方法
    
    //属性:姓名 工号
    //方法:备课 讲课
    abstract class Teacher{ 
    	int id ;//工号
    	String name;//姓名
    	//备课方法
    	public abstract void ready();
    	//讲课方法
    	public abstract void teach();
    }
    
    /**培优班CGB老师--主打电商项目*/
    class CGBTeacher extends Teacher{ 
    	@Override
    	public void ready() { 
    		System.out.println("正在备课...电商项目....");
    	}
    	@Override
    	public void teach() { 
    		System.out.println("正在授课...电商项目....");
    	}
    }
    /**SCD大数据老师--主打Scala语言*/
    class SCDTeacher extends Teacher{ 
    	@Override
    	public void ready() { 
    		System.out.println("正在备课...hadoop");
    	}
    	@Override
    	public void teach() { 
    		System.out.println("正在讲课...spark");
    	}
    }

[20210511180015159.png]: /images/20210827/8605d073a45e4fed96fab2f4bdeea793.png