精华内容
下载资源
问答
  • Java封装性 千次阅读
    2018-07-28 10:44:58

    信息的封装与隐藏

    使用者对类内部定义的属性(对象的成员变量)的直接操作会导致数据的错误、混乱或安全性问题。在面向对象程式设计方法中,封装(英语:Encapsulation)是指一种将抽象性函式接口的实现细节部份包装、隐藏起来的方法。

    封装是指隐藏对象的属性和实现细节,仅对外提供公共访问方式。封装可以被认为是一个保护屏障,防止该类的代码和数据被外部类定义的代码随机访问。要访问该类的代码和数据,必须通过严格的接口控制。

    封装最主要的功能在于我们能修改自己的实现代码,而不用修改那些调用我们代码的程序片段。

    封装原则:将不需要对外提供的内容都隐藏起来,把属性都隐藏,提供公共方法对其访问。

     

    封装的好处(优点):

    1)通过隐藏对象的属性来保护对象内部的状态(隐藏信息、实现细节)。

    2)提高了代码的可用性和可维护性,因为对象的行为可以被单独的改变或者是扩展(将变化隔离,类内部的结构可以自由修改,增加内部实现部分的可替换性)。

    3)禁止对象之间的不良交互提高模块化(良好的封装能够减少耦合)。

    4)可以对成员变量进行更精确的控制。

    5)容易保证类内部数据间的一致性,从而提高软件的可靠性。

     

    抽象和封装的不同点:

    抽象和封装是互补的概念。一方面,抽象关注对象的行为。另一方面,封装关注对象行为的细节。一般是通过隐藏对象内部状态信息做到封装,因此,封装可以看成是用来提供抽象的一种策略。

     

    实现Java封装

    Java中通过将数据声明为私有的(private),再提供公共的(public)方法:getXxx()setXxx()实现对该属性的操作,以实现下述目的:

    1)隐藏一个类中不需要对外提供的实现细节;

    2)使用者只能通过事先定制好的方法来访问数据,可以方便地加入控制逻辑,限制对属性的不合理操作;

    3)便于修改,增强代码的可维护性;

     

    为属性封装:

    private  属性类型 属性名称; // private修饰的成员在自己所在的类中可以使用,在类外边不可以使用

    为方法封装:

    private 方法返回值 方法名称(参数列表){}

    下面看一下实现Java封装的示例:

    public class Person{
        /**
         * 修改属性的可见性来限制对属性的访问(一般限制为private)
         * name和age属性设置为私有的,只能本类才能访问,其他类都访问不了,如此就对信息进行了隐藏。
         */
        private String name;
        private int age;
        /**
         * public方法是外部类访问该类成员变量的入口。
         * 通常情况下,这些方法被称为getter和setter方法。
         * 因此,任何要访问类中私有成员变量的类都要通过这些getter和setter方法。
         */
        public int getAge(){
          return age;
        }
    ​    // 对每个值属性提供对外的公共方法访问,也就是创建一对赋取值方法,用于对私有属性的访问。
        public String getName(){
          return name;
        }​
        public void setAge(int age){
          // 采用 this 关键字是为了解决实例变量(属性age)和局部变量(参数age)之间发生的同名的冲突。
          this.age = age;
        }​
        public void setName(String name){
          this.name = name;
        }
    }

                  

    JavaBean

    JavaBean是一种Java语言写成的可重用组件。

    所谓javaBean,是指符合如下标准的Java类:

    1)类是公共的

    2)有一个无参的公共的构造器

    3)有属性,且有对应的get、set方法

    4)用户可以使用JavaBean将功能、处理、值、数据库访问和其他任何可以用java代码创造的对象进行打包,并且其他的开发者可以通过内部的JSP页面、Servlet、其他JavaBean、applet程序或者应用来使用这些对象。用户可以认为JavaBean提供了一种随时随地的复制和粘贴的功能,而不用关心任何改变。

     

    更多相关内容
  • java封装性

    2012-07-23 13:35:32
    java封装性
  • Java封装性及四种权限修饰符详解

    千次阅读 2020-08-24 09:05:54
    文章目录1、封装概述2、封装性的使用3、封装的作用4、四种权限修饰符5、四种权限修饰符测试 1、封装概述        封装(Encapsulation)是面向对象方法的重要原则,就是把对象的...

    1、封装概述

           封装(Encapsulation)是面向对象方法的重要原则,就是把对象的属性和操作(或服务)结合为一个独立的整体,并尽可能隐藏对象的内部实现细节。

    封装的优点

    1. 良好的封装能够减少耦合。

    2. 类内部的结构可以自由修改。

    3. 可以对成员变量进行更精确的控制。

    4. 隐藏信息,实现细节。


    2、封装性的使用

    public class Main {
    
        public static void main(String[] args) {
            Student student = new Student();
            student.name="皮皮虾";
            student.age=20;
            
            student.show();
        	student.age=-5;
            student.show();
        }
    
    }
    
    
    class Student{
        String name;
        int age;
    
        public void show() {
            System.out.println("name:"+name+",age:"+age);
        }
    
    }
    

    在这里插入图片描述

    上述代码表面上看没有什么问题,但在实际开发中对于属性肯定会有一些限制,例如:年龄不能为负数

    解决方法

    • 提供getter和setter方法获取属性和给属性赋值,且在该方法中可以设置条件判断
    • 使用权限修饰符来注销掉原来的例如student.age=20; 这种赋值方法。
    public class Main {
    
        public static void main(String[] args) {
            Student student = new Student();
    
            student.setAge(5);
            student.show();
            student.setAge(-2);
            student.show();
        }
    
    }
    
    
    class Student{
        private String name;
        private int age;
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
        	//条件判断
            if (age >= 0){
                this.age = age;
            }else {
                this.age = 0;
            }
    
        }
    
        public void show() {
            System.out.println("name:"+name+",age:"+age);
        }
    
    }
    

    在这里插入图片描述


    3、封装的作用

    • 对象的数据封装特性彻底消除了传统结构方法中数据与操作分离所带来的种种问题,提高了程序的可复用性和可维护性,降低了程序员保持数据与操作内容的负担。
    • 对象的数据封装特性还可以把对象的私有数据和公共数据分离开,保护了私有数据,减少了可能的模块间干扰,达到降低程序复杂性、提高可控性的目的。

    4、四种权限修饰符

          Java中,可以使用访问控制符来保护对变量方法构造方法的访问。Java 支持 4 种不同的访问权限。

    • default (即默认,什么也不写): 在同一包内可见,不使用任何修饰符。使用对象:类、接口、变量、方法。

    • private : 在同一类内可见。使用对象:变量、方法。 注意:不能修饰类(外部类)

    • public : 对所有类可见。使用对象:类、接口、变量、方法

    • protected : 对同一包内的类和所有子类可见。使用对象:变量、方法。 注意:不能修饰类(外部类)。

    在这里插入图片描述

    通过以下表来说明访问权限:

    修饰符类内部同一包内不同包子类同一工程
    privateYes
    default(缺省)YesYes
    protectedYesYesYes
    publicYesYesYesYes

    对于class的权限修饰符只可以用public和default(缺省)
    public类可以在任意地方被访问
    default类只可以被同一包内部的类访问


    5、四种权限修饰符测试

    在同一包下,创建Main类和test类
    在这里插入图片描述
    Main.java

    public class Main {
    
        String defaultName;
        private String privateName;
        public String publicName;
    
    
        private void privateMethod() {
            defaultName = "1";
            privateName = "2";
            publicName = "3";
        }
    
        public void publicMethod() {
            defaultName = "1";
            privateName = "2";
            publicName = "3";
        }
    
         void defaultMethod() {
            defaultName = "1";
            privateName = "2";
            publicName = "3";
        }
    }
    

    test.java
    在这里插入图片描述
    在这里插入图片描述

    在另一个包下就建立test02类
    在这里插入图片描述

    test02.java
    在这里插入图片描述

    在另一个包下,原先的私有结构、缺省声明的结构都无法使用。

    在这里插入图片描述


    觉得不错的小伙伴可以点赞关注和收藏哦!

    Java学习路线目录索引

    在这里插入图片描述

    展开全文
  • Java三大特性的第一个分水岭——封装性

    千次阅读 多人点赞 2022-04-10 18:40:15
    本篇主要讲解Java面向对象的三大特征之一:封装性。 从设计思想、权限修饰符、作用范围、使用细节代码举例来让大家学会封装性

    大家好,我是卷心菜,大二学生一枚,本篇主要讲解Java面向对象的三大特征之一:封装性。如果您看完文章有所收获,可以三连支持博主哦~,嘻嘻。


    一、设计思想

    • 封装性的思想:以类为载体,将类的属性、行为(可以理解为Java中的方法)封装起来,对使用者隐藏其具体实现细节,只对外公开简单的接口。大白话就是说,该隐藏的隐藏,该暴露的暴露。
    • 封装性的目的:便于外界调用,避免外部操作对类内部数据的影响,从而提高系统的可扩展性、可维护性。

    二、权限修饰符

    Java中有四种权限修饰符,作用范围从小到大依次是:

    • private
    • 缺省(就是什么都不写)
    • protected
    • public

    用代码体现就是:

    public class One {
        private int age;
        String name;
        protected String major;
        public char gender = '男';
    }
    

    三、作用范围

    刚刚讲过了,这四种权限修饰符有不同的作用范围,那么它们的作用范围到底是什么呢?

    修饰符类内部同一个包不同包的子类同一个工程
    privateYES
    缺省YESYES
    protectedYESYESYES
    publicYESYESYESYES

    四、使用细节

    4种权限可以用来修饰类及类的内部结构:

    属性、方法、构造器、内部类

    注意:修饰类的话,只能使用:缺省、public,不然就会出现编译型异常
    在这里插入图片描述

    总结封装性:Java提供了4种权限修饰符来修饰类及类的内部结构,体现类及类的内部结构在被调用时的可见性的大小。


    五、代码举例

    编写一个类,有四个成员变量,其中一个权限修饰符为public,其余都是private,都有对应的getter()和setter():

    public class One {
        private int age = 20;
        private String name = "cabbage";
        private String major = "计算机科学与技术";
        public char gender = '男';
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public String getMajor() {
            return major;
        }
        public void setMajor(String major) {
            this.major = major;
        }
        public char getGender() {
            return gender;
        }
        public void setGender(char gender) {
            this.gender = gender;
        }
    }
    

    最后写一个测试类:

    public class TestDemo {
        public static void main(String[] args) {
            One one = new One();
            one.gender = '女';
            one.setAge(21);
            one.setName("hello");
            one.setMajor("大数据");
            System.out.println(one.gender);
            System.out.println(one.getAge());
            System.out.println(one.getName());
            System.out.println(one.getMajor());
        }
    }
    

    运行结果:
    在这里插入图片描述
    从代码和运行结果可以看出,属性gender权限修饰符作用范围最大,在测试中,可以直接通过"对象.方法"来改变属性值,这样就不符合封装性的思想,破坏了封装性;其它的三个属性值的改变,都是通过setter()和getter()来修改的,确保了封装性思想的落实:隐藏该隐藏的。


    通过将属性声明为私有的private,再提供共有的public方法setter()和getter()来实现对属性的操作。来实现以下的目的:

    • 隐藏类中不需要对外提供的实施细节
    • 用户只需要通过实现定制好的方法访问数据,可以方便的加入控制逻辑,限制对属性的不合理操作
    • 便于修改,增强代码的可维护性

    谢谢阅读,一起进步,嘻嘻~

    展开全文
  • Java类的三大特性之一:封装性

    千次阅读 2019-03-29 16:04:47
    我是这样理解Java类的封装性的:使用Java类的封装性就好比是对快递进行打包,但是又不完全等于打包。因为我们对快递打包是越严密越好,可是我们把一个类严严实实的包装起来那这个类就是去其存在的意义了,可以说是一...

      概念(Idea;Notion;Concept)是人类在认识过程中,从感性认识上升到理性认识,把所感知的事物的共同本质特点抽象出来,加以概括,是自我认知意识的一种表达,形成概念式思维惯性。在人类所认知的思维体系中最基本的构筑单位。心理学上认为,概念是人脑对客观事物本质的反映。所以,想要学好知识,对概念的理解尤为重要。学好一门编程语言也是如此。
      但是,有些人说了:我对概念就不怎么上心,但是我也可以写出代码,实现我想要的功能。这话没错,但是在我们学习一门编程语言时往往会陷入一个误区:基础概念什么的知道就行,锻炼能力才是最终要的。殊不知,能力的提升是建立在基础之上的,经济基础决定上层建筑。所以我们今天就来聊聊Java语言中最基础的一个概念,Java类的三大特性之一:封装性。

    1. 什么是封装性
      封装性,顾名思义,就是将一些东西打包成一个整体,用专业术语来讲就是:对用户隐藏其实现细节,使用该类的用户可以通过该类提供的接口来访问该类,使用户不能轻易的操作此数据结构,只能执行类允许公开的数据的一个小系统。
    2. 使用封装的好处
      我们前面说到,使用该类的用户只能执行类允许公开的数据,这样一来就避免了外部操作对内部数据的影响,提高了程序的可维护性。下面通过几段代码来直观的看一下使用封装的好处。

    class Person{
    	//Person类的私有属性:姓名,年龄,性别
    	private String name;
    	private int age;
    	private String sex;
    	
    	//用户可以通过以下方法访问或操作内部数据,如:姓名,年龄,性别
    	public void setName(String n){
    		name = n;
    	}
    	public void setAge(int a) {
    		age = a;
    	}
    	public void setSex(String s) {
    		sex = s;
    	}
    	
    	public String getName(){
    		return name;
    	}
    	public int getAge(){
    		return age;
    	}
    	public String getSex(){
    		return sex;
    	}
    }
    

    图1
    根据上述代码和图片我们可以看出,主方法中新建的对象不能直接访问Person类中的私有属性,只能通过该类留给我们的一些访问接口访问和操作内部数据,避免外部操作对内部数据的影响。
      我们再来设想一种情况:一个十分庞大的程序,有10000个对象具有这个Person类的属性,现在想将年龄由int改为String。对于以上情况如果不使用封装的话:

    class Person{
    	//Person类的属性:姓名,年龄,性别
    	public String name;
    	public int age;
    	public String sex;
    }
    
    Person P = new Person();
    P.age = 35;
    P.name = "王二麻子";
    P.sex = "男";
    //..................................
    //..................................(表示具有Person类的属性的对象还有很多个)
    

    我们需要修改上万个位置,估计修改完之后我的表情应该是这样的
    在这里插入图片描述
    但是如果我们使用了封装就完全不一样了:

    class Person{
    	//Person类的私有属性:姓名,年龄,性别
    	private String name;
    	private String age;//将年龄改为String型
    	private String sex;
    //用户可以通过以下方法访问或操作内部数据,如:姓名,年龄,性别
    	public void setName(String n){
    		name = n;
    	}
    	public void setAge(int a) {
    		age = String.valueOf(a);//改动
    	}
    	//后续代码省略...........
    }
    

    这样一来,我们就省了很多力气,提高了代码的可维护性,估计改代码的时候我的表情是这样的:
    在这里插入图片描述

    3. 对Java类封装性的理解
      其实对Java类的封装性的理解有很多方式,这里说说博主本人的理解吧!我是这样理解Java类的封装性的:使用Java类的封装性就好比是对快递进行打包,但是又不完全等于打包。因为我们对快递打包是越严密越好,可是我们把一个类严严实实的包装起来那这个类就是去其存在的意义了,可以说是一个“死类”,开发人员不能通过对外的接口来访问它,对开发人员来说这个类没有任何作用。
      试想一下:一座房子就像是一个类,里面的家具就是这个类私有的属性,墙就如同是封装,如果墙上没有安装门窗的位置,而是严严实实的一堵墙,那这座房子跟黑盒子没什么区别,同样,它也没有存在的意义。

    特殊声明:本人并不是大佬,只是说一说自己在学习Java过程中的理解,文章有不正确的地方欢迎大家批评指正。最后希望大家不喜勿喷,营造良好的学习环境。
    温馨提示:道路千万条,学习第一条。平时不学习,招聘两行泪!!!

    展开全文
  • java中对象的封装性

    千次阅读 2020-07-08 20:17:35
    java中对象的封装性 1.概述 我们程序设计追求“高内聚,低耦合”。  高内聚 :类的内部数据操作细节自己完成,不允许外部干涉;  低耦合 :仅对外暴露少量的方法用于使用。 隐藏对象内部的复杂性,只对外公开...
  • JAVA_封装性例子

    2012-08-16 13:02:04
    一个详细讲解JAVA_封装性的例子 希望可以帮助到你。
  • 浅谈java封装

    2020-09-03 21:04:40
    封装封装就是将属性私有化,提供...*实现封装的步骤:(1)修改属性的可见来限制对属性的访问。(2)为每个属性创建一对赋值方法和取值方法,用于对这些属性的访问。(3)在赋值和取值方法中,加入对属性的存取限制。
  • Java反射破坏了封装性

    千次阅读 多人点赞 2019-06-02 19:53:15
    在讨论这个问题之前,让我们先来简单复习一下Java反射的知识。 Java 反射 一、类型信息 在回顾Java反射之前,我们先来看一下RTTI(Run-Time Type Identification),运行时类型识别,它能在运行时就能够自动识别每个...
  • MLDN魔乐视频教程,讲述了Java封装性,包含视频教程、原代码、PDF格式的文件,供大家下载学习。
  • JAVA封装性的概念

    千次阅读 2017-03-07 18:12:08
    一、封装性的概念 用到private关键字来时用 1、封装性是面向对象思想的三大特征之一。 2、封装就是隐藏实现细节,仅对外提供访问接口。  封装有: 属性的封装、方法的封装、类的封装、组件的封装、模块化封装、...
  • Java封装性).avi

    2021-07-12 17:03:52
    Java封装性).avi
  • Java封装性

    千次阅读 2011-08-16 10:58:44
    class Person{ private String name ; // 声明姓名属性 private int age ;...封装性Java中有很多种形式,private只是最基本的一种形式,也是一种比较常见的形式。 类中的每一个属性都必须封装。
  • 什么是java封装.pdf

    2020-05-19 19:54:11
    什么是JAVA封装?封装就是将属性私有化,提供公有的方法访问私有属性,做法:修改属性可见来限制对属性的访问,给每个属性创建get和set方法。 适合初学者学习和加深印象理解,也适合伙伴们复习交流用。
  • 1.封装性  封装性就是把对象的属性和服务结合成一个独立的相同单位,并尽可能隐蔽对象的内部细节,包含两个含义:  ◇ 把对象的全部属性和全部服务结合在一起,形成一个不可分割的独立单位(即对象)。  ◇信息...
  • java封装性

    千次阅读 2016-12-03 12:47:43
    封装类大多数变量都是私有的,变量通过他们自己类的方法修改,一个类只向其它类公开一部分成员(通常是方法)作为接口; 若变量或方法为公有,它就是接口的一部分,其它类可以访问它;若为私有,它是实现的一部分,...
  • java封装的作用和含义

    万次阅读 2018-10-18 22:10:46
    程序设计追求“高内聚,低耦合”。...3.“高内聚”:封装细节,便于修改内部代码,提高可维护 4.“低耦合”:简化外部调用,便于调用者使用,便于扩展和写作。 java中使用“访问控制符”来控制哪些细节需要封...
  • 封装,是java的特点,也是优势,但是同时也是它的劣势,为什么? 因为有时候,class被封装在jar中,即class中,没办法去逐步去看源代码。 封装,即将class文件放入jar,供java文件调用,是java的特点,是java的优势...
  • Java封装详解,很简单

    千次阅读 2022-01-16 12:51:41
    大家好,今天来给大家分享一下Java封装 面向对象有三大特征: 1.封装 2.继承 3. 多态 我们来讲Java封装,它也是Java面向对象的三大特征之一 封装 ,大白话的解释就是,把一个东西,装到箱子了,只留小小的口,用于...
  • Java语言:封装的自我理解

    千次阅读 2020-07-18 23:02:34
    Java中,封装就是将类中的一些成员封装起来,这里的成员包括成员方法和成员属性,他们都是可以封装的,封装顾名思义也就是不让外部随意访问,亦或者根本就不让你访问,这要根据成员的性质来判断。就像你的基本信息...
  • 主要介绍了java 中的封装介绍及使用方法的相关资料,封装是指一种将抽象函式接口的实现细节部份包装、隐藏起来的方法,需要的朋友可以参考下
  • Java实验2 类的封装性和继承性设计实验.doc
  • java-三大特性之一封装性

    万次阅读 多人点赞 2016-12-07 19:29:02
    封装性java面向对象的特征之一; 三大特性之一,封装性; 封装是一个面向对象的术语,其含义其实很简单,就是吧东西包装起来。等下就用这种思维来解释封装性以及他带来的好处; 其实;成员变量和成员方法的...
  • 封装的必要:在对象的外部为对象的属性赋值,可能存在非法数据的录入,存在不安全隐患。就目前的技术而言,并没有办法对属性的赋值加以控制。所以要实现属性的封装非常重要! 什么是封装? 概念:尽可能隐藏对象的...
  • 1.反射可以提高程序灵活和扩展。 2.反射就像一面具有特异功能的镜子,通过类的全量限定名(包名+类名),复制出和原类功能上没有任何差异的镜像类,包括类的私有属性、私有方法一并会被这面镜子穿透,并获取其...
  • Java封装和继承

    千次阅读 2022-04-08 15:24:44
    Java中的封装: 1)广义上:一切公共的代码的抽取都可以叫做封装。一般体现在公共方法的封装。工具类。 2)狭义上:隐藏对象的属性和实现细节。①将属性私有化,使用private关键字修饰。②为使用private关键字修饰...
  • 在面向对象程式设计方法中,封装(英语:Encapsulation)是指一种将抽象函式接口的实现细节部份包装、隐藏起来的方法。封装可以被认为是一个保护屏障,防止该类的代码和数据被外部类定义的代码随机访问。要访问该类...
  • Java封装实例

    千次阅读 2019-05-17 15:00:58
    在面向对象程式设计方法中,封装(英语:Encapsulation)是指,一种将抽象函式接口的实作细节部份包装、隐藏起来的方法。 封装可以被认为是一个保护屏障,防止该类的代码和数据被外部类定义的代码随机访问。 要...
  • 编程中封装的作用/优点

    千次阅读 2021-03-01 08:02:14
    最近学习了Java三大特性中的封装,所以在这里总结一下自己堆封装的理解和简介,给大家做出参考。什么是封装(Encapsulation):封装(Encapsulation)是面向对象方法的重要原则,就是把对象的属性和操作(或服务)结合为一...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 559,112
精华内容 223,644
关键字:

java封装性

java 订阅
友情链接: na6api_v2011.rar