1、类、封装

类与对象

对象在需求中的使用

​ 对面向对象有了了解之后，我们来说说在具体问题中如何使用面向对象去分析问题，和如何使用面向对象。

​ 我们把大象装冰箱为例进行分析。

​ 在针对具体的需求，可以使用名词提炼的办法进行分析，寻找具体的对象。

​ 需求：把大象装冰箱里

​ 对象：大象、冰箱

​ 分三步：

​ 1、打开冰箱门

​ 2、将大象装进去

​ 3、关闭冰箱门

分析发现打开、装、关闭都是冰箱的功能。即冰箱对象具备如下功能：

​ 冰箱打开

​ 冰箱存储

​ 冰箱关闭

用伪代码描述，上述需求中有两个具体的事物 大象 和 冰箱

描述大象：

class 大象{}

描述冰箱

class冰箱
{
    void 打开(){}
    void 存储(大象){}
    void 关闭(){}
}

​ 当把具体的事物描述清楚之后，需要使用这些具体的事物，java使用具体的事物，需要通过new关键字来创建这个事物的具体实例。

使用对象：

​ 1、创建冰箱的对象

​ 冰箱 bx = new 冰箱();

​ 2、调用冰箱的功能

​ 对象.功能()；

​ bx.打开();

​ bx.存储(new 大象());

​ bx.关闭();

总结：

​ 1、先按照名词提炼问题领域中的对象

​ 2、对对象进行描述，其实就是在明确对象中应该具备的属性和功能

​ 3、通过new的方式就可以创建该事物的具体对象

​ 4、通过该对象调用它以后的功能。

对象的内存图解

经过上面对小汽车的描述，和java代码测试，我们虽然可以将生活中的事物使用java代码描述出来，但是这些代码在内存中是如何执行的，接下来我们需要研究下对象在内存的图解。

接下来就是分析对象在内存中的分配情况。这里需要画图一步一步演示，严格按照画图流程讲解内存对象创建过程。

类和对象的区别

​ 面向对象的编程思想力图在程序中对事物的描述与该事物在现实中的形态保持一致。为了做到这一点，面向对象的思想中提出两个概念，即类和对象。其中，类是对某一类事物的抽象描述，而对象用于表示现实中该类事物的个体。接下来通过一个图例来抽象描述类与对象的关系，如下图所示。

​ 在上图中，可以将玩具模型看作是一个类，将一个个玩具看作对象，从玩具模型和玩具之间的关系便可以看出类与对象之间的关系。类用于描述多个对象的共同特征，它是对象的模板。对象用于描述现实中的个体，它是类的实例。从上图中可以明显看出对象是根据类创建的，并且一个类可以对应多个对象，接下来分别讲解什么是类和对象。

​ 经过前面几个知识点的学习，基本上掌握了类是用于描述事物的，类中可以定义事物的属性和行为。而对象是通过描述的这个类，使用new关键字创建出来，通过对象就可以调用该对象具体的属性和功能了。

局部变量和成员变量区别

​ 理解清楚了类和对象之后，结合前5天的学习知识，发现在描述类的属性和前面学习定义变量差别不大，唯一区别就是位置发生了改变，那么类中定义的变量，和在方法定义的变量有啥差别呢？

回忆以前学习时变量的定义方式，和位置，以及现在定义类中属性的特点。总结下面几点异同

区别一：定义的位置不同

​ 定义在类中的变量是成员变量

​ 定义在方法中或者{}语句里面的变量是局部变量

区别二：在内存中的位置不同

​ 成员变量存储在对内存的对象中

​ 局部变量存储在栈内存的方法中

区别三：声明周期不同

​ 成员变量随着对象的出现而出现在堆中，随着对象的消失而从堆中消失

​ 局部变量随着方法的运行而出现在栈中，随着方法的弹栈而消失

区别四：初始化不同

​ 成员变量因为在堆内存中，所有默认的初始化值

​ 局部变量没有默认的初始化值，必须手动的给其赋值才可以使用。

基本类型和引用类型作为参数传递

​ 引用类型数据和基本类型数据作为参数传递有没有差别呢？我们用如下代码进行说明，并配合图解让大家更加清晰

class demo
{
    public static void main(string[] args)
    {
        int x = 4;
        show(x);
        system.out.println("x="+x);
    }
    public static void show(int x)
    {
        x = 5;
        
    }
}

​ 基本类型作为参数传递时，其实就是将基本类型变量x空间中的值复制了一份传递给调用的方法show()，当在show()方法中x接受到了复制的值，再在show()方法中对x变量进行操作，这时只会影响到show中的x。当show方法执行完成，弹栈后，程序又回到main方法执行，main方法中的x值还是原来的值。

class demo 
{
    int x ;
    public static void main(string[] args) 
    {

        demo d = new demo();
        d.x = 5;
        show(d);
        system.out.println("x="+d.x);
    }
    public static void show(demo d)
    {
        d.x = 6;
    }
}

​ 当引用变量作为参数传递时，这时其实是将引用变量空间中的内存地址(引用)复制了一份传递给了show方法的d引用变量。这时会有两个引用同时指向堆中的同一个对象。当执行show方法中的d.x=6时，会根据d所持有的引用找到堆中的对象，并将其x属性的值改为6.show方法弹栈。

​ 由于是两个引用指向同一个对象，不管是哪一个引用改变了引用的所指向的对象的中的值，其他引用再次使用都是改变后的值。

封装

封装概述

​ 提起封装，大家并不陌生。前面我们学习方法时，就提起过，将具体功能封装到方法中，学习对象时，也提过将方法封装在类中，其实这些都是封装。

​ 封装，它也是面向对象思想的特征之一。面向对象共有三个特征：封装，继承，多态。接下来我们具体学习封装。

封装表现：

​ 1、方法就是一个最基本封装体。

​ 2、类其实也是一个封装体。

从以上两点得出结论，封装的好处：

​ 1、提高了代码的复用性。

​ 2、隐藏了实现细节，还要对外提供可以访问的方式。便于调用者的使用。这是核心之一，也可以理解为就是封装的概念。

​ 3、提高了安全性。

封装举例

机箱：

​ 一台电脑，它是由cpu、主板、显卡、内存、硬盘、电源等部件组长，其实我们将这些部件组装在一起就可以使用电脑了，但是发现这些部件都散落在外面，很容造成不安全因素，于是，使用机箱壳子，把这些部件都装在里面，并在机箱壳上留下一些插口等，若不留插口，大家想想会是什么情况。

总结：机箱其实就是隐藏了办卡设备的细节，对外提供了插口以及开关等访问内部细节的方式。

私有private

了解到封装在生活的体现之后，又要回到java中，细说封装的在java代码中的体现，先从描述person说起。

描述人。person

属性：年龄。

行为：说话：说出自己的年龄。

class person {
    int age;
    string name;

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

public class persondemo {
    public static void main(string[] args) {
        // 创建person对象
        person p = new person();
        p.age = -20; // 给person对象赋值
        p.name = "人妖";
        p.show(); // 调用person的show方法
    }
}

​ 通过上述代码发现，虽然我们用java代码把person描述清楚了，但有个严重的问题，就是person中的属性的行为可以任意访问和使用。这明显不符合实际需求。

​ 可是怎么才能不让访问呢？需要使用一个java中的关键字也是一个修饰符 private(私有，权限修饰符)。只要将person的属性和行为私有起来，这样就无法直接访问。

class person {
    private int age;
    private string name;

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

​ 年龄已被私有，错误的值无法赋值，可是正确的值也赋值不了，这样还是不行，那肿么办呢？按照之前所学习的封装的原理，隐藏后，还需要提供访问方式。只要对外提供可以访问的方法，让其他程序访问这些方法。同时在方法中可以对数据进行验证。

​ 一般对成员属性的访问动作：赋值(设置 set)，取值(获取 get)，因此对私有的变量访问的方式可以提供对应的 setxxx或者getxxx的方法。

class person {
    // 私有成员变量
    private int age;
    private string name;

    // 对外提供设置成员变量的方法
    public void setage(int a) {
        // 由于是设置成员变量的值，这里可以加入数据的验证
        if (a < 0 || a > 130) {
            system.out.println(a + "不符合年龄的数据范围");
            return;
        }
        age = a; 
    }

    // 对外提供访问成员变量的方法
    public void getage() {
        return age;
    }
}

总结：

​ 类中不需要对外提供的内容都私有化，包括属性和方法。

​ 以后再描述事物，属性都私有化，并提供setxxx getxxx方法对其进行访问。

注意：私有仅仅是封装的体现形式而已。

this关键字

成员变量和局部变量同名问题

当在方法中出现了局部变量和成员变量同名的时候，那么在方法中怎么区别局部变量成员变量呢？可以在成员变量名前面加上this.来区别成员变量和局部变量

class person {
    private int age;
    private string name;
    
    public void speak() {
        this.name = "小强";
        this.age = 18;
        system.out.println("name=" + this.name + ",age=" + this.age);
    }
}

class persondemo {
    public static void main(string[] args) {
        person p = new person();
        p.speak();
    }
}

对象的内存解释

我们已经学习了如何把生活中的事物使用java代码描述，接下来我们分析对象在内存中的分配情况。这里需要画图一步一步演示，严格按照画图流程讲解内存对象创建使用过程。

class person {
    private int age;
    public int getage() {
        return this.age;
    }
    public void setage(int age) {
        this.age = age;
    }
}
public class persondemo {
    public static void main(string[] args) {
        person p = new person();
        p.setage(30);
        system.out.println("大家好，今年我" + p.getage() + "岁");
    }
}

​ 下图为程序中内存对象的创建使用过程。

程序执行流程说明：

​ 1、 先执行main方法（压栈），执行其中的 person p = new person()；

​ 2、 在堆内存中开辟空间，并为其分配内存地址0x1234，紧接着成员变量默认初始化(age = 0)；将内存地址0x1234赋值给栈内中的person p 变量

​ 3、 继续执行p.setage(30)语句，这时会调用setage(int age)方法，将30赋值为setage方法中的“age”变量；执行this.age = age语句，将age变量值30 赋值给成员变量this.age为30；

​ 4、 setage()方法执行完毕后（弹栈），回到main()方法，执行输出语句system.out.println()，控制台打印p对象中的age年龄值。

注意：

​ this到底代表什么呢？this代表的是对象，具体代表哪个对象呢？哪个对象调用了this所在的方法，this就代表哪个对象。

​ 上述代码中的 p.setage(30)语句中，setage(int age)方法中的this代表的就是p对象。

this的应用

学习this的用法之后，现在做个小小的练习。

需求：在person类中定义功能，判断两个人是否是同龄人

class person {
    private int age;
    private string name;
    
    public int getage() {
        return age;
    }

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

    public string getname() {
        return name;
    }

    public void setname(string name) {
        this.name = name;
    }

    public void speak() {
        system.out.println("name=" + this.name + ",age=" + this.age);
    }

    // 判断是否为同龄人
    public boolean equalsage(person p) {
        // 使用当前调用该equalsage方法对象的age和传递进来p的age进行比较
        // 由于无法确定具体是哪一个对象调用equalsage方法，这里就可以使用this来代替
        /*
         * if(this.age == p.age) { return true; } return false;
         */
        return this.age == p.age;
    }
}

总结

类与对象

类，用于描述多个对象的共同特征，它是对象的模板。
对象，用于描述现实中的个体，它是类的实例。
类的定义：使用关键字class来定义java中的类
    格式：
    class 类名 {
        //属性
        数据类型 变量名;
        …
        //方法
        修饰符 返回值类型 方法名(参数){   }
        …
    }
    创建对象：
    格式：
        类名 对象名 = new 类名();

封装（private关键字）

封装，把对象的属性与方法的实现细节隐藏，仅对外提供一些公共的访问方式
    封装的体现：
        变量:使用 private 修饰，这就是变量的封装
        方法:也是一种封装，封装了多条代码
        类： 也是一种封装，封装了多个方法
    private关键字，私有的意思
        它可以用来修饰类中的成员(成员变量，成员方法)
        private的特点：
            private修饰的成员只能在当前类中访问，其他类中无法直接访问
    this关键字
        this关键字，本类对象的引用
        this是在方法中使用的，哪个对象调用了该方法，那么，this就代表调用该方法的对象引用
        this什么时候存在的？当创建对象的时候，this存在的
        this的作用：用来区别同名的成员变量与局部变量（this.成员变量）
            public void setname(string name) {
                this.name = name;
            }