今天内容安排：
1、物流系统交通工具数据封装
2、模拟物流系统快递任务类定义
3、完成长方形类与数学工具类

01交通工具类封装需求.avi
02交通工具封装需求分析.avi
03类的定义格式与使用格式.avi
04类定义格式的进一步解释.avi
05交通工具类代码实现.avi

01交通工具类封装需求

* A: 交通工具类封装需求
    * a: 需求
        * 定义交通工具类，完成类封装(数据类型的封装)。
            * 要求具有属性：
                * 车辆编号、品牌型号、负责人
            * 要求具有以下的功能：
                * 获取属性值功能
                * 为属性赋值功能
                * 运输功能
                * 保养功能

02交通工具封装需求分析

* A: 交通工具封装需求分析
    * a: 需求分析
        * 定义交通工具类依据需求定义。
        * 定义测试类用于测试代码，只有一个main方法
    * b: 所需知识点
        * 数据类型的定义
            * 定义格式
            * 成员变量
            * 成员方法
        * 数据类型的使用
            * 创建对象
            * 调用方法

03类的定义格式与使用格式

* A: 类的定义格式
    * a: 在前边我们学习过的水果类是定义类的一部分，一个完整的类其成员变量一般需要使用private修饰，不光需要成员变量还需要成员方法。
    * b: 定义格式：
        创建.java文件，文件名与类名相同。
        public class 类名{
            private 数据类型  变量名1;
            private数据类型  变量名2;
            …其他成员变量

            public 返回值类型 方法名(参数类型 参数名，参数类型 参数名2…) {
            方法体;
        }
        …其他成员方法

        对应属性的get/set方法
        }
* B: 使用格式
    * a: 创建对象
        在测试类的main方法中创建交通工具类对象
        class Test {
            public static void main(String[] args) {
                    Transportation  t = new Transportation();
            }
        }
    * b: 调用对象方法
        class Test {
            public static void main(String[] args) {
                //创建交通工具对象
                    Transportation  t = new Transportation();
                    //为某个属性赋值与取值，这里为型号赋值并取值打印
                    t. setModel(“宝马X5”);
                    String  model = t.getModel();
                    System.out.println(model);
                    //调用功能性方法
                    t. transport();
                    t. carCare();
            }
        }
* C: 案例代码
    /*
     * 自定义类型：人类
     * 
     * 成员变量：
     *     姓名、年龄、性别
     * 成员方法：
     *  吃饭、睡觉、打豆豆、对属性们的获取和赋值
     *  
     *  private：让外界无法访问，用于修饰成员
     *  this：用于区分成员变量与局部变量(定义时，明显展示出来的功能。而功能本质，面向对象后再解释)
     *  方法定义时，一般是没有static的。
     *  
     */
    public class Person {

        //定义成员变量
        private String name;
        private int age;
        private String sex;
        private boolean isLoveJava = true;
        
        //定义成员方法
        public void eat() {
            System.out.println(name+"吃了");
        }
        
        public void sleep() {
            System.out.println(name+"睡了");
        }
        
        public void hitBeanBean() {
            System.out.println(name+"打了，爽了，敲代码了！");
        }
        
        //获取属性值与为属性赋值的过程
        //获取姓名值
        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 String getSex() {
            return sex;
        }

        public void setSex(String sex) {
            this.sex = sex;
        }

        public boolean isLoveJava() {
            return isLoveJava;
        }

        public void setLoveJava(boolean isLoveJava) {
            this.isLoveJava = isLoveJava;
        }    
        
    }
    
    /*
     * 测试自定义数据类型：交通工具类
     * 
     * 方法调用时，静态static修饰的方法只能访问static修饰的成员(成员方法与成员变量)
     * 指的是：
     *         直接调用时，必须用static修饰
     *         如果是通过对象名调用的，就可以不用static修饰
     */
    public class Test {

        public static void main(String[] args) {
            
            //创建对象
            Person p = new Person();
            
            //调用方法,main方法通过对象调用方法时，该对象的类其方法不用static修饰
            p.setName("诸葛亮");
    //        使用private修饰的成员，外界无法访问
    //        p.name
            
            p.eat();
            p.sleep();
            p.hitBeanBean();
            
            String name = p.getName();
            System.out.println(name);
    //        main直接调用method时，method必须用static修饰
    //        method();
        }
        
        public void method() {
            System.out.println("我是一个方法");
        }
    }

04类定义格式的进一步解释

* A: 类定义格式的进一步解释
    * a: 成员变量
        * 与局部变量不同，局部变量定义在一个代码块内，通常是一个方法代码块内。成员变量定义在类中方法外，可以被该类中所有方法使用。
        * 成员变量通常使用private修饰，阻止本类以外的其他类访问。
    * b: this区分局部变量与成员变量
        * 成员变量不能重名，局部变量不能重名，但是成员与局部变量可以重名，但是需要使用this区分。
        * 使用this访问的为成员变量，直接访问的为局部。没有局部变量会自动查找是否有成员变量。
    * c: 成员方法
        * 定义在类中的方法又叫成员方法。常规方法定义格式：
            访问权限修饰符  其他修饰符(通常没有)  返回值类型  方法名称(参数类型 参数名1，参数类型 参数名2…)  {
                方法体;
            } 
* B: 类的使用
    * a: 对象创建格式
        * 数据类型  对象名= new 数据类型();
    * b: 对象方法的调用
        * 无返回值：
            * 对象名.方法名(参数);
        * 有返回值：
            * 返回值类型  变量名 = 对象名.方法名(参数);

05交通工具类代码实现

* A: 交通工具类代码实现
    /*
     * 自定义交通工具类
     * 
     * 要求具有属性：
     * 车辆编号、品牌型号、负责人
     * 
     * 要求具有以下的功能：
     *         获取属性值功能
     * 为属性赋值功能
     *         运输功能
     *         保养功能
     */
    public class Transportation {
        
        private String number;//车辆编号
        private String model;//品牌型号
        private String admin; //负责人
        
        //运输功能
        public void transport() {
            System.out.println("运输了");
        }
        
        //保养功能
        public void carCare() {
            System.out.println("保养了");
        }
        
        //get/set方法
        public String getNumber() {
            return number;
        }
        
        public void setNumber(String number) {
            this.number = number;
        }

        public String getModel() {
            return model;
        }

        public void setModel(String model) {
            this.model = model;
        }

        public String getAdmin() {
            return admin;
        }

        public void setAdmin(String admin) {
            this.admin = admin;
        }            
    }
    
    public class Test {
        public static void main(String[] args) {                
            Transportation t = new Transportation();                
            t.setAdmin("张亮");
            t.setModel("三蹦子");
            t.setNumber("京P5151MLT");
            
            t.transport();
            t.carCare();
        }
    }

====================================第一阶段=============================================================
06面向对象概述.avi
07类的定义详解.avi
08类与对象的关系.avi
09private封装this.avi
10对象的内存解释.avi

06面向对象概述

* A: 面向对象概述
    * a: 面向对象概念
        * 面向对象是Java的基本特征。深刻地理解面向对象是设计良好Java软件项目的基础。
        * 面向对象(Object Oriented,OO)是软件开发过程中使用的一种思维方式 。将功能封装进对象，强调具备了功能的对象，不关注过程。
    * b: 面向对象特点
        * 是一种更符合人们思考习惯的思想
        * 可以将复杂的事情简单化
        * 将程序由执行者转换成为指挥者
    * c: 面向对象特性
        * 封装
        * 继承
        * 多态

07类的定义详解

* A: 类的定义详解
    * a: 类的基本概念
        * 具有相同特征（属性）和行为(功能)的一类事物的抽象。
        * 注意：实际上所属关系是直接属于类的均称为成员，如成员变量、成员方法、后边学习的成员内部类，并不单指成员变量。
    * b: 类在Java中代码的体现形式
        * 使用class(类)来抽象一个现实生活中的事物

 * 定义成员变量对应事物的属性，用private修饰，提供get/set方法
 * 定义成员方法对应事物的功能
* c: 定义格式
public class 类名{
private 数据类型 变量名1;
private 数据类型 变量名2;
…其他成员变量

            public 返回值类型 方法名(参数类型 参数名，参数类型 参数名2…) {
            方法体;
            }
        每个属性对应的get/set方法
        }
* B: 成员变量
    * a: 直接定义在类中的变量称为成员变量，在面向对象思想设计上，是类的组成部分。
    * b: 成员变量与局部变量辨析
        * 成员变量
            * 定义位置：类中，整个类中均可以访问。
            * 内存：成员变量随着对象的建立而建立，存在于对象所在的堆内存中。
            * 默认值：成员变量有默认值。
            * 回收：随着对象的回收而回收。
        * 局部变量
            * 定义位置：定义在局部范围，如方法内，语句内等。
            * 内存：局部变量存在于栈内存中。
            * 默认值：没有默认值。
            * 回收：随着作用域结束而回收，通常为语句或方法范围。
        * 变量访问原则
            * 就近原则
    * c: 注意
        * 成员变量的访问不再使用从前的方式，而使用调用属性对应的get/set方法的方式。即类的使用不再包含直接使用对象访问属性，均是在调用方法。
* C: 成员方法
    * a: 成员方法一般可分为两类
        * 没有业务的属性get/set方法，与属性对应
        * 有业务的普通方法，属于类的功能

08类与对象的关系

* A: 类与对象的关系
    * 类是抽象概念，对象是类的具体实例。
    * 一个类可以有多个对象，一个对象只属于一个类。
    * 可以说创建对象是类最主要的使用方式。

09private封装this

* A: private关键字
    * private关键字是私有化修饰符，访问权限修饰符的一种，只有在本类中才能访问的成员，
        是封装类中成员变量最常用的修饰符。
    * 用于修饰成员，包括成员变量与成员方法。
* B: 封装
    * 把数据和方法包装进类中，以及具体实现的隐藏，常共同被称作是封装。
    * 封装的结果是一个同时带有特征和行为的数据类型。
    * 我们前边所完成的水果项类的定义就是封装的一部分。同样，成员变量与成员方法以及对应的private修饰，公共的get/set方法均为封装的一部分。
* C: this关键字
    * this一般出现在类的一个方法的定义当中，代表当前对象的引用。
    * 通常用其将本对象中的成员与其他作用域成员区分开来。
    * 当一个类定义好之后，如果不创建对象this是没有意义的。
    * 一个类可以有多个对象。每个对象都有各自的属性值，各个对象的方法均是类中定义的那个方法逻辑。定义中的this就代表调用方法的这个对象。
    (this代表本类对象的引用。this代表所属方法的所属对象。this代表谁来调用我，我就代表谁)

10对象的内存解释

* A: 对象的内存解释
    * a: 对象内存位置
        * 对象由new关键字创建，如同数组，实体存在于堆内存中
        * 任何事物均可以定义成类，创建对象，属于引用类型。
        * 而对象的引用变量是一个普通变量。

================================第二阶段============================================================
11快递任务类需求.avi
12快递任务类代码实现.avi
13快递任务类的使用.avi

11快递任务类需求

* A: 快递任务类需求
    * a: 定义快递任务类
        * 要求具有属性：
            * 单号、货物重量
            * 要求具有以下的功能：
                * 送前任务准备方法，使用打印语句描述(后为抽象方法)
                * 发送货物方法，使用某种交通工具运输
                * 送后任务执行，使用打印语句描述（后为抽象方法）

12快递任务类代码实现

* A: 快递任务类代码实现
    /*
     * 快递任务类
     * 
     * 快递单号(String)
     * 货物重量(double)
     * 
     * 送前：本方法内逻辑：货物检查、验单、装货、货物人联系确定
     * 送货：简单提示语、使用交通工具运输
     * 送后：简单打印：满意度调查、XXX车辆已归还    调用交通工具类的车辆保养功能
     * get/set
     */
    public class SendTask {

        private String number; //快递单号
        private double goodsWeight; //货物重量
        
        //送前方法
        public void sendBefore() {
            System.out.println("已经非常严格地检查过货物了！");
            System.out.println("已经将货物和单号对上号了！");
            System.out.println("已经将货物非常轻地装上了运货车辆！");
            System.out.println("已经跟亲商量好什么时候到货了！");
        }
        
        //送货
        public void send(Transportation t) {
            System.out.println("快递小哥正在风驰电掣地赶过来！");
            //调用参数：交通工具    对象的运输方法，帮助我完成货物运输
            t.transport();
        }
        
        //送后
        public void sendAfter(Transportation t) {
            System.out.println("已经非常客观地对商品进行了评价，没有水军！");
            //调用参数：交通工具　　对象的获取车类型的方法，表明车辆已经归还
            System.out.println(t.getModel()+"车辆已经归还");
            //调用参数：交通工具　　对象的保养方法
            t.carCare();
        }
        
        //========gs==========================================

        public String getNumber() {
            return number;
        }

        public void setNumber(String number) {
            this.number = number;
        }

        public double getGoodsWeight() {
            return goodsWeight;
        }

        public void setGoodsWeight(double goodsWeight) {
            this.goodsWeight = goodsWeight;
        }    
    }

13快递任务类的使用

* A: 快递任务类的使用
    /*
     * 测试快递任务类
     */
    public class Test {

        public static void main(String[] args) {
            //创建快递任务类对象
            SendTask task = new SendTask();
            //调用快递任务类对象的方法
            //调用送前方法
            task.sendBefore();
            System.out.println("=================");
            //调用送货方法
                //创建交通工具类对象
            Transportation t = new Transportation();
            t.setNumber("京Q51MLT");
            t.setAdmin("张亮");
            t.setModel("布加迪威龙");
            
            task.send(t);
            System.out.println("=================");
            //调用送后方法
            task.sendAfter(t);
        }
    }

================================================第三阶段======================================================
14面向对象易混淆知识点简介.avi
15自定义类练习_定义同桌类.avi
16成员变量与方法参数的区别需求.avi
17长方形类与数学工具类的定义及使用.avi

14面向对象易混淆知识点简介

* A: 面向对象易混淆知识点简介
    * a: 自定义类型与已给定类型均属于一种数据类型
        * 在面向对象学习开始后，我们要习惯将自定义类型看做是普通的数据类型，
            与String在使用上没有区别，均为引用数据类型只是功能方法不同而已。
        * 基本数据类型是特殊的，只是因为接近底层，将数据类型内置到了语言本身当中。
            引用数据类型才是正常的Java面向对象思想。我们平常绝大多数操作均为引用数据类型的操作。
        * 自定义类型可以像int一样，作为成员变量，作为方法参数，作为返回值类型定义。
    
* B: 案例代码
    /*
     * 自定义数据类型可以与基本数据类型一样：定义为成员变量、方法参数、返回值类型
     */
    public class School {

        private String name;//学校名称
        private int personNumber;//学校规模，比如学生数量
        private Person[] students;
        //自定义引用数据类型作为成员变量类型
        //private Person boss;
        
        //自定义引用数据类型作为方法参数类型
        public void kaixuedianli(Person boss) {
            
            System.out.println("有请"+boss.getName()+"讲话");
        }
        
        //自定义引用类型作为返回值类型
        public Person xuanjuxiaozhang() {
            Person p = new Person();
            p.setName("柳岩");
            
            return p;
        }
    }

15自定义类练习_定义同桌类

* A: 案例代码
    /*
     * 衣服的属性：
     *     颜色
     *     材料
     *  品牌
     * 衣服的功能：
     *     保暖
     */
    public class YiFu {
        private String color;
        private String cailiao;
        private String pinpai;
        
        public void baonuan() {
            System.out.println("保暖了！");
        }

        //=========GS===================================
        
        public String getColor() {
            return color;
        }

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

        public String getCailiao() {
            return cailiao;
        }

        public void setCailiao(String cailiao) {
            this.cailiao = cailiao;
        }

        public String getPinpai() {
            return pinpai;
        }

        public void setPinpai(String pinpai) {
            this.pinpai = pinpai;
        }            
    }
    
    /*
     * 成员变量：
     *         String name 姓名
     *         String sex 性别
     *         int age 年龄
     *         YiFu chuanzhuo 同桌的穿着
     * 成员方法：
     *         void eat(String tool)  吃饭
     *         void helpMeStudy()    帮助我学习
     *         void helpXiYiFu(YiFu yifu) 帮助我洗衣服  
     */
    public class TongZhuo {

        //定义成员变量
        private String name;
        private String sex;
        private int age;
        private YiFu chuanzhuo;
        
        //定义成员方法
        public void eat(String tool) {
            System.out.println("使用"+tool+"吃饭！");
        }
        
        public void helpMeStudy() {
            System.out.println("非常贴心地晚上去我宿舍帮助我学习！");
        }
        
        public void helpXiYiFu(YiFu yifu) {
            
            String pinpai = yifu.getPinpai();
            String color = yifu.getColor();
            String cailiao = yifu.getCailiao();
            
            System.out.println("帮助我洗了我"+pinpai+"品牌"+color+"颜色，"+cailiao+"材料的衣服！");
        }

        //=========GS===================================
        
        public String getName() {
            return name;
        }

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

        public String getSex() {
            return sex;
        }

        public void setSex(String sex) {
            this.sex = sex;
        }

        public int getAge() {
            return age;
        }

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

        public YiFu getChuanzhuo() {
            return chuanzhuo;
        }

        public void setChuanzhuo(YiFu chuanzhuo) {
            this.chuanzhuo = chuanzhuo;
        }
    }
    
    /*
     * 测试同桌类
     */
    public class Test2 {

        public static void main(String[] args) {
            
            TongZhuo tz = new TongZhuo();
            
            tz.setName("陈梦");
            System.out.println(tz.getName());
            
            tz.eat("筷子");
            tz.helpMeStudy();
            
            YiFu yf = new YiFu();
            yf.setCailiao("貂绒");
            yf.setColor("黑");
            yf.setPinpai("爱马仕");
            
            tz.helpXiYiFu(yf);
            
            
        }

    }

16成员变量与方法参数的区别需求

* A: 成员变量与方法参数定义区分
        * a: 为了进一步理解面向对象的属性与方法的设计。通过以下练习进一步理解成员属性与方法参数的区别。
            * 练习如下：
                * 定义长方形类，有返回周长方法与返回面积方法。
                * 定义数学工具类，求两数和的2倍方法，求两数积的方法。
                    * 类对应现实生活中的事物
                        * 当变量属于事物本身的一部分时定义为成员变量。
                        * 当变量只是逻辑上需要的外部值时通常定义为方法的参数。

17长方形类与数学工具类的定义及使用

* A: 长方形类与数学工具类的定义及使用
    * a: 长方形类
        /*
         * 长方形类
         * 
         * 求周长方法
         * 求面积方法
         */
        public class ChangFX {
            //对于长与宽，在映射现实事物时，是属于长方形的一部分的。所以定义为成员变量。
            private int width;
            private int height;
            
            //求周长方法
            public int getZC() {
                return (width+height)*2;
            }
            
            //求面积方法
            public int getMJ() {
                return width*height;
            }

            //=======GS==========================================
            
            public int getWidth() {
                return width;
            }

            public void setWidth(int width) {
                this.width = width;
            }

            public int getHeight() {
                return height;
            }

            public void setHeight(int height) {
                this.height = height;
            }
        }
    * b: 数学工具类
        /*
         * 自定义数学工具类
         * 
         * 求两数和的2倍方法
         * 求两数积方法
         */
        public class MyMath {
            //对于数学工具类，两个数逻辑上不能是类的一部分，所以不再成员位置定义
        //    private int number1;
        //    private int number2;
            
            //因为功能需要一些数值参与计算，又不属于成员变量，这时可以在方法上定义参数供方法使用
            //求周长方法
            public int get2Times(int number1,int number2) {
                return (number1+number2)*2;
            }
            
            //求面积方法
            public int getMultiply(int number1,int number2) {
                return number1*number2;
            }
        }
    * c: 测试类
        /*
         * 类对应现实生活中的事物
         * 当变量属于事物本身的一部分时定义为成员变量。
         * 当变量只是逻辑上需要的外部值时通常定义为方法的参数。
         * 
         * 用来测试长方形类与自定义的数学工具类
         */
        public class Test {

            public static void main(String[] args) {
                //创建长方形对象
                ChangFX cfx = new ChangFX();
                //为长方形的属性赋值
                cfx.setWidth(500);
                cfx.setHeight(200);
                //通过长方形的属性计算出周长
                int zc2 = cfx.getZC();
                System.out.println(zc2);
                //通过长方形的属性计算出面积
                System.out.println(cfx.getMJ());
                
                //创建数学工具类对象
                MyMath mm = new MyMath();
                System.out.println(mm.get2Times(200, 300));
                System.out.println(mm.getMultiply(200, 300));
                
            }
        }

18复习今天的内容