什么是面向对象

一、面向过程&面向对象

• 面向过程思想
  1. 步骤清晰简单，第一步做什么，第二部做什么…
  2. 面对过程适合处理一些较为简单的问题
• 面向对象思想
  1. 物以类聚，分类的思维模式，思考问题首先会解决问题需要哪些分类，然后对这些分类进行单独思考。最后，才对某个分类下的细节进行面向过程的思索。
  2. 面向对象适合处理复杂的问题，适合处理需要多人协作的问题！
• 对于描述复杂的事物，为了从宏观上把握、从整体上合理分析，我们需要使用面向对象的思路来分析整个系统。但是，具体到微观操作，仍然需要面向过程的思路去处理。

二、什么是面向对象

• 面向对象编程(Object-Oriented Programming, OOP)
• 面向对象编程的本质就是：以类的方式组织代码，以对象的方式组织(封装)数据
• 抽象
• 三大特性
  1. 封装：例子——把钱放到罐子里，留出一个取钱的口
  2. 继承：例子——父子（儿子继承父亲的财产）
  3. 多态：例子——人去学习，小明学习好，小红学习差，都是学生，但表现出的学习效果不一样

有一部分人在教书——老师
还有一部分人在学习——学生

• 从认识论角度考虑是先有对象后有类。对象，是具体的事物。类，是抽象的，是对对象的抽象
• 从代码运行角度考虑是先有类后有对象。类是对象的模板

三、回顾方法及加深

• 方法的定义
  1. 修饰符
  2. 返回类型
  3. break：跳出switch，结束循环和return的区别
  4. 方法名：注意规范就OK，见名知意
  5. 参数列表：(参数类型, 参数名)…
  6. 异常抛出：疑问，后面再说
• 方法的调用：递归
  1. 静态方法
  2. 非静态方法
  3. 形参和实参
  4. 值传递和引用传递
  5. this关键字

package com.jacyzhu.oop;

import java.io.IOException;

// Demo类
public class Demo01 {

    // main方法
    public static void main(String[] args) {

    }

    /*
    修饰符 返回值类型 方法名(...) {
       // 方法体
       return 返回值
    }
     */
    // return 结束方法，返回一个结果！
    public String sayHello() {
        return "Hello, world!";
    }

    public void print() {
        return;
    }

    public int max(int a, int b) {
        return  a>b ? a : b; // 三元运算符
    }

    // 数组下标越界：ArrayIndexOutOfBounds

    public void readFile(String file) throws IOException {

    }
}

1.静态方法

学生类

package com.jacyzhu.oop;

public class Student {

    // 静态方法
    public static void say() {
        System.out.println("学生说话了");
    }
}

调用静态方法

package com.jacyzhu.oop;

public class Demo02 {

    public static void main(String[] args) {
        Student.say();
    }
}

运行结果：
学生说话了

2.非静态方法

非静态方法

package com.jacyzhu.oop;

public class Student {

    // 静态方法
    public static void say() {
        System.out.println("学生说话了");
    }

    // 非静态方法
    public void say1() {
        System.out.println("学生又说话了");
    }
}

调用非静态方法

package com.jacyzhu.oop;

public class Demo02 {

    public static void main(String[] args) {
        Student.say();

        // 实例化这个类 new
        // 对象类型 对象名 = 对象值
        Student student = new Student();
        // 对象名字.方法
        student.say1();
    }
}

运行结果：
学生说话了
学生又说话了

错误调用

package com.jacyzhu.oop;

public class Demo02 {

    public static void main(String[] args) {
        Student.say();

        // 实例化这个类 new
        // 对象类型 对象名 = 对象值
        Student student = new Student();
        // 对象名字.方法
        student.say1();
    }

    // 和类一起加载的
    public static void a() {
        b(); // 错误 不能调用方法b()
    }

    // 类实例化之后才存在
    public void b() {

    }
}

正确调用

    public static void a() {
        b(); // 正确
    }

    // 类实例化之后才存在
    public static void b() {

    }

    public void a() {
        b(); // 正确
    }

    // 类实例化之后才存在
    public void b() {

    }

3.形参和实参

package com.jacyzhu.oop;

public class Demo03 {
    public static void main(String[] args) {
        // 实际参数和形式参数的类型要对应
        int add = Demo03.add(1, 2);
        System.out.println(add);
    }

    public static int add(int a, int b) {
        return a+b;
    }
}

运行结果：
3

4.值传递

package com.jacyzhu.oop;

// 值传递
public class Demo04 {
    public static void main(String[] args) {
        int a = 1;
        System.out.println(a); // 1

        Demo04.change(a);
        System.out.println(a); // 1
    }

    // 返回值为空
    public static void change(int a) {
        a = 10;
    }
}

运行结果：
1
1

5.引用传递

package com.jacyzhu.oop;

// 引用传递：对象，本质还是值传递
// 对象，内存！
public class Demo05 {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name); // null

        Demo05.change(person);
        System.out.println(person.name); // Jacy
    }

    public static void change(Person person) {
        // person是一个对象：指向的是Person person = new Person();这是一个具体的人，可以改变属性！
        person.name = "Jacy";
    }
}

// 定义了一个Person类，有一个属性：name
class Person{
    String name;
}

运行结果：
null
Jacy