Java07：面向对象01

1 初识面向对象

1.1 面向过程&面向对象

1）面向过程思想：
（1）步骤清晰简单；
（2）适合处理较为简单的问题；

2）面向对象思想：
（1）物以类聚，分类的思维模式，思考解决问题需要哪些分类，然后对这些分类单独思考，最后对某个分类进行面向过程的思考；
（2）面向对象适合处理复杂的问题，适合需要多人协作的问题；

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

1.2 什么是面向对象

1）面向对象编程（Object-Oriented Programming，OOP）
2）面向对象编程的本质就是 ：以类的方式组织代码，以类的方式组织（封装）数据；
3）抽象：编程思想！持续的学习后才会有所理解；多实践多测试自己的想法；
4）面向对象三大特性：
（1）封装
（2）继承
（3）多态
5）从认识论角度考虑是先有对象后有类。对象是具体的事物。类 是抽象的，是对对象的抽象；
6）从代码运行角度考虑先有类后有对象。类是对象的模板。

2 方法回顾加深

2.1 方法的定义

1. 修饰符
2. 返回类型
3. break 跳出switch，结束循环 和return的区别
4. 方法名:见名知意、驼峰命名
5. 参数列表：参数类型、参数名
6. 异常抛出

/**由 class修饰的是类名*/
public class Demo01ReplayMethod {
    // main主方法（一般一个程序中只有一个）
    public static void main(String[] args) {

    }
    /*
    修饰符 返回值类型 方法名(){
        // 方法体
        return 返回值;//返回值要和返回值类型一致
    }
     */
    //return 结束方法，返回一个结果
    public String sayHello(){
        return "Hello";
    }
    public void hello(){
        return;
    }
    //入参
    public int max(int a, int b){
        return a>b ? a: b;//三元运算符
    }
    //异常
    public void readFile(String file) throws IOException {
        return;
    }
}

2.2 方法的调用

2.2.1方法的调用

1. 静态方法
2. 非静态方法
3. 形参和实参

public class Employee {
    //static修饰的方法 是和类一起加载的
    public static String say(){
        return "发工资了哦";
    }
    //没有用static修饰的方法 是在实例化后才存在
    public String write(){
        //因此非静态方法 可以调用静态方法
        say();
        return "报销单";
    }
    //形式参数
    public int add(int a, int b){
        return a+b;
    }

public class Demo02MethodInvocation {
    public static void main(String[] args) {
        /*1.调用静态方法：类名.方法名 */
        String say = Employee.say();
        System.out.println(say);

        /*2.调用非静态方法：实例化对象`new`后，再调用 */
        Employee employee = new Employee();
        String write = employee.write();
        System.out.println(write);

		/*3.实参*/
        int sum = employee.add(1, 2);
        System.out.println(sum);
    }
}

2.2.2 值传递和引用传递

package com.f.oop;
//值传递
public class Demo03PassByValue {
    public static void main(String[] args) {
        int a= 1;
        System.out.println(a);// 结果：1
		
        new Demo03PassByValue().change(1);
        System.out.println(a);// 结果：1
    }
    public void change(int a){
        a= 10;
    }
}

/**
 * pass by reference 引用传递
 * 传递的是对象，本质还是值传递
 * 难点：`对象`的理解；`内存`的理解
 */
public class Demo04Reference {
    public static void main(String[] args) {
        Person person = new Person();
        System.out.println(person.name);// 结果：null

        Demo04Reference.change(person);
        System.out.println(person.name);// 结果：tom

    }
    public static void change(Person person){
        /* person是一个对象，指向的是：
        Person person = new Person();
        是一个对象（具体的人），可以改变*/
        person.name= "tom";
    }
}
/** 定义一个 person类，有一个属性：name */
class Person{
    String name;
}

2.2.2 this关键字：当前对象，当前类

3 对象的创建和分析

3.1 类对象的关系

1）类是一种抽象的数据类型，它是对某一类事物整体描述/定义，但是并不能代表某一具体的事物。
（示例_1）动物、植物、手机、电脑…
（示例_2）Person类、Pet类、Car类等，这些类都是用来描述/定义某一类具体的事物具备的特点和行为

package com.f.oop2Constructer;
//员工类: 就是一个模板
public class Employee {
    //1.属性：字段
    String name;
    int age;

    //2.方法
    public void work(){
        //this:指代当前类
        System.out.println(this.name + "在工作");
    }
}

2）对象是抽象概念的具体实例
（示例_3）Tom是人的一个具体的实例。
（示例_4）能够体现出特点，展现出功能的是具体的实例，而不是抽象的概念。

package com.f.oop2Constructer;
// 一个项目应该只有一个 main方法
public class Application {
    public static void main(String[] args) {
        /*
        类：是抽象的，实例化后会返回一个自己的对象！
        employee对象就是一个 Employee类的具体实例！ */
        Employee tom = new Employee();
        Employee jerry = new Employee();

        tom.name = "汤姆";
        tom.age = 18;
        System.out.println(tom.name);
        System.out.println(tom.age);

        jerry.name = "杰瑞";
        jerry.age = 16;
        System.out.println(jerry.name);
        System.out.println(jerry.age);
    }
}

3.2 创建与初始化对象

1）使用 new关键字创建对象。创建时除了分配内存空间，还会给创建好的对象 进行默认初始化，和对类中的构造器的调用；
2）类中的构造器：也称为构造方法，是在创建对象的时候必须要调用的。
3）构造器有以下两个特点：
（1）必须和类的名字相同；
（2）必须没有返回类型，也不能写 void。
4）构造器的作用：
（1）使用 new关键字，其本质还是在调用构造器；
（2）用来初始化值
5）注意点：
（1）：一旦定义了有参构造，必须显式定义无参构造
快捷键：Alt + Insert

package com.f.oop2Constructer;
/**
 * 显式定义构造器
 * 一个类即使什么也不写，它也会存在一个方法
 */
public class Company {
    String name;
    //无参构造
    public Company() {}
    //有参构造
    public Company(String name) {
        this.name = name;
    }
}

package com.f.oop2Constructer;

/**一个项目应该只有一个 main方法!
 * 类：是抽象的，实例化后会返回一个自己的对象！*/
public class Application {
    public static void main(String[] args) {
        //new 实例化对象
        Company company = new Company("xyd");
        System.out.println(company.name);
    }
}

3.3 回顾总结

1. 类与对象：
   类是一个模板，它是抽象的；对象是一个具体的实例

2. 方法：
   方法的定义、方法的调用

3. 对象的引用：
   引用类型；基本类型（8种）；
   对象是通过引用来操作的：栈（存的是地址）----堆（存储的是内容）。

4. 属性：字段Field 成员变量
   修饰符 属性类型 属性名 = 属性值;
   默认初始化：
   数字：0、0.0；
   char：u0000；
   Boolean：false；
   引用类型：null。

5. 对象的创建和使用：
   5.1 必须使用 new关键字创建对象；
   5.2 构造器：Employee tom = new Employee();
   5.3 对象的属性：tom.name
   5.4 对象的方法：tom.work();

6. 类：
   静态的属性：即属性；
   动态的行为：即方法。