面向对象1 OOP、类、对象、封装

面向对象

1.概念

在学习之前，首先需要了解面向过程和面向对象(OOP)两个概念。

例：修建一座高楼，需要总工程师设计出建设的图纸，才能根据图纸去建造，并且在这一个过程中是不是需要水泥、细沙、钢筋、搭架子等各种各样的东西或行为，一座高楼是需要很多东西和行为去完成，在这个过程中，就是面向过程。而领导给每个部门分配各项任务，如基建部门、指挥部门、服务部门、验收部门等，相对于建造的整个过程中就显得明了清晰，这就是面向对象。

2.面向对象三大特征

1.封装：把相关的数据封装成”类“组件；

2.继承：类之间的关系，子类可以自动使用父类的属性和方法；

3.多态：增强软件的灵活性。

3.类和对象

java中最基本的单位就是类；类是一类事物的抽象，可以把类理解为设计的图纸、模板等 。

对象三个特点：

对象的状态：用来描述对象的基本特征。

对象的行为：用来描述对象的功能。

对象的标识：指对象在内存中都有唯一的地址值用来与其他对象区分。

类是一类事物的抽象，而对象是具体实现的物质。

计算机语言通过属性 + 行为描述现实世界中的事物，用成员变量描述事物的属性,用方法描述事物的行为。

4.编程思路

1. 抽象相关信息，封装成一个类，类相当于设计图纸
   1）特征------属性----------用成员变量来描述
   2）行为------方法----------用方法来描述

​ 2.创建对象，通过new关键字来创建对象，如Phone p = new Phone();
​ TIPS:p是一个引用类型变量，它保存着的是对象的地址值
​ 3.通过创建好的对象来调用功能 查看属性

package cn.tedu.oop;
/*本类用于初步学习面向对象编程*/
//分析手机这类事物--用类来描述
//特征：品牌 价格 颜色 尺寸
//行为：打电话 发微信 看直播
/*一个java文件中可以创建多个class,但是被public修饰的class只能有一个
* 而且这个公共类必须与文件名一致，也就是说公共类的名字就是文件名*/
public class TestCreateClass {
    //4.在公共类中创建一个程序的入口函数main()
    public static void main(String[] args) {
        //5.创建手机类对象p
        Phone p = new Phone();
        //6.通过”.“来调用对象的具体功能
        p.call();
        p.learn();
        p.message();
        //7.打印查看对象的具体值
        System.out.println(p.brand);
        System.out.println(p.color);
        System.out.println(p.size);
        System.out.println(p.price);
        //8.创建手机类对象p2
        Phone p2 = new Phone();
        p2.message();
        //9.修改p2对象的相关属性值并查看是否修改成功
        p2.brand = "HUAWEI";
        p2.color = "五彩斑斓的黑";
        p2.price = 8888.88;
        p2.size = 100;
        System.out.println(p2.brand);
        System.out.println(p2.color);
        System.out.println(p2.size);
        System.out.println(p2.price);
    }
}
//1.通过class关键字描述手机这一类事物
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 learn(){
        System.out.println("假装正在看直播~");
    }
}

5.封装

封装是隐藏对象的属性和实现细节,以提高安全性。

1.将一类事物的属性和行为进行抽象，封装成一个"类"组件，比如：Phone类
2.对类中的资源用private进行修饰，private是一个权限修饰符 ,可以用来修饰成员变量和成员方法.被私有化的成员只能在本类中访问，提高程序的安全性
属性的封装,用private进行修饰，提供公共的属性设置值和访问值方法
getXxx() – 获取属性值
setXxx() – 设置属性值

访问私有资源？

成员变量:
setXxx() – --对外提供公共的设置值方式
getXxx() –-- 对外提供公共的获取值方式
成员方法:
把私有方法放在公共方法里供外界调用即可

package cn.tedu.oop;
/*本类用于测试封装*/

public class TestPrivate {
    public static void main(String[] args) {
        /*创建学生类的对象s,s表示保存的是对象的地址值*/
        Student s = new Student();
        /*通过创建好的对象查看属性值，调用方法*/
        s.study();  //调用学习功能
        s.eat();    //调用吃饭功能
        System.out.println(s.name);   //查看s对象下名字属性
        System.out.println(s.subject);  //查看s对象下科目属性
       // System.out.println(s.sno);   //查看s对象下学号属性
        System.out.println(s.getSubject());
        System.out.println();
    }
}
/*描述学生这一类事物的属性------成员变量*/
class Student{
    String name;   //姓名
    private  int sno;   //学号 此处设置privates私有的，上面则不能查看sno
    public String getSubject(){
        return subject;
    }
    public String setSubjiect(String subject){
        this.subject = subject;
        return subject;
    }
    public int getSno() {
        return sno;
    }

    public void setSno(int sno) {
        this.sno = sno;
    }

    String subject;  //学科

    //描述学生这一类事物的行为-------方法
    public void study(){
        System.out.println("学习Java");
    }
    public void eat(){
        System.out.println("干饭王！~");
    }
}

封装总结：

1）总结归纳一类事物的特点与行为，通过抽象，封装成一个“类”组件【重用性】
2）使用private关键字封装属性与方法，组织外界直接访问资源【安全性】

封装属性：
1>使用private修饰类中的成员变量,被private修饰的资源只能在本类中使用
2>对外提供公共的getXxx()【获取值】与setXxx()【设置值】
3>我们可以通过封装组织外界直接访问资源，想要访问，必须按照我的方式来

封装方法
1>使用private修饰类中的方法，被private修饰的资源外部无法直接访问
2>可以在本类的公共方法中调用此私有方法的功能

面向对象巩固练习：

package cn.tedu.oop;
/*本类用于面向对象的巩固练习*/
public class TestCar {
    //创建程序的入口函数main()
    public static void main(String[] args) {
        //3.创建汽车类对象c
        Car c = new Car();
        //4.通过汽车类对象c设置属性值
//        c.color = "暗夜紫";
//        c.brand = "BMW";
//        c.price = 200;
//        c.length = 0.2;
        //5.查看刚刚设置好的属性值
//        System.out.println(c.brand);
//        System.out.println(c.price);
//        System.out.println(c.color);
//        System.out.println(c.length);
        //6.通过c对象调用汽车类的方法
        c.start();
        //c.stop();
        //7.3调用提供的set与get方法，设置并获取对应属性的值
        c.setBrand("特斯拉");
        c.setColor("black");
        c.setPrice(200.02);
        c.setLength(3);
        System.out.println(c.getBrand());
        System.out.println(c.getColor());
        System.out.println(c.getLength());
        System.out.println(c.getPrice());
        //8.3 调用公共方法来实现私有方法功能的使用
        c.start();
    }
}
//1.抽象汽车这一类事物的属性与行为，封装成一个类组件
class Car{
    //2.属性--用成员变量来描述
    //7.1封装所有的属性值--使用private修饰
    private String color;
    private String brand;
    private double price;
    private double length;
    //7.2 生成所有属性的get与set方法
    /*右键空白处->Generate->Getter and Setter->按住Shift全选所有属性生成即可*/
    public String getColor() {
        return color;
    }

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

    public String getBrand() {
        return brand;
    }

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

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }

    public double getLength() {
        return length;
    }

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

    //3.行为--用方法来描述
    //8.2 可以在本类公共的方法里，调用私有方法
    public void start(){
        System.out.println("汽车开动了~");
        stop();//我们通过方法名+参数列表确定要调用哪个方法
    }
    //8.1封装方法，通过private修饰符
    private void stop(){
        System.out.println("汽车停止了~");
    }
}

使用3W1H原则描述面向对象OOP

1. WHAT----------是什么？

面向对象OOP是一种编程思想

2. WHY–为什么要使用它？

相较于之前的面向过程而言，面向过程强调的是过程，凡事亲力亲为，而面向对象强调的是结果，我们由之前每件事物的具体执行者转变为了指挥者要做事情，先创建对象出来，通过对象来完成具体业务，提高效率。

3. WHEN–何时何处使用它？

JAVA是一门面向对象的语言，万物皆对象，正是因为对象无处不在，所以容易被忽略，与其他的技术点来说，面向对象的思想无处不在，只要想干活，先创建对象。

4. HOW–如何使用它+使用时的注意事项？

编程顺序：
1）总结归纳一类事物的特点与行为，通过抽象，封装成一个“类”组件
类中包含：属性 --成员变量 (赋值) 行为–方法（调用）
2）通过new关键字创建指定类的对象
3）有了对象，就可以通过"对象."来使用类中的所有资源

注意事项：

1. 一个java文件中只能有一个公共类，且此类与文件名同名
2. 自定义抽象形成的类与公共类是并列关系
3. 在同包下，不能创建两个同名的class
4. 根据同一个类模板创建出来的多个对象间不会互相影响