zoukankan      html  css  js  c++  java
  • 11.抽象类和接口

    抽象类

    抽象类概述

    java中,一个没有方法体的方法应该定义为抽象方法, 二类中如果有抽象方法, 该类必须定义为抽象类.

    特点:

    • 抽象类和抽象方法必须使用abstract关键字修饰
      • public abstract class 类名{}
      • public abstract void eat();
    • 抽象类中不一定有抽象方法, 有抽象方法的类一定是抽象类
    • 抽象类不能直接实例化, 可以参照多态的方式, 通过子类对象实例化, 这叫抽象类多态
    • 抽象类的子类: 要么重写抽象类的所有抽象方法, 要么是抽象类

    Animal

    package abstractClass.abstractDemo;
    
    // 定义抽象类
    public abstract class Animal {
        // 定义抽象方法
        public abstract void eat();
    
        public void sleep() {
            System.out.println("睡觉");
        }
    
        // 有抽象方法,一定是抽象类, 但是抽象类中不一定有抽象方法
    }
    
    

    Cat

    package abstractClass.abstractDemo;
    
    public class Cat extends Animal {
        @Override
        public void eat() {
            System.out.println("猫吃鱼");
        }
    }
    
    

    Dog

    package abstractClass.abstractDemo;
    
    public abstract class Dog extends Animal {
    
    }
    

    Demo

    package abstractClass.abstractDemo;
    
    public class Demo {
        public static void main(String[] args) {
            Animal a = new Cat();
            a.eat();
            a.sleep();
        }
    }
    
    

    抽象类成员特点

    成员变量:

    • 可以是变量
    • 可以是常量

    构造方法:

    • 有构造方法, 但不能实例化
    • 用于子类访问父类数据的初始化

    成员方法:

    • 可以有抽象方法: 限定子类必须完成某些动作
    • 也可以有非抽象方法: 提高代码复用性

    Animal

    package abstractClass.member;
    
    public abstract class Animal {
        private int age = 20;
        private final String city = "北京";
    
        public Animal() {}
    
        public void show() {
            age = 40;
            System.out.println(age);
            System.out.println(city);
        }
    
        public abstract void eat();
    }
    
    

    Cat

    package abstractClass.member;
    
    public class Cat extends Animal {
        @Override
        public void eat() {
            System.out.println("猫吃鱼");
        }
    }
    
    

    Demo

    package abstractClass.member;
    
    public class Demo {
        public static void main(String[] args) {
            Animal a = new Cat();
            a.eat();
            a.show();
        }
    }
    
    

    接口

    概述

    接口是一种公共的规范, 只要符合规范标准,大家都可以通用

    java的接口更多的体现在对行为的抽象.

    接口特点

    接口用关键字interface修饰

    • public interface 接口名 {}

    类实现接口用implements表示

    • public class 类名 implements 接口名 {}

    接口不能直接实例化

    • 实例化需要参照多台方式, 通过实现类对象实例化, 称为接口多态
    • 多态的形式: 具体类多态, 抽象类多态, 接口多态
    • 多态前提: 有继承或者实现关系; 有方法重写; 有父(类/接口)引用指向(子/实现)类对象

    接口的实现类:

    • 要么重写接口中的所有抽象方法
    • 要么是抽象类

    Jumpping

    package javaInterface.interfaceDemo;
    
    public interface Jumpping {
        public abstract void jump();
    }
    
    

    Cat

    package javaInterface.interfaceDemo;
    
    public class Cat implements Jumpping {  // 接口的继承使用inplements关键字
        @Override
        public void jump() {
            System.out.println("猫跳高");
        }
    }
    
    

    Dog

    package javaInterface.interfaceDemo;
    
    public abstract class Dog implements Jumpping {
        // 抽象类继承接口,可以不重写方法
    }
    
    

    Demo

    package javaInterface.interfaceDemo;
    
    public class Demo {
        public static void main(String[] args) {
            // Jumpping j = new Jumpping();  // 接口是一个抽象类, 不能被实例化
             Jumpping j = new Cat();  // 接口实例化采用多态方式
             j.jump();
        }
    }
    
    

    接口成员的特点

    成员变量:

    • 只能是常量
    • 默认修饰父: public static final

    构造方法:

    • 接口没有构造方法, 因为接口主要是对行为进行抽象的, 没有具体存在
    • 一个类如果没有父类, 默认继承自Object类

    成员方法:

    • 只能是抽象方法
    • 默认修饰符: public abstract
    • 关于接口中的方法, JDK8和JDK9有一些新特性

    Inter

    package javaInterface.member;
    
    public interface Inter {
        // 成员变量
        public int num = 10;
        public final int num2 = 20;
        int num3 = 30; // 等价于 public static final int num3 = 30;
    
        // 构造方法
        // public Inter(){}  // 接口中没有构造方法
    
        // 成员方法
        // public void show() {}  // 接口中没有非抽象方法
    
        public abstract void method();  // 只能是抽象方法
    
        void show();  // 默认也是抽象方法
    
    }
    
    

    InterImpl

    package javaInterface.member;
    
    // public class InterImpl implements Inter {
    // 上述等价于 public class InterImpl extends Object implements Inter,
    // 也就是访问父类构造方法的时候, 访问的是object的无参构造方法, 而不是Inter的
    public class InterImpl extends Object implements Inter {
        public InterImpl() {
            super();
        }
    
        @Override
        public void method() {
            System.out.println("method");
        }
    
        @Override
        public void show() {
            System.out.println("show");
        }
    }
    
    

    Demo

    package javaInterface.member;
    
    public class Demo {
        public static void main(String[] args) {
            Inter i = new InterImpl();
            // i.num = 15;  // 接口中的变量默认为final修饰的
            System.out.println(i.num);
            // i.num2 = 30; // 常量不能赋值
            System.out.println(i.num2);
            System.out.println(Inter.num2);  // 接口中的变量默认是静态的
        }
    }
    
    

    猫和狗案例接口板

    Jumpping

    package javaInterface.catAndDog;
    
    public interface Jumpping {
        public abstract void jump();
    }
    
    

    Animal

    package javaInterface.catAndDog;
    
    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();
    }
    
    

    Cat

    package javaInterface.catAndDog;
    
    public class Cat extends Animal implements Jumpping {
    
        public Cat() {
        }
    
        public Cat(String name, int age) {
            super(name, age);
        }
    
        @Override
        public void eat() {
            System.out.println("猫吃鱼");
        }
    
        @Override
        public void jump() {
            System.out.println("猫可以跳高");
        }
    }
    
    

    Demo

    package javaInterface.catAndDog;
    
    public class Demo {
        public static void main(String[] args) {
            // 创建对象,调用方法
            Jumpping j = new Cat();
            j.jump();
            System.out.println("--------");
    
            Animal a = new Cat();
            a.setName("加菲");
            a.setAge(5);
            System.out.println(a.getName() + "," + a.getAge());
            a.eat();
            // a.jump();
    
            a = new Cat("加菲", 5);
            System.out.println(a.getName() + "," + a.getAge());
            a.eat();
            System.out.println("--------");
    
            Cat c = new Cat();
            c.setName("加菲");
            c.setAge(5);
            System.out.println(c.getName() + "," + c.getAge());
            c.eat();
            c.jump();
        }
    }
    
    

    类和接口的关系

    类和类的关系

    • 继承关系, 只能单继承, 但是可以多层继承

    类和接口的关系

    • 实现关系, 可以单实现, 也可以多实现, 还可以在继承一个类的同时实现多个接口

    接口和接口的关系

    • 继承关系, 可以单继承, 也可以多继承

    inter1

    package javaInterface.interfaceAndClass;
    
    public interface Inter1 {
    }
    
    

    Inter2

    package javaInterface.interfaceAndClass;
    
    public interface Inter2 {
    }
    
    

    Inter3

    package javaInterface.interfaceAndClass;
    
    public interface Inter3 extends Inter1, Inter2 {
        // 接口和接口可以多继承
    }
    
    

    InterImpl

    package javaInterface.interfaceAndClass;
    
    public class InterImpl extends Object implements Inter1, Inter2, Inter3 {
        // 类可以实现多个接口
    }
    
    

    抽象类和接口的区别

    成员区别

    • 抽象类: 变量,常量; 有构造方法; 有抽象方法, 也有非抽象方法
    • 常量; 抽象方法

    关系区别

    • 类与类: 继承, 单继承
    • 类与接口: 实现, 单实现, 多实现
    • 接口与接口: 继承, 单继承, 多继承

    设计理念

    • 抽象类: 对类抽象, 包括属性,行为
    • 接口: 对行为抽象, 主要是行为

    使用案例:门和报警器

    Alarm

    package javaInterface.doorAndAlarm;
    
    public interface Alarm {
        void alarm();
    }
    
    

    Door

    package javaInterface.doorAndAlarm;
    
    public abstract class Door {
        public abstract void open();
        public abstract void close();
    }
    
    

    AlarmDoor

    package javaInterface.doorAndAlarm;
    
    public class AlarmDoor extends Door implements Alarm {
        @Override
        public void open() {
            System.out.println("开门");
        }
    
        @Override
        public void close() {
            System.out.println("关门");
        }
    
        @Override
        public void alarm() {
            System.out.println("报警");
        }
    }
    
    

    抽象是对事物的抽象, 接口是对行为的抽象.

    形参和返回值

    抽象类作为形参和返回值

    方法的形参是抽象类名, 其实需要的抽象类的子类对象

    方法的返回值是抽象类名, 其实返回的是该抽象类的子类对象

    Animal

    package paramAndReturn.abstractAndReturn;
    
    public abstract class Animal {
        public abstract void eat();
    }
    
    

    Cat

    package paramAndReturn.abstractAndReturn;
    
    public class Cat extends Animal {
        @Override
        public void eat() {
            System.out.println("猫吃鱼");
        }
    }
    
    

    AnimalOperator

    package paramAndReturn.abstractAndReturn;
    
    public class AnimalOperator {
        public void useAnimal(Animal a) {
            a.eat();
        }
    
        public Animal getAnimal() {
            Animal a = new Cat();
            return a;
        }
    }
    
    

    Demo

    package paramAndReturn.abstractAndReturn;
    
    public class Demo {
        public static void main(String[] args) {
            // 创建对象
            AnimalOperator ao = new AnimalOperator();
            Animal a = new Cat();
            ao.useAnimal(a);
    
            Animal a2 = ao.getAnimal();
            a2.eat();
        }
    }
    
    

    接口作为形参和返回值

    方法的形参是接口名, 其实需要的接口的实现类对象

    方法的返回值是接口名, 其实返回的是该接口类的实现类对象

    Jumpping

    package paramAndReturn.interfaceAndReturn;
    
    public interface Jumpping {
        void jump();
    }
    
    

    Cat

    package paramAndReturn.interfaceAndReturn;
    
    public class Cat implements Jumpping {
        @Override
        public void jump() {
            System.out.println("猫可以跳跃");
        }
    }
    
    

    JumppingOperator

    package paramAndReturn.interfaceAndReturn;
    
    public class JumppingOperator {
        public void useJumpping(Jumpping j) {
            j.jump();
        }
    
        public Jumpping getJumpping() {
            Jumpping j = new Cat();
            return j;
        }
    }
    
    

    Demo

    package paramAndReturn.interfaceAndReturn;
    
    public class Demo {
        public static void main(String[] args) {
            // 创建操作类, 调用方法
            JumppingOperator jo = new JumppingOperator();
            Jumpping j = new Cat();
            jo.useJumpping(j);
    
            Jumpping j2 = jo.getJumpping();
            j2.jump();
        }
    }
    
    
  • 相关阅读:
    SpringCloud初体验:四、API GateWay 服务网关
    SpringCloud初体验:三、Feign 服务间调用(FeignClient)、负载均衡(Ribbon)、容错/降级处理(Hystrix)
    SpringCloud初体验:二、Config 统一配置管理中心
    SpringCloud初体验:一、Eureka 服务的注册与发现
    PHP 通过实现 Iterator(迭代器)接口来读取大文件文本
    SpringCloud初体验:前言
    springboot利用MockMvc测试controller控制器
    vue通过(NGINX)部署在子目录或者二级目录实践
    PHP 设计模式 原型模式(Prototype)之深/浅拷贝
    PHPstorm配置PHPunit对composer引入的php代码进行单元测试
  • 原文地址:https://www.cnblogs.com/ryxiong-blog/p/13890205.html
Copyright © 2011-2022 走看看