【Java】你真的懂封装吗?一文读懂封装—–建议收藏

勤奋不是嘴上说说而已,而是实际的行动,在勤奋的苦度中持之以恒,永不退却。业精于勤,荒于嬉;行成于思,毁于随。在人生的仕途上,我们毫不迟疑地选择勤奋,她是几乎于世界上一切成就的催产婆。只要我们拥着勤奋去思考,拥着勤奋的手去耕耘,用抱勤奋的心去对待工作,浪迹红尘而坚韧不拔,那么,我们的生命就会绽放火花,让人生的时光更加的闪亮而精彩。

导读:本篇文章讲解 【Java】你真的懂封装吗?一文读懂封装—–建议收藏,希望对大家有帮助,欢迎收藏,转发!站点地址:www.bmabk.com,来源:原文

在这里插入图片描述

在这里插入图片描述

前言

write in the front:

  • 如何理解封装?
    试想:我们使用微波炉的时候,只用设置好时间,按下“开始”即可运作。作为一个产品的使用者,我们希望生产者能把最简单的接口暴露给我们,而至于微波炉按下开关后,内部是具体如何运作的,这些细节不用我们操心。“高内聚,低耦合”。节省使用者的学习成本和时间成本程序设计也是如此。同时,由于封装了内部细节,提供了对外的接口,作为使用者的我们无法直接随意对内部进行操作,保证了内部数据的安全.
    在这里插入图片描述

  • 封装是程序设计的第一原则,Java设计中有两种封装的体现:

接下来我们具体感受一下Java中的封装(主要是讲封装在上的体现):

Part1:引入:

  • 我们用面向对象语言编程时会涉及到以下两个视角:

在这里插入图片描述

  • 类的实现者:实现类内部细节—微波炉内部设计者

  • 类的调用者:调用已有的类—微波炉的使用者

  • 封装的本质是不向类的调用者透露过多类的实现内容,只提供特定的接口,让类的调用者去使用类

我们在学习Java的时候经常会用到jdk-API文档,通过文档来查询某个类怎么使用:
在这里插入图片描述
此时我们的视角是:类的调用者,我们的目的是使用这个类,而不关注这个类的具体实现。这正是封装的体现。Java开发者实现了一些类,把这些类的具体实现内容(类的源码)封装,只向外提供一些(接口),方便类的调用者去直接使用(再不用看源码的情况下,能快速使用这个类)。

Part2:封装举例:

class Person{
    public String myName;
    public int age;
    public String sex;
}
public class TestDemo {
    public static void main(String[] args) {
        Person person1=new Person();
        person1.name=19;
    }
}

在这里插入图片描述

  • 假设类的实现者需要通过修改类的实现内容来升级功能:将name修改为myName:
class Person{
    private String myName = "yaoyao"//修改
    public int age;
    public String sex;
}
public class TestDemo {
    public static void main(String[] args) {
        Person person1=new Person();
        person1.myName=2000;//修改
    }
}

  • 结果/问题出现:
    • 由于类的实现者修改了类的实现,导致类的调用者不得也修改自己的代码—–高耦合、类的调用者使用类的成本增高–>程序复杂度过高,不便于维护(必须先学习源码,才可以使用)
    • 同时,直接公开属性,可能会由于类的调用者给属性赋值不合理的数据,导致属性错误/不合理–数据不安全
  • 解决—封装
    • 那么如何才能解决类的实现者在后期维护、修改的过程中,最大限度的不影响类的使用者呢(降低程序的复杂度)?以及保护属性数据的安全呢?—-封装。

Part3:如何封装:

3.1:private实现封装:

  • java中利用private,public两个关键字搭配来实现封装
    • private:成员变量、成员方法被private修饰时,类的调用者无法访问&使用,只有在类内部可以访问&使用。(即,这些被封装起来的属性/行为,对于类的调用者来说是不可见的–无法直接访问&调用)。
    • private:成员变量、成员方法被public修饰时,类的调用者可以直接访问&使用。

🌇eg:

class Person{
    private String myName = "yaoyao"//修改
    private int age=19;
    private String sex="femal";
    public void show(){
    	System.out.println(myName+age+sex);
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Person person1=new Person();
        person1.show();
    }
}
  • 这样形式是一个封装:将myName\age\sex封装起来了,无法通过对象直接访问,只可以通过一个公开的方法-show()来显示(只读不写)
  • 问题:属性被private修饰之后,调用者无法直接访问到属性,这样确实提高了可维护性、降低了耦合性,但是如何获取/修改被private修饰的属性呢?

3.2:getter&setter方法:

class Person{
    private String myName;
    public void setMyName(String name){//对外提供访问属性方法
    	this.myName = name;
    }
    public String getMyName(){//对外提供获取属性方法
    	return this.myName;
    }
}
public class TestDemo {
    public static void main(String[] args) {
        Person person1 = new Person();
        person1.setMyName("yaoyao");
        System.out.println(person1.getMyName());
    }
}
  • setter():设置公开setter方法,设置当前属性值
  • getter():设置公开getter方法,获取当前属性值.

📬Tips:

你可能会想,如果类的实现者修改了对外公开的属性/方法,这样不是同样会增加类的调用者的学习&使用成本嘛?
答: 一般类的设计都要求:类提供的 public 方法/属性能比较稳定–不频繁发生大的修改. 尤其是对于一些基础库中的类. 每次接口的变动都要仔细考虑兼容性问题

3.3:总结:封装步骤:

1. private修饰相应属性–属性私有化
2. 制作相对应公开的setter/getter方法

public void setXXX(参数列表){
	//验证传参是否合理
			...
	//合理即可赋值:
	属性 = 形参;
}
public void getXXX(){
	//权限判断
	return XXX;
}

3.4:实际封装应用案例:

public class Student(){
	private String name;//名字
	public static setName(String name){
		//对数据进行验证合理性
		if(name.length() >= 2 && name.length() <=10){
			this.name = name;
		}
		else{
			System.out.println("设置名字长度超过范围,未设置成功");
		}
	}
	public static getName(){
		return this.name;
	}
}
class Demo{
	public static void main (String[] args){
		Student student = new Student();
		//若传入这样不合理数据,则无法成功修改属性
		student.setName("hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh");
	}
}

3.5:补充:IDEA快速根据private生成getter()&setter

  • 鼠标右键选择generate(重构)/alt+insert
    在这里插入图片描述
  • 选择:
    在这里插入图片描述
    在这里插入图片描述
  • 即可生成:
    在这里插入图片描述

Part4:stetter()和构造器相结合

  • 【写法】:将setter写在构造器内部
  • 【作用】:保护属性数据安全
public class Student(){
	private String name;//名字
	public static setName(String name){
		//对数据进行验证合理性
		if(name.length() >= 2 && name.length() <=10){
			this.name = name;
		}
		else{
			System.out.println("设置名字长度超过范围,未设置成功");
		}
	}
	public static getName(){
		return this.name;
	}
	//构造器(本质:初始化数据)
	public Student(String name){
		setName(name);//直接在构造器内调用set方法
	}
}
class Demo{
	public static void main (String[] args){
		Student student = new Student("HHHHHHHHHHHHHHHhhhhhhhhhhhhhhhh");
	}

Part5:封装的意义/作用/好处

  • 安全性:用private隐藏内部细节(外部不能随意访问),对传入数据进行验证,保证安全合理。避免因为外部的无意修改,破坏内部数据—提高代码安全性
  • 复用性:这里是指使用类把属性、成员方法封装起来的封装。即,一旦类的实现者实现了一个类,下一次遇到同样的问题,不必再次写一遍,而是直接调用类实现者写好的代码即可—提高代码复用性。
  • 高内聚:隐藏类内部的实现细节,不允许外部干涉,便于后期维护——降低程序复杂度。
  • 低耦合:暴露少量接口供外部使用,且尽量方便。提高类使用者的学习成本、使用成本。便于协助、扩展。

Part6:

6.1:反思、深入

的确,我们谈到封装,可能最先想到的是类,并且封装在类上体现的学问、细节,确实很多。封装是一种思想,Java的函数本身是这种思想的明显体现。我的意思是,如果类中的属性都是public,我们仍然认为类是一种封装。但是如果只是单单的这样浅层次的封装,肯定会带来很多问题(如上文已经讲到的:安全性、使用成本…)

于是,我们需要更深层次的封装—上面Part所讲的,其实本质就是在类的基础上,再次封装(或许可以叫作套娃?)。

  • 可以这样理解:类是一个书包,封装了各种各样的文具、书(数据、对数据的操作)。—类的外层封装
  • 在书包中放个铅笔盒,专门用来放🖊,这个铅笔盒,我们叫作—封装在类中体现。本文大篇幅讲解的,其实是此封装!
  • public和private干嘛?
    • public修饰类:表示这个书包别人可以拿到(别人可以打开这个书包拉链)
    • public&private修饰方法/属性:封装类内部细节!private修饰属性,就相当于把数据封在铅笔盒中了,就算你拿到了书包并且打开,并不代表你可以打开铅笔盒获取铅笔!但是public修饰getter(),说明打开铅笔盒的操作是可以使用的。
      在这里插入图片描述

6.2:补充:函数体现封装

虽然类体现封装的确占大头,但是,函数(就是Java中的方法),也体现了封装,既然此文是讲封装,怎么能少的了我们的函数老爷呢?

  • 程序的构成
    程序由数据指令构成。大程序可以分为小程序,小程序可以再次细分—>子程序分而治之)。

    所有我们看到有些地方把函数也称为子程序。程序是数据,指令的集合。所以:函数也是封装的体现

6.3:总结:

通过上面,可以看到,其实程序本身就是封装,类、函数是封装中的封装…

总之,请记住:
封装是程序设计的第一原则, 类&方法是封装的不唯二体现。通过封装,我们才能站在更高层次思考问题


版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。

文章由半码博客整理,本文链接:https://www.bmabk.com/index.php/post/142449.html

(0)

相关推荐

发表回复

登录后才能评论
半码博客——专业性很强的中文编程技术网站,欢迎收藏到浏览器,订阅我们!