Java OOP 第一章 封装

Java OOP

前言

课程体系介绍：

Java OOP简介

课程目标

一、回顾与预习

1. 什么是类，什么是对象？

   类是抽象的，对象是类的具体的实例

2. 如何创建对象？

   语法：new 对象名称( ) 示例：new Dog( );

3. 写出在Java程序中接收控制台输入的代码

   1. 导包：import java.util.Scanner;

   2. 创建扫描仪对象： Scanner input = new Scanner(System.in);

   3. 接收输入：String str = input.next( ); int num = input.nextInt( );

4. 如何从现实世界中抽象出类？

   1）发现类 public class ClassName{ }

   2）发现类的特征（属性）

   3）发现类的行为（方法）

   -----------------------------华 丽 分 割 线------------------------------

5. 构造方法的作用和特点是什么？

   • 作用：初始化对象/实例化对象

   • 特点：①方法名与类名一致 ② 无返回值 ③ 分有参构造和无参构造

6. 什么是方法重载？

   概念： ①在同一个类中，方法名相同，参数列表（参数个数/参数的类型）不同，与方法的返回值无关。

   举例：

   System.out.println();
   System.out.println(true);
   System.out.println(100);
   System.out.println("hello java oop");
   

二、学习任务

• 设计“星沐生态农场”项目核心类类图

• 实现“星沐生态农场”中种植作物功能

• 实现“星沐生态农场”中查看生长状态和收获果实功能

三、学习目标

1. 掌握类和对象的概念
2. 会使用类图描述设计
3. 掌握面向对象设计的基本步骤
4. 掌握构造方法及其重载
5. 掌握封装的概念及其使用

四、面向对象的优点

面向对象（Object Oriented）

• 将构成问题的事物拆解成各个对象，建立对象的目的是为了描述每个事物在整个解决问题步骤中的行为。
• 优点： 易扩展、代码复用率高、利于后期扩展和维护，提升开发效率
• 不足： 一定程度上增加系统开销

五、设计类时遵循的原则

1. 属性和方法的设置是为了解决业务问题
2. 关注主要属性和方法
3. 如果没有必要，勿增加额外的类、属性与方法

六、星沐生态农场

游戏介绍 1

• “星沐生态农场”游戏的需求

  • 每个玩家拥有一块土地，可以选择种植作物

• 假设目前有两种作物可以选择，苹果树和玉米

  • 每种作物具有不同的生长特点

    • 苹果树的生长特性

    名称	品种	生长期时长	采摘期时长	果实数量
    苹果树	富士、金帅	10天	2天	100个

    • 玉米的生长特性

    名称	生长期时长	采摘期时长	果实数量	收割费用
    玉米	8天	3天	200个	家用收割机：50元、联合收割机：100元

• 作物在整个生长过程中会经历：生长期、采摘期和已死亡

  • 生长期结后进入采摘期，便可以采摘
    • 如果在采摘期内完成了采摘，则收获全部果实；否则将无法收获到果实
  • 采摘期结束后，作物死亡

游戏介绍 2

• 星沐生态农场”游戏的需求

  • 在程序运行窗口中，根据提示实现的功能

游戏介绍 3

本章完成种植作物功能，如图所示：

​ 根据控制台提示，选择种植的作物
​ 苹果树、玉米
​ 如果选择种植苹果树，则提示输入苹果树品种
​ 富士、金帅
​ 如果选择种植玉米，则提示输入收割机类型
​ 家用收割机、联合收割机
​ 每类收割机对应不同的收割费用
​ 控制台输出作物特性信息
​ 作物名称、生长期时长、采摘期时长、果实数量
​ 苹果树品种 或 玉米收割费用

七、使用面向对象思想实现“星沐生态农场”游戏

作物——现实世界的对象

问题思考：如何在计算机中使用面向对象思想描述农场里作物?

分析：从需求中归纳抽象出类的步骤

1. 从需求中提取名词，确定类
2. 从需求中提取名词，确定类属性
3. 从需求中查找动词，确定类方法

解决方案：用面向对象描述世界

用面向对象的思想描述世界

​ 第一步：从需求中提取名词，确定类

​ 1.玉米、苹果、 … …
​ 2.土地、游戏

第二步：从需求中提取名词，确定类属性

​ 名称、品种、生长期时长、采摘期时长、果实数量、生长状态、是否已采摘、收割费用、… …

第三步：从需求中查找动词，确定类方法

​ 种植苹果树、查看生长状态、收获果实、输出作物特性信息、… …

八、类图

使用类图描述类
用于分析和设计“类”
直观、容易理解

设计类时遵循的原则

1. 属性和方法的设置是为了解决业务问题
2. 关注主要属性和方法
3. 如果没有必要，勿增加额外的类、属性与方法

分析需求，设计玉米类，画出类图

九、定义类

定义苹果树（AppleTree）类，定义其属性及输出苹果树特性信息的方法

根据游戏需求，为相关属性赋初值

名称、品种、成长期时长、采摘期时长、果实数量、是否采摘

​ 生长状态初始值为“生长期”

​ 定义输出作物生长特性方法

package com.aiden;

/**
 * 苹果树
 * 【示例1：定义苹果树类】
 *
 * @Created by Aiden
 * @Date 2022-03-24
 */
public class AppleTree {

    private String name = "苹果树";        //名称
    private int growTime = 10;            //成长期
    private int harvestTime = 2;          //采摘期
    private int numsOfFruits = 100;       //果实数量
    private String brand;                 //品种
    private String status = "生长期";      //生长状态
    private boolean isHarvested = false;  //是否采摘

     //省略 getter/setter...

    /**
     * 输出苹果树的特性信息
     */
    public void print() {
        System.out.println("*****作物特性*****");
        System.out.println("您种植了" + this.name + "。");
        System.out.println("成长期" + this.growTime + "天,"
                + "采摘期" + this.harvestTime + "天，"
                + "果实数量为" + this.numsOfFruits + "，现在处于" + this.status + "。");
        System.out.println(this.name + "属于水果作物,品种：" + this.brand + "。");
    }

}

定义玉米类

定义玉米（Corn）类，定义其属性及输出苹果树特性信息的方法

定义属性时，根据游戏需求，为相关属性赋初值

名称、成长期时长、采摘期时长、果实数量
生长状态初始值为“生长期”
默认使用家庭收割机收割玉米，设置收割费用初始值为50

package com.aiden;

/**
 * 玉米
 * 【示例2：定义玉米类】
 *
 * @Created by Aiden
 * @Date 2022-03-24
 */
public class Corn {
    private String name = "玉米";       //名称
    private int growTime = 8;           //生长期
    private int harvestTime = 3;        //采摘期
    private int numsOfFruits = 200;     //果实数量
    private String status = "生长期";    //状态（生长期、成熟期、已死亡）
    private double harvestCost = 50.0;  //收割费用
    private boolean isHarvested = false; //是否采摘

    //省略 getter/setter...
    /**
     * 输出玉米的特性信息
     */
    public void print() {
        System.out.println("*****作物特性*****");
        System.out.println("您种植了" + this.name + "。");
        System.out.println("生长期" + this.growTime + "天，采摘期" + this.harvestTime + "天，产量" + this.numsOfFruits + ",现在处于" + this.status + "。");
        System.out.println(this.name + "属于农作物，收割费用为" + this.harvestCost + "元。");
    }
}

定义游戏类

创建游戏类Game
根据游戏需求中描述的相关流程，在main()方法中编写代码
选择“退出”选项，退出游戏；否则，循环显示菜单提示等候选择

package com.aiden;

import java.util.Scanner;

/**
 * 游戏类
 * 【示例3定义游戏类】
 * @Created by Aiden
 * @Date 2022-03-24
 */
public class Game {
    /**
     * 星沐生态农场游戏入口方法
     * @param args
     */
    public static void main(String[] args) {
        //定义扫描仪
        Scanner input = new Scanner(System.in);
        //定义是否退出的标识变量
        boolean exit=true;
       //循环操作
        do {
            System.out.println("欢迎来到星沐生态农场！");
            System.out.println("\n请选择：1.种植作物 2.查看生长状态 3.收获果实 4.退出");
            //定义接收用户选择的菜单序号变量
            int menuNo = input.nextInt();
            switch (menuNo) {//1.种植作物
                case 1:
                    System.out.print("请选择您要种植的作物：1.苹果树 2.玉米");
                    int type=input.nextInt();//接收种植的作物编号
                    if(type==1){//苹果树
                        AppleTree appleTree=new AppleTree();
                        System.out.println("请选择苹果树品种（1：富士 2：金帅）");
                         int brandNo=input.nextInt();//种苹果树品种编号
                        if (brandNo==1){//富士
                            appleTree.setBrand("富士");
                        }else if(brandNo==2){//金帅
                            appleTree.setBrand("金帅");
                        }else{
                            System.out.println("苹果树品种编号输入错误！");
                        }
                        //输出苹果树的特性信息
                        appleTree.print();
                    }else if(type==2){ //玉米
                        //创建玉米实例对象
                        Corn corn=new Corn();
                        //输出玉米特性信息
                        corn.print();
                    }else{
                        System.out.println("请选择正确的作物编号[1,2]!");
                    }
                    break;
                case 2:
                    System.out.println("查看生长状态，暂未实现！");
                    break;
                case 3:
                    System.out.println("收获果实，暂未实现！");
                    break;
                case 4:
                    exit=false;//控制do while循环
                    System.out.println("退出");
                    break;
                default:
                    System.out.println("您的输入有误！请重新输入");
                    break;
            }
        } while (exit);
        System.out.println("程序结束！");
    }
}

十、构造方法

问题： 实现种植苹果树功能时，先通过new关键字创建对象，再给属性赋值，需要使用多条语句才能完成

AppleTree appleTree = new AppleTree();
appleTree.setBrand(“金帅”);

可否在创建对象的同时完成赋值操作？

分析：使用构造方法

构造方法 是一种特殊的方法，用于完成对象的初始化

定义示例：

private String brand;
//无参
public AppleTree() {
  this.brand = "金帅";//this关键字是对一个对象的默认引用，这里用以区分同名成员变量
}
//有参，一旦自定义构造方法，系统将不再提供默认无参构造方法 
public AppleTree(String brand) {
 	this.brand = brand;
}
//有参
public AppleTree(String name,String brand,int growTime,int harvestTime,int numsOfFruits)  {
     this.name = name;
     this.brand = brand;
     this.growTime = growTime;
     this.harvestTime = harvestTime;
     this.numsOfFruits = numsOfFruits;
}

调用示例：

AppleTree appleTree = new AppleTree();  //调用无参构造方法
appleTree.print();     

AppleTree fuji = new AppleTree("富士"); //调用带参构造方法
fuji.print();

AppleTree pinkLady = new AppleTree("苹果树","粉红佳人",12，3，80);
pinkLady.print();

常见错误：

​ 当在类中定义了有参构造，无参构造将会被覆盖，从而导致引发编译错误

this关键字

this是对一个对象的默认引用
	调用成员变量
	调用成员方法
	调用已定义的构造方法

因为 this 关键字是在对象内部指代自身的引用，所以它只能调用实例变量、实例方法和构造方法，不能调用类变量和类方法，也不能调用局部变量

十一、方法重载

如下代码中AppleTree类的3个构造方法有什么共性特征？

public AppleTree() {
    //省略初始化代码
}
public AppleTree(String brand) {
    //省略初始化代码
}
public AppleTree(String name,String brand,int growTime)  {
   //省略初始化代码
}

生活中方法重载案例

public class Player {
    public void Play(歌曲) {  
        //演唱歌曲
    }
    public void Play(钢琴) {
        //弹奏钢琴
    }
    public void Play(剧本) {
        //根据剧本表演
    }
}

模仿举例：

​ 榨汁机 榨汁方法 参数（苹果、梨子、西瓜） 果汁

​ 运动员 运动方法 参数（体育用品 篮球、乒乓球、橄榄球） 运动

结论：

1.在同一个类中
2.方法名称相同
3.参数列表不同（参数的个数和参数类型以及参数的顺序）

构造方法也属于方法的重载

常见错误： 如下代码所示

class CompSalary {
    public void Pay(SE se)  {
        float money = se.BasePay + se.MeritPay;
         System.out.println("程序员的薪水:" + money);
    }
    public String Pay(SE se)  {
        float money = se.BasePay + se.MeritPay;
        return money.ToString();
    }
    ……
}

结论： 4.名称以及参数列表相同的方法，仅仅是返回值类型不同，不能称之为方法重载。

十二、封装

问题：下面代码有什么缺陷？如何解决设计的缺陷？

AppleTree appleTree = new AppleTree();
appleTree.name = "西瓜";//

方案：使用封装

面向对象三大特征之一 ：封装
将类的某些信息隐藏在类内部，不允许外部程序直接访问
而是通过该类提供的方法来实现对隐藏信息的操作和访问
封装的好处：

封装的步骤：

1. 修改属性的可见性——>设为private
2. 为每个属性创建公有的getter/setter方法——>getter:可读/setter:可写
3. 在getter/setter方法加入属性读写时的控制语句——>判断属性值的合法性

十三、访问修饰符

问题： Java中，如何限制和制约类之间的访问关系？

• 包

• 访问修饰符

• 类的访问修饰符

  修饰符/作用域	同一包中	非同一包中
  public	可以使用	可以使用
  默认修饰符	可以使用	不可以使用

• 类成员的访问修饰符

  修饰符/作用域	同一类中	同一包中	子类中	外部包
  private	可以使用	不可以使用	不可以使用	不可以使用
  默认修饰符	可以使用	可以使用	可以使用	不可以使用
  protected	可以使用	可以使用	可以使用	不可以使用
  public	可以使用	可以使用	可以使用	可以使用

十四、static关键字

问题： Java中，是否可以通过类名直接访问类的成员？
方案： 使用static关键字可以实现,用 static 修饰的属性、方法和代码块属于它所在的类，由这个类创建的所有对象可以共用同一个static成员。

public static void main(String[] args) {
    Hello.sayHi();
}

public class Hello{
    //静态方法
    public static void sayHi(){
        System.out.println("Hello World!");
    }  
}

调用静态成员的语法： 可直接调用类的成员，不需再消耗资源反复创建对象。

类名.成员变量名
类名.成员方法名();

使用static 修饰的属性称为静态变量或类变量
没有使用 static 修饰的属性称为实例变量

static： 静态，可用于修饰 属性、方法、内部类

使用static关键字修饰类变量、代码块

package com.aiden;

/**
 * @author Aiden
 */
public class StaticExample {
    public static int i;         //静态变量
    public static int j = 10; //静态变量
    public int k;                 //实例变量
	//静态代码块
    static {  
        System.out.println("*******执行静态代码块*********");
        i = 20;
        System.out.println("初始化k的值为" + i);
        System.out.println("初始化j的值为" + j);
    }
	//构造函数
    public StaticExample() {
        System.out.println("*******执行构造方法创建对象*******");
        k = 30;
        System.out.println("初始化k的值为：" + k);
    }

    /**
     * 测试方法
     * @param args
     */
    public static void main(String[] args) {
        StaticExample se = new StaticExample();
        System.out.println("*******main()方法中修改变量值*******");
        se.k++;             //引用实例变量
        StaticExample.j++;  //引用静态变量
        System.out.println("当前的i的值为：" + StaticExample.i);
        System.out.println("当前的j的值为：" + StaticExample.j);
        System.out.println("当前的k的值为：" + se.k);
    }
}

输出结果：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kQXylK3G-1648199640170)(E:\BDQN\BCSP\课件笔记\JavaOOP\OOP 01.assets\1648198482809.png)]

注意事项：

1. 方法里，不可以定义static变量，即：类变量不能是局部变量
2. static代码块在JVM初始化阶段执行，只会执行一次，一般情况下， 使用static代码块对static变量进行初始化。

使用static关键字修饰类方法

Java方法分类

1. 静态方法（又称类方法）：使用 static 关键字修饰的方法

2. 实例方法：未使用 static 关键字修饰的方法

   public class StaticExample {
       public static int i;
       public static int j = 10;
       public int k;
   
       //省略静态代码块、构造方法
       public static void staticMethod(){
           System.out.println("*******执行静态方法*******");
           //先创建对象，再通过对象访问其成员变量k
           StaticExample se = new StaticExample();
           se.k = 25;//这里k为非静态属性
           System.out.println("k的值为"+se.k);
       }
   }
   

   静态方法的调用： 用类名直接调用静态方法

   public static void main(String[] args) {
       //省略其他调用代码……
       StaticExample.staticMethod(); 
   }
   

下面代码是否正确？

使用static修饰与非static修饰的类成员的区别

	static、非private修饰	非static、private修饰
属性	类属性、类变量	实例属性、实例变量
方法	类方法	实例方法
调用	类名.属性 类名.方法() 对象.属性 对象.方法()	对象.属性 对象.方法()
归属	类	单个对象

十五、使用static、final关键字定义常量

问题： 以农场游戏为例，在生长过程中，作物生长状态值：生长期、采摘期和已死亡，不会发生变化，如何定义这样的变量？
方案： 通常使用static 和 final关键字定义类的常量

//定义常量类保存作物的生长状态
public class Constants {
    public static final String GROW = “生长期”;
    public static final String MATURE = "采摘期";
    public static final String DEAD = "已死亡";
}

测试调用：

public class ApplyTree {
    // … …省略部分代码
    public AppleTree(String brand){
        this.brand = brand;
        this.status = Constants.GROW;//使用静态常量
    }
}

注意事项：

1.常量名一般由大写字母组成
2.声明常量时一定要赋初值
3.定义常量时要求见名知意，便于阅读，易于代码修改和维护

十六、学习总结