毕25第一天-面向对象

• 面向对象与面向过程的区别

面向过程就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了。

面向对象是把构成问题的事物分解成各个对象，建立对象的目的不是为了完成一个步骤，而是为了描叙某个事物在整个解决问题的步骤中的行为。

直观的例子：人开门。

面向过程思想：1、打开门；2、关闭门。

面向对象思想：将人和门分为两个对象，每个对象有不同的方法，注意虽然是人开门，但是门开或关是门的行为，所以门这个对象有门开和门关得方法，人这个对象可以调用门得门开方法。

可以将面向过程比作事情的执行者，面向对象比作事情的指挥者。

比如我要去买早餐，我要和店家说来一份油条和豆浆，使用面向对象的我只需要指挥店家，点餐即可，而不需要知道油条与豆浆的具体制作过程。

• 类与对象

类是对现实生活中事物的描述。

对象就是这类事物，是实实在在存在的个体。

比如定义一个person类：

class Person
{
    String name;    //人的姓名
    int age;    //人的年龄
    void info()
    {
        System.out.println(name+","+age);
    }
}

在人这个类中的各种属性就是对现实中人的描述；

构建一个该类的对象p：Person p = new Person();

则该对象就是Person类实实在在存在的个体。具体对象是Java在堆内存中用new建立的实体。

• 成员变量与局部变量

作用范围：

成员变量作用于整个类中；局部变量作用于函数的作用域中。

在内存中的位置：

成员变量在对堆内存中，使用new构建了一个类对象，堆中便有了成员变量；局部变量存在于栈内存中。

• 匿名对象的应用

不使用类类型变量保存new出来的对象，直接new一个对象，如new Person();

例如下列语句：

new Person().name = "zhangsan";
new Person().age = 19;
new Person().info();

这里都没有使用一个类类型变量来存储new出来的新对象；

第一行语句执行完了在堆内存中new了一个对象name为zhangsan，age为0（默认初始化）；

第二行语句执行完了在堆内存中又new了一个对象name为null（默认初始化），age为19；

第三行语句执行完了在堆内存中又new了一个对象name为null（默认初始化），age为0（默认初始化）；

匿名对象使用方式：

一：当对对象的方法只调用一次时，可以使用匿名对象来完成，这样比较比较简化，但是如果对一个对象进行多次成员调用，就必须给该对象起个名字。

二：可以将匿名对象作为实际参数传递。

• 封装

封装是指隐藏对象的属性和实现细节，仅对外提供公共访问方式。

将属性私有化是封装的一种方式，例如将name和age属性设为private，另外为这两个属性设置public的getter和setter方法，就可以实现在setter方法中对属性设置加上一些逻辑条件来保证属性的合理性。

• 构造函数

特点：1、函数名与类名相同；2、不用定义返回值类型；3、不可以写return语句。

作用：给对象进行初始化。

注意：1、当一个类没有定义构造函数时，有默认的构造函数，如 Person(){}; ，当一个类定义了构造函数时，默认的构造函数就不存在了；2、多个构造函数是以重载的形式存在的；3、对象一构建就会调用与之对应的构造函数。

如Person类中可以定义如下构造函数：

class Person
{
    String name;
    int age;
    Person(){}    //默认构造函数
    Person(String n)
    {
        name = n;
    }
    Person(String n,int a)
    {
        name = n;
        age = a;
    }
}

在main函数中便可调用这些构造函数，根据传入的不同参数，选择不同的构造函数。

构建一个对象，构造函数只运行一次。

• 构造代码块

Person类中可能会出现这样的语句：

{
    System.out.println("I am a Person!");
}

这样的语句叫构造代码块，作用是给对象进行初始化，对象一构建就运行，而且优先于构造函数执行。

与构造函数的区别：

构造代码块是给所有对象进行统一的初始化，定义的是不同对象共性的初始化内容；而构造函数是给对应的对象初始化。

• this关键字

class Person
{
    String name;
    int age;
    Person(){}    //默认构造函数
    Person(String name)
    {
        name = name;
    }
    
    /*
    Person(String n,int a)
    {
        name = n;
        age = a;
    }
    */
}

 在之前的Person的定义中，构造函数为Person(String n)，这样的参数意思不明确，可以把他换为name，但是与此同时，原类别中也有name属性，两者重复了，这样调用Person("zhangsan")之后，name仍然为null；因此可以使用this关键字来区别属性name与参数name，修改如下：

class Person
{
    String name;
    int age;
    Person(){}    //默认构造函数
    Person(String name)
    {
        this.name = name;
    }
    public String getname()
    {
        return name;
    }
}

在main方法中构建一个新的Person类时，如下操作：

Person p = new Person("zhangsan");
System.out.println(p.getname());

便可以输出zhangsan，这是因为调用构造函数得到的对象是p，this.name相当于p.name，等同于p.name=name;（对象的属性=传入构造函数的参数）。哪个对象在调用this所在的函数，this就代表哪个对象。

• this关键字的应用

接下来写一个比较两个Person年龄的方法：

class Person
{
    String name;
    int age;
    Person(int age)
    {
        this.age= age;
    }
    public boolean compare(Person p)
    {
        return this.age==p.age;
    }
}

public class PersonTest
{
    public static void main(String[] args)
    {
        Person p1 = new Person(15);
        Person p2 = new Person(20);
        boolean b = p1.compare(p2);
        System.out.println(b);
    }
}

新构建了两个Person，一个15岁，一个20岁，并且写好了compare()方法用来比较；

使用了p1.compare(p2)之后，调用了Person中的compare()方法，这是this.age相当于p1.age，p.age相当于p2.age，这是由于compare方法是p1调用的，故this指的是p1，p2是作为参数传进去的，故p指的是p2。

• this关键字在构造函数间调用

class Person
{
    String name;
    int age;
    Person(int age)
    {
        this.age= age;
    }
    Person(int age,String name)
    {
        this(age);    //this用于构造函数之间相互调用
        this.name = name;
    }
}

public class PersonTest
{
    public static void main(String[] args)
    {
        Person p1 = new Person(15,"zhangsan");
    }
}

使用语句this(参数)，来在构造函数之间进行调用。