java基础之面向对象的思想

一、面向对象和面向过程的编程思想对比

面向过程：是一种以过程为中心的编程思想，实现功能的每一步，都是自己实现的（自己干活）。
面向对象：是一种以对象为中心的编程思想，通过指挥对象实现具体的功能，（指挥对象干活）。

面向对象和面向过程是相辅相成的，考虑问题的时候，通常采用面向对象的思想，解决问题的时候通常采用面向过程的思想。

一个注重整体，一个注重细节。

举例1：吃一盘菜。

面向过程：所有的步骤，我们都需要关心，都需要知道是如何实现的。重点在于过程。

面向对象：先思考，谁可以干炒菜这件事情。我发现，女朋友可以干这件事情，饭店里面的厨师也可以干这件事情，谁可以干，就让谁去干，我们不关心过程，只关心结果。

利用面向对象思想，可以指挥女朋友去炒菜，也可以指挥厨师去炒菜。

举例2：洗衣服

面向过程：每一步都需要我们自己关心，要先泡衣服，再洗衣服，再拧干，再晾起来等等。重点在于过程。

面向对象：先思考，谁可以干洗衣服这件事情。我发现，女朋友可以干这件事情，洗衣机也可以干这件事情，谁可以干，就让谁去干，我们不关心，对象是如何洗衣服，我们不关心过程，只关心结果。

利用面向对象思想，可以指挥洗衣机去洗衣服，也可以指挥女朋友去洗衣服。

二、面向对象思想的好处

不需要我们去干了，直接指挥对象做事情，我们从实现者，变成了指挥者

比如我们要获取一个随机数，我们没有自己书写数学中的随机算法，而是思考在java中谁可以干这件事，发现Random可以干这件事情，那我们就让Random去做，我们不关心实现的过程，只关心最终的结果。

面向对象，不关心过程，只关心结果。

三、类和对象

类和对象的关系：

什么是对象？客观存在的事物皆为对象，所以我们也常说万物皆对象。

什么是类？类是对客观世界中的一类具有共同属性和行为的事物的抽象。

类与对象之间的关系？

可以将类理解成一张设计图，根据设计图可以创建出具体存在的事物。即根据类去创建对象。

类是对事物的一种描述，对象则为具体存在的事物。

类由什么组成？

属性：指事物的特征，例如：手机事物（品牌，价格，尺寸）
行为：指事物能执行的操作，例如：手机事物（打电话，发短信）

类的定义：

类的组成是由属性和行为两部分组成

属性：在类中通过成员变量来实现，（类中方法外的变量）
行为：在类中通过成员方法来实现（和前面的方法相比去掉static关键字）

类的定义步骤：

① 定义类

② 编写类的成员变量

③ 编写类的成员方法

public class Student {
    // 属性 : 姓名, 年龄
    // 成员变量: 跟之前定义变量的格式一样, 只不过位置发生了改变, 类中方法外
    String name;
    int age;

    // 行为 : 学习
    // 成员方法: 跟之前定义方法的格式一样, 只不过去掉了static关键字.
    public void study(){
        System.out.println("学习");
    }
}

对象的创建和使用

创建对象的格式：

类名变量名 = new 类名();

此时的变量名也叫做对象名。
调用成员的格式：

对象名.成员变量

对象名.成员方法();

public class TestStudent {
    /*
        创建对象的格式:
                类名 对象名 = new 类名();
        调用成员变量的格式:
                对象名.变量名
        调用成员方法的格式:
                对象名.方法名();
     */
    public static void main(String[] args) {
        // 类名 对象名 = new 类名();
        Student stu = new Student();
        String name; null
        int age; 0 
         
        // 对象名.变量名
        // 默认初始化值
        System.out.println(stu.name);  // null
        System.out.println(stu.age);   // 0

        stu.name = "张三";
        stu.age = 23;

        System.out.println(stu.name);  // 张三
        System.out.println(stu.age);   // 23

        // 对象名.方法名();
        stu.study();
        // com.itheima.object1.Student@b4c966a
        // 全类名(包名 + 类名)
        System.out.println(stu);
    }
}

案例手机类的创建和使用

需求：首先定义一个手机类，然后定义一个手机测试类，在手机测试类中通过对象完成成员变量和成员方法的使用

分析：

成员变量：品牌, 价格
成员方法：打电话, 发短信
示例代码：

public class Phone {
    // 品牌, 价格
    String brand;
    int price;

    // 打电话, 发短信
    public void call(String name){
        System.out.println("给"+name+"打电话");
    }

    public void sendMessage(){
        System.out.println("群发短信");
    }
}

public class TestPhone {
    public static void main(String[] args) {
        // 1. 创建对象
        Phone p = new Phone();
        // 2. 给成员变量进行赋值
        p.brand = "大米";
        p.price = 2999;
        // 3. 打印赋值后的成员变量
        System.out.println(p.brand + "..." + p.price);
        // 4. 调用成员方法
        p.call("阿强");
        p.sendMessage();
    }
}

四、一个对象的内存图

五、二个对象的内存图

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

故事记忆法：把这五个特点，编成一个小故事去记忆。

小明家，养了一条狗，而且这条狗是一条母狗。有一天，母狗怀小狗了。

小红跟小明说：你家的狗生了吗？

小明说：未生出。

未：谐音记忆（位置）

代码中位置不同：

成员变量在是类中，方法外 ; 局部变量在方法里面或者方法声明上（形参）。

内存中位置不同：

成员变量在堆里面中对应的对象中的; 局部变量在栈里面的。

生：

生命周期：

成员变量跟对象有关的。当对象在堆中的空间被开辟出来后，成员变量就存在了。当对象被垃圾回收器回收从内存中消失的时候，成员变量就消失了。

局部变量跟方法有关的。当方法被调用进栈的时候，局部变量就存在了。当方法里面的代码执行完毕了，就要出栈，一旦出栈，方法里面的局部变量就会从内存中消失。

作用范围：

成员变量：整个类中有效 ; 局部变量：只在当前的方法中有效。

出：谐音记忆（初始化）

成员变量：有初始化值。

局部变量：没有初始化值的，想要使用，必须要先赋值才能使用。

七、private关键字

private关键字和public关键字

都是权限修饰符

private：私有的可以修改成员变量和方法，一旦修饰后只能在本类中使用
public：公共的可以修饰成员变量和方法，一点修饰后可以在人员地方使用

为什么要用private修饰？？

如果没有用private修饰，那么在外界可以获取成员变量的值，也可以直接对成员变量赋值，太危险，不安全，容易把不合理的值赋值给成员变量

为什么要写get和set方法？？

set方法是给成员变量赋值的，可以在set方法中写过滤条件

/*
    学生类
 */
public class Student {
    //成员变量
    private String name;
    private int age;

    //提供get/set方法
    public void setAge(int a) {
        if(a<0 || a>120) {
            System.out.println("你给的年龄有误");
        } else {
            age = a;
        }
    }

    public int getAge() {
        return age;
    }
}
/*
    学生测试类
 */
public class StudentDemo {
    public static void main(String[] args) {
        //创建对象
        Student s = new Student();
        //给成员变量赋值
        s.name = "林青霞";
        s.setAge(30);
       
    }
}

八、就近原则

当局部变量跟成员变量重名的时候，在使用时，优先使用距离比较近的那个变量

public class Student {
    //姓名 和 年龄
    private String name;
    private int age;

    //name的get和set
    //起变量名的时候，需要见名知意
    //就近原则：
    //当局部变量跟成员变量重名的时候
    //优先使用，距离最近的那个变量
    public void setName(String name){
        //此时有了一个局部变量name跟成员变量重名
        //那么下面这行代码，在使用name的时候，优先使用距离最近的name
        //其实就是把形参name的值，再赋值了给自己。
        //在这个过程，根本没有成员变量name的参与
        name = name;
    }

    public String getName(){
        //此时没有叫做name的局部变量
        //所以下面的return的时候，使用的是成员变量name
        return name;
    }

    //age的get和set
    public void setAge(int age){
        age = age;
    }

    public int getAge(){
        return age;
    }
}

九、this关键字

解决就近原则导致的问题：

当成员变量和局部变量重名的时候，我们可以在成员变量的前面加一个前缀this.

一旦加上了this.变量，就表示当前变量使用成员位置的变量。

public class Student {
    private String name;
    private int age;

    public void setName(String name) {
        this.name =  name; //这时候使用d饿就是成员变量的name
    }

    public String getName() {
        return name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public int getAge() {
        return age;
    }

    public void show() {
        System.out.println(name + "," + age);
    }
}

十、封装思想

面向对象的三大特征之一（封装、继承、多态），封装就是隐藏该隐藏的暴露该暴露的。

封装的好处：通过方法来控制成员变量的操作，提高代码的安全性，把代码用方法进行封装，提高代码的复用性。

十一、构造方法

构造方法的格式和执行时机

格式注意 :
- 方法名与类名相同，大小写也要一致
- 没有返回值类型，连void都没有
- 没有具体的返回值（不能由retrun带回结果数据）
执行时机：
- 创建对象的时候调用，每创建一次对象，就会执行一次构造方法
- 不能手动调用构造方法。手动调用指的是构造方法不能像其它方法一样通过对象名.方法名调用。
示例代码

class Student {
    private String name;
    private int age;

    //构造方法
    public Student() {
        System.out.println("无参构造方法");
    }

    public void show() {
        System.out.println(name + "," + age);
    }
}
/*
    测试类
 */
public class StudentDemo {
   
}

构造方法的作用（用于给对象的数据（属性）进行初始化）



public class Student {
    /*
        格式:
               1. 方法名需要跟类名相同, 大小写也要一致
               2. 没有返回值类型, 连void都没有
               3. 没有具体的返回值(不能由return带回具体的结果)
     */

    private String name;
    private int age;

    // 1. 如果一个类中没有编写任何构造方法, 系统将会提供一个默认的无参数构造方法
    public Student(){}

    // 2. 如果手动编写了构造方法, 系统就不会再提供默认的无参数构造方法了
    public Student(String name, int age){
        this.name = name;
        this.age = age;
        System.out.println("我是Student类的构造方法");
    }
    
     public Student(String name){
        this.name = name;
    }
  
    public void show(){
        System.out.println(name + "..." + age);
    }
}



public class TestStudent {
    public static void main(String[] args) {
        Student stu1 = new Student("张三",23);
        stu1.show();

        Student stu2 = new Student();
    }
}

十二、一个类的标准创建方式

/*
    JavaBean类: 封装数据
 */
public class Student {
    private String name;
    private int age;
//无参构造方法
    public Student() {
    }
//全参构造方法
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
//get/set方法
    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}


public class TestStudent {
    public static void main(String[] args) {
        // 1. 无参数构造方法创建对象, 通过setXxx方法给成员变量进行赋值
        Student stu1 = new Student();
        stu1.setName("张三");
        stu1.setAge(23);
        stu1.show();

        // 2. 通过带参数构造方法, 直接给属性进行赋值
        Student stu2 = new Student("李四",24);
        stu2.show();
    }
}