面向对象程序设计之封装

1. 练习讲解-猫抓老鼠小游戏

基于面向对象实现一个猫抓老鼠的小游戏，猫和老鼠都具备姓名和体重信息，猫每次抓住老鼠，体重增加老鼠体重的0.5倍；若猫的体重超过老鼠体重的20倍了，则猫抓不住老鼠，同时，老鼠逃跑。

Cat类

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Cat {
    private String  cName;
    private double cWeight;


    public void m1(Mouse m){
        while (true){
        if (cWeight>m.getMWeight()*20){
            m.tp();
            break;
        }else {
            cWeight+=m.getMWeight()/2;
            System.out.println("抓住了，目前猫的体重是："+cWeight);
        }
        }
    }
}

Mouse类

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Mouse {
    private String mName;
    private double mWeight;

    public void tp(){
        System.out.println("嘿嘿嘿！抓不到我了吧！");
    }
}

测试类

public class Demo {
    public static void main(String[] args) {
        Cat c =new Cat("Tom",2);
        Mouse m = new Mouse("jure",0.5);

        c.m1(m);
        }
    }

2.方法重载（Overload）

重载（Overload）是Java中多态性的实现策略；一个方法多种表现形态；多重 即一个类或者接口中存在多个同名的方法，但是这些方法的参数必须不同（个数，类型，顺序任选一项）

public class Demo {
    public void m1(){
        
    }
    public void m1(String name){

    }
    public void m1(String name ,int i){

    }
    public void m1(int i,String name){

    }
    public void m1(int i ){

    }
}

重载的使用场景：

**经常使用的System.out.println();其中println()方法就是典型的重载

*println()

*println(char c)

*println(boolean b)

*println(String s)

*...... 

重载联系：

**在一个Shape类中计算不同图形（圆形、矩形）的面积，方法的名称必须一致

public class Demo2 {
    public void m(int a,int b){
        System.out.println(a*b);
    }
    public void m(int a){
        System.out.println(Math.PI*a*a);
    }

    public static void main(String[] args) {
        Demo2 demo2 = new Demo2();
        demo2.m(2);
        demo2.m(5,8);
    }
}

3.package & import

3.1.package(包)

package 关键字用于声明代码所在的软件包，作用于将不同模块的功能代码通过package组织到不同的目录中分门别类存储，另外，包还可以用于标识软件的唯一性，包可以作为maven中的groupId声明方式一般使用域名倒置的写法

package com.softeem.j2016;
package cn.sina.music;

package edu.xxx.xxx.xxx;

3.2.import(导包)

由于一个Java程序可能会涉及到很多的不同的软件包package，并且在某个包中需要使用到其他包中的类或者接口，在此时就需要将其他包中的类或者接口导入到当前的类中，这个过程称之为导包，需要使用import关键字实现，例如：

import java.util.Scanner;
import java.util.Date;
import com.softeem.j2106.demo.Test;

4. 访问修饰符

Java中对于不同元素的访问权限可以通过一些特定的关键字（访问修饰符）来进行限定，这些关键主要包含以下：

**public

**protected

**private

以上修饰符可以用于修饰：

**类（常用 ：public、default）

**属性（常用：private）

**构造器（常用：public、private）

**方法（常用：public、protected、private）

关于访问修饰符的注意事项：

1.类只能使用public或default修饰（内部类除外）

2.属性通常使用private修饰，除非有些属性需要被子类重用

3.局部变量不可使用访问修饰符修饰

4.方法一般使用public修饰，也有些只为当前类服务的功能性方法使用private

5.构造器一般使用public修饰，在一些特殊场景（单例模式）也会见到构造器使用private修饰符

5. 封装（Encapsulation）

面向对象程序设计语言通常包含三大特征：封装、继承、多态。

5.1.信息隐藏

信息隐藏指的是对象的一种保护机制，使得他的属性或方法不被外部的程序直接访问，因为，使用这对内部类定义的数据（对象的成员变量）的直接操作会导致数据的错误、混乱或安全性的问题，不利于程序的解耦。

隐藏一个类的实现细节；防止对封装数据的未经授权的访问。使用者只能通过实现定制好的方法来访问数据，可以方便的加入控制逻辑，限制对属性的不合理操作，有利于保证数据的完整性；便于修改，增强代码的可维护性。

5.2.封装实现

封装的实现方式，通常是将类中的属性（成员变量）私有化，使用（private）修饰，针对这些属性提供公开的方法进行访问，从而达到隐藏实现细节，但外界依然可以安全获取数据的目的。

setter/getter方法

针对于属性提供的公开的一般都有固定的写法，通常称之为setter、getter方法，特点是：

**方法前缀使用set或get开头

**后缀一般使用属性名称首字符大写

**对于Boolean类型的get方法一般命名为isXxx

案例：

public class Demo3 {
    private String username;
    private String password;
    private String sex;
    private double money;
    private boolean marry;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getSex() {
        return sex;
    }

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

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }

    public boolean isMarry() {
        return marry;
    }

    public void setMarry(boolean marry) {
        this.marry = marry;
    }
}

对于以上用于表现数据的类一般称之为：实体类，后续也有很多类似的名词：

**entity：实体类

**dto：数据传输对象

**po：持久化对象

**vo：值对象

**pojo：普通Java对象

 **例如需要完成一个电商系统，内部包含商品信息，类别信息，订单信息，会员信息等。。。

5.3.封装的好处

Java中的封装性，带来的好处如下：

**信息隐藏，保障数据的安全访问

**提高的程序内聚性，降低耦合度

**提供了灵活的成员访问方式（setter/getter）

**提高了代码的可重用性