大数据——Java三大特征之一封装

最新推荐文章于 2021-07-19 18:30:17 发布

蜂蜜柚子加苦茶

最新推荐文章于 2021-07-19 18:30:17 发布

阅读量297

点赞数 2

文章标签：大数据 java

本文链接：https://blog.csdn.net/dsjia2970727/article/details/107504562

版权

封装

封装概述
封装的步骤
包的概述
包的定义
包的使用
类和类成员的访问控制
static关键字

封装概述

Java中封装的实质就是将类的状态信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。
封装反映课事物的相对独立性，有效避免了外部错误对此对象的影响，并且能对对象使用者由于大意产生的错误操作起到预防作用。同样面向对象编程提倡对象之间实现松耦合关系。
封装的好处在于隐藏类的实现细节，让使用者只能通过程序员规定的方法来访问数据，可以方便地加入存取控制修饰符，来限制不合理操作。
松耦合就是指尽量减少对象之间的关联性，以降低它们之间的复杂性和依赖性。

封装的步骤

修改属性的可见性

将Person类中的属性由public修改为private即可。
示例一：
将Person类的属性私有化。
关键代码：

public class Person {
    private String name;//姓名
    private String gender;//性别
    private int age;//年龄
}

分析：
将public修改为private后，其他类就无法访问了，如果访问则需要进行封装的第二步。

设置setter/getter()方法

可以手动添加setter/getter()方法，也可以使用组合键Ctrl+Shift+S由系统添加。
示例二：
为Person类中的私有属性添加setter/getter()方法。
关键代码：

public class Person {
    private String name;//姓名
    private String gender;//性别
    private int age;//年龄
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getGender() {
        return gender;
    }
    public void setGender(String gender) {
        this.gender = gender;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
}

设置属性的存取限制

此时，还没有对属性值设置合法性检查，需要在setter方法中进一步利用条件判断语句进行赋值限制。
示例三：
为setter方法设置限制：
关键代码：

public class Person {
    private String name;//姓名
    private String gender;//性别
    private int age;//年龄
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getGender() {
        return gender;
    }
    public void setGender(String gender) {
        if(gender.equals("男")||gender.equals("女")){
        this.gender = gender;
        }else {
            System.out.println("***性别不合法！***");
        }
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        if(age<0|age>150){
            System.out.println("***输入的年龄为：" + age + "，该年龄不合法，将重置！***");
            return;
        }
        this.age = age;
    }
    //构造方法
    public Person(){
        this.name="无名氏";
        this.gender="男";
        this.age=18;
    }
    public Person(String name,String gender,int age){
        this.name=name;
        this.gender=gender;
        this.age=age;
    }//方法：自我介绍
    public void say(){
        System.out.println("自我介绍一下，姓名：" + this.name + ",性别：" + this.gender + "，年龄：" + this.age + "岁。");
    }
//以上为Person类定义代码，以下为调用代码
    public static void main(String[] args) {
        Person hanbing=new Person();
        hanbing.setName("韩冰");
        hanbing.setGender("女");
        hanbing.setAge(221);
        hanbing.say();
    }
}

输出结果：
在这里插入图片描述
通过在setter方法中设置限制，避免了性别和年龄的误操作输入问题，这就是一个封装的典型实例。
示例四：

public class Dog {
    //private私有化，保护属性不能篡改
    private String name;
    private int health;
    private int love;
    private String  strain;
    //访问的接口
    public void setName(String name){//setter
        this.name=name;
    }
    public String getName(){//getter
        return this.name;
    }
    public void setHealth(int health){
        //health的正常范围0-100
        if(health<0||health>100){
            System.out.println("健康值的范围在0-100之间");
            System.out.println("赋的值不满足，强行默认值60");
            health=60;
//            this.health=60;
//            return;
        }
        this.health=health;
    }public int getHealth(){
        return this.health;
    }public void setLove(int love){
        if(love<0||love>100){
            System.out.println("亲密度的范围要在0-100");
            System.out.println("赋的值不满足，强行默认值100");
            love=60;
        }this.love=love;
    }public int getLove(){
        return this.love;
    }public void setStrain(String strain){
        this.strain=strain;
    }public String getStrain(){
        return this.strain;
    }
}
public class TestDog {
    public static void main(String[] args) {
        Dog d=new Dog();
        d.setName("阿黄");
        String str=d.getName();
        System.out.println(str);
        d.setHealth(-100);
        System.out.println(d.getHealth());
        d.setLove(50);
        System.out.println(d.getLove());
        d.setStrain("柯基");
        String di=d.getStrain();
        System.out.println(di);
    }
}

输出结果：
在这里插入图片描述

总结

封装：
保护属性
开一个出口以供使用

包的概述

Java中的包机制也是封装的一种。
包主要有以下3个方面：
包允许将类组合成较小的单元（类似文件夹），易于找到和使用相应的类文件。
防止命名冲突：Java中只有在不同包中的类才能重名。不同的程序员命名同名的类在所难免。有了包，类名就容易管理了。A定义了一个类Sort，封装在包A中，B定义一个类Sort，封装在包B中。在使用时，为了区别A和B分别定义的Sort类，可以通过包名区分开，如A.Sort何B.Sort分别对应于A和B定义的Sort类。
包允许在更广的范围内保护类、数据和方法。根据访问规则，包外的代码有可能不能访问该类。

包的定义

定义包的语法格式如下：
packa包名；
package是关键字。
包的声明必须是Java源文件中的第一条非注释性语句，而且一个源文件只能有一个包声明语句，设计的包需要与文件系统结构相对应。因此，在命名包时，要遵守一下编码规范：
一个唯一的包名前缀通常是全部小写的ASCII字母，不能以圆点开头或结尾并且是一个顶级域名com、edu、gov、net及org，通常使用组织的网络域名的逆序。
包名的后续部分依不同机构各自部门的规范不同而不同。

包的使用

为了使用不在同一包中的类，需要在Java程序中使用import关键字导入这个类。
import 包名. 类名；
import java.util.*; //导入java.util包中所有类
import cn.jtest.classandobject.School; //导入指定包中指定类
注意事项：
一个类同时引用了两个来自不同包的同名类。
必须通过完整类名来区分。
每个包都是独立的，顶层包不会包含子包的类。
package和import的顺序是固定的。
package必须位于第一行（忽略注释行）。
只允许有一个package语句。
其次是import。
接着是类的声明。

类和类成员的访问控制

包实际上是一种访问控制机制，通过包来限制和制约类之间的访问关系。访问修饰符也同样可以限制和制约类之间的访问关系。

类的访问修饰符

Java中类的访问修饰符。
public修饰符：公有访问级别
默认修饰符：包级私有访问级别
在这里插入图片描述

类成员的访问修饰符

Java中类成员的访问修饰符。
在这里插入图片描述

总结

public：公共的；全工程可见
protected：子类继承的时候使用；包级私有+子类
默认：包级私有，当前类所在的包中可见
private：私用的；只用自己可见

static关键字

一个类可以创建n个对象。如果n个对象中的某些数据需要共用，就需要使用static关键字修饰这些数据。
Java中，一般情况下调用类的成员都需要先创建类的对象，然后通过对象进行调用。使用static关键字可以实现通过类名加“.”直接调用类的成员，不需要创建类的对象。使用static修饰的属性和方法属于类，不属于具体的某个对象。

用static关键字修饰属性

用static修饰的属性称为静态变量或者类变量，没有使用static修饰的属性称为实例变量。
在实际开发中，用static关键字修饰属性的最常用场景就是定义使用final关键字修饰的常量。使用final关键字修饰的常量在整个程序运行时都不能被改变，和具体的对象没有关系，因此使用static修饰，如“static final int PERSON_LIVE=1;”。
注意：
常量名一般由大写字母组成。
声明变量时一定要赋初值。

用static关键字修饰方法

用static修饰的方法称为静态方法或者类方法，不用static关键字修饰的方法称为实例方法。
在静态方法中不能直接访问实例变量和实例方法。
在实例方法中可以直接调用类中定义的静态变量和静态方法。
实例五：

//演示static使用
public class TestStatic {
    static{//静态代码块
        //是在第一次访问该类时(在创建对象之前)执行，且只执行一次
        //往往用来加载配置文件
        System.out.println("静态代码块");
    }
    public TestStatic(){
        System.out.println("无参构造");
    }
    public int a = 1;
    public static int c=1;
    public void test(){
        a++;
        c++;//普通方法可以看到静态属性
    }
    public static void abc(){
        //静态方法中看不到普通属性和普通方法
        c++;
    }
public void def(){
        abc();//普通方法可以直接调用静态方法
}
    public static void main(String[] args) {
        TestStatic ts1=new TestStatic();
        ts1.test();
        System.out.println(c);
        System.out.println(ts1.a);
        System.out.println();
        TestStatic ts2=new TestStatic();
        System.out.println(ts2.a);
    }
}

输出结果：
在这里插入图片描述
示例六：

public class Test {
    public static void main(String[] args) {
        TestStatic ts1=new TestStatic();
        ts1.test();
        System.out.println(ts1.a);
        System.out.println(TestStatic.c);
        TestStatic.c++;
        TestStatic.abc();//在不同类中，可以用类名.方法名()来调用静态方法
        //往往用来做工具方法
    }
}

输出结果：
在这里插入图片描述
示例七：模拟实现选民投票过程：一群选民进行投票，每个选民只允许投一次票，并且当投票总数达到100时，就停止投票

public class Voter {
    public static int voteNum=0;
    public static void vote(){
        voteNum++;
    }
}
public class TestVoter {
    public static void main(String[] args) {
        for (int i = 1; i <=200 ; i++) {
            Voter.vote();
            System.out.println("当前投票数为："+Voter.voteNum);
            if(Voter.voteNum==100){
                System.out.println("投票完成");
                break;
            }
        }
    }
}

输出结果：
在这里插入图片描述

总结

static：
修饰属性是：全类共用一个存储空间
普通属性：一个对象用一个存储空间
修饰方法时：可以通过类型.方法名()调用
普通方法可以直接调用静态方法和普通方法
静态方法不能直接调用普通方法
普通方法可以直接调用普通属性和静态属性
静态方法不能直接调用普通属性
静态代码块：指在第一次访问该类时执行一次，且只执行这一次
静态变量必须是成员变量

蜂蜜柚子加苦茶

关注

2
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
大数据——Java三大特征之一封装

封装封装概述封装的步骤修改属性的可见性设置setter/getter()方法设置属性的存取限制总结包的概述包的定义包的使用类和类成员的访问控制类的访问修饰符类成员的访问修饰符总结static关键字用static关键字修饰属性用static关键字修饰方法总结封装概述Java中封装的实质就是将类的状态信息隐藏在类内部，不允许外部程序直接访问，而是通过该类提供的方法来实现对隐藏信息的操作和访问。封装反映课事物的相对独立性，有效避免了外部错误对此对象的影响，并且能对对象使用者由于大意产生的错误操作起到预防作用
复制链接

扫一扫