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

大象装进冰箱里。


面向过程：
1.打开冰箱。
2.存储大象。
3.关闭冰箱。
注重过程或者说行为的思考方式。
打开（）；
存储（）；
关闭（）；
比如：
binarySearch();
sort();
语言：C，basic

面向对象：
1.冰箱打开；
2.冰箱存储；
3.冰箱关闭。
class ArrayTool
{
binarySearch();
sort();
}
语言：C++，C#，Java
基于面向过程，将过程进行对象的封装。只要解决问题先找对象就可以了。
特点：
1.面向对象是更符合思考习惯的一种思想。
2.从过程的执行者转换成了对象的指挥者。
3.将复杂的问题简单化。

举例：
电脑城买电脑。自己动手写出过程和对象在该实例中的体现。

面试官的例子。

//电话
class phone{
//打电话
call();
//发信息
sendMessage();
}
1
2
3
4
5
6
7
//同学们在教室中上课
  // 对象：
class Student{  学习();} //同学
class Room{Student(元素类型)[] students=new Student[50]; getStudent(index); setStudent(student);}//教室

//人开门
class 人{
开门（门）
}
class 门{
开(){用的门的门轴，弹簧等};
}
1
2
3
4
5
6
7
8
9
10
11
12
类与对象的关系


类：用于描述事务的。
对象：该类事物具体的个体

/*
汽车：
    属性：
         轮胎数。
         颜色。
   行为：
         运行。
*/
//用java语言对其进行描述。
class Car{
//描述轮胎数
      int num;
//描述颜色
      String colour;
//描述运行功能
      void run(){
         System.out.println(num+","+colour);
     }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
描述事物中的属性和行为；
类就是由成员组成的。
属性对应的就是类中的成员变量。
行为对应的就是类中的成员方法。

class CarDemo
{
    public static void main(Sring[] args)
    {
    //定义该类的目的是为了定义主函数。让该类运行，在该类中调用Car中的内容。
    //要想使用Car类中的内容，必须先有Car的对象。
//如何创建对象呢？通过关键字new完成。
        Car c=new Car(); //创建了一个Car类型的变量c指向了Car类型的对象  //数据类型 变量名=初始化值；int x=4;
        //指挥对象做事情。对象.对象成员
        c.run();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
对象的内存体现

定义在方法中的变量都是局部变量。
先对象，new可以在堆中产生一个空间



类类型的参数传递

class CarDemo
{
    public static void main(Sring[] args)
    {
        Car c=new Car()；
        //指挥对象做事情。对象、对象成员。
        c.num=4；
        c.colour="red";
        c.run();

       Car c1=new Car()；        
        c1.num=4；
        c1.colour="red";
        c1.run();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
为了提高代码的复用性，修改如下：

class CarDemo
{
    public static void main(Sring[] args)
    {
       Car c1=new Car();
       Car c2=new Car();        
       show(c1);
       show(c2);
    }
    //将传递进来的汽车添加四个轮胎，并刷上红色。让其运行起来。
    public static void show(Car c){         //Car c1=c;
          c.num=4；
          c.colour="red";
          c.run();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
匿名对象

没有名字的对象。new Car();它是对象的简化定义方式。
匿名对象可以作为实际参数进行传递。

class CarDemo
{
    public static void main(Sring[] args)
    {
       show(new Car());
    }
    //将传递进来的汽车添加四个轮胎，并刷上红色。让其运行起来。
    public static void show(Car c){         //Car c1=c;
          c.num=4；
          c.colour="red";
          c.run();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
如果对象对方法只进行一次调用，可以简化为匿名对象的形式。
比如：

Car c=new Car();
c.run();
1
2
可以简化为

new Car().run();
1
如果

new Car().run();
new Car().run();
1
2
这里建立的是两个对象。

提问：以下代码运行结果是？

new Car().num=4;
new Car().colour="black";
new Car().run();
1
2
3

成员变量和局部变量的区别

1.源代码中定义的位置不同。
成员变量定义在类中。
局部变量定义在方法中（只要是类的下一级大括号都是局部的），也可以定义在语句里。
2.内存中的存储位置不同。
成员变量存储在堆内存的对象中。
局部变量存储在栈内存的方法中。
3.生命周期不同。
成员变量随着对象的出现而出现。
局部变量随着所属区间的运行而出现，随着所属区间的结束而释放。

面向对象的三个特征。
1.封装。2.继承。 3.多态。

封装（Encapsulation）

记住封装的概念和体现。
封装：是指隐藏对象的属性和实现细节，仅对外提供公共访问方式（接口）。
好处：
1.提高安全性。不允许直接访问细节。并通过公共的方式来访问。可以实现可控。
2.提高了易用性。
3.提高了复用性。
4.隔离了变化。
封装原则：
1.将不需要对外提供的内容都隐藏起来。
2.把属性都隐藏，提供公共方法对其访问。

私有

描述人：
属性：年龄。
行为：说话。

/*私有，权限修饰符，访问权限降低*/
//对私有的数据，可以通过方法的方式对其进行访问。
class Person{
   private int age;
   public void setAge(int a){
   //可以对数据进行控制
        if(a<0||a>130){
//        System.out.println(a+"，数值是错误的");
        //抛出异常
        throw new RuntimeException(a+"，数值是错误的");
        }
        else{
           age=a;
         }
   }
   public int getAge(){
         return age;
   }
   void speak(){
        System.out.println("age="+age);
   }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
封装的体现之一：将属性都私有化，对外提供对应的setXXX,getXXX方法来访问。

class PersonDemo(
     public static void main(String[] args){
             //创建person的对象。调用person的属性和行为。
             Person p=new Person();
//             p.age=-20;
             p.setAge(20);
             p.speak();
     }
)
1
2
3
4
5
6
7
8
9
成员函数的私有化？

class ArrayTool
{
   public void selectSort(int[] arr){
            swap（arr,a,b);
   }
    public void bubbleSort(int[] arr){
            swap（arr,a,b);
   }
   private void sawp(int[] arr,int a;int b)
   {   
   }
}
1
2
3
4
5
6
7
8
9
10
11
12
基本数据类型与引用数据类型参数传递

上面是 基本数据类型
下方是 引用数据类型


上面改的话，结果不变。
下方 如果改的化 结果为8
---------------------
【转载】仅作分享，侵删
作者：ChunyeLi
原文：https://blog.csdn.net/sinat_32512123/article/details/84894615

奈斯