SHOW ME THE CODE - 面向对象基本概念

置顶 已于 2024-05-04 16:50:18 修改
阅读量988 收藏 30
点赞数 15
分类专栏： JAVA 基础 文章标签： 面向对象基本概念 面向对象程序设计 Java 封装、继承、多态
于 2024-04-19 17:29:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/u011278722/article/details/137962289
版权
本文介绍了面向对象编程的基础概念，包括对象、类、封装、继承和多态。通过Vehicle和Bike类的示例，展示了如何在Java中实现抽象类、继承、方法重写和多态性。重点讲解了面向对象设计原则如单一职责原则(SRP)、开闭原则(OCP)、里氏替换原则(LSP)和接口隔离原则(ISP)。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

SHOW ME THE CODE - 面向对象设计系列

Java是一门面向对象语言，Object-Oriented Programing，面向对象编程。今天我们就来带大家了解一下面向对象的一些基本概念，最重要的是SHOW ME THE CODE。

什么是对象

我们先问一下AI 助手：
在这里插入图片描述

Physical Object: In the real world, an object is a thing that you can see or touch. This is the most common meaning of the word. Examples of physical objects include your phone, a chair, a tree (though some might argue a tree is a living thing), a book, or a cloud.

所谓对象，就是你能看得见，或者触摸的一个东西。比如说，手机，椅子，桌子，书，大树，云朵等等。

在编程语言中的对象

在面向对象编程语言中，有两个最基本的概念：对象、类

类

是对一类具有共同特征和行为的事物的抽象描述，这是一个模板或者蓝图，用于创建具有相同特性的对象。 类包含了对象的属性（用来描述对象的特征）和方法（用来定义对象的行为）。

在Java 语言中，类就是一个个我们定义的class，

对象

是类的具体实例，它是根据类的定义创建出来的实体。对象通过方法来操作自身的属性和状态。

类与对象比较

特性类对象
抽象程度抽象具体
存在形式静态动态
属性声明属性存储具体值
方法定义方法调用方法
创建方式通过 class 关键字定义使用 new 关键字创建

类是一个.java文件，通过编译后是一个.class文件，在程序运行时，.class文件会被加载至JVM的方法区（Method Area), 而我们通过new 创建的对象会存放在堆内存区（Heap).

Show Me The Code

我们定义了一个交通工具类：Vehicle.java，它是一个抽象类，我们使用了abstract关键用来标识该类是一个抽象类。

package com.txzq.ood;

public abstract class Vehicle {

	//属性定义，我们使用private关键字，将属性私有化
    private String type;

    private int speed;

    private int payloadCapacity;

    private int maxOccupancy;

    public Vehicle(String type, int speed, int payloadCapacity, int maxOccupancy) {
        this.type = type;
        this.speed = speed;
        this.payloadCapacity = payloadCapacity;
        this.maxOccupancy = maxOccupancy;
    }

	//抽象方法定义
    public abstract String toString();

    //抽象方法定义
    public abstract String transport(String start, String destination);

    public String getType() {
        return type;
    }

    public int getSpeed() {
        return speed;
    }

    public int getpayloadCapacity() {
        return payloadCapacity;
    }   

    public int getMaxOccupancy() {
        return maxOccupancy;
    }
   
}

接着我们定义了一个具体的类：Bike.java, 我们使用了extend关键字，表示继承Vehicle类

package com.txzq.ood;

public class Bike extends Vehicle
{

    public Bike(int speed, int payloadCapacity, int maxOccupancy) {        
        this("Bike", speed, payloadCapacity, maxOccupancy);

    }

    private Bike(String type, int speed, int payloadCapacity, int maxOccupancy) {
        super(type, speed, payloadCapacity, maxOccupancy);        
    }
    
	public String Fold()
	{
		System.out.println("The Bike was folded");
	}

    @Override
    public String transport(String start, String destination) {
        return "Transporting from "+start+" to "+destination+" by "+ this.getType();
    }

    @Override
    public String toString() {
        return "Bike [type=" + this.getType() + ", speed=" + this.getSpeed() + "km/hour, payloadCapacity=" + this.getpayloadCapacity() + "kg, maxOccupancy=" + this.getMaxOccupancy() + " person]";
    }  
}

接下来创建一个入口程序来创建一辆交通工具，来执行运输任务。

package com.txzq.ood;

public class App {
    public static void main(String[] args) {
        
        Vehicle vehicle = new Bike(20, 200, 2);
        System.out.println(vehicle);
        System.out.println(gotoSomeWhere(vehicle, "北京饭店", "天安门广场"));


        vehicle = new Car(200, 500, 5);
        System.out.println(vehicle);
        System.out.println(gotoSomeWhere(vehicle, "北京饭店", "天安门广场"));

    }

	public static String gotoSomeWhere(Vehicle vechile, String start, String end)
    {
        return vechile.transport(start, end);
    }

}

面向对象三大特性

  • 封装（Encapsulation）
  • 继承（Inheritance）
  • 多态（Polymorphism）

封装（Encapsulation）

封装，指的是将数据的表示和操作封装在一起，使得数据的内部结构对外界隐藏。在面向对象编程中，类（Class) 是封装的基本单元。类中包含了属性和方法，封装规定了属性只能通过内部方法修改，而不能直接从外部访问。

从我们上面的例子中，属性都是通过private关键字修饰，不能直接被访问（obj.someAttr），必须通过公共方法来访问obj.getSomeAttr()。

	//属性定义，我们使用private关键字，将属性私有化
    private String type;

    private int speed;

    private int payloadCapacity;

我们在main()方法中创建了一个vehicle对象，但是，我们没有办法直接访问vehicle的私有属性，我们以speed为例，下面的代码片段上第一种访问方式会造成编译出错。

	//我们创建了一个vehicle对象
    Vehicle vehicle = new Bike(20, 200, 2);

	//下面的写法是错误的,在程序编译的时候，下面这一行会报错
	int speed = vehicle.speed;

	//正确的方式是
	int speed = vehicle.getSpeed();
	
    System.out.println(vehicle);

继承（Inheritance）

继承指的是一个类可以从另一个类继承属性和方法，而继承的关系通常通常是“IS-A”的关系，例如，自行车是一种交通工具。在Java中，使用extends关键字来表示继承。

public class Bike extends Vehicle{
	...
	...
	public String Fold()
	{
		System.out.println("The Bike was folded");
	}

	@Override
    public String transport(String start, String destination) {
        return "Transporting from "+start+" to "+destination+" by "+ this.getType();
    }
	...
	...
}

这里需要注意的是，Vehicle是一个抽象类，抽象类中定义了两个抽象方法，所以当Bike继承Vehicle时，需要实现这两个抽象方法。这也是我们常听到的一个概念：Override，重写，也叫方法重写(Method Override)。

使用@Override注解，来实现方法重写。重写时，返回值类型和方法名称，参数要保持一致。

另外，Bike还多了一个独有的行为：Fold()，表示Bike可以被折叠。

多态（Polymorphism）

多态可以表现为多种形式，一种是面向抽象编程，如上面的例子中，
我们通过Vechile来定义对象，而创建对象的时候，可以是new一个Bike，也可以是new一个Car，但不管是Bike还是Car，他们都有transport这个行为。

例子中，gotoSomeWhere方法接收的是Vechile对象，在实际执行时，会根据Vechile的具体类型输出相应的结果。

		Vehicle vehicle = new Bike(20, 200, 2);
                vehicle = new Car(200, 500, 5);
        
        gotoSomeWhere(vehicle, "北京饭店", "天安门广场");

    }

	//接收Vechile类型的对象，实际会调用具体类型的transport方法输出结果。
	public static String gotoSomeWhere(Vehicle vechile, String start, String end)
    {
        return vechile.transport(start, end);
    }

而另一种多态的形式就是方法的重载(Method Overloading)，即方法名是相同的，但参数类型不相同。

class Math
{
	public int add(int a, int b)
	{
		return a + b;
	}

	public double add(double a, double b)
	{
		return a + b;
	}
}

总结

以上就是面向对象中几个最基本且最重要的概念，希望上面的讲解能够帮助大家理解这几个重要的概念。

欢迎关注我的公众号。
TXZQ聊IT技术与架构

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值