Java小白StudyDay10---抽象类、接口

最新推荐文章于 2022-10-23 15:38:15 发布

Java大世界

最新推荐文章于 2022-10-23 15:38:15 发布

阅读量184

点赞数

分类专栏：小白的Java代码之路文章标签：抽象类接口面向接口编程抽象方法接口实现

本文链接：https://blog.csdn.net/weixin_45036634/article/details/117906121

版权

小白的Java代码之路专栏收录该内容

11 篇文章 0 订阅

订阅专栏

抽象类、面向抽象编程、接口、面向接口编程

一、抽象类
二、接口
- 1、接口
- 2、面向接口编程

一、抽象类

抽象关键字 abstract
1.修饰类–被abstract修饰的类是抽象类
2.修饰方法–被abstract修饰的方法是抽象方法
格式：修饰符 abstract 返回值类型方法名（参数列表）；–没有方法体
1>一旦一个类中有抽象方法，那么这个类必须是抽象类
2>抽象类中既可以都是普通方法，也可以都是抽象方法，还可以混着来
3>抽象类不允许实例化–创建对象
4>如果一个类继承了抽象父类，那么：
方案一：继续抽象，作为抽象子类
方案二：实现抽象父类中的（所有！！！）抽象方法
5>创建时，如果想使用抽象父类，可以创建多态对象进行测试

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("抽象父类中的所有抽象方法都需要被实现");
    }
}

抽象类之构造方法
抽象类是否有构造方法？有
问题：既然抽象类不能实例化，为什么要有构造方法呢？
解释：不是为了自己使用，而是为了子类创建对象时使用super();

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的构造方法~");
    }
}

抽象类既可以定义变量，也可以定义常量
抽象类既可以有(全是)普通方法，也可以有(全是)抽象方法

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("香蕉不用洗，香蕉喜欢被扒皮");
    }
}

二、接口

1、接口

1.接口的关键字是interface
2.我们通过implments建立接口与接口实现类的关系 InterImpl implements Inter
3.接口可以看作是一种特殊的抽象类，因为它里面全是抽象方法
4.实现子类如果与父接口建立了实现关系，有两种方案：
方案一：继续抽象->抽象子类
方案二：不再抽象->实现父接口中所有的抽象方法
5.接口没有构造方法，实现子类可以创建对象的原因是调用了Object的无参构造
TIPS:问题：子类在创建对象时，默认会调用父类的无参构造
那如果接口的实现类在没有明确指定父类时，使用的是哪个构造方法呢？
答案：如果一个类没有明确指定父类的话，默认继承顶级父类Object
所以实现类构造方法中的super();调用的是Object类的无参构造
6.接口中没有普通成员变量，有的只是静态常量，所以当你定义int age = 10;时
会默认自动拼接成：public static final int age = 10;
7.接口中的方法都是抽象方法，可以简写void eat();
默认会自动拼接public abstract

package cn.tedu.inter;
/*本接口用于接口创建测试*/
/*1.我们通过interface关键字来定义接口*/
public interface Inter {
    /*2.接口中可以定义普通方法吗？--不可以！！！*/
    //public void eat(){}
    /*3.接口中可以有抽象方法吗？--可以！接口中的方法都是抽象方法*/
    public abstract void eat();
    public abstract void play();
}

package cn.tedu.inter;
/*本类作为Inter接口的实现类*/
/*1.实现类如果想要和接口建立实现关系，就通过implements来实现*/
/*2.接口实现类与接口建立关系以后，有两种解决方案：
* 方案一：作为抽象子类，不实现任何抽象方法
* 方案二：作为普通子类，实现父级接口中所有的抽象方法*/
//abstract public class InterImpl implements Inter{
public class InterImpl implements Inter{
    @Override//注解，标记实现了父接口的抽象方法
    public void eat() {
        System.out.println("吃粽子");
    }

    @Override//注解，标记实现了父接口的抽象方法
    public void play() {
        System.out.println("划龙舟");
    }
}

package cn.tedu.inter;
/*本类用于测试接口的实现类*/
public class InterTests {
    //创建程序的入口函数main()
    public static void main(String[] args) {
        //测试创建接口对象
        /*接口可以创建对象吗？--不可以！！！*/
        //Inter i = new Inter();

        //创建多态对象进行测试
        Inter i = new InterImpl();
        i.eat();
        i.play();

        //创建子类对象进行测试
        InterImpl i2 = new InterImpl();
        i2.eat();
        i2.play();
    }
}

总：

package cn.tedu.inter2;

import cn.tedu.inter.Inter;

/*本类用于进一步测试接口的使用*/
public class TestUserInter {
    public static void main(String[] args) {
        //创建多态对象进行测试
        Inter2 i = new Inter2Impl();
        //接口中的变量都是静态的，因为可以通过类名直接调用
        System.out.println(Inter2.age);
        //接口中的变量都是常量，因为不可以被重新赋值
        //Inter2.age = 30;
    }
}
//1.创建接口
interface Inter2{
    /*1.接口中有构造方法吗？--没有！！！*/
    //3.测试接口中是否可以创建构造方法
    //public Inter2(){}
    /*2.接口中可以有成员变量吗？--没有！！！
    * 实际上是一个静态常量，实际的写法public static final int age = 10;
    * 在接口中可以省略不写，接口中都是静态常量*/
    //接口中的变量实际上都是常量，因为必须初始化(赋值)
    int age = 10;
    /*3.接口里可以有抽象方法吗？--可以！全是
    * 方法定义可以简写，默认自动拼接public abstract */
    public abstract void eat();
    void eat2();
}
//2.创建接口实现类
/*如果一个类没有明确指定父类，那么它的父类就是Object顶级父类，默认存在此现象*/
//class Inter2Impl extends Object implements Inter2 {
class Inter2Impl implements Inter2 {
    //4.创建子类的构造方法
    public Inter2Impl(){
        super();//表示调用的是父类Object的无参构造
        System.out.println("我是实现类Inter2Impl的构造方法~");
    }
    //如果普通子类实现了接口，需要实现接口中的所有抽象方法
    @Override
    public void eat() {

    }

    @Override
    public void eat2() {

    }
}

2、面向接口编程

面向抽象编程：后天向上抽取形成的
面向接口编程：先天设计形成的，接口制定的是预先定义好的规则

package cn.tedu.design;
/*本类用于设计老师类，要求：面向抽象编程--后天向上抽取形成的结果*/
public class DesignTeacher1 {
    public static void main(String[] args) {
        CGBTeacher ct = new CGBTeacher();
        ct.ready();
        ct.teach();
        ACTTeacher at = new ACTTeacher();
        at.ready();
        at.ready();
    }
}
//三个课程的老师向上抽取共性形成父类Teacher类
abstract class Teacher{
    int id;//工号
    String name;//姓名
    public abstract void ready();
    public abstract void teach();

}

//1.创建培优老师类
class CGBTeacher extends Teacher{
    @Override
    public void ready() {
        System.out.println("正在备课...电商项目");
    }

    @Override
    public void teach() {
        System.out.println("正在讲课...电商项目...");
    }
}
class ACTTeacher extends Teacher{
    @Override
    public void ready() {
        System.out.println("正在备课...加强模块...");
    }

    @Override
    public void teach() {
        System.out.println("正在讲课...加强模块...");
    }
}
class SCDTeacher extends Teacher{
    @Override
    public void ready() {
        System.out.println("正在备课...hadoop");
    }

    @Override
    public void teach() {
        System.out.println("正在讲课...hadoop");
    }
}

package cn.tedu.design;
//刚刚的案例：面向抽象编程--后天向上抽取形成的结果
/*本类用于设计老师类，要求：面向接口编程--先天设计的结果*/
public class DesginTeacher2 {
}
//1.创建接口，设计形成父级接口--接口体现的是预先定义好的规则
interface Teacher2{
    void ready();
    void teach();
}
//2.创建接口实现类
class ACTTeacher2 implements Teacher2{
    @Override
    public void ready() {

    }

    @Override
    public void teach() {

    }
}
class CGBTeacher2 implements Teacher2{

    @Override
    public void ready() {

    }

    @Override
    public void teach() {

    }
}