Java面向对象概述—类+对象+封装

最新推荐文章于 2022-09-19 09:07:03 发布

7旅病娘

最新推荐文章于 2022-09-19 09:07:03 发布

阅读量493

点赞数

分类专栏： Java编程语言文章标签： java

本文链接：https://blog.csdn.net/Godyanqi/article/details/106500823

版权

Java编程语言专栏收录该内容

50 篇文章 4 订阅

订阅专栏

Java面向对象概述—类+对象+封装

前言
这几天一直奔波在路上，好几天没更新了，见谅见谅！本期来介绍一下Java中的面向对象编程思想，如果有哪些错误的观点，还请路过的大佬不吝赐教。感激不尽！

在程序开发的初期人们使用结构化开发语言，但是后来随着软件的开发规模越来越庞大，结构化语言的弊端也就逐渐的暴露出来。比如开发的时间大幅的延长，产品的质量也开始渐渐的不尽人意，结构化语言已经不再适合当前的软件开发。这时人们开始讲另一种开发思想引入到程序中来，即面向对象开发思想。

面向对象思想是人类最自然的一种思考方式，它将所有预处理的问题抽象为对象，同时了解这些对象具有哪些相应的属性和展示这些对象的行为以解决一些面临的实际问题。面向对象设计实质上就是对现实世界的对象进行建模的操作。

比如世界是由不同类别的事物组成的，有不同的颜色，不同的外形等等。这个问题本身就很抽象，可以说是“物以类聚”。比如当我们聊天的时候聊到咖啡就会在脑海中呈现出咖啡的形象，这些现实世界中客观存在的东西就是对象。可以这样理解。

一、面向对象的优点

首先，面向对象的优点就是与人类的思维习惯高度相似，面向对象的思想从人类考虑问题的角度出发，把人类解决实际问题的思维方式转变为程序开发的思想，变成使程序能够理解的过程。面向对象的程序设计思想能够让我们使用“类”的概念来模拟现实世界中的抽象概念，用“对象”来模拟现实世界中的实体，从而用计算机解决实际的问题。
信息隐藏。面向对象编程思想的引入，大大的提高的程序的可维护性和安全性；利用封装实现了模块化和信息的隐藏，即将类的属性和方法封装在类中，这保证了对他们的修改不会影响到其他对象，这样对程序的维护而言是一件极好的事。同时封装使得在对象外部不能随意访问对象的属性和方法，很好的避免了外部错误对它的影响，这样有效的提高了安全性。
提高了程序的可用性；一个类可以创建多个对象实例，增加了重用性。

二、万物皆对象

2.1什么是对象

在现实世界中，随处可见的东西都是对象，比如一本书，一个Mp3，或者一辆汽车、一项计划都可以被看做是对象。在Java的世界中，“万物皆对象”。

人类解决问题的方式总是习惯性的将复杂的问题简单化，接着就会有思考这些对象都是由什么组成的，比如原子是由原子核和核外电子组成。人们将对象划分为“静态”和“动态”两部分，静态部分顾名思义就是不能动的部分，这部分被称之为“属性”，任何对象都会都会具备其自身的属性。然而具有这些属性的动作也是一个很值得探讨的部分，这部分就被称之为动态部分。我们可以通过探讨对象的属性和行为了解对象。在程序世界中，面向对象的程序设计思想要以独享来思考问题。首先要将现实世界中的实体抽象为对象，然后再考虑它所具备的属性和行为。

Java是一种面向对象的编程语言（Object Oriented Programming Language OOPL），因此在程序的开发中我们需要学会并使用面向对象的思想来考虑实际问题并编写程序。在面向对象中，对象是用来描述一个客观事物的实体，用面向对象的方法解决问题时，首先要对现实世界中的对象进行归纳，找出与要解决的问题相关的。每一个对象都有自己的特征，其中包括静态特征和动态特征。静态特征就是可以用某些数据的来描述的特征，比如一个学生的姓名、身高、体重等等。动态特征就表现在对象的行为或者能力，比如跑，跳，唱歌，画画等等。

对象	静态特征	静态特征的值	动态特征
学生	姓名	爱编程	学习
·	身高	180cm	唱歌
老师	姓名	教编程	读书
·	年龄	35	讲课

2.2对象的属性和方法

在面向对象的编程思想中，把对象的静态特征和动态特征分别称为对象的属性和方法，他们是构成对象的两个主要因素。正是因为对象有了属性和方法才使他们变得与众不同。其中属性就是用来描述对象静态特征的一个数据项，这个数据项的值就是属性值。而方法是用来描述对象的动态特征（即行为）的一个动作序列。

在开发过程中，对象的属性被存储在一些变量里（插播一条广告：变量的相关内容在我已经发布的可以找得到：Java中的变量，你知道多少），对象的行为则可以通过定义方法来实现。

三、类

3.1什么是类

类就是同一类事物的同层。如果将现实世界中的一个事物抽象成对象，类就是这类对象的统称。如人类、鸟类、花类。类是构造对象时所依赖的规范，那种具有相同特性和行为的一类事物就称为类。类的思想就是这样产生的是世间事物抽象的称呼而对象则是这个事物相对应的实体。在实际开发遇到的问题中通常需要实例化类对象来解决。

在Java语言中，类中独享的行为是以方法的形式定义的，而类包括对象的属性和方法。类的具体实现后续会更新。

3.2类和对象的关系

类与对象的关系就如同模具和实物之间的关系，一个类为它的全部对象给出了一个统一的定义，而类中的每一个对象都是符合它这种定义的实体。因此类和对象的关系就是抽象和具体的关系。类是多个对象进行综合抽象的结果，就是实体对象的概念模型，而一个对象是一个类的实例。
用一组图来大概解释一下其中的关系：安排上！！！

在这里插入图片描述
类创建的一个实例就是“对象”，它和“现实世界”中的实体是一一对应的。可以这样来理解。

3.3类是对象的类型

Java中有很多的数据类型（插播一条广告：在我之前更新的文章里有关于数据类型的知识点：Java中的数据类型，传说中的四类八种），这些都是Java定义好的数据类型，实际开发过程中只需要用这些数据类型直接声明变量即可。事实上定义类就是抽取同类实体的共性自定义的一种数据类型。比如：人类、鸟类等等。

3.4Java的类模板

Java中的类将现实世界中的概念模拟到计算机中，因此需要在类中描述类所具有的属性和方法。

Java中的类模板如下所示：
语法：

public class <类名>{
	//定义属性部分
	属性1的类型 属性1；
	.....
	属性n的类型 属性n；

	//定义方法部分
	方法1；
	......
	方法n；
}

其中class是创建类的关键字，public表示公有的意思。开发程序时要遵循编码规范，遵守相的编码规则。

不能使用Java关键字
不能包含任何嵌入的空格或者除下划线和美元符号以外的特殊字符
不能以数字开头
类名通常由多个单词组成，单词首字母大写
类名应该简洁有意义，尽量使用完整单词，避免使用缩写，除非该缩写词已经被广泛使用

3.5如何定义类

类定义了对象将会拥有的属性和方法。具体步骤如下：
1.定义类名
通过定义类名来得到最外层的框架
语法：

public class 类名{
	//代码块
}

2.编写类的属性
通过在类的主体中定义变量来描述所具有的静态特征（属性），这些变量称为类的成员变量。
3.编写类的方法
通过在类的主体中定义方法来描述类所具有的行为，这些方法称为类的成员方法。
方法框架：

访问修饰符 返回值类型 方法名(){
//代码块
}

代码示例：
定义一个School类，定义三个成员变量，定义一个显示信息的方法
建议使用骆驼(Camel)命名法和帕斯卡（Pascal）命名法来命名

public class School {       //声明类
    String schoolName;      //定义String类型的变量schoolName  学校名称
    int classNumber;        //定义int类型的变量classNumber    教室数目
    int labNumber;          //定义int类型的变量labNumber       机房数目

    public void showStudent(){  //方法
        System.out.println(schoolName + "学校\n"
                + "教室数目：" + classNumber
                + "机房数目：" + labNumber);
    }
}

3.6如何创建对象

类的作用就是创建对象，由类生成对象称为类的实例化过程，一个实例也就是一个对象，一个类可以生成多个对象。
语法：

类名 对象名 = new 类名();

创建类的对象时候，需要使用Java的new关键字。
例如：创建School类的学生对象

School student = new School();

student对象类型就是School类型。使用new关键字创建对象时，并没有给它的数据成员赋值。那是因为考虑到每个对象的属性值可能不一样，所以在创建对象后再给它的数据成员赋值。
在Java中，要引用对象的属性和方法，需要使用“.”操作符号。对象名在左面，属性和方法名称在点的右面。

语法：

对象名.属性			//引用对象的属性
对象名.方法名		//引用对象的方法

安排上一段代码感受一下：

public class TestSchool {           //创建类
    public static void main(String[] args) {        //主方法
        School student = new School();          //创建对象
        System.out.println("初始化成员变量前：");    //提示信息
        student.showStudent();  //调用showStudent方法
        //给属性赋值
        student.schoolName = "某某";      
        student.classNumber = 10;
        student.labNumber = 15;

        System.out.println("初始化成员变量后：");    //提示信息
        student.showStudent();      //调用showStudent方法
    }
}

运行结果：
在这里插入图片描述

四、封装

4.1什么是封装

封装是面向对象编程的核心思想，也是面向对象三大特性之一，将对象的属性和行为封装起来，其载体就是类，类通常会对用户隐藏实现细节，这就是封装的思想。例如：我们在打游戏时，只需要敲键盘点鼠标就可以获得游戏体验，实现使用游戏中的相关功能，无需知道计算机内部是如何工作的。即使可能知道它的工作原理，但是在打游戏的过程中也不完全依赖于计算机工作原理这些细节性的问题。

采用封装的思想保证了类内部数据结构的完整性，应用该类的用户不能轻易地直接操作此数据结构，只能执行类允许的公开的数据。这样的方法很好的避免了外部操作对内部数据的影响，极大的提高了程序的可维护性。

下面用一组图来展示一下使用类实现封装特性：
在这里插入图片描述

4.2封装的特点

封装：

面向对象的三大特性之一，将类的状态信息隐藏在类内部，不允许外部程序直接访问，而通过该类提供的方法来实现对隐藏信息的操作和访问。

封装的具体步骤：

修改属性的可见性来限制对属性的访问；为每一个属性创建一对赋值（setter）方法和取值（getter）方法，用于对这些属性的存取；在赋值方法中，加入对属性的存取控制属性。

封装的好处：

隐藏类的内部细节，让使用者只能能通过程序规定的方法来访问数据；可以方便的加入存取控制语句，限制不合理操作。

封装时会用到多个权限控制符号来修饰成员变量和方法，区别如下：

private：成员变量和方法只能在其被定义的类内访问，具有类可见性。
默认：成员变量和成员方法只能被同在一个包的类访问，具有包可见性。
protected：可以被同一个包中的类访问，被同一个项目中的不同包的子类访问。
public：可以被同一个项目中的所有类访问，具有项目可见性，这是最大的访问权限。

代码示例：
创建学生类：

/**
 * 学生类  使用权限修饰符private和public进行封装
 */
class Student {             //创建学生类
    private String name = "神秘人";            //学生姓名
    private int age = 18;                       //学生年龄
    private int height = 180;                   //身高
    private String sex = "一名英俊潇洒的程序员";                  //性别

    /**
     * 读取学生姓名
     * @return  姓名
     */
    public String getName() {           //get方法
        return name;
    }

    /**
     * 指定学生姓名
     * @param name 姓名
     */
    public void setName(String name) {      //set方法
        this.name = name;
    }

    /**
     * 读取学生年龄
     * @return  年龄
     */
    public int getAge() {
        return age;
    }

    /**
     * 指定学生年龄
     * @param age   年龄
     */
    public void setAge(int age) {
        if (age > 10 || age < 35) {
            this.age = 18;
        }else{
            this.age = age;
        }
    }

    /**
     * 读取学生身高
     * @return  身高
     */
    public int getHeight() {
        return height;
    }

    /**
     * 指定学生身高
     * @param height        身高
     */
    public void setHeight(int height) {
        this.height = height;
    }

    /**
     * 读取学生性别
     * @return      性别
     */
    public String getSex() {
        return sex;
    }

    /**
     * 指定学生性别
     * @param sex
     */
    public void setSex(String sex) {
        this.sex = sex;
    }

    /**
     * 输出学生信息
     */
    public void print(){
        System.out.println("学生的自我介绍：\n 姓名：" + this.name
                + "\t年龄：" + this.age + "\t身高：" + this.height +  "\t我是" + this.sex);
    }
}

测试学生类：

/**
 * 测试学生类的封装
 */
public class StudentTest {      //创建测试类
    public static void main(String[] args) {    //主方法
        Student boyStudent = new Student();         //创建对象
        boyStudent.setName("爱编程");              //调用setName方法
        boyStudent.print();                         //调用print方法
    }
}

运行结果：
在这里插入图片描述

4.3 this关键字

上述代码中应用到了this关键字，在这里一起了解一下它的含义和用法

this关键字是对一个对象的默认引用，都有一个this引用变量，指向调用的这个方法的对象。

this关键字应用举例：

this调用成员变量，解决成员变量和局部变量的同名冲突

public void setName(String name){
this.name = name;	//成员变量和局部变量同名，必须使用this
}
public void setName(String xm){
name = xm;			//成员变量和局部变量不同命，this可以省略
}

使用this调用成员方法：

public void play(int n){
	money = money - somemoney;
	this.print();
}

使用this调用重载的构造方法，只能在构造方法中使用，必须是构造方法的第一条语句。

public Student(String name,String sex){
	this.name = name;
	this.sex = sex;
}
public Student(String name, int age ,int height, String sex){
	this(name,sex);		//调用重载的构造方法
	this.age = age;
	this.height = height;
}

注意：
因为this在对象内部指代自身的引用，所以this只能调用实例变量、实例方法和构造方法。
this不能调用类变量和类方法，也不能调用局部变量。

迟来漫长时间的更新！
关注我，持续更新！！！

7旅病娘

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
打赏
0
评论
Java面向对象概述—类+对象+封装

前言一、面向对象的优点二、万物皆对象2.1什么是对象2.2对象的属性和方法三、类3.1什么是类3.2类和对象的关系3.3类是对象的类型3.4Java的类模板3.5如何定义类3.6如何创建对象四、封装4.1什么是封装4.2封装的特点4.3this关键字
复制链接

扫一扫