Java_笔记_抽象类_接口

最新推荐文章于 2024-03-30 10:54:08 发布

SisinRyu

最新推荐文章于 2024-03-30 10:54:08 发布

阅读量1.1k

点赞数 3

分类专栏： JAVA 文章标签： java

本文链接：https://blog.csdn.net/SisinRyu/article/details/128257061

版权

JAVA 专栏收录该内容

64 篇文章 0 订阅

订阅专栏

一、抽象类

1.抽象类
1）定义：如果一个类中存在抽象方法，那么该类就必须声明为抽象类。
2）格式：
public abstract class 类名{}
3）作用：
抽取共性时，无法确定方法体，就把方法定义为抽象的。
强制让子类按照某种格式重写。
抽象方法所在的类，必须是抽象类。

2.抽象方法
1）定义：将共性的行为（方法）抽取到父类之后，由于每一个子类执行的内容不一样，
所以，在父类中不能确定具体的方法体。该方法就可以定义为抽象方法。
2）格式：
public abstract 返回值类型方法名（参数列表）;
3）代码：

public abstract class Person {
    public abstract void work();
}

3.抽象类和抽象方法的注意事项
1）抽象类不能实例化。
2）抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类。
父类不一定是抽象的。父类里有抽象方法，这个父类才是抽象类。
3）可以有构造方法。
作用：当创建子类对象时，给属性进行赋值。
4）抽象类的子类：重写抽象类中的所有抽象方法（推荐）；或变成抽象类。

4.练习：
编写带有抽象类的标准Javabean类
青蛙frog 属性：名字，年龄行为：吃虫子，喝水
狗dog 属性：名字，年龄行为：吃骨头，喝水
绵羊sheep 属性：名字，年龄行为：吃草，喝水
代码：

public abstract class Animal {
    private String name;
    private int age;

    public Animal() {
    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void drink() {
        System.out.println("动物在喝水");
    }

    public abstract void eat();
}

public class Dog extends Animal {
    public Dog() {
    }

    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}

public class Frog extends Animal {
    public Frog() {
    }

    public Frog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("青蛙在吃虫子");
    }
}

public class Sheep extends Animal {
    public Sheep() {
    }

    public Sheep(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("绵羊在吃草");
    }
}

public class Test {
    public static void main(String[] args) {
        //创建对象
        Frog f = new Frog("来福", 1);
        System.out.println(f.getName() + "," + f.getAge());//来福,1
        f.drink();//动物在喝水
        f.eat();//青蛙在吃虫子
    }
}

二、接口：一种规则。

1.接口的理解
public interface 运输{
}

public void 搬家（运输的接口 c）{
}

2.接口和抽象类的异同
1）抽象类更多用于父类中。
2）接口是一种规则，是对行为的抽象。

3.接口的定义
1）接口用关键字interface来定义。
2）public interface 接口名{}

4.接口的使用
1）接口不能实例化。
2）接口和类之间是实现关系，通过implements关键字表示。
public class 类名 implements 接口名{}
3）接口的子类（实现类）
重写接口中的所有抽象方法（推荐）；或变成抽象类。
4）注意1：
接口和类的实现关系，可以单实现，也可以多实现。
public class 类名 implements 接口名1，接口名2{}
5）注意2：
实现类可以在继承一个类的同时，实现多个接口。
public class 类名 extends 父类 implements 接口名1，接口名2{}

5.练习：
编写带有接口和抽象类的标准Javabean类
青蛙属性：名字，年龄行为：吃虫子，蛙泳
狗属性：名字，年龄行为：吃骨头，汪式游泳
兔子属性：名字，年龄行为：吃胡萝卜
代码：

public abstract class Animal {
    private String name;
    private int age;

    public Animal() {
    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public abstract void eat();
}

public class Dog extends Animal implements Swim {
    public Dog() {
    }

    public Dog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }

    @Override
    public void swim() {
        System.out.println("汪汪游泳");
    }
}

public class Frog extends Animal implements Swim {
    public Frog() {
    }

    public Frog(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("青蛙在吃虫子");
    }

    @Override
    public void swim() {
        System.out.println("青蛙在蛙泳");
    }
}

public class Rabbit extends Animal {
    public Rabbit() {
    }

    public Rabbit(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("兔子在吃胡萝卜");
    }
}

public interface Swim {
    public abstract void swim();
}

public class Test {
    public static void main(String[] args) {
        //创建青蛙的对象
        Frog f = new Frog("绿豆", 2);
        System.out.println(f.getName() + "," + f.getAge());//绿豆,2
        f.eat();//青蛙在吃虫子
        f.swim();//青蛙在蛙泳

        //创建兔子的对象
        Rabbit r = new Rabbit("白玉", 3);
        System.out.println(r.getName() + "," + r.getAge());//白玉,3
        r.eat();//兔子在吃胡萝卜
    }
}

6.接口中成员的特点
1）成员变量：
只能是常量。
默认修饰符：public static final。
2）构造方法：无。
接口不能创建对象，也不需要给子类的成员变量赋值。
3）成员方法：
只能是抽象方法。
默认修饰符：public abstract。

7.接口和类之间的关系：
1）类和类的关系
继承关系，只能单继承，不能多继承，但是可以多层继承。
2）类和接口的关系
实现关系，可以单实现，也可以多实现，还可以在继承一个类的同时实现多个接口。
细节：如果实现多个接口，必须重写里面所有抽象方法。
3）★接口和接口的关系
继承关系，可以单继承，也可以多继承。
细节：如果实现类实现了最下面的子接口，就需要重写这个体系中所有的抽象方法。

8.练习：
编写带有接口和抽象类的标准Javabean类：
现有乒乓球、篮球的运动员和教练。
乒乓球相关人员需要学习英语。
分析具体类、抽象类、接口。

乒乓球运动员：姓名，年龄，学打乒乓球，说英语
篮球运动员：姓名，年龄，学打篮球
乒乓球教练：姓名，年龄，教打乒乓球，说英语
篮球教练：姓名，年龄，教打篮球

代码：

public abstract class Athlete extends Person {
    public Athlete() {
    }

    public Athlete(String name, int age) {
        super(name, age);
    }

    public abstract void study();
}

public class BasketballCoach extends Coach {
    public BasketballCoach() {
    }

    public BasketballCoach(String name, int age) {
        super(name, age);
    }

    @Override
    public void teach() {
        System.out.println("篮球教练在教篮球");
    }
}

public class BasketballPlayer extends Athlete {
    public BasketballPlayer() {
    }

    public BasketballPlayer(String name, int age) {
        super(name, age);
    }

    @Override
    public void study() {
        System.out.println("篮球运动员在学习打篮球");
    }
}

public abstract class Coach extends Person {
    public Coach() {
    }

    public Coach(String name, int age) {
        super(name, age);
    }

    public abstract void teach();
}

public interface English {
    public abstract void speakEnglish();
}

//不让外界直接创建人的对象。
//因为直接创建顶层父类人的对象是没有意义的。
//所以写成抽象的。
public abstract class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

public class PingpongCoach extends Coach implements English {
    public PingpongCoach() {
    }

    public PingpongCoach(String name, int age) {
        super(name, age);
    }

    @Override
    public void teach() {
        System.out.println("乒乓球教练在教乒乓球");
    }

    @Override
    public void speakEnglish() {
        System.out.println("乒乓球教练在说英语");
    }
}

public class PingpongPlayer extends Athlete implements English {
    public PingpongPlayer() {
    }

    public PingpongPlayer(String name, int age) {
        super(name, age);
    }

    @Override
    public void study() {
        System.out.println("乒乓球运动员在学习乒乓球");
    }

    @Override
    public void speakEnglish() {
        System.out.println("乒乓球运动员在说英语");
    }
}

public class Test {
    public static void main(String[] args) {
        //创建运动员或教练的对象
        PingpongCoach c = new PingpongCoach("A", 30);
        System.out.println(c.getName() + "," + c.getAge());//A,30
        c.teach();//乒乓球教练在教乒乓球
        c.speakEnglish();//乒乓球教练在说英语
    }
}

9.JDK8开始接口中新增的方法
1）JDK7以前：接口中只能定义抽象方法。
2）JDK8新特性：接口中可以定义有方法体的方法。
1、默认方法：
允许在接口中定义默认方法，需要使用关键字default修饰。
作用：解决接口升级的问题。

接口中默认方法的定义格式：
格式：public default 返回值类型方法名（参数列表）{}
范例：public default void show(){}

接口中默认方法的注意事项：
默认方法不是抽象方法，所以不强制被重写。但是如果被重写，重写的时候去掉default关键字。
public可以省略，default不能省略。
如果实现了多个接口，多个接口中存在相同名字的默认方法，子类就必须对该方法进行重写。

2、静态方法
允许在接口中定义静态方法，需要用static修饰。
接口中静态方法的定义格式：
格式：public static 返回值类型方法名（参数列表）{}
范例：public static void show(){}

接口中静态方法的注意事项：
静态方法只能通过接口名调用，不能通过实现类名或者对象名调用。
public可以省略，static不能省略。

3）JDK9新特性：接口中可以定义私有方法。
1、普通的私有方法，给默认方法服务的
格式1：private 返回值类型方法名（参数列表）{}
范例1：private void show(){}

2、静态的私有方法，给静态方法服务的
格式2：private static 返回值类型方法名（参数列表）{}
范例2：private static void method(){}

10.接口的应用
1）接口代表规则，是行为的抽象。
想要让类拥有一个行为，就让这个类实现对应的接口。
2）接口多态：方法的参数是接口时，可传递接口所有实现类的对象。
接口类型 j = new 实现类对象（）；

11.适配器设计模式
1）设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。
使用设计模式是为了可重用代码、让代码更容易被他人理解，保证代码可靠性、程序的重用性。
简单理解：设计模式就是各种套路。
2）适配器设计模式目的：解决接口与接口实现类之间的矛盾问题。
3）适配器设计模式时机：当一个接口中抽象方法过多，但是只需要使用其中一部分的时候。
4）书写步骤：
编写中间类XXXAdapter，实现对应的接口。
对接口中的抽象方法进行空实现。
让真正的实现类继承中间类，并重写需要用的方法。
为避免其他类创建适配器类的对象，中间的适配器类用abstract进行修饰。