类和对象

面向对象和面向过程详解

我们常说高级语言分为：面向过程和面向对象。

面向过程：c

面向对象：c++, Java

共同点：面向过程和面向对象都是解决实际问题的一种具体思路。

区别：

大家描述一下如下两件事儿：

如何开汽车(事物比较简单，可以用线性的思维去解决)

面向过程：1.采离合2. 挂档3.踩油门,放离合4.开了

面向对象：

驾驶员

2.  汽车

驾驶员开汽车！Motor.start();

如何造汽车(事物比较复杂，使用简单的线性思维无法解决)

面向过程：1. 造车轮 2. 造发动机 3. 造车皮4. 挡风玻璃 …

面向对象：

车轮

买橡胶

到马来西亚

买飞机票

找到橡胶厂

掏钱买

用船将橡胶运到国内

造磨具

将橡胶放入磨具

出车轮

发动机

….

车壳

….

座椅

…

挡风玻璃

….

将上面的造出的东东，组装，汽车造出！

对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，可能需要面向过程的思路去处理。

解决简单问题可以使用面向过程解决，解决复杂问题：宏观上使用面向对象把握，细节处理上仍然使用面向过程

面向对象思考方式：遇到复杂问题，先从问题中找到名词，然后确立这些名词哪些可以作为类，再根据问题需求确定类的属性和方法，确定类之间的关系

一 对象和类的概念

java中有一句名言，万事万物皆对象，对象指的是一个具体的事物

比如一个叫小明的人就是一个对象，而类是对对象的抽象

人类就是一个类，小明就是人类的一个实例也就是对象，人类中可能有其他人也就是其他实例，小李，小孙等等

把车作一个类的话，对象就是 我家的别克车，对象也可以是你家的玛莎拉蒂车，对象就是具体的事物，而类就是对象的集合，所有对象的统称

类可以看做是一个模版，或者图纸，系统根据类的定义来造出对象

 比如车类，模板就是有四个轮子，发动机，座位，可以跑

车类的一个对象可以是你家的车，就有四个轮子，发动机，也能跑，也能带着你跑，车是你家的车，是一个实在的例子

类的定义

在java中类的定义方式是  class 类名

class Car{
    
}

比如这个Car类

上面的Car类一片空白，可以定义属性，有轮子，发动机，座位 可以定义跑的方法

class Car{
      String name;
      int age;
      String color;
      String zuowei; 
　　　 void run(){
　　　　　　System.out.println("我是汽车我能跑，还能带人跑");
　　　 }　   
}

上面定义了属性，有车的名字，车龄，颜色，座位，还有个跑的方法

创建了类了，就该创建对象了，通过车类得到你家的车

类名 对象名 = new 类名()

class Car{
      String name;
      int age;
      String color;
      String zuowei; 
　　　 void run(){
　　　　　　System.out.println("我是汽车我能跑，还能带人跑");
　　　 }
    　public static void main(String[] args){
          Car car = new Car();
          car.name="极品宝马"
          car.age=3;
          car.color="黑色";
          car.zuowei="真皮";
          car.run();
       }   
}        

你家的车改名叫极品宝马，已经3年的历史了，黑色，被你改装成了真皮沙发，还在跑

一般类中除了属性和方法还包含构造器，也就是构造函数，可以在创建对象的时候直接给属性赋值，相当于，直接给对象做个自我介绍

class Car{
      String name;
      int age;
      String color;
      String zuowei; 
      public Car(String name,int age,String color,String zuowei){
            this.name=name;
            this.age=age;
            this.color=color;
            this.zuowei=zuowei;
      }  
　　　 void run(){
　　　　　　System.out.println("我是汽车我能跑，还能带人跑");
　　　 }
    　public static void main(String[] args){
          Car car = new Car("极品宝马",3,"黑色","真皮");
                   car.run();
       }   
}        

这和上面的效果是一样的，如果在定义类的时候不创建构造器，系统会默认定义一个无参构造器

类中的属性：[修饰符]  属性类型  属性名 = [默认值] 

可以直接赋初始值，也可以不赋值，系统会默认初始值

属性可以是基本数据类型，也可以是引用数据类型 

类中的方法：定义该类的功能，比如吃饭，睡觉，打架这些动态的行为，可以这么理解，属性是名词，方法是动词，方法展现的是该类能干什么事，有什么行为

方法定义格式：

[修饰符]  方法返回值类型  方法名(形参列表) {

// n条语句

}

在类中定义的变量成为成员变量，在方法定义在定义的变量称为方法变量，两者之间的区别是什么呢？

（1）在类中的位置不同

　　　　　　成员变量在类中方法外

　　　　　　局部变量：方法定义中，或者方法声明上

（2）在内存的位置不同

　　　　　　成员变量：在堆中

　　　　　　局部变量：在栈中

（3）声明周期不同

　　　　　　成员变量：随着对象的创建而存在，随着对象的消失而消失

　　　　　　局部变量：随着方法的调用而存在，随着方法的调用完毕而消失

（4）初始化值不同

　　　　　　成员变量：有默认值

　　　　　　局部变量：没有默认值，必须定义，赋值，然后才能使用　　

类和对象实例：

1 定义一个“点”（Point）类用来表示三维空间中的点（有三个坐标）。要求如下：

2 可以生成具有特定坐标的点对象。

3 提供可以设置三个坐标的方法。

4 提供可以计算该“点”距另外点距离的方法。

class Point {
    double x, y, z;
    
    public Point(double _x, double _y, double _z) {
        x = _x;
        y = _y;
        z = _z;
    }
    
    public double  getDistance(Point p) {//传参数，参数就是Point的一个对象
　　　　　　//计算两点之间的距离
        return  Math.sqrt((x - p.x)*(x - p.x) + (y - p.y)*(y - p.y) + (z - p.z)*(z - p.z));
    }
}

class Test {
    public static void main(String[] args) {
        Point p = new Point(5.0, 6.0, 7.8);
        Point origin = new Point(0.0, 0.0, 0.0);
　　　　　//通过调用方法得到距离
        System.out.println(p.getDistance(origin));
    }
}

结果

 上面的例子中有一个 public double getDistance(Point p)方法，没错 它的类型是Point类 也就是我创建的类，它需要传递的是一个Point对象

如果你看到一个方法需要的参数是一个类名，就应该知道这里实际需要的是一个具体的对象。
该方法还可以传递一个匿名对象，所谓匿名对象就是没有名字的对象，
比如getDistance(new Point(1,2,3));这样也可以调用该方法

匿名对象

(1)没有名字的对象
(2)应用场景
A:调用方法，仅仅只调用一次的时候。
b:可以作为实际参数传递。