菜鸡的Java笔记 第十一 - java 封装性

1.1封装的基础实现。
        封装是把过程和数据包围起来，对数据的访问只能通过已定义的接口。面向对象计算始于这个基本概念，即现实世界可以被描绘成一系列完全自治、封装的对象，这些对象通过一个受保护的接口访问其他对象。封装是一种信息隐藏技术，在java中通过关键字private实现封装。什么是封装？封装把对象的所有组成部分组合在一起，封装定义程序如何引用对象的数据，封装实际上使用方法将类的数据隐藏起来，控制用户对类的修改和访问数据的程度。
    1.2封装的作用
        ① 对象的数据封装特性彻底消除了传统结构方法中数据与操作分离所带来的种种问题，提高了程序的可复用性和可维护性，降低了程序员保持数据与操作内容的负担。
        ②对象的数据封装特性还可以把对象的私有数据和公共数据分离开，保护了私有数据，减少了可能的模块间干扰，达到降低程序复杂性、提高可控性的目的。

/*封装性   说的是 安全性 不让外部对象直接调用或者是修改
  需要解决的是 把属性保护起来 JAVA 关键字 private  
  但是 太安全了  外部无法访问  
  如想现在需要通过对象操作类中的属性在java 中有个要求 可以使用 setter,getter 设置或 取得属性
  以public String name 封装为例
    设置属性 public void setName(String n):  名称 要首字母大写
    取得属性 public void getName():    
*/

// 以后只要是类中的属性全部都要使用private 封装 封装后的是属性必须按照要求编写 setter,getter 方法

class Person { //现在定义一个类
    //定义类中的两个属性
    private String name; // 表示人的姓名
    private int age;  // 表示人的年龄
    public void tell(){
        System.out.println("姓名：" + name +"年龄：" + age);
    }
    public void setName(String n){
        name = n;
    }
    public void getName(){
        return name;
    }
    public void setAge(int a){
        if(a >= 0&&a <= 100){
            age = a;
        }
    }
    public void getAge(){
        return age;
    }
}
public class T{// 另一个类
    public static void main (String args[]){
        Person per = new Person();
        per.setName("少爷"+"\n");
        per.setAge(-3);
        per.tell();
    }
}

/*  private 声明的属性只能够被类的内部做访问
    private 声明的属性必须有对应的 setter,getter 方法
*/

>>>
    在JAVA中所有面向对象的概念都是以类与对象的关系为主的。那么下面通过一个具体的程序来研究一下，为什么需要有封装性。
    范例：观察如下程序代码

class Person { //现在定义一个类
    //定义类中的两个属性
    String name: // 表示人的姓名
    int age:  // 表示人的年龄
    public void tell(){
        system.out.println("姓名：" + name +"年龄：" + age):
    }
}
public class T{// 另一个类
    public static void main (String args[]){
        Person per = new Person():
        per.neme = "少爷"：
        per.age = -30:
        per.tell():
    }
}
// 姓名：少爷，年龄：-30

现在的代码没有语法错误，但是从显示的角度来讲，这个代码是有错误的，而且问题严重。这样的错误严格来讲就属于业务错误。那么造成这种出错的原因是什么?
        最大的错误在于当前类中的属性可以直接被类外部的对象调用。所以，此时就认为这样的操作属于不安全的操作
    那么现在最需要解决的问题设计将内部的属性保护起来，即，不让外部直接操作。为此在JAVA中提供有一个 private 关键字，利用此关键字可以实现封装。

    加入 private 之后，就表示此时 name 与 age 两个属性只能够被person类访问。
    范例;错误调用

    现在发现，使用了private 定义的属性，类的外部不能够直接进行访问了，所以安全性是最高的
    那么如果现在需要通过对象操作类中的属性，那么JAVA 中就有了一个明确额要求:可以使用 setter,getter 方法设置或取得封装内容，以 privare String name 封装属性为例：
        设置数据：public void setName(String n )；
        取得数据：public String getName();
    以 private int age ；封装属性为例：
        设置数据：public void setAge(int a)；
        取得数据：public int getAge();
    范例：修改程序，使得外部可以访问私有属性

    开发原则：以后只要是类中的属性全部使用 private 封装，封装后的属性必须严格按照要求编写 setter，getter 方法，不管当前代码是否调用了 getter，必须提供
    如果非要进行一些检测操作，则可以修改 setter 方法（只是现在临时说明）



// 姓名：哪吒，年龄：0

/*  private 声明的属性只能够被类的内部做访问
        private 声明的属性必须有对应的 setter,getter 方法
    */

>>>>>
    private 声明的属性只能够被类的内部所访问；
    private 声明的属性必须有对应的 setter，getter 方法，而且方法名称要求按照严格标准编写

---------------------------------------------

封装的简单例子：
先来个例子看看；

public class Man{
    //对属性的封装，一个人的姓名，年龄，妻子都是这个对象（人）的私有属性
    private String name;
    private int age;
    private Woman wife;
    //对该人对外界提供方法的封装，可以设定妻子，姓名，年龄也可以获得男人的姓名和年龄
　　// 方法封装
　　public void setWife(Woman wife){
　　    this.wife = wife;
　　}
　　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 class Woman{
　　// 属性封装
　　private String name;
　　private int age;
　　private Man husband;
　　// 方法封装
　　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 Man getHusband(){
　　    return husband;
　　}
　　public void setHusband(Man husband){
　　    this.husband = husband;
　　}
}

/**
仔细看就会发现，Man类没有提供getWife的方法，这是因为男人不想让自己的妻子被外界访问，接下来呢，就是封装可以把一个对象的属性私有，而提供一些可以被外界访问的属性的方法，比如说，name属性，Man和Woman类都有相应的get和set方法，外界都可以通过这些方法访问和修改。同时对一些对象不想让外界访问的属性，就不提供其方法，比如说Man的wife属性，就没有get方法。外界是不能得到Man类的wife属性的
*/
上面那例子可能没有突出封装的好处，下面来个超简单的表达下：

public class Show{
    public static void show(String str){
        System.out.println(str);
    }
}

上面就是对 System.out.println();的封装。
调用的时候 ：

public class Use{
    public static void main(String[] args){
        Show.show("封装")；
    }
}

这样用的时候就不用使：System.out.println("封装")；