java（九）面向对象与面向过程

1.面向对象与面向过程

    什么是面向对象、面向过程？

面向过程
自顶向下、逐步求精、模块化封装函数主张按功能把软件系统逐步细分，对每个涉及到的功能都进行一次数据处理然后输出。由主函数负责把函数中的所有接口串接起来，程序的实现非常强调达到某功能的算法。每个函数都有唯一的入口和出口。

通俗的来讲：当解决一个问题的时候，面向过程会把事情拆分成： 一个个函数和数据（用于方法的参数） 。然后按照一定的顺序，执行完这些方法（每个方法看作一个个过程），等方法执行完了，事情就搞定了。

面向对象
面向对象的方法也是利用面向过程的结构化程序流来设计的，面向对象是一种更优秀的程序设计方法，它的基本思想是使用类、对象、继承、封装、消息等基本概念来进行程序设计的。它强调直接以现实世界中的事物(即对象)来思考、认识问题，并根据对象的本质特点把它们抽象为系统中的，使之成为构成系统的基本单元，于是就使得软件系统组件有了直接映像到客观世界的可能，并可以保持客观世界中事物及其相互关系的本来面貌。

通俗的来讲：当解决一个问题的时候，面向对象会把事物抽象成对象的概念，就是说这个问题里面有哪些对象，然后给对象赋一些属性和方法，然后让每个对象去执行自己的方法，问题得到解决。

举例说明：冰箱里面放有脏衣服，怎么洗干净？

 面向过程：
                    1 执行加洗衣粉方法；
                    2 执行加水方法；
                    3 执行洗衣服方法；
                    4 执行清洗方法；
                    5 执行烘干方法；
 自己做
        弊端：麻烦 费时间 费精力
        优点：提高生活的情调
    面向过程：执行者  凡事都要自己做 亲力亲为  
        弊端：费时间 费精力 做出来的结果也不一定是最优的

   面向对象：
   洗衣机： 加入一些属性和方法  洗衣服方法  清洗方法  烘干方法       人：加洗衣粉方法  加水方法
   然后 人.加洗衣粉 人.加水   洗衣机.洗衣服 洗衣机.清洗  洗衣机.烘干.总之由人付出一定代价解决问题
   面向对象：指挥者 凡事通过其他方式解决  借鸡生蛋/借刀杀人

  面向过程和面向对象一定是互斥的吗？

肯定不是。
我们在处理问题时可以完全的面向过程 但是不能完全面向对象。你让女朋友做饭 你这个角度而言 面向对象，从女朋友这个角度而言呢？如果GF做 面向过程；如果GF不做 叫外卖 面向对象；从餐馆这个角度而言呢？应该是要做饭 面向过程；如果餐馆不做 可以叫别家餐馆做；别的餐馆都不做 这个饭始终没人做 相互踢皮球。从中可以看出什么 这个事最终要被处理-面向过程，所以 面向过程其实是最基本的思路 而面向对象是基于面向过程的思路

面向对象有什么样的好处呢？

可以仿真的模拟现实生活中的事物，可以实现更加复杂的业务逻辑。比如说淘宝在买东西的时候 查看商品->付款->生成订单->物流信息。

  如何描述一个坐标呢？

在面向过程的思想里面：
        int x,y;
        int[] point={1,2};
        额外的 如果是一组坐标
        int x1,y1,x2,y2,x3,y3....
        int[][] points={{1,2},{3,4},{5,6}};
        其次对于他们之间的操作
        getDistance(p1,p2) 求两点间的距离
        你会发现 数据 和 操作 是分开的，弊端就是不方便统一管理
 在面向对象的思想里面：
        p1=创建一个Point对象并且制定x=1,y=2
        p2=创建一个Point对象并且指定x=3,y=4
        p1.x p1.y
        p1.getDistance(p2) 让p1自己去和p2之间计算距离
        好处在于将数据和操作统一起来了，意味着将点拟人化 该事物的数据和操作就可以统一起来了。

2 对象与类

什么是对象？

但凡是真实存在的且具体的事物 都称之为对象，就是由某一个类所描述出来的具体的事物，比如一个打火机 一根烟 一个手机 一台电脑等等。

 什么是类？

具有相同行为和特征的一些具体事物的总称，类似于于大楼设计图纸，而对象就是由该图纸所建成的具体的大楼

类就是用于描述事物的；类主要描述事物的那些方面呢？
        属性-数据-成员变量；行为-函数-成员函数。我们一般在夸一个人， 长得像我女朋友、 个子很高、眼睛很漂亮、声音像泷泽萝拉、身材像大桥未久、气质如乔碧萝， 以上都是在描述这个事物的特征 属性 可以用数据来表示。篮球打得好、歌唱的好、马骑的好、 嘴巴的BitBox也好、 以上都是在描述这个事物的行为 可以用函数来表示。
  比如我们要描述一个坐标：
     属性 x y
     行为 getDistance()
class Point{
    double x;
    double y;
public double getDistance(Point other){
        ...
    }
}
注意：建议一个类一个.java文件 方便类管理
也就意味着当我们在创建一个类的时候 其实就是在自定义一个数据类型

对象就是由一个类所描述的内容从而产生的一个具体的事物。
    目前而言 但凡创建对象 用new关键字格式：类名/数据类型 变量名=new 类名(); 如何访问对象中的成员呢 变量名.成员

代码示例:
(1)计算两点之间的距离

//计算两点之间的距离
class Test01{
    public static void main(String[] args){
        Point p1=new Point();
        Point p2=new Point();
        p1.x=10;
        p1.y=20;
        p2.x=30;
        p2.y=40;
        System.out.println(p1.getDistance(p2));
        System.out.println(p2.getDistance(p1));
    }
}
/*
 点类Point
        数据 x横坐标 y纵坐标
        行为 getDistance(Point other) 返回当前点和传入点other之间的距离
*/

//计算两个坐标之间的距离
class Point{
    double x;
    double y;
    public double getDistance(Point other){
        return Math.hypot(x-other.x,y-other.y);
    }
}

(2)计算 一元二次方程
 

class Test02{
    /*
    定义一个解决一元二次方程的类
        数据 
            a,b,c,delt
        行为
            isSolved() 判断是否有解
            getRoot1() 获取第一个解
            getRoot2() 获取第二个解
    QuadrationEquation
    */
    public static void main(String[] args){
        QuadrationEquation qe=new QuadrationEquation();
        qe.a=10;
        qe.b=50;
        qe.c=5;
        System.out.println(qe.isSovled());
        System.out.println(qe.getRoot1());
        System.out.println(qe.getRoot2());
    }
}

class QuadrationEquation{
    double a;
    double b;
    double c;
    double delt;
    //计算detl的值
    public boolean isSovled(){
        delt=b*b-4*a*c;
        return delt>=0;
    }
    //第一个结果
    public double getRoot1(){
        return (-b+Math.sqrt(delt))/(2*a);
    }
    //第二个结果
    public double getRoot2(){
        return (-b-Math.sqrt(delt))/(2*a);
    }
}

 （3）计算三角形的周长、面积
 

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;
        t.p2=p2;
        t.p3=p3;
        System.out.println(t.getLength());
        System.out.println(t.getArea());
    }
}

//计算两个坐标之间的距离
class Point{
    double x;
    double y;
    public double getDistance(Point other){
        return Math.hypot(x-other.x,y-other.y);
    }
}

 

/*
三角形类Triangle
        数据 Point p1,p2,p3
        行为 getArea() 返回当前三角形的面积
             getLength() 返回当前三角形的周长
*/
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);
    }
}

 3 对象的内存图解 I

  （1）在堆内存中开辟一个空间并分配地址

  （2）按照类的描述，在该空间中定义成员变量 并且有默认初始化值

  （3）加载成员函数进入方法区(只加载一次)

  （4）对象创建完毕 将空间地址赋值给相应的变量

  （5）变量(p1/p2)调用成员变量 
          先通过该变量所存储的地址去堆空间中找，然后在该空间中找相应的成员变量

  （6）变量(p1/p2)调用成员函数
          直接去方法区中找该成员函数 ，将该函数加载进栈内存开始运行，为了方便区分哪个对象调用的该成员函数，由     this这个关键字段 来区分 this主要存的是当前对象的地址。
        注意：当成员函数在操作变量的时候
            先在当前函数的空间里找 局部变量
            如果没有找到，再去this所指向的堆内存中对象所属空间里去找

 

4.封装与private关键字 

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

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

 目前发现的两个问题：

1.我们可以通过对象直接修改对象中的成员变量
    弊端：如果赋予了一个错误的值 那么势必回导致程序后期的运行结果
    那么如何解决呢？你的内裤能否被别人直接看到？你的银行密码能否被别人直接修改？就是说我们对象的成员变量并不是完全需要向外界可访问的；如果能够被外界访问 那么势必也能被外界修改
    class Person{
        int age;
    }
    Person p=new Person();
    System.out.println(p.age);  //只是访问并打印
    p.age=-10;  //不符合现实业务逻辑 给出的是一个错误的数据
                //访问并修改
    我们防范外界直接修改对象的成员变量？
    private私有化关键字
    成员变量加了private的话 修改不行了 获取也不行了，此时就死局了~ 不能保证后期对成员变量不进行修改或获取。本质上而言 我们应该防范的是什么？无条件强制的给成员变量修改，就是说 修改是可以修改的 但是你不能忽略对象的感受 万一给一个错误的值怎么办？不能直接修改的意思就是间接修改(是不是应该加上相应的对值的判断 语句if-else)，顾客给收营员100块钱 对于这个100块钱的真假 由谁来鉴别？收营员自己
    setter 是一个Java当中的规范 修改器 主要负责修改成员变量
    本身就是一个成员函数 命名方式一般为 setXxx:setAge setName

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

    建议：今后的代码中 成员变量一律私有 然后再去设置访问器和修改器
    注意：如果成员变量和局部变量重名了 如何区分呢？只需要在成员变量之前加this.即可.

 2.我们只能将对象创建完毕之后，再进行对成员变量的赋值
        对于一个人而言 是出生后才有的性别 还是出生前就有性别， 有些人 出生前就有姓名了 有些人出生后才有的姓名
        隐喻的对象
                有些对象创建之前成员变量就有值（不含默认初始化）
                有些对象创建之后成员变量才有值
        所以就有一个问题了 如何在创建对象之前之中对我们的成员变量进行赋值呢？所以用到了构造函数。

5.构造函数

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

 代码示例：

//对于一个人性别、年龄
class Test01{
    public static void main(String[] args){
        Person p1=new Person();//new 构造函数();
        /*
        p1.setAge(10);
        System.out.println(p1.getAge());
        */
        Person p2=new Person(10);
        Person p3=new Person("旺财",30);
    }
}

class Person{
    private String name="小明"; //每一个Person对象创建之前都叫小明
    private int age=5;      //每一个Person对象创建之前都是5岁
    //private int wheelNum=4; //轮胎的个数
    
    /* 
    隐藏默认的
    public Person(){

    }
    */
    public Person(){    //无名 无年龄
        System.out.println("姓名："+this.name+",年龄:"+this.age);
    }
    public Person(int age){//无名 有年龄
        this.age=age;
        System.out.println("姓名："+this.name+",年龄:"+this.age);
    }
    public Person(String name,int age){ //有名 有年龄
        this.name=name;
        this.age=age;
        System.out.println("姓名："+this.name+",年龄:"+this.age);
    }
    void show(){
        System.out.println("今年"+age+"岁");
    }
    public void setAge(int age){
        if(age<0||age>150){     //局部变量age
            this.age=0;          //成员变量age
        }else{
            this.age=age;        //左边成员 右边局部
        }
    }
    public int getAge(){
        return age;
    }
    public void setName(String name){
        this.name=name;
    }
    public String getName(){
        return this.name;
    }
}

 

6.构造函数和成员函数的区别 

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

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

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

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

8. 对象的内存图解 II

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

9.练习：

（1）实现一个简单的栈结构Stack
  类图：

图示：

//需求：实现一个简单的栈结构Stack
class Test01{
    public static void main(String[] args){
        Stack stack=new Stack(20);
        for(int e=1;e<=20;e++){
            stack.push(e);
        }
        stack.push(21);
        System.out.println(stack.size());
        System.out.println(stack.toString());
        System.out.println(stack.peek());
        System.out.println(stack.pop());
        System.out.println(stack.toString());
        System.out.println(stack.isEmpty());
        stack.clear();
        System.out.println(stack.toString());
        System.out.println(stack.pop());
    }
}

/**
Stack是一个简单的由一维数组实现的栈结构
支持入栈出栈等常见操作,但不支持动态扩容操作
为了方便简化代码，默认此Stack中只能存储int型数据
@author li
@version 1.0
*/
public class Stack{
    private int[] data; // 容器 用于存储栈元素 data.length表示栈的最大容量
    private int top=-1;    // 栈顶标记 用于标记栈顶元素的位置 当栈为空时 top=-1 栈中有效元素的个数top+1
    private int capacity=10;    //默认最大容量为10
    /**
    创建一个默认容量为10的栈
    */
    public Stack(){
        this(capacity);
    }
    /**
    创建一个指定容量为capacity的栈
    @param capacity 
    由调用者传入的指定容量
    如果capacity<0 则容量置为0
    如果capacity>100 则容量置为100 
    */
    public Stack(int capacity){
        if(capacity<0){
            capacity=0;
        }
        if(capacity>100){
            capacity=100;
        }
        this.data=new int[capacity];
    }
    /**
    将元素e入栈，如果栈当前已满，则无法加入
    @param e 用户指定入栈的元素
    */
    public void push(int e){
        if(size()==data.length){
            System.out.println(">>>栈已满，无法添加元素"+e);
            return;
        }
        data[++top]=e;
    }
    /**
    从栈中弹出一个元素，如果栈已经是空，则返回-1即可(没有学异常 -1表示错误)
    @return 返回当前栈顶的元素，如果栈为空则返回-1
    */
    public int pop(){
        if(isEmpty()){
            System.out.println(">>>栈为空，无法弹栈元素");
            return -1;
        }
        return data[top--];
    }
    /** 
    获取当前栈顶元素(不出栈)，如果栈已经是空，则返回-1即可
    @return 返回当前栈顶的元素，如果栈为空则返回-1
    */
    public int peek(){
        if(isEmpty()){
            System.out.println(">>>栈为空，无法获取栈顶元素");
            return -1;
        }
        return data[top];
    }
    /**
    判断当前栈是否为空
    @return true表示栈空 否则栈不为空
    */
    public boolean isEmpty(){
        return top==-1;
    }
    /**
    清空当前的栈
    */
    public void clear(){
        top=-1;
    }
    /**
    获取栈中有效元素的个数
    */
    public int size(){
        return top+1;
    }
    /**
    返回栈的字符串表现形式
    */
    public String toString(){
        if(isEmpty()){
            return "[]";
        }
        String s="[";
        for(int i=0;i<size();i++){
            s+=data[i];
            if(i==size()-1){
                s+="]";
            }else{
                s+=",";
            }
        }
        return s;
    }
}

 （2)对数用构造函数使用

class Test02{
    public static void main(String[] args){
        Demo d1=new Demo();
        Demo d2=new Demo(10);
        Demo d3=new Demo(10,20);
        Demo d4=new Demo(10,20,30);
    }
}
class Demo{
    int a;
    int b;
    int c;
    public Demo(){
        this(0,0,0);
        //Demo(0,0,0);//这种调用方式 其实是把Demo(...)当成成员函数去调用了
    }
    public Demo(int a){
        this(a,0,0);//Demo(a,0,0);
    }
    public Demo(int a,int b){
        this(a,b,0);//Demo(a,b,0);
    }
    public Demo(int a,int b,int c){
        this();
    }
    public void Demo(int a,int b,int c){

    }
    public void show(){
        System.out.println(a+","+b+","+c);
    }
    private void init(){
        System.out.println(".....");
        System.out.println(".....");
        System.out.println(".....");
        System.out.println(".....");
        System.out.println(".....");
        System.out.println(".....");
        System.out.println(".....");
        System.out.println(".....");
        System.out.println(".....");
        System.out.println(".....");
    }
}