09 面向对象1 类 对象 封装

1.面向对象

1.1 面向对象的概念

“面向对象的方法主要是把事物给对象化，包括其属性和行为。面向对象编程更贴近实际生活的思想。总体来说面向对象的底层还是面向过程，面向过程抽象成类，然后封装，方便使用就是面向对象，（万物皆对象）。”

面向对象(Object Oriented)是软件开发方法，一种编程范式。面向对象的概念和应用已超越了程序设计和软件开发，扩展到如数据库系统、交互式界面、应用结构、应用平台、分布式系统、网络管理结构、CAD技术、人工智能等领域。面向对象是一种对现实世界理解和抽象的方法，是计算机编程技术发展到一定阶段后的产物。
面向对象是相对于面向过程来讲的，面向对象方法，把相关的数据和方法组织为一个整体来看待，从更高的层次来进行系统建模，更贴近事物的自然运行模式。

对象的含义是指具体的某一个事物，即在现实生活中能够看得见摸得着的事物。在面向对象程序设计中，对象所指的是计算机系统中的某一个成分。在面向对象程序设计中，对象包含两个含义，其中一个是数据，另外一个是动作。对象则是数据和动作的结合体。对象不仅能够进行操作，同时还能够及时记录下操作结果。

面向过程强调的是过程,比如,把大象装冰箱,一共分3步:
第1步：打开冰箱门
第2步：把大象放进去
第3步：关上冰箱门
而面向对象强调的是结果,比如:
什么样的冰箱?什么样的大象?谁负责把大象装进去?

衣服脏了，我们可以让女盆友帮忙洗，不需要关注中间过程是怎么洗的，就可以拿到干净的衣服，当然，这首先需要有一个对象~~

面向过程----是一种思想，凡事要亲力亲为
面向对象----是一种思想，只关注结果

1.2 面向对象有三大特征：

封装：把相关的数据封装成一个“类”组件
继承：是子类自动共享父类属性和方法，这是类之间的一种关系
多态：增强软件的灵活性和重用性

2.类和对象

2.1 类

1. java最基本的单位就是类，类似于类型
2. 类是一类事物的抽象
3. 可以理解为模板或者设计图纸
   注意:类在现实世界并不存在,它只是一种对象的数据类型

2.2 对象

每个对象有三个特点，对象的状态，对象的行为和对象的标识。

1. 对象的状态用来描述对象的基本特征
2. 对象的行为用来描述对象的功能
3. 对象的标识是指对象在内存中都有一个唯一的地址值用来和其他对象区分开来
4. 类是一类事物的抽象，对象是具体的实现

2.3 类和对象的关系

计算机语言通过属性 + 行为来描述现实世界中的事物，在java语言中，我们可以通过类来描述一类事物,用成员变量描述事物的属性,用方法描述事物的行为。

其中：

1. 我们先创建类，再通过类创建出对象
2. 我们可以通过一个类创建出多个对象
3. 类是抽象的，对象是具体的

2.4 类的创建使用

在编写代码之前,我们需要分析下需求:
比如我们要把手机这一类事物抽象成代码：
那么这个事物的类型就是"手机",可以用类来描述.
类中包含的就是手机抽取出来的共性的属性与功能.

手机的属性：颜色，尺寸，品牌，价格
手机的功能功能：打电话，发短信，听音乐

对象：除此之外,我们还可以创建对象,就相当于是照着图纸制造出来的一个个的手机,比如1号手机对象，包含特有的成员变量和方法
我们通过class关键字创建类，通过new关键字创建对象。
接下来我们开始编码吧!
打开idea
创建module：
创建包: demo
创建类: TestPhone.java

package demo;
/**
 * 本类用于面向对象的入门案例
 * 用来设计收集这一类事物
 */
//1.在同一个java文件中，可以定义多个class，但是被public修饰的公共类只能有一个
//  并且要求这个公共类的名字就是当前java文件的名字
public class TestPhone {
    public static void main(String[] args) {
        //4.在main（）方法中，通过new关键字创建Phone的对象
        Phone p = new Phone();
        //5.可以通过手机类的对象p来调用方法
        p.call();
        p.message();
        p.video();
        //6.可以通过手机类的对象p来查看属性
        System.out.println(p.brand); //null
        System.out.println(p.color);  //null
        System.out.println(p.size);   //0.0
        System.out.println(p.price);  //0.0
        //7.通过new关键字创建手机类的对象p2
        Phone p2 = new Phone();
        //8.通过p2对象设置值
        p2. brand = "华为";
        p2. color = "五彩斑斓的黑";
        p2. price = 88888.88;
        p2. size = 5.6;
        //9.通过p2对象查看属性值
        System.out.println(p2.price);
        System.out.println(p2.brand);
        System.out.println(p2.color);
        System.out.println(p2.size);

    }
}

//1.通过class关键字创建手机类--用来描述手机这一类事物
//2.类似抽象的，类抽象的描述一类事物的特征/属性
//  特征：品牌 价格 颜色 尺寸
//  行为：打电话 发短信 看直播
    class Phone{
//2.通过成员变量描述一类事物的特征/属性/字段/成员变量--位置：类里方法外
    String brand; //品牌
    double price; //价格
    String color; //颜色
    double size;  //尺寸
    //3.通过方法描述一类事物的功能
    //方法的格式：修饰符，返回值类型，方法名（参数列表）{方法体}
    public void call(){
        System.out.println("正在打电话*");
    }
    public void message(){
        System.out.println("正在发短信！");
    }
    public void video(){
        System.out.println("正在看直播~");
    }
}

2.5 对象在内存中的存储过程

Java把内存分成5大区域，我们重点关注栈和堆。

1. 一般来讲局部变量存在栈中，方法执行完毕内存就被释放
2. 对象(new出来的东西)存在堆中，对象不再被使用时，内存才会被释放
3. 每个堆内存的元素都有地址值
4. 对象中的属性都是有默认值的
   TIPS: 栈与队列指的是一种数据的结构。
   栈：先进后出（FILO – First In Last Out）
   队列：先进先出（FIFO – First In First Out）

创建对象时，内存经历了什么：

1. 创建对象时，会在堆中开辟好空间：break,price等，存放引用类型p，并把p放入栈底；
2. 在堆内存中开辟一块空间，存放Phone对象
3. 完成对象的初始化，并赋值默认值
4. 给初始化完毕的对象赋予唯一的地址值
5. 把地址值交给引用类型变量p来保存

2.6 面向过程

面向过程也是一种编程思想，这种思想，强调凡事要亲力亲为，每一步都是自己来做

2.7 面向对象

java是一门面向对象的语言
面向对象OOP也是一种编程思想，强调的是结果，我不在意是怎么完成的，我在意的是有对象可以帮我干活；比如：我们想吃饭，不在意是哪个厨师做的，只要有厨师做，就行

2.8 类

类是指类型Type，用Java中的关键字class来描述
类是一类事物进行抽象总结出来的特征与行为
所以，我们可以把类看做是一类事物的模板/设计图纸

2.9 对象

对象就是根据类创建出来的一个个独立且具体的实例
一个类可以创建出多个对象，对象直接互不影响，我们通过对象唯一的地址区分对象

2.10 对象创建过程分析

比如：Phone p = new Phone();这句话在内存中发生了什么？

1. 可以在堆内存中开辟一块空间用来存放映像
2. 这个对象需要进行初始化
3. 初始化完毕以后就会为这个对象生成一个唯一的地址值
4. 在栈内存中开辟一块空间用来存放引用类型Phone类型的变量p
5. 将堆内存中对象的地址值交给引用类型的变量p来保存
6. 后续就可以根据p中保存的地址，找到堆中的对象，并对对象做操作

3.封装

3.1 概述

封装是隐藏对象的属性和实现细节,仅仅对外提供公共的访问方式,比如类和方法
好处:

提高安全性
提高重用性

3.2 private关键字

是一个权限修饰符 ,可以用来修饰成员变量和成员方法.被私有化的成员只能在本类中访问

3.3 练习：封装学生案例

创建包: demo
创建类: TestPrivate.java

package demo;

/**
 * 本类用于测试面向对象的第一大特性--封装
 */
public class TestPrivate {
    public static void main(String[] args) {
        //4.创建学生类对象s
        Student s = new Student();
        //5.通过对象操作学生类的属性与方法
        System.out.println(s.name);   //因为name没有赋值，所有打印为初始值null
        s.study();     //正在学习中
        //*2subject属性在student中
//        s.subject = "java学习中";
//        System.out.println(s.subject);  //java学习中
        //6.3 在main方法中操作subject属性
        s.setSubject("CGB");//设置值
        System.out.println(s.getSubject());  //打印值
    }
}

//1.描述学生这一类型特征：学号 姓名 科目 功能 ：学习 吃饭 睡觉
class Student {
    //2.特征:学号 姓名 科目 ---成员变量/属性
    int sno;  //学号
    String name;  //姓名
    //*1private是一个修饰符，被它修饰的资源只能在本类中使用，是权限最小的修饰
    //6.1 封装subjec属性
    private  String subject;   //科目
    //6.2 我们需要提供一个公共的方式，供外界使用
    //右键空白行--Generate--Getter and Setter--选中subject属性
    /*如果一个方法需要返回结果，那么这个方法定义的返回值类型就不再是void了，
    * 至于具体设置成什么类型，与返回值的类型保持一致
    * 比如我们要返回的subject是String类型，所以方法的返回值类型为String
    * 返回值通过关键字return进行返回 */


    public String getSubject() {
        return subject;
    }

    public void setSubject(String subject) {
        //如果一个类中的成员变量与局部变量同名，需要使用this关键字指定，我们规定this指定的是成员变量
        this.subject = subject;
    }

    //3.功能 ：学习 吃饭 睡觉
    public void study(){
        System.out.println("正在学习中");
    }
    public void eat(){
        System.out.println("正在吃饭中");
    }
    public void sleep(){
        System.out.println("正在睡觉中");
    }
}

3.2 方法的使用

package method;
/*
本类用于测评方法的使用
 */
public class TestMethod {
    public static void main(String[] args) {
        //方法1：
        int result = sum(1,5);
        System.out.println(result);

        //方法2：
        System.out.println(sum(2,5));

        //多次使用不好用
        System.out.println(get());
        System.out.println(get()+"宝塔镇河妖");
        //可以多次使用，甚至可以拼接字符串
        String s = get();
        System.out.println(s);
        System.out.println(s+"宝塔镇河妖");
        System.out.println(s+13135773);



    }

    //1.定义一个方法：功能：传入俩个数字，计算这俩个数字的和，并将结果返回
    // 格式：修饰符 返回值类型 方法名 （参数列表） {方法体}
    public static int sum(int a, int b){
        return a+b;
    }
    public static String get(){
        return "天王盖地虎";
    }

}

3.3 综合案例练习

package oop;

/**
 * 本类用于面向对象综合案例
 */
public class TestCar {
    public static void main(String[] args) {
        //在main方法中创建汽车类对象
        Car c = new Car();
        Car c2 = new Car();
        Car c3 = new Car();

        //6.1 给c对象设置汽车品牌为"野马”，并打印设置后的属性值
        c.setBrand("野马");
        System.out.println(c.getBrand());
        //6.2 给c2对象设置汽车价格为30w，并打印设置好的价格
        c.setPrice(300000);
        System.out.println(c.getPrice()+"元");
        //6.3 给c3对象的汽车颜色设置为“青青草原”,并打印设置好的颜色
        c.setColor("青青草原");
        System.out.println("车辆的颜色为"+c.getColor()+"色");
        //6.4 获取c2对象的颜色，并解释为什么是这样的打印效果
        System.out.println(c2.getColor());
        //没有设置过值，所以是默认值null

        c.start();
//        System.out.println(start());  被private修饰的资源，只能在本类当中使用



    }
}
//1.定义一个汽车类，描述汽车类型
class Car{
    //2.定义属性--成员变量
    //3.对所有属性进行封装
    private String brand;   //品牌
    private String color;   //颜色
    private double length;   //车长
    private int price;   //价格

    //3.2 给所有属性提供设置值得SetXxx()与获取值得getXxx
    //右键--Generate--getter and setter -- 按住shift 全选所有属性

    public String getBrand() {
        return brand;
    }
    public void setBrand(String brand) {
        this.brand = brand;
    }


    public String getColor() {
        return color;
    }
    public void setColor(String color) {
        this.color = color;
    }


    public double getLength() {
        return length;
    }
    public void setLength(double length) {
        this.length = length;
    }


    public int getPrice() {
        return price;
    }
    public void setPrice(int price) {
        this.price = price;

    }

    //4 提供car自己的方法
    public void start(){
        System.out.println("我的小车车启动了");
        stop();
    }
    private   void stop(){
        System.out.println("我的小车车停下来了");
        //在本类的公共方法里，调用私有方法的功能

    }

}

3.4 teacher案例练习

package oop;

/**
 * 本类用于练习面向对象2
 */
public class TestTeacher {
    public static void main(String[] args) {
        Teacher t1 = new Teacher();
        Teacher t2 = new Teacher();
        Teacher t3 = new Teacher();

        // 1.创建老师类对象t1，所授课目为CGB，姓名为泡泡
        t1.setSubject("CGB");
        t1.setName("泡泡");
        System.out.println(t1.getSubject());
        System.out.println(t1.getName());
        //2.创建老师类对象t2，工号为13089，部门为java教研二部
        t2.setNum(13089);
        t2.setDept("java教研二部");
        System.out.println(t2.getNum());
        System.out.println(t2.getDept());
        //3.创建老师类对象t3，姓名为涛涛，工号为10086，部门为java教研一部，所授课目为SCD
        t3.setName("涛涛");
        t3.setNum(10086);
        t3.setDept("java教研一部");
        t3.setSubject("SCG");
        System.out.println(t3.getName());
        System.out.println(t3.getNum());
        System.out.println(t3.getDept());
        System.out.println(t3.getSubject());


    }
}


//1.定义老师类
//1.1 属性：姓名 工号  部门 所授科目   并封装
//1.2 功能：备课方法  授课方法
class Teacher {
    private String name;
    private int num;
    private String dept;
    private String subject;

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

    public int getNum() {
        return num;
    }
    public void setNum(int num) {
        this.num = num;
    }

    public String getDept() {
        return dept;
    }
    public void setDept(String dept) {
        this.dept = dept;
    }

    public String getSubject() {
        return subject;
    }
    public void setSubject(String subject) {
        this.subject = subject;
    }

    //1.2 提供功能
    public void ready(){
        System.out.println("正在备课中");

    }
    public void teach(){
        System.out.println("正在授课中");

    }
}

4.修饰符

4.1 访问控制符

用来控制一个类，或者类中的成员的访问范围。

TIPS:default是表示不写修饰符,默认,如果写default单词来修饰会报错

4.2 匿名对象

没有名字的对象，是对象的简化表示形式。
使用场景：
当被调用的对象只调用一次时（多次会创建多个对象浪费内存）
Demo d = new Demo();
d.sleep();
d.game();
//这个d就是对象的名字。
也可以写成：
new Demo().show();//创建了一个对象调方法
new Demo().game();//又创建了一个对象调方法