Java笔记Day_08

面向对象编程思想[OOP]

为什么要学习思想? 思想可以决定行为

学习编程思想可以改变编程的"行为" -->编程的方式

        面向对象: 更侧重于对象使用的一种编程方式 //面向对象编程思想是面向过程编程思想的升级

        面向过程: 更侧重于编程过程书写的一种编程思想

面向过程编程思想: 凡事必躬亲 //亲力亲为 

        重点关注的是: 完成功能的过程 -->C语言

面向对象编程思想: 自己的事情别人做 //懒人思维: 行为上的懒: 行为上的懒, 思维很敏捷

        重点关注的是: "谁"能帮助我完成此需求 -->C++语言 和 Java语言

面向对象编程思想的特性

        封装性, 继承性, 多态性

面向对象编程思想的特点

        1.更符合日常的思维习惯

        2.把复杂的问题简单化

        3.把我们从执行者变成指挥者

洗衣服: 

        1.面向过程:

                泡一泡 --> 搓一搓 -->揉一揉 -->甩一甩 -->晾起来

        2.面向对象: //洗衣机 , 妈妈

                打开洗衣机 -->放衣服

买电脑:

        1.面向过程:

                去中关村 --> 去选店家, 选配置 --> 和老板谈价格 -->自己组装 --> 自己搬回家

        2.面向对象: //对象: 电商APP, 朋友

                打开某东 --> 选电脑 -->下单

去饭店吃饭: 去饭店坐下来, 说的第一句话是什么? --> 服务员点单

通过服务员点单案例, 我们了解到: 万物皆对象[Thinking in Java(Java编程思想)]

        世间万物都可以是对象, 都具备功能, 都可以帮助"我们"完成需求

        1.眉毛: 是 --> 美观 //功能性不那么强的也是对象, 对象不一定是 人

        2.PM2.5 / 垃圾 :是 //对象不一定干好事

        3.念头 / 面向对象编程思想: 是 //对象不一定真实存在

类和对象

类: 种类, 类别 --> 代码中 : 类型 //范围

        类是一类事物的抽象 //抽象指的是: 没有具体到一个东西,而是一个模糊的范围

        技巧: 所有的名词表达都是 类 !

        我们使用的不是类, 而是此类的对象 //我们使用的不是一类事物, 而是这类事物中的一个具体的东西

对象: 具体的东西

        对象是此类事物的具体化

        技巧: 具体/具体化

        我们使用的是对象, 对象是隶属于类的, 是类中具体的一个东西

类和对象的关系: 类是一类事物的抽象, 对象是此类事物的具体化

是先有类还是先有对象: 先有类, 再有对象 //类: 对象的模板

        99%的情况都是都是先有类后有对象, 1%的情况是先有对象后有类  //就算是1%的这种情况,也会再看到对象后立刻给其分类!

那么已知生活中有很多 类[事物] , 如果让这些事物 出现在代码中呢 ??? 在Java中,定义 类[class] 即可, 在class中去描述事物

为什么要让生活中的事物出现在代码中 : 代码存在的意义是为了解决生活中的问题,生活中的东西出现在代码中才能模拟生活中的场景,从而解决生活中的问题;

如何描述一类事物

如何描述一类事物: 定义类

格式:

        public class 类名{

        }

之前定义的Demo, Test类, 这些类不是用来描述一类事物的, 而是启动代码用的 -->启动类

现在定义的是 描述事物的类, 所以类的名字要见名知意 ! 手机: Phone 学生:Student 狗: Dog

        //例如: 描述手机的类

        public class Phone{

        }

注意: 描述事物的类中, 不要写main方法! 而是去写描述事物的东西: 属性, 行为

        //例如: 描述手机的类

        public class Phone{

        //属性: 特征[成员变量: 定义在类中方法外的变量]

        //成员变量的定义格式: 数据类型 变量名; -->成员变量可以不赋值, 因为成员变量有默认值, 默认值参照数组元素的默认值

        -->手机的属性: 品牌, 价格, 颜色 --> 定义哪些属性, 是根据自己的需求来的 // : 不知道属性什么类型,  就定义成字符串类型[String]

        String brand; //品牌

        int price; //价格

        String color; //颜色

        //行为: 功能[成员方法: 定义在类中方法外的方法, 所有的方法都是成员方法]

        //成员方法的定义格式 和 讲方法时 方法的定义格式一致, 但是今天咱不写static关键字

        //描述事物的类中定义方法, 不加static , main方法所在的类中, 定义方法就加static!!!

        //打电话
        public void call(){
            //打电话的逻辑 -> 方法体
        }
        //发短信
        public void sendMessage(String name){
            //给谁发短信
        }

}

在描述事物这件事情上[定义事物描述类] 是 属性更重要 还是 行为更重要?

如何使用此类事物

如何使用此类事物: 创建对象

格式:

        类名 对象名 = new 类名();

有了对象, 就可以使用对象的属性和行为 --> 小数点[调用]

    //对象调用属性
    对象名.属性名 -> 获取对象的属性值
    对象名.属性名 = 值; -> 修改对象的属性值
    //对象调用方法
    对象名.方法名(实际参数); -> 直接调用 : void 返回值的方法 / 有返回值的方法[不推荐]
    System.out.println(对象名.方法名(实际参数)); -> 输出调用 : 有返回值的方法
    返回值类型 变量名 = 对象名.方法名(实际参数); -> 赋值调用 : 有返回值值的方法
        
为什么加 对象名. : 为了说明是哪一个对象在调用

两个对象的内存图

private访问权限修饰符

private访问权限修饰符

        public > protected > 不写 > private

private: 私有的

        作用 : 被 private 关键字修饰的成员[成员变量,成员方法]只能在当前类[本类]中使用
        
        私有让成员只能在本类中访问,出了自己的类就不可以使用了 !
        
        但是 : 如果赋的值是正确的值那么也一样赋值不了 ! 

getter and setter 方法

当属性被私有修饰之后,还需要给属性提供公共的访问!!

getXxx 方法 -> 获取属性值的方法
        返回值类型 : Xxx属性的类型
        形参列表 : 无形参的方法
            
setXxx方法 -> 设置该属性值的方法
        返回值类型 : void
        形参列表 : (Xxx属性的类型 变量名)            

要求[死命令] : 只要定义事物描述类,事物描述类中的所有属性全都用 private 修饰 , 并给每一个属性提供对应的 getter and setter 方法  !!

getter方法的执行流程图

setter 方法的执行流程图

变量访问到就近原则问题

变量访问时有远近关系 :
    局部位置 比 成员位置 要近 !
        
变量访问的就近原则问题 : 当访问变量时, 变量会优先访问离自己最近的那个变量 !      
    
想要打破变量的就近访问问题 :
    打破局部位置变量的访问,强制访问本类成员位置上的变量 : this.变量名

this关键字

this关键字:

 1.实操场景[具体怎么用]: 打破局部位置约束, 强制访问本类成员位置上的变量 / 方法

        this.变量名: 强制访问本类成员位置上的变量 --> 打破变量就近访问原则的

        this.方法名(实参): 强制访问本类成员位置上的方法 --> 不会这样写!因为不存在局部方法, 只要是在访问方法,就一定访问的是成员方法, 所以可以省略this.

2.理解层面[如何理解this的含义]: 当前对象的引用 //哪个对象调用含有this关键字的方法,那么方法内的this关键字就代表哪个对象!

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

成员变量,成员方法 都 属于对象 !

记忆技巧 :

1. 因为在类中位置不同,所以导致作用域不同和在内存中的位置不同

2. 因为在内存中位置不同,所以导致默认值不同和生命周期不同

        如果变量,方法没有被使用时 : 颜色是灰的 !

面向对象之封装性

封装: 包起来!

哪些场景体现了Java面向对象的封装性:

        1.循环: 重复的代码封装到循环内 --> 提高代码的复用性

        2.方法: 重复的功能逻辑封装到方法内 --> 提高代码的复用性[方法还带来了数据的传递]

        3.private: 把事物的属性全部用私有修饰, 导致了属性只能在当前类中使用 --> 提高代码的安全性

        4.定义事物描述类: 把一类事物的属性和行为 封装到一个类中 --> 提高了代码的多样性

构造方法[构造器]

构造方法: 虽然是方法, 但是是特殊的方法[和其他方法有好多不一样的地方, 但是本质上还是方法]

        方法: 封住了特定功能的代码

        构造: 构建 创造 

        --> 用来构建和创造"对象"的方法

new关键字:

        1.创建了对象

        2.在堆内存中开辟空间

        3.调用构造方法

构造方法的格式:

        //无参构造

        访问权限修饰符 类名(){

                //方法体;

        }

        //有参构造/带参构造

        访问权限修饰符 类名(形参列表){

                //方法体

        }

格式解释:

        访问权限修饰赋: 可以写public, protected, 不写, private -->但是一般写public

        类名: 构造方法的名字必须和类名 一模一样! --> 大小写都一样 //构造方法不遵循小驼峰式命名

        (): 构造方法的形参列表 -->如果没有形参: 无参构造, 如果有形参: 有参构造/带参构造

        

注意事项:

        1.构造方法是通过关键字new来调用的!

        2.构造方法的名字必须和类名 一模一样! --> 大小写都一样 //构造方法不遵循小驼峰式命名

        3.构造方法是没有 返回值类型 这个板块! 连void都不可以写! //因为调用完构造方法的结果一定是生成了一个此类对象!

        4.如果在一个类中没有定义构造方法, JVM会赠送一个默认的无参构造

        5.在一个类中是可以有多个构造方法的 -->写晚餐构造, 写有参构造! //构造方法是可以重载的!

        6.只要你在类中定义了构造, 那么JVM默认赠送的构造方法就不送的了 !  
        7. 就算有构造方法 也不能省略 set 方法的编写 -> 因为 set方法可以修改对象的属性 , 而构造一旦new出来,一定生成了新的对象的!    

标准事物描述类[JavaBean]的编写步骤[重重点]

1. 私有所有属性 -> private
2. 自动生成无参构造 -> 右键 -> generate -> constructor -> select none
3. 自动生成有参构造 -> 右键 -> generate -> constructor -> ctrl + a + ok
4. 自动生成 getter and setter 方法 -> 右键 -> generate -> getter and setter -> ctrl + a + ok
    
// 如果题目有需求,再编写此类事物的行为[功能方法]