封装（面向对象设计的基本步骤 ，使用类图描述面向对象设计，构造方法（Constructor），方法重载 ，关键字：static ，this关键字，final常量，封装）

学习目标：

掌握面向对象设计的基本步骤

使用类图描述对象设计

掌握构造方法和方法重载

static修饰符

掌握封装的概念及其使用

---

学习内容：

1.面向对象设计的基本步骤

面向对象设计的过程就是抽象的过程，分以下三步来完成

发现类 发现类的属性 发现类的方法

 

 

2. 使用类图描述面向对象设计

类图：分为三个部分
    第一行：表示类名
    第二行：表示各个属性
        (+、-表示访问修饰符/访问权限)
        +：表示public，公开的
        -：表示private，私有的
        例如：+name:String   表示public String name;
    第三行：表示各个方法
        例如：+print()：void 表示public void print(){}

建模工具

Visio Visio

是office软件系列中的负责绘制流程图和示意图的软件，是一款便于IT和商务人员就复杂信息、系统和流程进行可视化处理、分析和交流的软件。

Rose

Rational Rose是Rational公司出品的一种面向对象的统一建模语言的可视化建模工具。用于可视化建模和公司级水平软件应用的组件构造。

PowerDesigner

PowerDesigner是Sybase的企业建模和设计解决方案，采用模型驱动方法，将业务与IT结合起来，可帮助部署有效的企业体系架构，并为研发生命周期管理提供强大的分析与设计技术。

练习1——使用类图描述面向对象设计

运用面向对象思想抽象出Dog类和Penguin类，画出对应类图

 答案

3.通常将系统中固定是使用的几个值，设置为常量，而且通常设置为公共的静态常量，语法如下：

public static final  类型 常量名  = 常量值;

public 是便于在程序的任何地方都可以使用这个变量，如果不是public，那么有些地方将不能使用static是便于可以直接使用“类名.常量名”这样的语法，而不需要再去创建对象了，简化使用。

final是设置成常量，以达到不能修改值的目的，照应常量的目的————系统中固定使用的值

通常会在包中创建一个字典类（DictionaryUtil）来放一些系统程序需要用到的常量配置

例：

public class DictionaryUtil {
    public static final String SEX_MALE = "雄";
    public static final String SEX_FEMALE = "雌";
}

调用方法：

 String sex = choice == 1 ? DictionaryUtil.SEX_MALE : DictionaryUtil.SEX_FEMALE;

4.构造方法（Constructor）：对象的创建就是通过构造方法来完成，当类实例化一个对象时会自动调用构造方法

构造方法是一种特殊的方法，它是一个与类同名且无返回值类型的方法。

语法：

访问修饰符类名（参数）{
//初始化对象
}

作用：创建并初始化对象！！！

分类：无参构造和有参构造

无参的构造方法（系统会默认提供的午餐构造方法）

一个类中只有一个无参构造方法

有参的构造方法（系统不会自动提供，需要开发者收订自定义创建）

一旦开发者自己创建 了有参的构造方法后，那么系统将不再提供默认的无参构造，这个时候如果强行使用无参构造，程序将会报错！

因此，开发者在创建了有参构造之后，通常需要顺手将无参构造也手动创建出来。

有参构造示例：

 public Penguin() {
    }

    public Penguin(String name, String sex) {
        this.name = name;
        this.sex = sex;
    }
}

有参构造的调用 有参构造的调用直接可以代替代码中被注释掉的代码

 /*Penguin penguin = new Penguin();
        penguin.name = name;
        penguin.sex = sex;*/
        Penguin penguin = new Penguin(name,sex);
        penguin.print();

使用快捷键生成构造方法：

Alt键 + insert键，选择Constructor，然后根据需要选择构造方法中的参数。

5.方法重载

同一个类中，不允许同时存在多个一摸一样的方法，如果同一个类中需要用到同名方法时，就需要使用方法重载（overload）:

同一个类中

方法名相同参数项（参数个数不同，类型不同）

示例：

 public void getSum(int a){

    }

    public void getSum(double a){

    }

与返回值.访问修饰符无关（返回值相同不相同，或者访问修饰符相同不相同都不影响他们是不是方法重载）

优点：

方法重载其实是对一般方法的一种升级，可以根据参数的不同，采用不同的实现方法，而且不需要编写多个名称，只要记住一个方法即可。

方法重载的示例：

public class CalcNum {

    public int getSum(int a,int b){
        return a + b;
    }

    /*private void getSum(int b,int a){
    }*/

    public int getSum(int a,double b){
        return 0;
    }

    public int getSum(double a,int b){
        return 0;
    }

    public void getSum(int a){

    }

    public void getSum(double a){

    }

    public double getSum(double a,double b, double c){
        return a + b + c;
    }
}

方法重载的调用：

public class CalcNumApplication {
    public static void main(String[] args) {
        CalcNum calcNum = new CalcNum();
        System.out.println(calcNum.getSum( 1 , 9));
        System.out.println(calcNum.getSum( 1.9 , 9.5,6.4));
    }
}

6.关键字：static 

表示：表示静态的意思，static修饰的成员变量和普通方法，都是类级别的，都可以使用类名来调用

注意：！！！static不能修饰类

使用：

static可以修饰成员变量，修饰普通方法，修饰代码块

public class A{
static int a;//静态变量，也叫做类变量
}

public static void show(){
//静态方法，也叫做类方法
}

static{
//静态代码块，也叫做类代码块
}
}

static修饰的变量属于这个类所有，即由这个类创建的所有对象共用同一个static变量。

举例类级别的变量（静态变量）与对象级别的变量（普通变量）的区别：

例一

      大家在教室上课，一上午的时间，大家都要瞌睡

       对象级别的变量（普通变量）：给每个同学都发了一个杯子，大家各自喝自己水杯里的水，不会影响到其他同学的杯子

        类级别的变量（静态变量）：提供了一个饮水机，一个同学喝了一杯，那么其他同学再使用时，就发现少了一杯水。

例二

package com.oop.day05;
/**
 * @authorDesc 诸神在上，佑我程序，玄功护体，BUG皆去！
 * @author zhangjianguo
 * @date 2022-10-26 17:06:34
 * @version 1.0.0
 * @description
 */
public class StaticApplication {
    static int i = 20;
    int j = 20;

    public static void main(String[] args) {
        StaticApplication s1 = new StaticApplication();
        s1.i--;
        s1.j--;
        StaticApplication s2 = new StaticApplication();
        s2.i--;
        s2.j--;
        System.out.println(s2.i);
        System.out.println(s2.j);
    }
}

解析：

示例三 静态变量执行的优先级

1.在同一个类中

package com.oop.day05;
/**
 * @authorDesc 诸神在上，佑我程序，玄功护体，BUG皆去！
 * @author zhangjianguo
 * @date 2022-10-26 17:06:34
 * @version 1.0.0
 * @description
 */
public class StaticApplication {
    static int i = 20;//第一步加载
    static int m = 20;//第二步加载
    int j;
    int k= 25;
    static {
        i = 10;
        System.out.println("static代码块中的i的初始值");//第三步加载
    }
    public StaticApplication() {
        j = 20;
        System.out.println("构造方法中j的初始值是 + j");
    }
    public  static  void getNum(){
        System.out.println("静态方法中得到i的值是：" + i);
    }

    public static void main(String[] args) {
        StaticApplication s1 = new StaticApplication();
        System.out.println("main方法中的i的值是" + StaticApplication.i);
        StaticApplication.getNum();
        System.out.println("main方法中m的值是" + s1.m);
        System.out.println("main方法中k的值是" + s1.k);

    }
}

执行结果

 解释：执行的结果是先加载类中的代码，因为static修饰的是类级别的，

            在执行构造方法前要先执行静态的属性变量值然后是静态代码块，再然后执行的才是main方法里面的

2..不在在同一个类中

public class StaticApplication {
    static int i = 20;
    static int m = 20;
    int j;
    int k= 25;
    static {
        i = 10;
        System.out.println("static代码块中的i的初始值");
    }
    public StaticApplication() {
        j = 20;
        System.out.println("构造方法中j的初始值是 + j");
    }
    public  static  void getNum(){
        System.out.println("静态方法中得到i的值是：" + i);//这一步
    }

   
}

package com.oop.day05;

public class StaticTest {
    public static void main(String[] args) {
        StaticApplication s1 = new StaticApplication();
        System.out.println("main方法中的i的值是" + StaticApplication.i);
        StaticApplication.getNum();
        System.out.println("main方法中m的值是" + s1.m);
        System.out.println("main方法中k的值是" + s1.k);

    }
}

应该是先执行main 方法中的第一行然后执行，然后 在执行构造方法前要先执行静态的属性变量值然后是静态代码块，然后再按照创建对象执行构造方法即public  static  void getNum(){
        System.out.println("静态方法中得到i的值是：" + i);
    }

这一步。

最后普通的静态方法只能通过调用才能被加载，即 public StaticApplication() {}这种方法。

7.封装：追求程序的安全性

  意义：

          将类的某些信息隐藏起来，只提供对外开放的接口，那么我们就可以再这个接口中编写限制/保证数据或程序安全的逻辑代码。

优点：

        便于使用者正确使用系统，防止错误修改属性
        有助于系统之间的松耦合，提高系统独立性（防止一个功能出现问题，导致整个系统都不能            使用）
        提高软件的可重用性（一次编写，多个地方都可以使用）
        降低了构建大型系统的风险

 

步骤：

(1).隐藏

     即：属于私有化：private int health;

     使用者不能直接使用另一个类创建出来的对象的私有属性

(2).提供对外开放的方法：（设置方法+获取方法）

     对外开放就要求这个方法必须是public的 

   设置方法  

public void setHealeth(int health){

this.health = healeh;
}

     获取方法

public void getHealeth(){

return health;
}

使用这些方法就需要调用这些方法：调用方法如下

Dog dog = new Dog(this.strain);
dog.setHealth(-1000);
System.out.println("狗子的健康值是：" + dog.getHealth());

(3).在方法中编写限制的逻辑代码：以防止使用者对属性随意赋值，这样可以保证数据的安全性

public void setHealth(int health){
if(health < 0 || health > 100){
  System.out,println("健康值设置错误，已默认设置为60");
  health = 60;
}
this.health = health;
}

封装时会用到多个权限修饰符来修饰成员变量和方法

 

8.this关键字：表示当前对象

      调用者就是this，谁是调用者谁就是this

 public boolean check(User user){
        System.out.println("参数的姓名：" + user.getName());
        System.out.println("调用者的姓名：" + this.name);
        if(user.getName().equals(this.name) && user.getAge() == this.age){
            return true;
        }
        return false;
    }

 boolean flag2 = user2.check(user1);
        System.out.println(flag2);

user2.check(user1);user2是调用者，所以是this

 作用：

        使用this调用成员变量，解决成员变量和局部变量的同名冲突（主要使用）

         使用this调用成员方法，this可以省略，直接调用print（）；

         如果使用this调用重载的构造方法，只能在构造方法中使用，必须是构造方法中的第一条语句

public Dog() {
        this("安安","秋田犬");//调用重载的构造方法
    }

    public Dog(String name, String strain) {
        this.name = name;
        this.strain = strain;
    }