精华内容
下载资源
问答
  • java中对象封装性

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

    java中对象的封装性

    1.概述
    我们程序设计追求“高内聚,低耦合”。
     高内聚 :类的内部数据操作细节自己完成,不允许外部干涉;
     低耦合 :仅对外暴露少量的方法用于使用。

    隐藏对象内部的复杂性,只对外公开简单的接口。便于外界调用,从而提高系统的可扩展性、可维护性。通俗的说,把该隐藏的隐藏起来,该暴露的暴露出来。这就是封装性的设计思想。

    2.封装的作用
    使用者对类内部定义的属性( 对象的成员变量) 的直接操作会导致数据的错误、混乱或 安全性 问题。
    在这里插入图片描述
    信息的封装和隐藏
    Java中通过将数据声明为私有的(private),再提供公共(public)方法:getXxx() 和setXxx()实现对该属性的操作,以实现下述目的:
    隐藏一个类中不需要对外提供的实现细节;
    使用者只能通过事先定制好的方法来访问数据,可以方便地加入控制逻辑,限制对属性的不合理操作;
    便于修改,增强代码的可维护性;

    class Animal {
    	private int legs;// 将属性legs定义为private,只能被Animal类内部访问
    	public void setLegs(int i) { // 在这里定义方法 eat() 和 move()
    		if (i != 0 && i != 2 && i != 4) {
    		System.out.println("Wrong number of legs!");
    		return;
    	}
    		legs = i;
    	}
    	public int getLegs() {
    		return legs;
    	}
    }
    public class Zoo {
    	public static void main(String args[]) {
    		Animal xb = new Animal();
    		xb.setLegs(4); // xb.setLegs(-1000);
    		//xb.legs = -1000; // 非法
    		System.out.println(xb.getLegs());
    	}
    }
    

    3.四种访问权限修饰符
    Java权限修饰符public、protected、(缺省)、private置于 类的成员定义前,用来限定对象对该类成员的访问权限。

    在这里插入图片描述
    对于class的权限修饰只可以用public和default(缺省)。
     public类可以在任意地方被访问。
     default类只可以被同一个包内部的类访问。

    展开全文
  • 及其对象封装性 本章主要内容 2.1 类的声明和对象定义 2.2 类的成员函数 2.3 对象成员的引用 2.4 类的封装性和信息隐蔽 2.5 构造函数和析构函数 2.6 对象指针 2.7 动态存储 2.1类的声明和对象定义 类是具有相同...
  • 面向对象的特点,封装性,继承性,多态性!

    万次阅读 多人点赞 2015-01-29 19:37:02
    2.封装封装是面向对象编程的核心思想,将对象的属性和行为封装起来,而将对象的属性和行为封装起来的载体是类,类通常对用户隐藏其实现的细节,这就是封装的思想,在Java中通常通过建立一个实体类,用来封装对象的...

    1.面向对象程序设计有三大特点,分别是封装,继承,多态,接下来就介绍一下这三个特点,积累一下。

    2.封装,封装是面向对象编程的核心思想,将对象的属性和行为封装起来,而将对象的属性和行为封装起来的载体是类,类通常对用户隐藏其实现的细节,这就是封装的思想,在Java中通常通过建立一个实体类,用来封装对象的属性和行为,通过setXxx()和getXxx()方法封装起来,例如,用户在使用一款软件的时候,只需知道如何使用软件,点击某个按钮就可以实现一定的功能,用户不需要知道软件是如何被开发出来的,软件内部是如何工作的,在使用该软件时不依赖于开发时的细节和软件内部工作的细节。

    采用封装的思想保证了类内部数据结构的完整性,应用该类的用户不能轻易直接操纵该数据结构,而只能执行该类允许公开的数据。这样可以避免外部对内部数据的影响,提高程序的可维护性。

    总结一下,封装性就是利用抽象数据类型将数据和基于数据的操作封装在一起,保护数据并隐蔽具体的细节,只保留有限的接口与外界联系。

    接下来附上一个封装的例子,定义一个实体类,声明属性为私有的,通过setXxx()和getXxx()的公共方法来封装数据(即封装属性),利用this关键字来引用成员变量,最后通过建立一个测试类来调用setXxx()和getXxx()方法,其中实体类中有两个构造方法,一个为无参构造方法,一个为有参构造方法,代码如下所示:

    Student.java文件,实体类代码:

    package tom.bean;
    
    /*
     * 学生实体类
     */
    public class Student {
    	private String name;// 声明一个私有字符串变量,表示姓名
    	private int age;// 声明一个私有整型变量,表示年龄
    	private String sex;// 声明私有一个私有字符串变量,表示性别
    	private String major;// 声明一个私有字符串变量,表示专业
    
    	public Student() { // 无参构造方法
    	}
    
    	public Student(String name, int age, String sex, String major) { // 有参构造方法
    		this.name = name;
    		this.age = age;
    		this.sex = sex;
    		this.major = major;
    	}
    
    	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 String getSex() {	//获得性别的方法
    		return sex;
    	}
    
    	public void setSex(String sex) {	//设置性别的方法
    		this.sex = sex;
    	}
    
    	public String getMajor() {	//获得专业的方法
    		return major;
    	}
    
    	public void setMajor(String major) {	//设置专业的方法
    		this.major = major;
    	}
    
    }
    

    Test.java文件,测试类代码:

     

    package tom.test;
    
    import tom.bean.Student;
    
    public class Test {
    	public static void main(String[] args){
    		Student student=new Student();//实例化Student对象
    		/*设置各个属性的内容*/
    		student.setName("Lc");
    		student.setAge(22);
    		student.setSex("男");
    		student.setMajor("软件工程专业");
    		/*获得学生各个属性的内容,打印输出信息*/
    		System.out.print("第一位学生的信息如下:"+"\n"+"姓名为"+student.getName());
    		System.out.print(",年龄为"+student.getAge());
    		System.out.print(",性别为"+student.getSex());
    		System.out.print(",专业为"+student.getMajor());
    		
    		Student student1=new Student("123nh", 21, "女", "英语专业");
    		System.out.print("\n");
    		System.out.print("第二位学生的信息如下:"+"\n"+"姓名为"+student1.getName());
    		System.out.print(",年龄为"+student1.getAge());
    		System.out.print(",性别为"+student1.getSex());
    		System.out.print(",专业为"+student1.getMajor());
    	}
    }
    


    运行测试类后结果如下:

    3.继承性,简单来说就是使子类的对象拥有父类的全部属性和行为,同时可以增添自己的所特有的属性和行为。这样可以节省写共同具有的属性和方法代码的时间,有利于代码的复用,这就是继承的基本思想。软件的代码使用继承思想可以缩短软件开发的时间,复用那些已经定义好的类可以提高系统和软件的性能,减少系统和软件在使用过程中出现错误的几率。一个类可以是其他类的父类,为其他类提供属性和行为,也可以是其他类的子类,继承父类的属性和方法,子类的实例都是父类的实例,但不能说父类的实例是子类的实例。

    继承的实现,在Java语言中,继承通过extends关键字来实现,用这个extends关键字时指明当前的类为子类,并指明从哪个类继承而来,即在子类的声明中,通过使用extends关键字来指明其父类,其基本格式如下:

    修饰符 class 子类名 extends 父类名{

    类体

    }

    接下来附上一个小例子,定义一个People类,其中有姓名,年龄和性别属性和setXxx()和getXxx()的方法,作为父类,在定义一个Student类,继承于父类,作为子类,在子类中只定义2个属性,一个学号,一个专业,再定义一个Test测试类,实例化子类,利用子类对象调用父类的属性和方法,具体见代码:

    目录结构如下图:

    People.java文件代码:

    package tom.bean;
    
    /*
     * 定义一个人类,作为Student的父类
     */
    public class People {
    	private String name;//声明一个私有变量,表示姓名
    	private int age;//声明一个私有变量,表示年龄
    	public String sex="男";//声明一个公有变量,表示性别,初始化为男
    	
    	public People() {	//无参构造方法
    	}
    
    	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 String getSex() {	//获得性别方法
    		return sex;
    	}
    
    	public void setSex(String sex) {	//设置性别方法
    		this.sex = sex;
    	}
    	
    	
    }
    


    Student.java文件代码:

    package tom.bean;
    
    /*
     * 定义一个学生类,继承于人类,作为子类
     */
    public class Student extends People{
    	private String stuId;//声明一个变量,表示学号
    	private String major;//声明一个变量,表示专业
    	
    	public Student(){	//定义无参构造方法		
    	}
    
    	public String getStuId() {	//获得学号方法
    		return stuId;
    	}
    
    	public void setStuId(String stuId) {	//设置学号方法
    		this.stuId = stuId;
    	}
    
    	public String getMajor() {	//获得专业方法
    		return major;
    	}
    
    	public void setMajor(String major) {	//设置专业方法
    		this.major = major;
    	}
    	
    	
    }
    


    Test.java文件的代码:

    package tom.test;
    
    import tom.bean.Student;
    
    /*
     * 测试类,实例化子类,调用父类的属性和方法,也调用自己所特有的方法
     */
    public class Test {
    	//主方法
    	public static void main(String[] args) {
    		Student student = new Student();//实例化Student类
    		student.setName("Xg");//调用父类People类的设置姓名的方法
    		student.setAge(22);//调用父类People类的设置年龄的方法
    		student.setStuId("2012131735");//调用Student类的设置学号的方法
    		student.setMajor("软件工程");//调用Student类的设置专业的方法
    		/*打印输出学生信息*/
    		System.out.println("学生信息如下:");
    		System.out.print("姓名为"+student.getName());
    		System.out.print(",年龄为"+student.getAge());
    		System.out.print(",性别为"+student.sex);
    		System.out.print(",学号为"+student.getStuId());
    		System.out.print(",专业为"+student.getMajor());
    	}
    }
    


    运行Test.java文件后,结果如下图所示:

    4.多态性,简单来说就是一个程序中同名的多个不同方法共存的情况,通常使用方法的重载和重写(也叫覆盖)来实现类的多态性,多态性允许以统一的风格编写程序,以处理种类繁多的已存在的类以及相关类,多态的实现并不依赖具体类,而是依赖抽象类和接口,在多态的机制中,父类通常会被定义为抽象类,在抽象类中给出一个方法的标准,而不给出实现的具体过程,通过继承父类来实现,而比抽象类更方便的是将抽象类定义为接口。这里先暂时介绍到这里,多态中使用方法的重写和重载以后在专门写一篇文章!以免这篇文章篇幅过长!

    5.以上就是面向对象程序设计的三大特点,仅供大家学习参考,写得不好请见谅,如有错误请指出,谢谢!

    展开全文
  • 面向对象封装、继承、多态这三个特性,面向对象编程按照现实世界的特点来管理复杂的事物,把它们抽象为对象具有自己的状态和行为,通过对消息的反应来完成任务。这种编程方法提供了非常强大的多样,大大增加了...
  • 面向对象三大特征之一封装性

    千次阅读 2017-01-18 16:34:44
    封装:是指隐藏对象的属性和实现细节,仅对外提供公共访问方式。2、封装的分类与好处 狭义的封装:属性的封装与方法的封装 广义的封装:包的管理、组件、框架、应用程序... 好处: 将变化隔离 便于使用

    一、面向对象的三大特征
    封装 (Encapsulation)
    继承 (Inheritance)
    多态 (Polymorphism)

    二、封装

    1、什么是封装
    封装:是指隐藏对象的属性和实现细节,仅对外提供公共访问方式。
    2、封装的分类与好处
    狭义的封装:属性的封装与方法的封装
    广义的封装:包的管理、组件、框架、应用程序...
    好处:
        将变化隔离
        便于使用
        提高重用性
        提高安全性

    三、封装与隐藏
    例如:使用者对类内部定义的属性的直接操作会导致数据的错误、混乱或安全性问题。

    public class TestEncapsulation {
    
        public static void main(String[] args) {
            Account a = new Account();
    
            /*a.balance = 1200;//随意更改不安全
            a.balance = -1200;*/
    
            boolean result = a.save(1200);
            System.out.println("存钱:"+result+",现在账户余额:"+a.getBalance());
    
            result = a.save(-1200);
            System.out.println("存钱:"+result+",现在账户余额:"+a.getBalance());
    
            result = a.withdraw(100);
            System.out.println("取钱:"+result+",现在账户余额:"+a.getBalance());
    
            result = a.withdraw(2000);
            System.out.println("取钱:"+result+",现在账户余额:"+a.getBalance());
        }
    
    }
    /*class Account{
        double balance;
    }*/
    
    class Account{
        private double balance;//封装隐藏
    
        //提供公共的访问方式
        //1、获得账户余额
        public double getBalance(){
            return balance;
        }
    
        //2、对余额的修改只能通过save和withdraw两个方法操作
        public boolean save(double money){
            if(money>0){
                balance += money;
                return true;
            }
            return false;
        }
    
        public boolean withdraw(double money){
            if(money > 0 && money <= balance){
                balance -= money;
                return true;
            }
            return false;
        }
    }
    Java中通过将数据声明为私有的(private),再提供公共的(public)方法:getXxx()和setXxx()实现对该属性的操作,以实现下述目的:
        隐藏一个类中不需要对外提供的实现细节;
        属性的封装:使用者只能通过事先定制好的方法来访问数据,可以方便地加入逻辑控制,限制对属性的不合理操作;
        方法的封装:使用者按照既定的方式调用方法,不必关心方法的内部实现,便于使用;
        便于修改,增强代码的可维护性;
    /*
     * 创建程序,在其中定义两个类:Person和TestPerson类。定义如下:
        用setAge()设置人的合法年龄(0~130),用getAge()返回人的年龄。
        在TestPerson类中实例化Person类的对象p,调用setAge()和getAge()方法,体会Java的封装性。
     */
    public class TestPerson {
    
        public static void main(String[] args) {
            Person p = new Person();
            p.setAge(22);
            System.out.println(p.getAge());
        }
    
    }
    class Person{
        private int age;
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            if(age>0 && age<130){
                this.age = age;
            }
        }
    }

    四、四种权限修饰符
    这里写图片描述

    展开全文
  • 封装性:封装是一种信息隐蔽技术,它体现于类的说明,是对象的重要特性。封装使数据和加工该数据的方法(函数)封装为一个整体,以实现独立性很强的模块,使得用户只能见到对象的外特性(对象能接受哪些消息,具有...

    封装性:封装是一种信息隐蔽技术,它体现于类的说明,是对象的重要特性。封装使数据和加工该数据的方法(函数)封装为一个整体,以实现独立性很强的模块,使得用户只能见到对象的外特性(对象能接受哪些消息,具有哪些处理能力),而对象的内特性(保存内部状态的私有数据和实现加工能力的算法)对用户是隐蔽的。封装的目的在于把对象的设计者和对象的使用者分开,使用者不必知晓其行为实现的细节,只须用设计者提供的消息来访问该对象。

    继承性:继承性是子类共享其父类数据和方法的机制。它由类的派生功能体现。一个类直接继承其他类的全部描述,同时可修改和扩充。继承具有传递性。继承分为单继承(一个子类有一父类)和多重继承(一个类有多个父类)。类的对象是各自封闭的,如果没继承性机制,则类的对象中的数据、方法就会出现大量重复。继承不仅支持系统的可重用性,而且还促进系统的可扩充性。

    多态性:对象根据所接收的消息而做出动作。同一消息被不同的对象接受时可产生完全不同的行动,这种现象称为多态性。利用多态性用户可发送一个通用的信息,而将所有的实现细节都留给接受消息的对象自行决定,如是,同一消息即可调用不同的方法。例如:同样是 run 方法,飞鸟调用时是飞,野兽调用时是奔跑。多态性的实现受到继承性的支持,利用类继承的层次关系,把具有通用功能的协议存放在类层次中尽可能高的地方,而将实现这一功能的不同方法置于较低层次,这样,在这些低层次上生成的对象就能给通用消息以不同的响应。在 OOPL 中可通过在派生类中重定义基类函数(定义为重载函数或虚函数)来实现多态性。

    展开全文
  • 面向对象程序设计具有4个共同特征:抽象性、封装性、继承性和多态性
  • 理解什么是面向对象之前先理解一下什么是面向过程。   面向过程   过程就是一件事情的先后经过;从什么开始到什么介绍,有一个时间上的先后顺序。 程序过程就体现在代码执行的先后顺序。 面向过程,就是一种...
  • 对象封装

    2020-03-19 09:41:03
    1.什么是类,什么是封装? 1)类:具有相同特性(数据元素)和行为(功能)的对象的抽象就是类。因此,对象的抽象是类,类的具体化就是对象,也可以说类的实例是对象,类实际上就是一种数据类型。类具有属性,它是...
  • 面向对象中--封装的理解

    千次阅读 2020-03-11 11:07:44
    封装是保证软件部件具有优良的模块的基础,封装的目标就是要实现软件部件的“高内聚、 低耦合”,防止程序相互依赖而带来的变动影响。 在面向对象的编程语言中,对象封装 的最基本单位,面向对象封装比传统...
  • Java面向对象三大特性(封装、继承、多态)

    千次阅读 多人点赞 2021-05-19 20:59:41
    面向对象的语言有三大特性:封装、继承、多态。三大特性是面向对象编程的核心。下面就来介绍一下面向对象的三大特性。 如果想了解面向对象可以看一下这一篇博客类和对象 一、封装 1.封装的概念 在我们写代码的时候...
  • 面向对象可以说是一种对现实是事物的抽象,将一类事物抽象成一个类,类里面包含了这类事物具有的公共部分,以及我们对这些部分的操作,也就是对应的数据和过程。 面向对象思想的三大特性,我们应该如理解呢? ...
  • Java 面向对象——封装

    千次阅读 多人点赞 2021-04-12 21:03:57
    面向对象——封装1、类和对象1.1、什么是对象1.2、什么是类1.3、什么是对象的属性1.4、什么是对象的行为1.5、类和对象的关系1.6、类的定义1.7、对象的使用成员变量和局部变量2、封装2.1、private 关键字2.1、this ...
  • 面向对象——(封装)

    万次阅读 多人点赞 2018-07-22 15:54:00
    面向对象的概念:  理解面向对象:  面向对象是相对于面向的过程而言的。  面向过程和面向对象都是强调的一种思想。... 面向对象:把功能封装对象,强调具备了功能的对象。  面向对象是基...
  • JAVA 面向对象对象 封装

    万次阅读 多人点赞 2021-05-06 15:58:57
    面向对象概念 面向对象其实是一种编程思想,通过它可以把生活中复杂的事情变得简单化,从原来的执行者变成了指挥者。 面向对象是基于面向过程而言的。 面向过程强调的是过程,比如: 打开冰箱门 2. 把大象放进去 3. ...
  • C++的封装性

    千次阅读 2018-08-15 13:13:32
    相比于C语言,C++中提供了一种非常实用并且也非常常用的方法——封装,封装是指将某些具有相同属性或性质的变量等归纳...若果没有封装性: #include &amp;lt;iostream&amp;gt; using namespace std; int...
  • Java类的三大特性之一:封装性

    千次阅读 2019-03-29 16:04:47
      我们再来设想一种情况:一个十分庞大的程序,有10000个对象具有这个Person类的属性,现在想将年龄由int改为String。对于以上情况如果不使用封装的话: class Person{ //Person类的属性:姓名,年龄,性别 ...
  • Java面向对象 - 封装、继承和多态

    千次阅读 2021-01-16 10:39:55
    第1关:什么是封装,如何使用封装 ...对于封装而言,一个对象它所封装的是自己的属性和方法,所以它是不需要依赖其他对象就可以完成自己的操作。使用封装有四大好处: 良好的封装能够减少耦合。 类内部的结构可以
  • 面向对象 封装

    千次阅读 2015-02-02 18:46:48
     一、理解面向对象 ... 面向对象和面向过程都是一种思想,就看自己怎么想了,面向对象是基于面向过程的。 面向对象的特点:  1. 是一种符合人们思考习惯的思想  2. 可以将复杂的事情简单化
  • C#第六讲:面向对象封装

    千次阅读 2019-06-13 10:52:31
    封装性是个比较概念化的东西,从我们实际的生活中我们可以找到很多的列子来类比这一特性。比如我们常用的手机,所有的零部件都被安装在手机的外壳之中,我们正常情况下,不能把cpu扣下来,也不能把里面的主板掰断,...
  • c++类和类的封装对象线程封装

    千次阅读 2017-07-30 09:18:02
    c++类和类的封装对象线程封装C++面向对象编程介绍 面向对象编程(Object Oriented Programming),简称OOP。 在传统的面向过程编程中,数据以及数据的相关操作函数都是分离的独立个体; 对象,如周围的一切其实都是...
  • 面向对象封装学习总结

    千次阅读 多人点赞 2021-10-26 09:28:41
    面向对象封装的个人理解和难题关于面向对象封装的个人理解类和对象封装难题汇总银行账户坐标点学生随机数排序 关于面向对象封装的个人理解 类和对象 类:对事物的一种描述(具有共同属性和行为的事物的抽象)...
  • Java面向对象 - 封装、继承和多态的综合练习

    千次阅读 多人点赞 2021-01-16 10:54:10
    2.封装;3.继承;4.构造函数;5.super()和this()。 面向对象思想 构造器:new就是一个构造器,作用是:①分配空间;②赋初始值(避免错误,简化输入); new Object(Parameters)构造器调用构造函数,传参为了赋初始...
  • Java面向对象封装、继承、多态

    千次阅读 2015-09-30 16:44:06
    为什么要面向对象编程? 以前开发的过程通常是采用面向过程编程,面向过程是以过程为中心来进行编程设计,本质上是分析出需要哪些过程,在编程时一步步的对其实现,但是随着软件规模的扩大,这种面向过程的设计模式...
  • C#面向对象封装(超详细)

    千次阅读 多人点赞 2020-06-03 21:11:10
    什么是封装? 为什么要封装? 封装有什么好处? 封装具体怎么实现? 实参和形参? get和set?
  • 在面向对象程序设计中,设计了对象、类、封装、继承、消息传递和多态等基本概念,下面就分别来谈谈这些概念: 对象(object):好比一个人,有多种属性:姓名、性别、年龄、体重等,都有多种行为:吃饭、走路等,...
  • 类和对象之间的关系?封装继承多态?

    千次阅读 2018-03-04 09:19:00
    在面向对象的编程思想中把对象的属性和行为分别称为对象的属性和方法,是构成对象的两个主要因素;在编程中,对象的属性被存储在一些变量里;对象的行为则通过定义方法来实现。三大基本特征:封装,继承,多态。 ...
  • 前言:今天第一次上C++课程。根据老师的所讲内容进度,记录C++知识!... 面向对象程序设计的基本元素是对象,面向对象程序的主要结构特点是: 1. 程序一般由类的定义和类的使用两部分组成; ...
  • Python是面向对象编程的语言,具有封装,继承,多态的特性。
  • Java面向对象知识点前言一、封装二、多态三、继承四、抽象五级标题六级标题总结 前言 面向对象(Object Oriented)是软件开发方法,一种编程范式。面向对象是一种对现实世界理解和抽象的方法,是计算机编程技术发展到...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 319,039
精华内容 127,615
关键字:

对象具有封装性吗