Java——面向对象进阶（三）

最新推荐文章于 2024-06-29 11:59:11 发布
最新推荐文章于 2024-06-29 11:59:11 发布
阅读量1.1k 收藏 38
点赞数 25
文章标签： java 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_73551991/article/details/139692390
版权

在这里插入图片描述

前言：
抽象类，接口，内部类

文章目录

一、抽象类

在Java中，抽象类是一种不能被实例化的类，它通常用于定义一些共用的方法和字段，在该类中不知道具体的实现，但还是想让子类必须去实现这些方法，所以将成员方法定义成抽象方法，该类定义成抽象类。abstract 用于修饰方法方法和类，修饰的方法是抽象方法，修饰的类是抽象类。

1.1 抽象方法

使用abstract 关键字修饰方法，该方法就成了抽象方法，抽象方法只包含一个方法名，而没有方法体。

定义格式：
修饰符 abstract 返回值类型 方法名 (参数列表);

示例:
public abstract void run();

1.2 抽象类

使用abstract 关键字修饰类，

形式:
abstract class 类名字 { 

}

示例:
public abstract class Animal {
    public abstract void run()；
}

！注意：抽象类不一定有抽象方法，但有抽象方法的类一定要定义成抽象类

1.3 抽象类的使用

  1. 继承抽象类：

    • 如果一个类继承了一个抽象类，并且这个类不是抽象类，那么它必须实现所有从抽象类继承的抽象方法。
    • 如果一个类继承了一个抽象类，但没有实现所有的抽象方法，那么这个类必须声明为抽象类。

  2. 抽象类的继承链：

    • 一个抽象类可以继承另一个抽象类，并且可以选择性地实现部分或全部继承的抽象方法。
    • 最终，必须有一个具体（非抽象）的子类实现所有抽象方法。

示例代码：

  1. 子类实现所有抽象方法

    abstract class Animal {
    abstract void makeSound();
    abstract void eat();
}

class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("Woof!");
    }

    @Override
    void eat() {
        System.out.println("Dog is eating.");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        myDog.makeSound();
        myDog.eat();
    }
}

    Dog类继承了Animal类，并且实现了所有的抽象方法。

  2. 子类没有实现所有抽象方法，必须声明为抽象类

    abstract class Animal {
    abstract void makeSound();
    abstract void eat();
}

abstract class Canine extends Animal {
    @Override
    void makeSound() {
        System.out.println("Howl!");
    }
    // `eat` 方法没有实现，所以 Canine 仍然是抽象类
}

class Dog extends Canine {
    @Override
    void eat() {
        System.out.println("Dog is eating.");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal myDog = new Dog();
        myDog.makeSound();
        myDog.eat();
    }
}

    Canine类实现了makeSound方法，但没有实现eat方法，因此Canine必须声明为抽象类。Dog类继承了Canine并实现了eat方法，使得Dog成为具体类，可以被实例化。

二、 接口

接口（Interface）在Java中是一个重要的概念，用于定义一组方法的规范，而不提供任何实现。接口主要用于定义类之间的契约和规范，确保实现这些接口的类遵循相同的方法签名。

2.1 接口的定义和实现

接口的定义：
接口使用interface关键字定义，接口中的所有方法默认是public和abstract，所有成员变量默认是public static final。以下是一个简单的接口示例：

public interface Animal {
    void makeSound();
    void eat();
}

实现接口
类通过implements关键字实现接口，一个类可以实现多个接口，这与抽象类的单继承限制不同。以下是实现Animal接口的两个类：

public class Dog implements Animal {
    @Override
    public void makeSound() {
        System.out.println("Woof!");
    }

    @Override
    public void eat() {
        System.out.println("Dog is eating.");
    }
}

public class Cat implements Animal {
    @Override
    public void makeSound() {
        System.out.println("Meow!");
    }

    @Override
    public void eat() {
        System.out.println("Cat is eating.");
    }
}

类实现接口的要求：

  1. 必须重写实现的全部接口中所有抽象方法。
  2. 如果一个类实现了接口，但是没有重写完全部接口的全部抽象方法，这个类也必须定义成抽象类。

如果一个类实现了多个接口，而这些接口有相同的抽象方法，那么这个类只需要实现这个抽象方法一次即可，因为Java不允许同一个类中出现重复的方法签名。这种情况下，类只需要提供一次方法的实现，而不需要重复实现多次。

2.2 default 关键字

default 关键字主要用于接口中的默认方法（default methods），这是从Java 8开始引入的特性。默认方法允许在接口中为方法提供默认的实现，这样可以在不破坏现有实现的情况下，向接口添加新的方法。

默认方法（Default Methods）定义方式：

public interface InterfaceName {
    // 抽象方法
    void regularMethod();

    // 默认方法
    default void defaultMethod() {
        // 默认实现
        System.out.println("This is a default method.");
    }
}

在上面的例子中，defaultMethod 就是一个默认方法。默认方法使用 default 关键字修饰，它提供了一个默认的实现。所有实现了这个接口的类都会继承这个默认方法，如果需要的话，可以在实现类中重写默认方法。

示例：

public interface Vehicle {
    void start();
    
    default void honk() {
        System.out.println("Vehicle is honking.");
    }
}

public class Car implements Vehicle {
    @Override
    public void start() {
        System.out.println("Car is starting.");
    }

    // Car可以选择不重写honk方法，使用默认实现
}

public class Bike implements Vehicle {
    @Override
    public void start() {
        System.out.println("Bike is starting.");
    }

    @Override
    public void honk() {
        System.out.println("Bike is honking."); // Bike提供了自己的honk方法实现
    }
}

当需要扩展一个接口，但又不能破坏所有实现这个接口的类时，可以使用默认方法。

注意事项:
如果一个类实现了多个接口，而这些接口有相同的默认方法，实现类必须重写这个默认方法来解决冲突。

interface A {
    default void hello() {
        System.out.println("Hello from A");
    }
}

interface B {
    default void hello() {
        System.out.println("Hello from B");
    }
}

class C implements A, B {
    @Override
    public void hello() {
        A.super.hello(); // 明确指定调用接口A的默认方法
        //B.super.hello(); 或明确指定调用接口B的默认方法
    }
}

2.3 实现接口时遇到的问题

  1. 如果一个类继承了一个类并实现了一个接口，且父类和接口中有都有相同签名的方法。

    • 处理办法一：如果父类中的方法体，能满足当前业务的需求，在子类中可以不用重写。
    • 处理办法二：如果父类中的方法体，不能满足当前业务的需求，需要在子类中重写。

  2. 如果一个接口中，有多个抽象方法，但在实现类中，只需要用其中一个或部分

    • 方法一：实现类声明为抽象类
      你可以将实现类声明为抽象类，并只实现部分抽象方法，这样子类就可以根据需要选择性地实现接口的方法。

      // 定义一个接口
interface MyInterface {
    void method1(); // 抽象方法1
    void method2(); // 抽象方法2
    void method3(); // 抽象方法3
}

// 实现类声明为抽象类，并只实现部分方法
abstract class MyAbstractClass implements MyInterface {
    @Override
    public void method1() {
        System.out.println("Implemented method1");
    }
    
    // 不需要实现 method2 和 method3
}

// 子类继承抽象类，选择性实现部分方法
class MyClass extends MyAbstractClass {
    @Override
    public void method2() {
        System.out.println("Implemented method2");
    }
}

    • 方法二：使用适配器模式（Adapter Pattern）
      如果不想使用抽象类，可以使用适配器模式，它允许提供接口的默认实现，然后子类可以选择性地覆盖它们。

      // 定义一个接口
interface MyInterface {
    void method1(); // 抽象方法1
    void method2(); // 抽象方法2
    void method3(); // 抽象方法3
}

// 创建适配器类，提供接口的默认实现
abstract class MyInterfaceAdapter implements MyInterface {
    @Override
    public void method1() {
        // 默认实现
    }
    
    @Override
    public void method2() {
        // 默认实现
    }
    
    @Override
    public void method3() {
        // 默认实现
    }
}

// 子类选择性地覆盖需要的方法
class MyClass extends MyInterfaceAdapter {
    @Override
    public void method2() {
        System.out.println("Implemented method2");
    }
}

三、内部类

内部类（Inner Class）是定义在另一个类内部的类。Java 提供了多种内部类，包括成员内部类、局部内部类、匿名内部类和静态内部类。

按定义的位置来分：

  1. 成员内部内，类定义在了成员位置 (类中方法外称为成员位置，无static修饰的内部类)
  2. 静态内部类，类定义在了成员位置 (类中方法外称为成员位置，有static修饰的内部类)
  3. 局部内部类，类定义在方法内
  4. 匿名内部类，没有名字的内部类，可以在方法中，也可以在类中方法外。

3.1 成员内部类

定义格式:

class OuterClass {
    class InnerClass {
        // Inner class members
    }
}

内部类的使用格式：

 外部类.内部类。 // 访问内部类的类型都是用 外部类.内部类

创建内部类实例：

  • 方式一：外部直接创建成员内部类的对象

    OuterClass outer = new OuterClass();
OuterClass.InnerClass inner = outer.new InnerClass();
//或
OuterClass.InnerClass inner = new OuterClass().new InnerClass();

  • 方法二：在外部类中定义一个方法提供内部类的对象

    public class Outer {
    private class Inner{
    }
    
    public Inner getInstance(){
        return new Inner();
    }
}

public class Test {
    public static void main(String[] args) {
        Outer outer = new Outer();
	    Inner inner = outer.getInstance();
    }
}

成员内部类的细节

  1. 成员内部类可以被一些修饰符所修饰，比如： private，默认，protected，public，static等

  2. 成员内部类可以访问外部类的所有成员，包括私有成员。这是因为成员内部类持有一个对外部类实例的引用Outer.this。

    public class Outer {
    private String outerField = "Outer field";

    class Inner {
        void display() {
            System.out.println("Inner class accessing: " + outerField);
            System.out.println("Inner class accessing through Outer.this: " + Outer.this.outerField);
        }
    }

    public static void main(String[] args) {
        Outer outer = new Outer(); // 创建外部类对象
        Outer.Inner inner = outer.new Inner(); // 创建内部类对象
        inner.display(); // 调用内部类的方法
    }
}

//输出:
Inner class accessing: Outer field
Inner class accessing through Outer.this: Outer field

    内存图示例:内存图示例

  3. 在 JDK 8 之前，局部变量必须显式声明为 final 才能被成员内部类。在 JDK 8 及之后，只要局部变量在初始化后没有被修改，它们就被隐式地视为 final（即有效 final），不再需要显式声明为 final。

3.2 静态内部类

定义格式：

class OuterClass {
    static class StaticInnerClass {
        // 静态内部类的成员
    }
}

创建实例：

OuterClass.StaticInnerClass innerObject = new OuterClass.StaticInnerClass();

静态内部类的特点

  1. 静态内部类可以直接访问外部类的静态成员，但不能访问外部类的非静态成员，如果要访问需要创建外部类的对象，用对象调用。

    public class Outer {
    private static String staticOuterField = "Static Outer Field";
    private String nonStaticOuterField = "Non-Static Outer Field";

    static class StaticInner {
        void display() {
            // 静态内部类可以访问外部类的静态成员
            System.out.println("Static Inner Class accessing static outer field: " + staticOuterField);
            
            // 但不能直接访问外部类的非静态成员
            // System.out.println("Static Inner Class accessing non-static outer field: " + nonStaticOuterField); // 编译错误
        }
    }

    public static void main(String[] args) {
        // 创建静态内部类的实例
        StaticInner inner = new StaticInner();
        inner.display(); // Output: Static Inner Class accessing static outer field: Static Outer Field
        
        // 如果要访问外部类的非静态成员，需要创建外部类的对象
        Outer outer = new Outer();
        System.out.println("Access non-static outer field through outer object: " + outer.nonStaticOuterField);
    }
}

  2. 无需外部类实例： 可以直接创建静态内部类的实例，而不需要外部类的实例。

  3. :静态内部类中没有隐含的 Outer.this。

3.3 成员内部类

局部内部类是定义在方法或作用域内部的内部类。

特点

  • 作用域限制： 局部内部类的作用域仅限于定义它的方法或代码块中，不能在外部访问。
  • 访问权限： 局部内部类可以访问外部类的所有成员，包括私有成员。
  • 访问局部变量： 局部内部类可以访问方法内的 final 局部变量（JDK 8+版本可以访问非 final 的局部变量，但其值不能在局部类中被修改）。
  • 生命周期： 局部内部类的生命周期仅限于方法调用，方法结束后局部内部类实例也会被销毁。

示例

public class Outer {
    private int outerField = 10;

    public void methodWithLocalInnerClass() {
        final int localVar = 20; // JDK 8+ 可以不用final修饰，但不可变

        class LocalInner {
            void display() {
                System.out.println("Outer field: " + outerField);
                System.out.println("Local variable: " + localVar);
            }
        }

        // 创建局部内部类的实例并调用方法
        LocalInner inner = new LocalInner();
        inner.display();
    }

    public static void main(String[] args) {
        Outer outer = new Outer();
        outer.methodWithLocalInnerClass();
    }
}

3.4 匿名内部类（最常用）

匿名内部类是一种没有显式声明类名的内部类，它在创建对象的同时定义类的实现。匿名内部类通常用于创建只需使用一次且没有额外的逻辑的类实例。

格式：

new 类名或者接口名() {
     重写方法;
};
这里同时包含了继承或实现，方法重写，创建对象
从new关键字到";"整个整体是匿名内部类的实例，"{}"内的是匿名内部类，没有类名

使用：
以接口为例，匿名内部类的使用，代码如下：

interface Swim {
    public abstract void swimming();
}

public class Test {
    public static void main(String[] args) {
        // 接口 变量 = new 实现类(); // 多态,走子类的重写方法
        Swim s2 = new Swim() {
            @Override
            public void swimming() {
                System.out.println("蛙泳...");
            }
        };
        s2.swimming();
    }
}


如果你喜欢这篇文章，点赞👍+评论+关注⭐️哦！
欢迎大家提出疑问，以及不同的见解。

拉普达的城
关注
  • 25
    点赞
  • 踩
  • 38
    收藏
    觉得还不错? 一键收藏
  • 15
    评论
JAVA-SE入门学习——第六讲面向对象进阶
06-08
在Java SE的学习过程中，面向对象进阶是一个重要的环节，它涵盖了案例驱动模式、分类思想、分包思想以及在实际项目中的应用。下面将详细阐述这些知识点。 首先，案例驱动模式是一种有效的学习和编程方法。它的核心...
java实现的教学管理系统——适合java进阶入门者
10-12
它涵盖了面向对象编程、数据管理以及简单的用户交互等基础概念，是理解Java编程语言特性和应用的良好起点。以下是对这个系统及其相关知识点的详细阐述： 1. **面向对象编程**：Java是一种典型的面向对象编程（OOP）...
java多态——面向对象进阶
Datoulu1的博客
06-01 398
对象的多种形态。（就是爸爸管儿子）例子：Father f = new Son();这里的Father是父类，Son是继承父类Father的子类。
Java——面向对象进阶（一）
weixin_73551991的博客
06-07 1548
前言面向对象进阶(一)：static，继承，this和super关键字。
Java——面向对象进阶（封装、继承、多态）
qq_59599094的博客
11-16 1311
Java面向对象三大特性——封装、继承、多态
Java学习笔记12.——面向对象进阶之静态变量
muzik_ijik的博客
12-21 1078
对于static的疑问来源于为什么不能访问非静态的成员变量和方法，this关键字是当初的开发者没有设置，因为static代表是公用使用的，在堆区中有一个静态存储空间。静态变量是随着类的加载而加载的，优先与对象出现的。原因如下：百度如下：1.静态变量是在类加载时初始化的，而不是在对象创建时初始化的。这是因为在Java中，类的加载是一个独立的过程，发生在对象创建之前。2.类加载是JVM（Java虚拟机）的一项重要工作，它负责将类的字节码转换为可执行的Java代码。
Java基础篇——面向对象进阶
尘的学习记录
08-14 138
1、包​​学习的最大理由是想摆脱平庸，早一天就多一份人生的精彩；迟一天就多一天平庸的困扰。各位小伙伴，如果您：想系统/深入学习某技术知识点…一个人摸索学习很难坚持，想组团高效学习…想写博客但无从下手，急需写作干货注入能量…热爱写作，愿意让自己成为更好的人…1、包什么是包？包是用来分门别类的管理各种不同类的，类似于文件夹、建包利于程序的管理和维护。建议包名全部英语小写，并达到见名知义的效果。导包import 包名.类名;...
JAVA学习笔记05——面向对象进阶
dsad3as12的博客
04-28 597
1.面向对象三大特征——继承 class Person { String name; int height; public void rest(){ } } class Student extends Person { String major; //专业 public Student(String name,int height,String major) { //天然拥有父类的属性 this.name = name;
012——面向对象进阶
遇事不决 ， 可问春风
10-06 89
面向对象进阶。
JAVA面向对象程序设计——面向对象进阶(初学者见解)
SUFEI0916的博客
06-17 95
1.成员变量 变量可以分为成员变量和局部变量，成员变量是在类范围内定义的变量，局部变量是在方法中定义的变量。 2.this关键字 this关键字总是指向调用该方法的对象。 大多数情况下，在方法中访问类中的实例成员变量无须使用this前缀，如果方法中的一个局部变量和实例变量同名，但程序又需要在该方法中访问该实例变量，则必须使用this前缀。 例如： public class Hero{ String name;//定义实例属性name public void setName(String...
黑马20天学会Java——面向对象进阶（超详细笔记）
weixin_50523986的博客
05-27 1191
extends作用：当子类继承父类后，就可以直接使用父类公共的属性和方法优势：可以提高代码的复用性继承设计规范：子类们相同特征（共性属性，共性方法）放在父类中定义子类独有的的属性和行为应该定义在子类自己里面继承的特点子类可以继承父类的属性和行为，但是子类不能继承父类的构造器Java是单继承模式：一个类只能继承一个直接父类Java不支持多继承、但是支持多层继承Java中所有的类都是Object类的子类子类可以继承父类的私有成员，只是不能直接访问（get，set方法访问）
第十二课 Java基础篇——面向对象进阶（一）
weixin_61694989的博客
08-01 967
第十二课 Java基础篇——面向对象进阶
Educoder题目：Java面向对象 - 封装、继承和多态答案解析.md
11-08
Educoder题目：Java面向对象 - 封装、继承和多态答案解析
孙卫琴《Java面向对象编程》配套PPT
11-30
Java语言完全支持面向对象编程，其三大特性——封装、继承和多态，是OOP的核心。 1. 封装：这是面向对象编程的基础，它将数据和操作数据的方法捆绑在一起，形成一个独立的实体，即对象。在Java中，通过访问修饰符...
面向对象程序设计——入门
03-04
这份名为“面向对象程序设计——入门”的资料，以PPT的形式，为初学者提供了一个系统的学习路径，涵盖了面向对象的基本概念、核心原则以及在Java语言中的实现方法。 1. **面向对象的基本概念** - **对象**：对象是...
配置系统PATH环境变量
最新发布
weixin_44626980的博客
06-29 563
PATH环境变量在操作系统中起着非常重要的作用，特别是在命令行或脚本中执行程序时，系统会根据PATH环境变量中定义的路径查找可执行文件。当用户在命令行或脚本中输入一个命令时，系统会根据PATH环境变量中定义的路径依次查找对应的可执行文件，如果找到则执行。本文详细介绍了如何配置系统的PATH环境变量，包括在Windows和Linux系统中的操作步骤。在Linux系统中，可以通过编辑shell配置文件来配置PATH环境变量，常用的shell配置文件包括.bashrc、.bash_profile等。
Java面试题:Redis为什么速度快
qq_55630615的博客
06-25 829
因为Redis是纯内存操作,执行速度非常快,性能的瓶颈是网络延迟而非执行速度I/O多路复用模型主要就是实现了高效的网络请求。
教程：Spring Boot中如何集成GraphQL
weixin_44627014的博客
06-27 582
接下来，定义GraphQL的Schema（模式）以描述数据结构和查询方式。@Component在这个例子中，我们创建了一个简单的类，实现了接口，并定义了一个简单的hello查询，返回一个字符串。通过本文的教程，我们学习了如何在Spring Boot应用中集成和使用GraphQL。
基于weixin小程序智慧物业系统的设计
ing65768的博客
06-27 391
管理员账户功能包括：系统首页，个人中心，管理员管理，用户管理，员工管理，房屋管理，缴费管理，车位管理，报修管理。主要技术：Java,Spring,mybatis,mysql,jquery,html。工作人员账号功能包括：系统首页，维修管理，维修指派，公告管理，轮播图信息。服务器：SpringBoot自带 apache tomcat。JDK版本：Java JDK1.8。数据库可视化工具： navicat。数据库版本： mysql5.7。开发工具：IDEA(推荐)开发系统：Windows。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 15
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值