面向对象之抽象_接口_多态

最新推荐文章于 2024-08-28 20:58:28 发布
最新推荐文章于 2024-08-28 20:58:28 发布
阅读量916 收藏 21
点赞数 43
分类专栏： 面向对象 文章标签： java 开发语言 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73627305/article/details/140699848
版权

一.抽象

1.抽象的介绍abstract

​ 1.将多个类中共有的方法抽取到父类,发现方法体没法实现,所以将此方法定义成抽象方法

​ 2.抽象方法所在的类一定是抽象类

​ 3.抽象类

public abstract class 类名{}

​ 4.抽象方法

修饰符 abstract 返回值类型 方法名(参数);

​ 5.注意:子类继承父类之后必须要重写父类中的所有抽象方法

public abstract class Animal {
    private String brand;

    public Animal() {
    }

    public Animal(String brand) {
        this.brand = brand;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }

    //抽象方法
    public abstract void eat();
    public abstract void drink();
    public abstract void sleep();
}

public class Dog extends Animal{

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

    @Override
    public void drink() {
        System.out.println("狗喝水");
    }

    @Override
    public void sleep() {
        System.out.println("狗睡觉");
    }
}


public class Test01 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        dog.setBrand("哈士奇");//继承的
        String brand = dog.getBrand();//继承的
        System.out.println("brand = " + brand);
        System.out.println("====================");
        dog.eat();//重写的
        dog.drink();//重写的
        dog.sleep();//重写的
    }
}

​ 6.抽象类不能直接new对象,只能创建非抽象子类的对象

​ 7.抽象类中,可以有构造方法,是供子类创建对象时,初始化父类属性使用的

​ 8.抽象类中可以有成员变量,构造,成员方法

​ 9.抽象类中不一定非得有抽象方法,但是有抽象方法的类一定是抽象类

​ 10.抽象类的子类,必须重写父类中的所有抽象方法,否则,编译无法通过,除非该子类也是抽象类

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

    public Employee() {
    }

    public Employee(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 work();
}


public class Teacher extends Employee{
    public Teacher() {
    }

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

    @Override
    public void work() {
        System.out.println("讲师在讲课");
    }
}

public class Test {
    public static void main(String[] args) {
        Teacher t1 = new Teacher("张三", 23);
        t1.work();
    }
}

二.接口

1.基本介绍

1.概述:一种标准一种规范

2.关键字:interface

3.实现:implements

4.成员:

jdk7:
a.成员变量:public static final修饰的不写也有
b.抽象方法:public abstract 返回值类型 方法名(->不写abstract默认也有

jdk8:
默认方法:
public default 返回值类型 方法名(参数){
方法体
return 结果

}
静态方法:
public static 返回值类型 方法名(参数){
方法体
return 结果

}

jdk9:
私有方法:
带private的方法

5.使用:

public interface 接口名{

}

public class 类名 implements 接口名

6.注意

在实现类中重写接口的所有抽象方法

创建实现类对象(接口不能直接new对象),调用重写的方法

public interface USB {
    public abstract void open();
    public abstract void close();
}

public class Mouse implements USB{
    @Override
    public void open() {
        System.out.println("鼠标开启");
    }

    @Override
    public void close() {
        System.out.println("鼠标关闭");
    }
}


public class Test01 {
    public static void main(String[] args) {
        Mouse mouse = new Mouse();
        mouse.open();
        mouse.close();
    }
}

2.接口中的成员

2.1抽象方法

1.格式

public abstract 返回值类型 方法名();

2.注意:

即使没有abstract,默认也有

3.使用

​ a.创建实现类实现接口

​ b.在实现类里重写抽象方法

​ c.创建实现类对象

​ d.调用重写方法

2.2默认方法

1.格式:

public defalut 返回值类型 方法名(){
			方法体
            return 结果
}

2.注意:只能在接口中定义

3.使用:

​ a.定义实现类,实现接口

​ b.在实现类中,可重写默认方法,也可不重写

​ c.创建实现类对象,调用默认方法(有重写调重写)

public interface USB {
    //默认方法
    public default void methodDef(){
        System.out.println("我是接口中的默认方法");
    }
}

public class Mouse implements USB{
    @Override
    public void methodDef(){
        System.out.println("我是重写的接口中的默认方法");
    }
}

public class Test01 {
    public static void main(String[] args) {
        Mouse mouse = new Mouse();
        mouse.methodDef();
    }
}

2.3静态方法

1.格式

publuc static 返回值类型 方法名(参数){
		方法体
		return 结果
}

public interface USB {
   
    //静态方法
    public static void methodSta(){
        System.out.println("我是接口中的静态方法");
    }
}

public class Test01 {
    public static void main(String[] args) {
        USB.methodSta();
    }
}

2.4成员变量

1.格式

public static final 数据类型 变量名 = 值

2.注意:
a.不写static final 默认也有
b.被static final修饰的变量名一般都是大写

public interface USB {
    /*
      final代表最终的
      被final修饰之后不能被二次赋值
     */
    public static final int NUM = 100;
    int NUM1 = 10;
}

public class Test01 {
    public static void main(String[] args) {
        System.out.println(USB.NUM);
        System.out.println(USB.NUM1);
    }
}

3.接口的特点

1.接口可以多实现:

 public class InterfaceImpl implements InterfaceA,InterfaceB{}

2.接口可以多继承

 public Interface InterfaceA extends InterfaceB,InterfaceC{}

3.一个类可以继承一个父类的同时实现一个或者多个接口

  public class InterfaceImpl extends Fu implements InterfaceB,InterfaceC{}

当一个类实现多个接口时,如果接口中的抽象方法有重名且参数一样的,只需要重写一次

public interface InterfaceB {
    public abstract void methodAbs();
}

public interface InterfaceC {
    public abstract void methodAbs();
}


public class InterfaceImpl implements InterfaceB,InterfaceC{
    @Override
    public void methodAbs() {
        System.out.println("我是重写的methodAbs");
    }
}

当一个类实现多个接口时,如果默认方法有重名的,参数一样,要重写一次

public interface InterfaceB {
    public abstract void methodAbs();

    public default void methodDef(){
        System.out.println("我是接口B中的methodDef方法");
 }
}

public interface InterfaceC {
 public abstract void methodAbs();

public default void methodDef(){
     System.out.println("我是接口C中的methodDef方法");
 }
}

public class InterfaceImpl implements InterfaceB,InterfaceC{
 @Override
 public void methodAbs() {
    System.out.println("我是重写的methodAbs");
 }

    @Override
 public void methodDef() {
        System.out.println("我是重写的默认方法");
    }

}

4.接口和抽象类区别

1.相同点:
a.都位于继承的顶端,用于被其他类实现或者继承
b.都不能new
c.都包含抽象方法,其子类都必须重写这些抽象方法

2.不同点:
a.抽象类:一般作为父类使用,可以有成员变量,构造,成员方法,抽象方法等
b.接口:成员单一,一般抽取接口,抽取的都是方法,是功能的大集合
c.类不能多继承,接口可以

三.多态

1.前提

1.必须有子父类继承关系或者接口实现关系

2.必须有方法重写(没有方法的重写多态没有任何意义)

3.父类引用指向子类对象:

父类类型 对象名 = new 子类对象()

类似于:double b = 10

2.多态的基本使用

1.定义一个父类或者接口

2.定义一个子类或者实现

3.重写抽象方法

4.父类引用指向子类对象

5.调用重写的方法

public class Animal {
    public void eat(){
        System.out.println("动物要吃饭");
    }
}

public class Dog extends Animal{
    public void eat(){
        System.out.println("狗啃骨头");
    }

    //特有方法
    public void lookDoor(){
        System.out.println("狗会看门");
    }
}


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

    //特有方法
    public void catchMouse(){
        System.out.println("猫会抓老鼠");
    }
}

public class Test01 {
    public static void main(String[] args) {
        //原始方式new对象
        Dog dog = new Dog();
        dog.eat();
        dog.lookDoor();
        System.out.println("==========");
        Cat cat = new Cat();
        cat.eat();
        cat.catchMouse();

        System.out.println("==========");

        //多态形式new对象
        Animal animal = new Dog();
        animal.eat();
        //animal.lookDoor();//多态前提下,不能直接调用子类特有功能
        System.out.println("==========");

        Animal animal1 = new Cat();
        animal1.eat();
        //animal1.catchMouse();//多态前提下,不能直接调用子类特有功能
    }
}

3.多态的条件下成员的访问特点

3.1成员变量

看等号左边是谁,先调用谁中的成员变量,子类没有,找父类

public class Fu {
    int num = 100;
}

public class Zi extends Fu{
    int num = 10;
}


public class Test {
    public static void main(String[] args) {
        Fu fu = new Zi();
        System.out.println(fu.num);//父类的100
        
        System.out.println("============");

        Zi zi = new Zi();
        System.out.println(zi.num);//子类的10
    }
}

3.2成员方法

看new的是谁,先调用谁中的成员方法,子类没有,找父类

public class Fu {
    int num = 100;
    public void method(){
        System.out.println("父类中的method方法");
    }
}

public class Zi extends Fu{
    int num = 10;

    public void method(){
        System.out.println("子类中的method方法");
    }
}

public class Test {
    public static void main(String[] args) {
        //多态方式
        Fu fu = new Zi();
        System.out.println(fu.num);//父类的100
        fu.method();

        System.out.println("============");

        //原始方式
        Zi zi = new Zi();
        System.out.println(zi.num);//子类的10
        zi.method();
    }
}

4.多态的好处

1.多态的new法

父类类型 对象名 = new 子类对象() 相当于大类型接收了小类型的数据

2.多态的好处

原始方式 :等号左右两边一样

​ a.好处:既能调用子类特有的,还能调用重写的,还能调用从父类继承过来的

​ b.坏处:扩展性差

多态方式:父类引用指向子类对象

​ a.好处:扩展性强

​ b.弊端:不能直接调用子类特有方法

5.多态中的转型

5.1向上转型

父类引用指向子类对象(默认)

5.2向下转型

1.可理解为强转

2.父类类型 对象名1 = new 子类对象() (向上转型)

子类类型 对象名 = (子类类型)对象名1 (向下转型)

类似于:double b = 10;

​ int i = (int) b;

3.用于调用子类特有功能

public class Animal {
    public void eat(){
        System.out.println("动物要吃饭");
    }
}

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

    //特有方法
    public void catchMouse(){
        System.out.println("猫会抓老鼠");
    }
}

public class Dog extends Animal {
    public void eat(){
        System.out.println("狗啃骨头");
    }

    //特有方法
    public void lookDoor(){
        System.out.println("狗会看门");
    }
}

public class Test01 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        method(dog);
    }

    public static void method(Animal animal) {//Animal animal = Dog  Animal animal = Cat
        animal.eat();
        //向下转型
        Dog dog = (Dog) animal;
        dog.lookDoor();
    }
}

6.转型可能会出现的问题

1.ClassCastException -> 类型转换异常

2.出现原因:转型的时候,等号左右两边类型不一致

3.解决:做判断(instanceof)

对象名 instanceof 类型 -> 关键字前面的对象是否属于关键字后面的类型

public class Animal {
    public void eat(){
        System.out.println("动物要吃饭");
    }
}

public class Dog extends Animal {
    public void eat(){
        System.out.println("狗啃骨头");
    }

    //特有方法
    public void lookDoor(){
        System.out.println("狗会看门");
    }
}


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

    //特有方法
    public void catchMouse(){
        System.out.println("猫会抓老鼠");
    }
}

public class Test01 {
    public static void main(String[] args) {
        Dog dog = new Dog();
        method(dog);

        Cat cat = new Cat();
        method(cat);
    }

    public static void method(Animal animal) {//Animal animal = Dog  Animal animal = Cat
        if (animal instanceof Dog){
            animal.eat();
            //向下转型
            Dog dog = (Dog) animal;
            dog.lookDoor();
        }

        if (animal instanceof Cat){
            animal.eat();
            Cat cat = (Cat) animal;
            cat.catchMouse();
        }

    }
}
你蹀没牙
关注
  • 43
    点赞
  • 踩
  • 21
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C# 面向对象之多态
weixin_40960364的博客
01-18 556
一、多态简介 什么是多态？ 面向对象开发的三大特征：封装、继承和多态。 在继承的前提下，实例化出不同的对象，这些对象调用相同的方法，但是却表现出不同的行为，这就叫多态。 C# 中体现多态有三种方式：虚方法；抽象类；接口 这节课咱们就来分别介绍下这三种方法在啥时候用，以及怎么使用。 二、虚方法 1.啥叫虚方法？ 在父类中使用virtual关键字修饰的方法，就是虚方法。（virtual中文释义：虚拟的） 在子类中可以使用override关键字对该虚方法进行重写。（override本身就...
面向对象之抽象
zhouym_的博客
04-20 5516
抽象类Abstract 抽象类 形状类：三角形 圆形 矩形 父类的方法必须要存在,因为我们多态的必要条件是必须存在方法重写 方法的实现毫无意义 提供一个方法的声明即可,不需要实现,就是抽象方法 抽象类的特点: 1.抽象方法和抽象类使用 abstract 修饰 2.有一个抽象方法的类必须是抽象类 3.抽象类中一定有抽象方法吗? --> 不一定 4.没有抽象方法的抽象类有意义吗? --> ...
面向对象_多态_抽象类_接口
xiaowei的博客
06-03 2518
09.01_面向对象(多态的概述及其代码体现)A:多态(polymorphic)概述 事物存在的多种形态 B:多态前提 a:要有继承关系。 b:要有方法重写。 c:要有父类引用指向子类对象。 C:案例演示 代码体现多态public class Demo1_polymorphic { /** * 成员变量：编译时看左边（父类），运行时看左边（父类） * 成员方
java 面向对象多态_java面向对象多态特性
weixin_35411480的博客
02-12 234
一、多态的概念多态是继封装，继承之后，面向对象的三大特性。现实事物经常会体现出多种形态，如学生，学生是人的一种，则一个具体的张三同学既是学生也是人，即出现两种形态。java作为面向对象的语言，同样可以描述一个事物的多种形态，java中多态的代码体现在一个子类对象(实现类对象)既可以给这个子类(实现类对象)引用变量赋值，又可以给这个子类(实现类对象)的父类(接口) 变量赋值。父类的引用变量指向子类对...
Java面向对象之抽象类、接口
阿常的博客
01-28 1512
在之前的文章中，我们依次介绍了类与对象、面向对象三大特征的封装、以及继承（一）、继承（二） 和 多态。本文我们接着补充抽象类和接口。
抽象类_接口_多态_继承整合案例.docx
08-04
1. **继承**：继承是面向对象编程语言的一个基本特性，它允许创建一个新的类（子类），该类继承了现有类（父类）的所有属性和方法。Java支持单继承，即一个类只能有一个直接父类。 - 类：在Java中，类可以作为...
Python面向对象之接口、抽象类与多态详解
09-20
在探讨Python面向对象编程的过程中，接口、抽象类和多态是三个核心概念。理解这三个概念能够帮助我们在设计和实现软件时保持良好的可扩展性和复用性。 首先，接口在某些编程语言（比如Java）中是定义一个类必须实现...
Lesson_面向对象继承，多态，接口_实训
07-10
在这个"Lesson_面向对象继承，多态，接口_实训"中，我们将深入探讨这三个关键概念：继承、多态和接口，并通过实践来加深理解。 首先，让我们来看看**继承**。继承是面向对象编程的一个重要特性，它允许一个类（子类...
D11接口，多态.zip_d11接口_java接口_mannerglc_多态
09-21
多态是继封装、继承之后，面向对象的第三大特性。 Java作为面向对象的语言，同样可以描述一个事物的多种形态。如Student类继承了Person类，一个Student的对象便既是Student，又是Person。 Java中多态的代码体现在一...
启动Application 报错：no mapping for GET /（已解决）
qq_3512323979的博客
08-26 2139
no mapping for GET /因为我使用的是框架嘛，然后生成了一个SpringBoot项目后，resources下面就会有一个static的类，用于存放静态资源类，后面我把静态资源放在里面，但是启动启动类后，报错一直匹配不到。： 正常的话，我们使用SpringBoot框架，他会给我们提供许多便利，包括静态资源的自动服务，默认的话，他会去。报这个错可能还有其他原因，我的是因为这个，大家可以根据日志信息一步步检查，肯定可以解决的！类并覆盖其方法时，就会失去静态资源的自动服务
开发多线程程序时，需要注意那些问题
OO_SEN的博客
08-23 2496
线程安全 竞态条件（Race Condition）：当多个线程同时访问和修改共享资源时，可能会出现竞态条件，导致不确定的行为。需要通过同步机制（如互斥锁、读写锁、原子操作）来保护共享资源。 死锁（Deadlock）：当两个或多个线程相互等待对方释放锁时，程序会陷入死锁状态。避免死锁的一些策略包括：避免嵌套锁、确保加锁顺序一致、使用超时机制等。 活锁（Livelock）：与死锁不同，活锁是指线程不断地尝试获取资源但总是失败，导致无法继续执行。避免频繁重试操作或使用退避算法可以减少活锁的发生。 优先级反转（P
linux上datax 安装以及使用
寂夜了无痕的博客
08-24 2748
linux上datax 安装以及使用
操作系统原子操作
zzt_is_me的博客
08-28 881
所谓的原子操作就是不可被拆分的操作，对于多线程对全局变量进行操作时，就再也不用再线程锁了，和pthread_mutex_t保护作用是一样的，也是线程安全的，有些编译器在使用时需要加-march=i686编译参数。2、type只能是整数相关的类型，浮点型和自定义类型无法使用。功能：把value赋值给*ptr,并返回*ptr的旧值。功能：以上操作返回的是*ptr与value计算后的值。使用原子操作实现一个线程安全的无锁队列。1、该功能并不通用，有些编译器不支持。功能：以上操作返回的是*ptr的旧值。
Java设计模式之建造者模式详细讲解和案例示范
最新发布
weixin_39996520的博客
08-28 697
建造者模式是一种创建型设计模式，允许用户通过一步步地构造复杂对象的方式来避免直接使用大量的构造函数或复杂的初始化过程。它通过将对象的创建过程分解为多个步骤，并允许这些步骤以链式调用的方式来执行，最终生成一个完全构建的对象。首先，我们定义一个Order类，该类包括了多个字段，如订单ID、客户信息、商品列表、配送地址等。// Getter方法省略...在这个例子中，类提供了构建Order对象所需的各个方法，每个方法返回实例，以便进行链式调用。
Spring WebFlux – CVE-2023-34034 – 撰写和概念验证
技术超强的网络安全平台
08-28 460
Spring框架是一个广泛使用的基于Java的应用程序框架，为企业级Java应用的开发提供基础设施支持。是一个功能强大的身份验证和访问控制框架，也是保护基于 Spring 的应用程序的行业标准。它提供身份验证和授权，并且可以轻松扩展以满足自定义要求。Spring WebFlux是在 Spring 5 中引入的，作为传统框架的响应式编程替代方案。Spring WebFlux 的核心设计旨在处理异步、非阻塞和反应式编程范例。它提供了一种反应式编程模型，允许开发人员构建可扩展、响应迅速且具有弹性的应用程序。
基于jenkins部署maven项目
静水深流
08-26 1283
如上所示，构建后，我们处于项目的根目录之下，可以进行后续的操作，如启动target目录下的jar包、将jar包传输到需要部署的服务器上、打docker镜像bing上传等等，需要根据实际情况进行选择，而这些都可以在“Add post-build step”选项中进行选择。我们主要关注上述几个部分，在General部分，可以对项目进行一个简单的描述，源码管理部分，需要配置对应的源码url，如下图所示。如上所示，选择“构建一个maven项目”，如果没有改选项，则需要安装maven构建的插件，请参考之前的文章。
C++的内存模型
qhu1600417010的博客
08-28 731
C++ 的内存模型包含了程序运行时如何分配、访问、管理内存的规则，涵盖了多线程环境下的数据一致性、内存对齐、以及虚拟内存管理等内容。掌握这些概念对于编写高效、安全的 C++ 程序至关重要。
@Transactional中使用线程锁导致了锁失效与解决方案
liuruiaaa的博客
08-23 1464
@Transactional中使用线程锁导致了锁失效与解决方案
SpringBoot日常：扩展接口之CommandLineRunner和ApplicationRunner
qq_32590535的博客
08-28 367
日常开发中我们可能经常会遇到这样的场景，像启动容器完成后需要去执行一些业务逻辑，SpringBoot给我们提供了两个接口来帮助我们实现这种需求，两个启动加载接口分别是CommandLineRunner和ApplicationRunner。本文简单介绍如何使用该扩展点实现业务。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值