深入理解面向对象编程：概念、优势与实践-优快云博客

本文链接：https://blog.youkuaiyun.com/Gao_xu_sheng/article/details/136182125

1. 面向对象

1.1 概述

面向对象（OOP, Object-oriented programming）：一种编程思路，编程思想。
面向对象和面向过程比较：都是编程思想，面向过程是面向对象的基础，面向对象是基于面向过程的。
- 面向过程(POP)：更强调解决问题的基本步骤，强调问题的解决方式，更强调的是方法。
  - 编程思路：自上向下、不断分解。
- 面向对象(OOP)：更强调解决问题的主体，更强调谁来解决这个问题，更强调的是数据，更强调的是对象，更强调的是谁拥有数据和操作数据的权力。
  - 编程思路：自底向上，不断拼装。
- 例子：
  - 洗衣服：
    - 面向过程：
      准备盆
      
      放洗衣粉
      
      放水
      
      搅匀
      
      泡衣服
      
      揉一揉
      
      搓一搓
      
      拧干
    - 面向对象：
      找到洗衣机
      
      衣服放进去
      
      放洗衣粉
      
      摁按钮
  - 买酱油：
    - 面向过程：
      通知小明买酱油
      
      走路去超市
      
      一手交钱一手交货
      
      买酱油回来
    - 面向对象：
      通知小明买酱油
      
      拿回酱油

总结：二者都是一种思想，面向对象是相对于面向过程而言的。面向过程，强调的是功能行为，以函数为最小单位，考虑怎么做。面向对象，将功能封装进对象，强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。面向对象更加强调运用人类在日常的思维逻辑中采用的思想方法与原则，如抽象、分类、继承、聚合、多态等。

1.2 面向对象的好处

符合人的思维习惯：凡事找对象，找工具，找人，而不是找方法。
复杂的问题简单化。
由执行者变成了指挥者。

1.3 面向对象三大特征

封装
继承
多态

2. 类和对象

2.1 概述

定义：

类：种类，类别。从某个角度来看，具有相同特征或行为的人或事物的集合。具有一定的特征，行为。是抽象的一种状态。
抽象：抽取事物的关键信息，形成一个概念，一种感觉。
对象：事物的具体体现。

说明：

类：就是具有相同特征和行为的事物的一种定义。
对象：类的实现
属性：也就是特征。是对事物特征的描述。特点
方法：也就是行为。对事物功能的描述。能干啥

类和对象的使用(面向对象思想的落地实现)

创建类，设计类的成员
创建类的对象
通过"对象.属性"或"对象.方法"调用对象的结构

示例：

人：
- 类别：人类
- 特征：
  - 有眼睛
  - 有嘴
  - 有四肢
- 行为：
  - 会说话
  - 会行走
计算机：
- 类别：计算机类
- 特征：
  - 形状
  - 大小
  - 颜色
  - 品牌
- 行为：
  - 看电影
  - 放音乐
  - 敲代码

代码示例：

/**
 * 计算机类
 * @author Coding-Future
 */
public class Computer{
    /**
     * 形状
     */
    String shape;
    /**
     * 大小
     */
    String size;
    /**
     * 颜色
     */
    String color;
    /**
     * 品牌
     */
    String brand;
  
    void watch() {
        System.out.println("看电影");
    }

    void voice() {
        System.out.println("听音乐");
    }

    void code() {
        System.out.println("敲代码");
    }
}

2.2 对象的创建和使用

语法结构：
类名对象名 = new 类名();
语法解释：
- 类名：要创建的对象所属类型，如：Computer，Scanner。
- 对象名：给创建的对象取一个名字，使用合法的标识符即可。
- =：将对象的地址，赋值给对象名。
- new：在堆内存中开辟一段空间，用于存储该类型的数据。
- 类名：和前面声明引用的类名一样。

访问对象属性：

语法结构：
对象名.属性名 // 访问
对象名.属性名 = 值; // 修改
语法示例：

public class ComputerTest {
    public static void main(String[] args) {
        Computer computer = new Computer();
        computer.shape = "方形";
        computer.color = "太空金";
        computer.size = "14寸";
        computer.brand = "联想";
    }
}

访问对象方法：

语法结构：
对象名.方法名();
语法示例：

public class ComputerTest {
    public static void main(String[] args) {
        Computer computer = new Computer();
        computer.shape = "方形";
        computer.color = "太空金";
        computer.size = "14寸";
        computer.brand = "联想";
        computer.code();
        computer.voice();
        computer.watch();
    }
}

创建对象对内存的理解

创建一个对象对内存的理解
创建多个对象对内存的理解

下方代码的执行结果？
public class PersonTest {
    public static void main(String[] args) {
        //2. 创建Person类的对象
        Person p1 = new Person();
        //Scanner scanner = new Scanner(System.in);
        //调用对象的结构：属性、方法
        //调用属性：“对象.属性”
        p1.name = "Tom";
        p1.isMale = true;
        System.out.println(p1.name);
        //调用方法：“对象.方法”
        p1.eat();
        p1.sleep();
        p1.talk("Chinese")
        //*******************************
        Person p2 = new Person();
        System.out.println(p2.name);
        System.out.println(p2.isMale);
        //*******************************
        //将p1变量保存的对象地址值赋给p3,导致p1和p3指向了堆空间中的同一个对象实体。
        Person p3 = p1;
        System.out.println(p3.name);
        System.out.println(p3.age);
        p3.age = 10;
        System.out.println(p1.age);
    }
}

//1.创建类，设计类的成员
class Person {

    //属性
    String name;
    int age = 1;
    boolean isMale;

    //方法
    public void eat() {
        System.out.println("人可以吃饭");
    }

    public void sleep() {
        System.out.println("人可以睡觉");
    }

    public void talk(String language) {
        System.out.println("人可以说话,使用的是：" + language);
    }

}

2.3 成员变量和局部变量

定义：
- 成员变量：定义在类中的成员位置的变量，就是成员变量,也可以叫做属性。
- 局部变量：定义在方法中的变量，就是局部变量。
不同点：
- 代码层面：定义位置不同
  - 成员变量：定义在类中方法外。
  - 局部变量：定义在方法体{}中，形参，代码块{}中。
- 关于权限修饰符的不同
  - 成员变量:可以在声明时时,使用权限修饰符
  - 常见的权限修饰符:private、public、却省、protected --->封装性,目前使用确省就可以了。
  - 局部变量,不可以写权限修饰符。
- 内存层面：空间不同
  - 成员变量：属于对象，和对象的位置相同，在堆内存的对象中。(非static)
  - 局部变量：属于方法，和方法的位置相同，在栈的方法中。
- 存在时间：时间不同，生命周期不同
  - 成员变量：随着对象的创建而存在，随着对象的消失而消失。(栈中没有任何引用指向该对象时，该对象就变成了垃圾，随后就会被垃圾回收器回收掉). GC
  - 局部变量：随着方法的调用而存在，随着方法的调用结束而消失。
- 默认初始化状态不同：
  - 成员变量：有默认的初始化值。
  - (byte、short、int、long) : 0; (float、double) : 0.0;char : '\u0000'; (boolean) : false;引用数据类型(类,数组，接口):null
  - 局部变量：没有默认的初始化值，必须先手动赋值，才能使用。
  - 定义一个具有成员变量和局部变量的类，看是否能够调用出来。
  - ```
  public class DemoTest {
    
      String name = "Lisa";
      int age = 18;
  
      void info() {
          System.out.println("我叫" + name + ",今年" + age + "岁");
      }
  
      void show(double legLong) {
  
     
          System.out.println("我叫" + name + ",今年" + age + "岁,腿长" + legLong + "米");
      }
  
      public static void main(String[] args) {
          DemoTest demo = new DemoTest();
          demo.info();
          double legLong = 1.3;
          demo.show(legLong);
      }
  }
```

2.4 匿名对象

匿名对象：没有名字的对象
语法格式：
new 类名();
匿名对象的使用场景：
- 如果某个对象在创建之后，其方法只调用一次，那么就可以使用匿名对象来调用。这种写法会节省一些内存空间，因为在栈中没有开辟空间存储地址，但是在堆中是存在没有指针的对象，GC就自动回收了。
- 可以作为某个方法的返回值。这种调用形式，在被调用方法中，这个对象是匿名对象，但是在调用者，这个对象可能不是匿名对象。
注意事项：
- 匿名对象可以给成员变量赋值，但是这样做没有任何意义。因为匿名对象一旦被赋值，匿名对象就变成了垃圾，很快被回收掉。即使没有被回收，我们也无法使用这个匿名对象。
示例：

public class DemoTest {
    public static void main(String[] args) {
        new Demo().name = "lisi";
        new Demo().say();
    }


}

class Demo {
    String name;

    void say() {
        System.out.println(name + "说:你好！");
    }
}