JAVA 面向对象（二）

1.封装与private关键字

private关键字 就是一个权限关键字 除此之外还有public 、protected 、默认不写。
    private关键字 表示私有权限 该成员变量或成员函数只能够在类中被访问 外界不可访问

下面来看一个简单的代码：

class Test03{
    /* 
    点类Point
        数据 x横坐标 y纵坐标
        行为 getDistance(Point other) 返回当前点和传入点other之间的距离

    三角形类Triangle
        数据 Point p1,p2,p3
        行为 getArea() 返回当前三角形的面积
             getLength() 返回当前三角形的周长
    */
    public static void main(String[] args){
        Triangle t=new Triangle();//先创建对象
        Point p1=new Point();
        p1.x=0;//再给对象赋值
        p1.y=10;
        Point p2=new Point();
        p2.x=0;
        p2.y=0;
        Point p3=new Point();
        p3.x=10;
        p3.y=0;
        t.p1=p1;//t1.p1=null;
        t.p2=p2;
        t.p3=p3;
        System.out.println(t.getLength());
        System.out.println(t.getArea());
    }
}
class Triangle{
    Point p1;
    Point p2;
    Point p3;
    public double getArea(){
        double side1=p1.getDistance(p2);
        double side2=p1.getDistance(p3);
        double side3=p2.getDistance(p3);
        double s=(side1+side2+side3)/2;
        return Math.sqrt(s*(s-side1)*(s-side2)*(s-side3));
    }
    public double getLength(){
        return p1.getDistance(p2)+p1.getDistance(p3)+p2.getDistance(p3);
    }
}
class Point{
    double x;
    double y;
    public double getDistance(Point other){
        return Math.hypot(x-other.x,y-other.y);
    }
}

假设给t1.p1=null;Triangle类里的对象p1会进行调用函数，但是空是不能调用函数的，故会发生空指针异常，即NullPointerException。

对于上述的假设目前发现两个问题：

1.我们可以通过对象直接修改对象中的成员变量。
    弊端：如果赋予了一个错误的值 那么势必会导致程序后期的运行结果。

2.我们只能将对象创建完毕之后，在进行对成员变量的赋值。

如果能够被外界访问 那么势必也能被外界修改。比如有一个人Person的类。

class Person{
        int age;
    }
    Person p=new Person();
    System.out.println(p.age);  //只是访问并打印
    p.age=-10;  //不符合现实业务逻辑 给出的是一个错误的数据
                //访问并修改
    为了防范外界直接修改对象的成员变量。
    所以引出了private私有化关键字
    成员变量加了private的话 外界对它修改不行了 获取也不行了。

此时就死局了~ 但是我们不能保证后期对成员变量不进行修改或获取

本质上而言 我们应该防范的是什么？是无条件强制的修改成员变量.
    就是说 修改是可以修改的 但是你不能忽略对象的感受 万一给一个错误的值怎么办？
    不能直接修改的意思就是间接修改(是不是应该加上相应的对值的判断如语句if-else)
    如果顾客给收营员100块钱

    对于这个100块钱的真假 由谁来鉴别？应该是收营员自己，那么在代码中谁来当收银员呢？就是setter.

    setter 是一个Java当中的规范 修改器 主要负责修改成员变量
    本身就是一个成员函数 命名方式一般为 setXxx:setAge setName

    getter 访问器 主要负责访问成员变量(返回成员变量) getter看需求

    建议：今后的代码中 成员变量一律私有 然后再去设置访问器和修改器(根据需求，有时也可不要)。

面向对象三大特征：封装 继承 多态
封装：从字面意义上来看 封装就是将一些杂七杂八的东西进行统一的管理
           例如：收纳盒 衣柜 冰箱 书柜
    最大的好处就是节约代码 方便管理 降低耦合性
在代码中有什么体现：
    循环：主要解决有规律且重复性执行的代码
    函数：主要解决具有独立功能的一段代码 后期进行复用即可
    数组：主要解决多种同类型数据的操作 统一操作 方便类管理
    类：主要将数据和行为进行统一方便操作 仿真现实中的事物

2. 成员变量与局部变量的区别

    1.存储位置
        局部变量存储在栈内存中函数的所属空间里
        成员变量存储在堆内存中对象的所属空间里
    2.生命周期
        局部变量随着函数的进栈而存在，随着函数的弹栈而消失
        成员变量随着对象的创建而存在，随着对象的销毁而消失
    3.访问范围
        局部变量的访问范围仅仅在函数当中
        成员变量的访问范围在当前类中
    4.初始化值
        局部变量必须先进行初始化 之后再能被调用
        成员变量在创建时有默认初始化

3. 构造函数

        对于一个人而言 是出生后才有的性别 还是出生前就有性别
        有些人 出生前就有姓名了 有些人出生后才有的姓名
        隐喻的对象
                有些对象创建之前成员变量就有值（不含默认初始化）
                有些对象创建之后成员变量才有值
        所以就有一个问题了 如何在创建对象之前之中对我们的成员变量进行赋值呢？
    
    构造函数的主要作用：在创建对象之时对成员变量进行赋值操作
    构造函数的格式：
    权限修饰符 函数名(参数列表){
        函数体;
    }
    对比和之前学过的函数来说
    构造函数
        没有函数类型关键字
        没有返回值类型（并不意味着没有return）
        函数名必须是类名
    但凡创建一个对象 构造函数就执行一次
    问题：我们之前并没有写构造函数
            如果类中没有定义任何构造函数的情况下，则会有一个默认无参的构造函数
            public ClassName(){}
            如果类中有明显定义的构造函数 则默认无参的构造函数不存在了
        所以 一般而言 我们最好将那个无参的构造函数写出来！！！！！！！
    成员变量的赋值其实经历了三个阶段
        默认初始化-    显式初始化  -      针对性初始化
                  类中成员变量被赋值        构造函数

    构造函数和成员函数有什么样的区别
        构造函数只在创建对象的时候调用 而且仅仅调用一次
        成员函数在创建对象之后调动 可以调用任意次数

        成员函数能否调用成员函数 可以
        成员函数能否调用构造函数 不可以的
        构造函数能否调用成员函数 可以 只不过此时的成员函数不应该当做对象的特有行为而向外界提供的
                                仅仅是构造函数中的代码略多 从而分出来的函数 本质上这个函数还是构造函数的内容
                                那么该函数一般被定义为private
        构造函数能否调用构造函数 可以 适当减少代码的冗余 提高构造函数的利用率
                                原则上一般是参数较少的构造函数调用参数较多的构造函数
                                具体的调用方式并不像成员函数一样 写个方法名
                                注意：成员函数劲量和构造函数别重名
                                this(...) 对this的调用必须是构造器中的第一个语句
                                在注意一点：构造函数可以调用构造函数 但是不能产生回调
                                ERROR:递归构造器调用
    
    那么有了构造函数 是否还需要Setter和Getter吗？
        不一定 看需求 如果确定数据后期要被修改 则添加

4. 对象的内存图解II

    1.在堆内存中开辟一个空间并分配地址
    2.对成员变量进行【默认初始化】
    3.相应的构造函数进栈 刚开始就对成员变量进行【显式初始化】
    4.接着再去执行构造函数中的内容【针对性初始化】
    5.构造函数执行完毕 弹栈 将对象的地址赋值给相应变量即可