七 类与对象

---

一、引入面向对象的思想

1、什么是面向对象的思想？
面向对象的思想是基于面向过程的思想发展而来的。

面向过程：强调的是实现功能的每一个步骤
面向对象：强调的是对象，然后由这个对象去调用功能

2、面向对象的特点：
（1)、是一种更加符合我们现实生活习惯的思想
（2)、可以将复杂的事情简单化
（3)、我们从之前的参与者（执行者）变成了指挥者

举例：
    吃饭：
        面向过程的思想：先去菜市场买菜--洗菜--切菜--做菜--装盘--吃
        面向对象的思想：点外卖--厨师做菜--打包--外卖小哥送餐
    
    接水：
        面向过程的思想：拿起水杯--走到饮水机面前--选择热水还是冷水--接水--喝
        面向对象的思想：祈求同桌去接水--同桌拿起你的水杯--同桌接水--你喝水
    
    学习大数据：
        面向过程的思想：自己买材料--自己看视频--自己写代码--自己解决bug--学不会
        面向对象的思想：老师给你资料--老师给你录屏--老师教你--老师带着你写代码
                       --老师帮助你解决bug--学会了--帮助你模拟面试--拿到高薪

需求：将大象装进冰箱
面向过程的思想：
分析过程：
（1）打开冰箱门
（2）把大象装进冰箱
（3）关闭冰箱门

伪代码实现：

   class Demo{
        public static void main(String[] args){
           System.out.println("打开冰箱门");
            //注意，打开冰箱门这个动作肯定不是一行输出语句就能搞定的
            //现在只是为了演示面向过程的思想，就用一句输出语句代替
            //假设将来我们在这个程序中要开很多次门
            //我们可以将打开冰箱门这个功能封装成一个方法，然后main方法调用
            //同理，把大象装进冰箱以及关闭冰箱门
            open();
            put();
            close();

        }
        public static void open(){
            //写打开冰箱门的功能实现代码
            System.out.println("打开冰箱门");
        }

        public static void put(){
            //写把大象装进冰箱的功能实现代码
        }

        public static void close(){
            //写关闭冰箱门的功能实现代码
        }
    }

面向对象的思想：
    面向对象的思想实现该需求：
        1、我们要考虑需求中有哪些类？
        2、每一个类中都有些什么？
        3、类与类之间的关系又是什么呢？
    
    1、我们要考虑需求中有哪些类？
        如何分析有哪些类呢？
            方式1：需要用到UML这门课的知识
            方式2：名词提取法
        使用第二种方式分析有哪些类？
            题目：将大象装进冰箱
            大象类，冰箱类，测试类

    2、每一个类中都有些什么？
        大象类：
            属性：体积，鼻子，脚掌，象牙...
            功能：被装进冰箱，喝水，叫...

        冰箱类：
            属性：品牌，价格，材质...
            功能：打开冰箱门,关闭冰箱门....

        测试类：（创建对象，使用对象的地方）
            main方法，实现需求   

    3、类与类之间的关系又是什么呢？
        测试类中使用大象类和冰箱类完成需求

伪代码实现：
    //定义一个大象类：
    class Elephant{
        体积;
        鼻子;
        象牙;

        被装进冰箱();
        喝水();
        叫();
    }        

    //定义一个冰箱类：
    class IceBox{
        品牌;
        价格;
        材质;

        打开冰箱门();
        关闭冰箱门();
    } 

    //定义一个测试类实现需求
    class Demo{
        public static void main(String[] args){
             //调用冰箱类中的打开冰箱门的方法
             //调用大象类中的被装进冰箱的方法
             //调用冰箱类中关闭冰箱门的方法
        }
    }</font>

---

提示：以下是本篇文章正文内容，下面案例可供参考

二、类与对象

1.类与对象的关系

 类相当于抽象的概念
对象是类的具体表现

2.如何用java语言描述现实世界的事物呢？

举例：人
    五官，姓名，年龄，性别....
    吃饭，学习，说话....

水杯：
    颜色，材质，形状，容积...
    装水，泡茶...

属性：用于描述事物的信息
行为：用来描述事物能够做什么的

我们学习编程语言，目的其实用来描述现实世界的事物
而我们现在所学的语言：java
现在就要开始学习如何用java来描述一个现实世界的事物
首先，我们知道java的最基本的单位是：类
所以我们应该通过java中的类去描述现实世界的事物
按照我们分析现实事物的角度出发得到一个与java中类的对应关系
现实事物：                        类：
    属性：用于描述事物的信息         成员变量：用于描述事物的信息
    行为：用来描述事物能够做什么的    成员方法：用来描述事物能够做什么的

类：是一组成员变量和成员方法的集合，可以把类看作一个抽象的概念
对象：是该类的具体的表现，具体到一个个体
举例：
    事物：人
        属性：姓名，性别，年龄...
        行为：吃饭，睡觉，学习...
    
    类：Person
        成员变量：name,gender,age
        成员方法：eat(),sleep(),study()
    
    对象：是该类的具体的表现，具体到一个个体
        学生，老师，医生，律师，程序员

接下来学习如何定义一个类

3、定义一个类：
成员变量：
成员方法：
事物：
属性：用来描述事物的信息
行为：用来描述事物能够做什么

    类：
        成员变量：事物的属性
        成员方法：事物行为
    定义一个类，其实就是定义这个类中成员变量和成员方法。

    案例：我们来完成一个学生类的定义

    学生：
        属性：姓名，性别，年龄
        行为：学习，吃饭，睡觉

    类：
        成员变量：name,gender,age
        成员方法：study(),eat(),sleep()

   如何定义一个成员变量？
        1、定义的位置：在类中，方法外
        2、定义的格式：
            数据类型 变量名;

   如何定义一个成员方法？
        1、定义的位置：在类中
        2、定义的格式：
            修饰符 返回值类型 方法名(参数列表){
                方法体;
            }

我们之前教大家定义修饰符的时候，使用public static
而现在，由于我们还没有学过static的作用，
现在先去掉static,现在只用public,直到学到了static，我们在加上。

如何创建对象：
    类名 对象名 = new 类名()

通过对象访问成员变量：对象名.非私有的成员变量名
通过对象访问成员变量：对象名.非私有的成员方法

现在我们来定义关于手机的类

eg:

package com.shujia.wxl.day08;

/*
            定义一个手机类：
                属性：品牌，价格，颜色
                行为：打电话，发信息，听音乐

            定义一个类：Phone
                成员变量：brand,price,color
                成员方法：call(String s),sendMessage(),listenMusic()
 */
class Phone{
    //定义成员变量
    String brand;
    int price;
    String color;

    //成员方法
    public void call(String s){
        System.out.println("打电话给"+s);
    }

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

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


public class PhoneTest {
    public static void main(String[] args) {
        //根据手机类创建一个手机对象
        Phone p1 = new Phone();
        //通过创建出来的手机对象访问对象成员变量
        //创建对象另外一种说法：实例化
        System.out.println(p1.brand); //null
        System.out.println(p1.price); //0
        System.out.println(p1.color); //null

        //给对象的成员变量进行赋值
        p1.brand = "华为";
        p1.price = 9999;
        p1.color = "曜石黑";

        System.out.println("手机的品牌是："+p1.brand);
        System.out.println("手机的价格是："+p1.price);
        System.out.println("手机的颜色是："+p1.color);

        //通过对象调用成员方法
        p1.call("杨老板"); //注意，调用对象的成员方法的时候，需要注意是否要传参！
        p1.sendMessage();
        p1.listenMusic();

    }
}

一个对象的内存图如下：

eg:

package com.shujia.wxl.day08;

/*
    创建两个对象并赋值调用
 */
//同一个包下，类名不能重复
class Phone1{
    //成员变量
    String brand;
    int price;
    String color;

    //成员方法
    public void call(String s){
        System.out.println("打电话给"+s);
    }

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

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

public class PhoneTest2 {
    public static void main(String[] args) {
        //定义一个手机类
        Phone1 p1 = new Phone1();
        //给手机对象p1成员变量赋值
        p1.brand = "小米";
        p1.price = 1999;
        p1.color = "白色";
        System.out.println(p1.brand+"---"+p1.price+"---"+p1.color);
        p1.call("雷军");
        p1.sendMessage();
        p1.listenMusic();

        //定义第二个手机对象
        Phone1 p2 = new Phone1();
        p2.brand = "苹果";
        p2.price = 4999;
        p2.color = "黑色";
        System.out.println(p2.brand+"---"+p2.price+"---"+p2.color);
        p2.call("乔布斯");
        p2.sendMessage();
        p2.listenMusic();
    }
}

创建两个对象的内存图

eg:

package com.shujia.wxl.day08;

/*
        3个对象的内存图
        其中有两个引用指向同一个对象

 */
class Phone3{
    //成员变量
    String brand;
    int price;
    String color;

    //成员方法
    public void call(String s){
        System.out.println("打电话给"+s);
    }

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

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


public class PhoneTest3 {
    public static void main(String[] args) {
        //定义一个手机类
        Phone3 p1 = new Phone3();
        //给手机对象p1成员变量赋值
        p1.brand = "小米";
        p1.price = 1999;
        p1.color = "白色";
        System.out.println(p1.brand+"---"+p1.price+"---"+p1.color);
        p1.call("雷军");
        p1.sendMessage();
        p1.listenMusic();

        //定义第二个手机对象
        Phone3 p2 = new Phone3();
        p2.brand = "苹果";
        p2.price = 4999;
        p2.color = "黑色";
        System.out.println(p2.brand+"---"+p2.price+"---"+p2.color);
        p2.call("乔布斯");
        p2.sendMessage();
        p2.listenMusic();

        //创建第三个手机对象，将第一个对象名赋值给它
        Phone3 p3 = p1;
        p3.brand = "华为";
        p3.price = 19999;
        p3.color = "蓝色";
        System.out.println(p1.brand+"---"+p1.price+"---"+p1.color);
    }
}

3个对象的内存图，其中有两个引用指向同一个对象

注：认真理解，有图有真相，不然后面很麻烦ψ(｀∇´)ψ