【Java】面向对象核心知识点（二），文章层次分明，内容精益求精，代码简单易懂

于 2024-05-04 09:00:00 发布
阅读量1k 收藏 30
点赞数 26
文章标签： java eclipse windows idea vscode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_60631827/article/details/138360836
版权

目录

一、构造方法

1.1 概念

1.2 作用

1.3 代码

二、抽象

2.1 概念

2.2 作用

2.3 注意

2.4 代码

三、接口

3.1 概念

3.2 作用

3.3 注意

3.4 语法

3.5 代码

四、内部类

4.1 成员内部类

4.2 局部内部类

4.3 静态内部类

4.4 匿名内部类

（原创文章，转载请注明出处）

博主是计算机专业大学生，不定期更新原创优质文章，感兴趣的小伙伴可以关注博主主页支持一下，您的每一个点赞、收藏和关注都是对博主最大的支持！

一、构造方法

1.1 概念

  • 构造方法是一种特殊的方法，在创建对象（通过new󠁪关键字）时被自动调用。
  • 构造方法的名称与类名完全相同，并且没有返回类型（即使它是void󠁪也不行）。
  • 在Java中，一个类可以有多个构造方法，可以有不同的参数列表以满足不同的对象创建需求。

1.2 作用

  • 对象的创建和初始化：构造方法用于创建对象并初始化对象的状态
  • 属性的赋值：构造方法可以接受参数，并使用这些参数来完成对对象属性的赋值

1.3 代码

（1）无参构造

① 例子类

public class Example {
    // 无参构造
    public Example() {
        System.out.println("自动调用了无参构造");
    }
}

② 测试类

public class ExampleTest {
    public static void main(String[] args) {
        new Example();
        // 输出：自动调用了无参构造
    }
}

（2）含参构造

① 学生类

public class Student {
    String name;
    Integer age;
    // 含参构造
    public Student(String name, Integer age) {
        this.name = name;
        this.age = age;
        System.out.println("自动调用了含参构造");
        System.out.println("姓名：" + this.name + "，年龄：" + this.age);
    }
}

② 测试类

public class StudentTest {
    public static void main(String[] args) {
        new Student("张三", 22);
        // 输出：
        // 自动调用了含参构造
        // 姓名：张三，年龄：22
    }
}

二、抽象

2.1 概念

（1）抽象类

  • 在Java中，使用abstract󠁪关键字定义的类称为抽象类。
  • 抽象类是一个不能被实例化的类。它只能被继承。抽象类中可以包含普通方法的定义和实现，也可以包含抽象方法的定义。

（2）抽象方法

  • 在Java中，使用abstract󠁪关键字定义的方法称为抽象方法。
  • 抽象方法是一种没有实现的方法，需要在继承的子类中进行具体实现。如果一个类包含抽象方法，那么该类必须被声明为抽象类。

2.2 作用

  • 代码复用：把相同的代码抽抽取到父类（抽象类），实现了多态性并提高代码的灵活性
  • 强制重写：让继承抽象类的子类强制重写父类中的方法，或者说防止子类遗忘重写

2.3 注意

  • 抽象类中不一定有抽象方法，有抽象方法的类一定是抽象类
  • 抽象类不能实例化；但抽象类中可以有构造方法（用于给属性赋值）
  • 抽象类的子类，要么重写抽象类中的所有抽象方法，要么是抽象类

2.4 代码

① 父类

// 抽象类
public abstract class Father {
    // 成员变量
    private String name;
    // 抽象方法
    public abstract String say();
    // 构造方法
    public Father(String name) {
        this.name = name;
    }
    // 实例方法
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

② 子类

public class Child extends Father {
    // 强制实现父类构造方法
    public Child(String name) {
        super(name);
    }
    // 强制实现父类抽象方法
    @Override
    public String say() {
        return this.getName() + "实现了父类构造方法";
    }
}

③ 测试类

public class Test {
    public static void main(String[] args) {
        Child child = new Child("子类");
        System.out.println(child.say());
        // 输出：子类实现了父类构造方法
    }
}

三、接口

3.1 概念

  • 接口是一种抽象数据类型，定义了一组方法的契约。
  • 接口使用interface󠁪关键字定义，强调类型的抽象和行为的规范。
  • 接口包含全局变量和抽象方法（JDK8之前不能包含普通方法，JDK8重新定义接口，可包含默认方法和静态方法（也叫类方法）。

接口定义如下：

public interface MyInterface {
    // 全局常量（Fields）
    String NAME = "全局常量";

    // 抽象方法（Abstract Methods）
    String abstractMethods();

    // 默认方法（Default Methods）
    default String defaultMethods() {
        return "默认方法";
    }

    // 静态方法（Static Methods）
    static String staticMethods() {
        return "静态方法";
    }
    // 嵌套类型（Nested Types）
    /* 嵌套的接口、类或枚举 */
}

说明：

  • 接口中的全局常量默认使用“public static final”进行修饰，修饰符可省
  • 接口中的抽象方法默认使用“public abstract”进行修饰，修饰符可省
  • 接口中的默认方法使用“default”修饰, 允许有方法体
  • 接口中的静态方法使用“static”修饰, 允许有方法体

3.2 作用

  • 接口是对方法进行抽象处理的规则，具有安全性，规范性，可维护性。
  • 接口的引入主要是为了实现多重继承的效果，以及定义行为的规范，使得不同的类可以共享相同的行为定义。

3.3 注意

  • 接口的子类（实现类），要么重写接口中的所有抽象方法，要么是抽象类。
  • 接口不能实例化；接口和类之间是实现关系，通过implements实现接口。
  • 使用接口的目的是为了克服单继承的限制，一个类只能有一个父类，而一个接口可以同时继承多个父接口。
  • 与抽象类不同，接口不能有构造方法，也不能有实例变量（只能有静态常量）。

3.4 语法

（1）子接口可继承多个父接口

修饰符 interface 子接口 extends 父接口1,父接口2,... { ... }

（2）类通过implements实现接口

修饰符 class 类名 implements 接口1,接口2,...{ ... }

（3）子类继承父类并实现接口

修饰符 class 子类 extends 父类 implements 接口1,接口2,...{ ... }

3.5 代码

① 接口

public interface MyInterface {
    // 全局常量（Fields）
    String NAME = "全局常量";

    // 抽象方法（Abstract Methods）
    String abstractMethods();

    // 默认方法（Default Methods）
    default String defaultMethods() {
        return "默认方法";
    }

    // 静态方法（Static Methods）
    static String staticMethods() {
        return "静态方法";
    }
}

② 父类

public abstract class Father {
    abstract String say();
}

③ 子类

public class Child extends Father implements MyInterface {
    @Override
    public String abstractMethods() {
        return "强制重写接口抽象方法";
    }

    @Override
    public String defaultMethods() {
        return "强制重写接口默认方法";
    }

    @Override
    String say() {
        return "强制重写父类抽象方法";
    }
}

④ 测试类

public class InterfaceTest {
    public static void main(String[] args) {
        Child child = new Child();
        System.out.println(child.NAME);
        System.out.println(child.abstractMethods());
        System.out.println(child.defaultMethods());
        System.out.println(child.say());
        // 输出：
        // 全局常量
        // 强制重写接口抽象方法
        // 强制重写接口默认方法
        // 强制重写父类抽象方法
    }
}

四、内部类

4.1 成员内部类

（1）概念：在一个类中定义的类被称为成员内部类

（2）功能：成员内部类可以访问外部类的所有成员（包括属性和方法）

（3）语法：

//实例化成员内部类对象语法格式
外部类名.内部类名 变量名 = new 外部类名().new 内部类名();

（4）代码：

① 成员内部类

class Outer {
    String outerAttribute = "外部类成员属性";
    String outerMethod() {
        return "外部类成员方法";
    }
    // 定义成员内部类并使用成员方法和属性
    class Inner {
        String getOuterAttribute() {
            return outerAttribute;
        }
        String getOuterMethod() {
            return outerMethod();
        }
    }
}

② 测试类

public class InnerTest {
    public static void main(String[] args) {
        Outer.Inner inner = new Outer().new Inner();
        System.out.println(inner.getOuterAttribute());
        System.out.println(inner.getOuterMethod());
        // 输出：
        // 外部类成员属性
        // 外部类成员方法
    }
}

4.2 局部内部类

（1）概念：在方法中定义的类被称为局部内部类（也称方法内部类）

（2）功能：局部内部类可以访问外部类的所有成员（包括属性和方法），但局部内部类中变量和方法却只能在所属方法中访问

（3）代码

import org.junit.Test;

public class Outer {
    String outerAttribute = "外部类成员属性";
    String outerMethod() {
        return "外部类成员方法";
    }
    // 单元测试
    @Test
    public void show() {
        // 定义局部内部类并使用成员方法和属性
        class Inner {
            String getOuterAttribute() {
                return outerAttribute;
            }
            String getOuterMethod() {
                return outerMethod();
            }
        }
        // 注意：局部内部类只能在外部类的方法中创建对象并使用
        Inner inner = new Inner();
        System.out.println(inner.getOuterAttribute());
        System.out.println(inner.getOuterMethod());
        // 输出：
        // 外部类成员属性
        // 外部类成员方法
    }
}

4.3 静态内部类

（1）概念：使用static关键字修饰的成员内部类称为静态内部类

（2）功能：静态内部类只能访问外部类的静态成员（包括属性和方法）

（3）语法：

//实例化静态内部类对象语法格式
外部类.内部类 变量名 = new 外部类.内部类();

（4）代码

① 静态内部类

public class Outer {
    static String outerAttribute = "外部类成员属性";
    static String outerMethod() {
        return "外部类成员方法";
    }
    // 定义静态内部类并使用成员方法和属性
    static class Inner {
        String getOuterAttribute() {
            return outerAttribute;
        }
        String getOuterMethod() {
            return outerMethod();
        }
    }
}

② 测试类

public class InnerTest {
    public static void main(String[] args) {
        Outer.Inner inner = new Outer.Inner();
        System.out.println(inner.getOuterAttribute());
        System.out.println(inner.getOuterMethod());
        // 输出：
        // 外部类成员属性
        // 外部类成员方法
    }
}

4.4 匿名内部类

（1）概念：没有名称的内部类称为匿名内部类，为一个表达式，非常规的类

（2）功能：可以通过匿名对象重写方法，不用再进行实例化对象，可节省代码

（3）语法：

new 父类/接口(参数){
    @Override
    重写父类/接口方法
}

可以简单理解为：匿名内部类本质上是一个没有名字的子类对象、或者接口的实现类对象

（4）代码：

① 父类

public abstract class Father {
    public abstract void show();
}

② 测试类

public class AnonymityInnerTest {
    public static void main(String[] args) {
        // 这里new的后面部分，其实就是一个Father的子类对象
        new Father() {

            @Override
            public void show() {
                System.out.println("重写父类抽象方法");
            }
        }.show(); // 调用匿名内部类继承父类的方法
        // 输出：重写父类抽象方法
    }
}

若有不妥之处，恳请读者批评指正

Kenneth_Creative
关注
  • 26
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值