前言

  上一篇文章给大家介绍了在java中，通过idea中的DeBug工具来调试我们的程序。并且通过九个经典的问题供大家练习我们之前学的java基础知识，之后在介绍判断两个数组相同案例的时候给大家留了两个问题供大家思考。最后通过思维导图帮助大家回顾整篇文章介绍的相关知识，慢慢地培养读者java的整体架构，让读者将java的基础知识融会贯通，各个知识点之间可以相互调用。本文给大家介绍面向对象的相关知识。相信大家在大学的时候一定都学过C语言，我们的C语言就是面向过程的，而我们现在的Java语言就是典型的面向对象的编程语言。首先给大家介绍面向过程与面向对象的区别

一、面向过程VS.面向对象

  首先 ​​面向对象​​​ (Object Oriented,OO) 的思想对软件开发相当重要，它的概念和应用甚至已超越了程序设计和软件开发，扩展到如数据库系统、交互式界面、应用结构、应用平台、分布式系统、网络管理结构、CAD 技术、人工智能等领域。面向对象是一种 对现实世界理解和抽象的方法，是计算机编程技术发展到一定阶段后的产物。而 ​​面向过程​​ (Procedure Oriented) 是一种 以过程为中心 的编程思想。这些都是以什么正在发生为主要目标进行编程，不同于面向对象的是谁在受影响。与面向对象明显的不同就是 封装、继承、类。

  其次是编程思想以及各自的优势不同：

  面向过程：是一种以过程为中心的编程思想。都是以什么正在发生为主要目标进行编程。其特点为就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。不支持丰富的“面向对象”特性（比如继承、多态），并且不允许混合持久化状态和域逻辑。

   面向对象：是一类以对象作为基本程序结构单位的程序设计语言，指用于描述的设计是以对象为核心，而对象是程序运行时刻的基本成分。是把构成问题事务分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。在内部被表示为一个指向一组属性的指针。任何对这个对象的操作都会经过这个指针操作对象的属性和方法。

二、类和对象

1、类和对象的理解

类，顾名思义，即为客观存在的事物皆为对象 ，所以我们也常常说万物皆对象。在java中，类是对现实生活中一类具有共同属性和行为的事物的抽象。类是对象的数据类型，类是具有相同属性和行为的一组对象的集合。其实也可以将其简单的理解为类就是对现实事物的一种描述。
  类的组成包括属性(指事物的特征，例如：手机事物（品牌，价格，尺寸）)以及行为（指事物能执行的操作，例如：手机事物（打电话，发短信））。

  类与对象的关系为：类是对现实生活中一类具有共同属性和行为的事物的抽象，而对象是能够看得到摸的着的真实存在的实体，当然，也可以简单的理解为类是对事物的一种描述，对象则为具体存在的事物。

2、类的定义

  前面我们也介绍了，类是由属性和行为两部分组成的。当然属性(​​类中方法外的变量​​)在类中通过成员变量(​​和前面的方法相比去掉static关键字即可​​)来体现，而行为是在类中通过成员方法来体现。接下来我们介绍定义一个类的详细步骤：

• ①、定义类
• ②、编写类的成员变量
• ③、编写类的成员方法

  具体的格式如下：

public class 类名 {
  // 成员变量
  变量1的数据类型 变量1；
  变量2的数据类型 变量2;
  …
  // 成员方法
  方法1;
  方法2;  
}

  相应的示例如下：

public class Phone {
    //成员变量
    String brand;
    int price;

    //成员方法
    public void call() {
        System.out.println("打电话");
    }

    public void sendMessage() {
        System.out.println("发短信");
    }
}

  这里需要我们注意的是：类定义之后我们是无法直接运行的，这点还请大家特别注意。我们定义好类之后就是通过对象对我们定义好的类进行使用了。

3、对象的使用

  创建对象的格式：​​类名 对象名 = new 类名();​​调用成员的格式：​​对象名.成员变量、对象名.成员方法();​​具体调用的示例如下：

public class PhoneDemo {
    public static void main(String[] args) {
        //创建对象
        Phone p = new Phone();

        //使用成员变量
        System.out.println(p.brand);
        System.out.println(p.price);

        p.brand = "小米";
        p.price = 2999;

        System.out.println(p.brand);
        System.out.println(p.price);

        //使用成员方法
        p.call();
        p.sendMessage();
    }
}

  具体我们运行的结果如下：

  以上就是对我们定义好的类进行使用的一个过程，从上面示例可以得出：我们只有在对象使用的时候才可以运行出我们想要的结果，这点还需要我们特别掌握。

4、综合案例

  我们为了让大家更好的巩固该知识点，再通过一个相对综合的小案例帮助大家理解，具体需求如下：

  首先定义一个学生类，然后定义一个学生测试类，在学生测试类中通过对象完成成员变量和成员方法的使用

  首先我们定义一个​​Student类​​，然后里面主要包括的成员变量：姓名，年龄…；而成员方法包括学习，做作业…。最后我们定义一个​​StudentDemo类​​进行相应的测试。

  根据其分析我们首先创建Student的类，具体实现如下：

/*
    学生类
 */
public class Student {
    //成员变量
    String name;
    int age;

    //成员方法
    public void study() {
        System.out.println("好好学习，天天向上");
    }

    public void doHomework() {
        System.out.println("键盘敲烂，月薪过万");
    }
}

  然后我们创建相应的测试类，具体实现如下：

public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();

        //使用对象
        System.out.println(s.name + "," + s.age);

        s.name = "林青霞";
        s.age = 30;

        System.out.println(s.name + "," + s.age);

        s.study();
        s.doHomework();
    }
}

  具体的执行结果如下：

三、对象内存图

  在介绍对象内存图之前首先给出测试用例，我们的学生类用java实现如下：

/*
    学生类
 */
public class Student {
    //成员变量
    String name;
    int age;

    //成员方法
    public void study() {
        System.out.println("好好学习");
    }

    public void doHomework() {
        System.out.println("多做练习");
    }
}

  首先我们分析单个对象的内存调用情况，其测试类代码用实现如下；

/*
    单个对象
 */
public class StudentTest01 {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();
        System.out.println(s);

        //使用成员变量
        System.out.println(s.name + "," + s.age);

        s.name = "张曼玉";
        s.age = 28;

        System.out.println(s.name + "," + s.age);

        //使用成员方法
        s.study();
        s.doHomework();
    }
}

  其执行结果如下：

  接着我们通过一张图来理解成员变量使用过程：

  成员方法调用过程如下：

  接着我们分析的是多个对象内存图，同样给出其测试代码，具体实现如下：

/*
    多个对象
 */
public class StudentTest02 {
    public static void main(String[] args) {
        //创建第一个对象并使用
        Student s1 = new Student();

        s1.name = "林青霞";
        s1.age = 30;
        System.out.println(s1.name + "," + s1.age);

        s1.study();
        s1.doHomework();

        //创建第二个对象并使用
        Student s2 = new Student();

        s2.name = "张曼玉";
        s2.age = 28;
        System.out.println(s2.name + "," + s2.age);

        s2.study();
        s2.doHomework();
    }
}

  其具体执行结果如下：

接着我们针对其结果分析其成员变量使用过程，具体如下图所示：

同理，其成员方法调用过程如下图所示：

  通过上述分析：多个对象在堆内存中，都有不同的内存划分，成员变量存储在各自的内存区域中，成员方法多个对象共用的一份。

  最后我们分析多个对象指向相同内存图，首先给出其测试代码，实现如下：

/*
    多个对象指向相同
 */
public class StudentTest03 {
    public static void main(String[] args) {
        //创建第一个对象并使用
        Student s1 = new Student();

        s1.name = "林青霞";
        s1.age = 30;
        System.out.println(s1.name + "," + s1.age);

        //把第一个对象的地址赋值给第二个对象
        Student s2 = s1;

        s2.name = "张曼玉";
        s2.age = 28;
        System.out.println(s1.name + "," + s1.age);
        System.out.println(s2.name + "," + s2.age);
    }
}

  具体执行结果如下：

接着我们分析其多个对象指向相同内存原理，具体如下图所示：

  由此分析可得：当多个对象的引用指向同一个内存空间（变量所记录的地址值是一样的）；只要有任何一个对象修改了内存中的数据，随后，无论使用哪一个对象进行数据获取，都是修改后的数据。

四、成员变量和局部变量

  接下来我们大致介绍一下成员变量和局部之间的区别：

- 类中位置不同：成员变量（类中方法外）局部变量（方法内部或方法声明上）。

- 内存中位置不同：成员变量（堆内存）局部变量（栈内存）。

- 生命周期不同：成员变量（随着对象的存在而存在，随着对象的消失而消失）局部变量（随着方法的调用而存在，醉着方法的调用完毕而消失）。

- 初始化值不同：成员变量（有默认初始化值）局部变量（没有默认初始化值，必须先定义，赋值才能使用）。

  我们在写代码的时候一定会用到变量，这个时候，我们就得分清楚什么时候用全局变量，什么时候用局部变量了，这一点至关重要，还希望大家一定要掌握。

五、封装

1、​​private​​关键字

  private是一个修饰符，可以用来修饰成员（成员变量，成员方法）。另外，被private修饰的成员，只能在本类进行访问，针对private修饰的成员变量，如果需要被其他类使用，提供相应的操作：

  提供“get变量名()”方法，用于获取成员变量的值，方法用public修饰

  提供“set变量名(参数)”方法，用于设置成员变量的值，方法用public修饰

  我们首先给大家实现​​Student​​类，具体实现如下：

/*
    学生类
 */
public class Student {
    //成员变量
    String name;
//    int age;
    private int age;

    //提供get/set方法
    public void setAge(int a) {
//        age = a;

        if(a<0 || a>120) {
            System.out.println("你给的年龄有误");
        } else {
            age = a;
        }
    }

    public int getAge() {
        return age;
    }

    //成员方法
    public void show() {
        System.out.println(name + "," + age);
    }
}

  接下来，我们实现​​StudentDemo​​的测试类，具体实现如下：

/*
    学生测试类
 */
public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();

        //给成员变量赋值
        s.name = "林青霞";
//        s.age = 30;
//        s.age = -30;
        s.setAge(30);
//        s.setAge(-30);

        //调用show方法
        s.show();
    }
}

  具体执行的结果如下：

  为了我们更好的使用private关键字，给大家一个稍微综合的案例，以下是具体的需求：

  需求：定义标准的学生类，要求name和age使用private修饰，并提供set和get方法以及便于显示数据的show方法，测试类中创建对象并使用，最终控制台输出 林青霞，30

  我们首先实现该​​Student​​类，具体实现如下：

/*
    学生类
 */
public class Student {
    //成员变量
    private String name;
    private int age;

    //get/set方法
    public void setName(String n) {
        name = n;
    }

    public String getName() {
        return name;
    }

    public void setAge(int a) {
        age = a;
    }

    public int getAge() {
        return age;
    }

    public void show() {
        System.out.println(name + "," + age);
    }
}

  接下来，我们实现​​StudentDemo​​类，具体实现如下：

/*
    学生测试类
 */
public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();

        //使用set方法给成员变量赋值
        s.setName("林青霞");
        s.setAge(30);

        s.show();

        //使用get方法获取成员变量的值
        System.out.println(s.getName() + "---" + s.getAge());
        System.out.println(s.getName() + "," + s.getAge());

    }
}

  具体执行的结果如下：

2、​​this​​关键字

  this修饰的变量用于指代成员变量，其主要作用是（区分局部变量和成员变量的重名问题）；方法的形参如果与成员变量同名，不带this修饰的变量指的是形参，而不是成员变量。方法的形参没有与成员变量同名，不带this修饰的变量指的是成员变量。我们用一个实例加以说明；还是我们首先给出​​Student​​类，具体实现如下：

/*
    学生类
 */
public class Student {
    private String name;
    private int age;

//    public void setName(String n) {
//        name = n;
//    }

    public void setName(String name) {
//        name = name;
        this.name = name;
    }

    public String getName() {
        return name;
    }

//    public void setAge(int a) {
//        age = a;
//    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    public void show() {
        System.out.println(name + "," + age);
    }
}

  接着我们对其通过​​StudentDemo​​类进行测试，具体测试代码实现如下：

/*
    学生测试类
 */
public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();

        //使用set方法给成员变量赋值
        s.setName("林青霞");
        s.setAge(30);

        //调用show方法
        s.show();
    }
}

  具体的实现结果如下：

  接下来，我们给大家解释this的相关原理。this代表当前调用方法的引用，哪个对象调用的方法，this就代表哪一个对象。测试的代码如下：

public class StudentDemo {
    public static void main(String[] args) {
        Student s1 = new Student();
        s1.setName("林青霞");
        Student s2 = new Student();
        s2.setName("张曼玉");
    }
}

  具体该代码的内在执行如下图所示：

  封装是面向对象三大特征之一（封装，继承，多态）；是面向对象编程语言对客观世界的模拟，客观世界里成员变量都是隐藏在对象内部的，外界是无法直接操作的。封装的原则：将类的某些信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问；成员变量private，提供对应的getXxx()/setXxx()方法。封装可以让我们通过方法来控制成员变量的操作，提高了代码的安全性，另外把代码用方法进行封装，提高了代码的复用性。我们在之后的代码应用中经常会使用封装这一功能的，从而提高我们代码的复用性。

六、构造方法

  构造方法是一种特殊的方法。​​Student stu = new Student();​​具体的格式如下：

public class 类名{

​        修饰符 类名( 参数 ) {
​        }
}

  我们通过一个案例来说明构造方法的详细实现过程，具体的需求如下：

   需求：主要是完成对象数据的初始化

  首先我们还是定义一个​​Student​​类来实现其主要功能，具体代码如下：

public class Student {
    private String name;
    private int age;

    //构造方法
    public Student() {
        System.out.println("无参构造方法");
    }

    public void show() {
        System.out.println(name + "," + age);
    }
}

  接下来，我们通过编写测试代码来测试该功能的实现：

public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();
        s.show();
    }
}

  具体执行结果如下：

  在构造方法的时候我们需要注意如下的事项：

  构造方法的创建：如果没有定义构造方法，系统将给出一个默认的无参数构造方法；如果定义了构造方法，系统将不再提供默认的构造方法。

  构造方法的重载：如果自定义了带参构造方法，还要使用无参数构造方法，就必须再写一个无参数构造方法。

  推荐的使用方式：无论是否使用，都手工书写无参数构造方法。

  重要功能：可以使用带参构造，为成员变量进行初始化。

  具体的我们通过一个小案例来对其进行说明，我们还是前面使用多次的​​Student​​类：

/*
    学生类
 */
public class Student {
    private String name;
    private int age;

//    public Student() {
//        System.out.println("无参构造方法");
//    }

    public Student() {}

    public Student(String name) {
        this.name = name;
    }

    public Student(int age) {
        this.age = age;
    }

    public Student(String name,int age) {
        this.name = name;
        this.age = age;
    }

    public void show() {
        System.out.println(name + "," + age);
    }
}

  我们编写其测试类进行测试：

/*
    测试类
 */
public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s1 = new Student();
        s1.show();

        //public Student(String name)
        Student s2 = new Student("林青霞");
        s2.show();

        //public Student(int age)
        Student s3 = new Student(30);
        s3.show();

        //public Student(String name,int age)
        Student s4 = new Student("林青霞",30);
        s4.show();
    }
}

  具体执行结果如下：

  为了让大家更好的掌握构造类的相关用法，我们再给出一个案例，方便大家巩固；具体需求如下：

  定义标准学生类，要求分别使用空参和有参构造方法创建对象，空参创建的对象通过setXxx赋值，有参创建的对象直接赋值，并通过show方法展示数据。

  具体用代码实现如下：

public class Student {
    //成员变量
    private String name;
    private int age;

    //构造方法
    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    //成员方法
    public void setName(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    public void show() {
        System.out.println(name + "," + age);
    }
}

  接下来通过测试类测试其功能实现：

public class StudentDemo {
    public static void main(String[] args) {
        //无参构造方法创建对象后使用setXxx()赋值
        Student s1 = new Student();
        s1.setName("林青霞");
        s1.setAge(30);
        s1.show();

        //使用带参构造方法直接创建带有属性值的对象
        Student s2 = new Student("林青霞",30);
        s2.show();
    }
}

  具体执行结果如下：

七、知识汇总

  文章最后，我们将本文介绍的所有知识点通过xmind做一个总结；具体知识点总结如下：

总结

  上一篇文章给大家介绍了在java中，通过idea中的DeBug工具来调试我们的程序。并且通过九个经典的问题供大家练习我们之前学的java基础知识，之后在介绍判断两个数组相同案例的时候给大家留了两个问题供大家思考。最后通过思维导图帮助大家回顾整篇文章介绍的相关知识。本文给大家介绍面向对象的相关知识，主要包括面向对象和面向过程的区别以及类和对象、分析了对象内存图以及成员变量和局部变量。最后介绍了封装以及构造方法的相关知识，并且每个知识点给出了相应的案例，最后通过一张思维导图总结其相应的知识点。现在的java发展的如火如荼，在开发这块占据着举足轻重的地位。因此，作为计算机行业的一名开发人员，学习java是很有必要的。让我们一起在java的海洋里遨游吧！！！生命不息，奋斗不止，我们每天努力，好好学习，不断提高自己的能力，相信自己一定会学有所获。正如经典所说：“人不负青山，青山定不负人。”让我们一起向未来！加油！！！

参考文献

​​1].[关于面向对象和面向过程本质的区别（个人感悟）​​

​​2].[如何通俗易懂地举例说明「面向对象」和「面向过程」有什么区别？​​