JAVA 面向对象 特征一(封装与隐藏)详解

简介: JAVA 面向对象 特征一(封装与隐藏)详解

前言

耦合度:是指模块之间的依赖关系,包括控制关系、调用关系、数据传递关系。联系越多,其耦合性越强,同时表明其独立性越差。

耦合性:在android开发过程中,主要注意的是activity间关联程度。耦合的强弱取决于activity间意图的复杂性、调用的方式以及通过界面传送数据的多少。

我们的程序设计追求就是:‘高内聚,低耦合’

高内聚:类的内部操作细节自己完成,不允许外部干涉。

封装性思想:隐藏对象内部的复杂性,只对外公开简单的接口,便于外界调用,从而提高系统的可扩展性,可维护性。

通俗的说:就是把该隐藏的隐藏起来,该暴露的暴露出来,这就是封装性的设计思想

下面来举个例子来看看封装性的体现:

public class demo4 {
    public static void main(String[] args) {
        Animal animal=new Animal();
        animal.name="大黄";
        animal.age=6;
       // animal.legs=2;
        animal.setLegs(-4);
        animal.info();
        System.out.println(animal.getLegs(1));
    }
}
class Animal{
    String name;
    int age;
    private int legs;
    //对属性的设置
    public void setLegs(int aa){
        if (aa>=0&&aa%2==0){
            legs=aa;
        }else {
            legs=0;
        }
    }
    //获取属性的值
    public int getLegs(int legs){
        return legs;
    }
    public void info(){
        System.out.println("name:"+name+",age:"+age+",legs:"+legs);
    }
}

对成员变量legs进行的设置,加上权限修饰符private,对属性进行设置,和获取值,就是用setLegs()和getLegs()方法,这就是封装性的一种体现。

比如还有:不对外暴露的私有方法,也是封装性的体现。

封装性的体现,需要权限修饰符来配合。

有四种权限修饰符,权限大小由小到大排序为:

private ,缺省 ,protected ,public

图示如下:

这四种修饰符,可以修饰类,以及类的内部的结构:属性,方法,构造器,内部类

而具体的 修饰类只可以用:public ,缺省

修饰类内部的结构,这四种权限修饰符都可以。

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

下面演示下这四个访问修饰符,加强理解

项目目录结构,这样更清晰,知道我在说什么

1、首先演示在同类中的情况,在modifier包下创建A类

/**
 * @Author: ly
 * @Date: 2022/11/13
 * @Description: 演示在同类中 四个访问修饰符
 */
public class A {
    //四个属性
    public int n1 = 100;
    protected int n2 = 200;
    int n3 = 100;
    private int n4 = 100;
    public void m1() {
        //该方法可以访问 四个属性
        System.out.println("n1=" + n1 + " n2=" + n2 + " n3=" + n3 + " n4=" + n4);
    }
}

2、演示在同包中,在modifier包下创建B类

/**
 * @Author: ly
 * @Date: 2022/11/13
 * @Description: 演示在同包中 四个访问修饰符
 */
public class B {
    public void say() {
        A a = new A();
        //在同一个包下,可以访问public、protected、和 默认修饰属性或方法,不能访问private 属性或方法
        System.out.println("n1=" + a.n1 + " n2=" + a.n2 + " n3=" + a.n3);
    }
}

3、演示在子类中,新建一个包model,让后创建C类

/**
 * @Author: ly
 * @Date: 2022/11/13
 * @Description: 演示在子类中 四个访问修饰符
 */
public class C extends A {
    public void say() {
        //在子类中,前提是该子类与A类不在同一个包中,如果C类与A类在同一个包中,默认的修饰符也可以访问到
        //这点不要弄混了。(因为默认修饰符在同包中修饰的属性或方法本来就是可见的)
        //可以访问public、protected修饰属性或方法,不能访问private,默认 属性或方法
        System.out.println("n1=" + n1 + " n2=" + n2);
    }
}

之后在modifier包下,创建Test类进行测试输出

public class Test {
    public static void main(String[] args) {
        A a = new A();
        a.m1();
        B b = new B();
        b.say();
        C c = new C();
        c.say();
    }
}

输出结果

n1=100 n2=200 n3=100 n4=100
n1=100 n2=200 n3=100
n1=100 n2=200

4、演示在不同包中,在model包中创建Test类

/**
 * @Author: ly
 * @Date: 2022/11/13
 * @Description: 演示在不同包中
 */
public class Test {
    public static void main(String[] args) {
        A a = new A();
        //在不同包下,可以访问public修饰的属性或方法
        //但是不能访问protected,默认,private修饰的属性或方法
        System.out.println(a.n1);
    }
}


目录
相关文章
|
14天前
|
Java 编译器
封装,继承,多态【Java面向对象知识回顾①】
本文回顾了Java面向对象编程的三大特性:封装、继承和多态。封装通过将数据和方法结合在类中并隐藏实现细节来保护对象状态,继承允许新类扩展现有类的功能,而多态则允许对象在不同情况下表现出不同的行为,这些特性共同提高了代码的复用性、扩展性和灵活性。
封装,继承,多态【Java面向对象知识回顾①】
|
2天前
|
SQL 安全 Java
JAVA代码审计SAST工具使用与漏洞特征
JAVA代码审计SAST工具使用与漏洞特征
11 2
|
16天前
|
安全 Java 数据安全/隐私保护
Java 封装怎么理解
封装是Java中的一种重要机制,它将对象的状态(数据)和行为(方法)打包在一起并控制外部访问权限,以保护数据不被随意修改。封装的主要目的包括数据保护、接口设计和增强模块性。通过使用`private`、`protected`及`public`等访问控制修饰符,结合getter和setter方法,可以有效隐藏对象内部实现细节。下面是一个简单的`BankAccount`类示例,展示了如何通过封装保护类的内部状态,确保数据安全和一致性,简化类的使用。理解封装有助于编写高质量代码和设计优秀程序架构。
|
12天前
|
Java
java中面向过程和面向对象区别?
java中面向过程和面向对象区别?
23 4
|
16天前
|
Java 数据安全/隐私保护
Java 封装详解
在 Java 中,封装是面向对象编程的关键特性,通过将对象的状态(数据)和行为(方法)结合并利用访问控制保护数据,防止外部随意访问和修改。主要特点包括访问控制(如 `private` 和 `protected`)、数据隐藏及方法暴露(如 getter 和 setter)。封装的优点在于保护数据、隐藏实现细节、易于维护以及提高代码可读性。下面是一个简单的 `Person` 类封装示例,展示了如何通过 getter 和 setter 控制对类内部状态的访问,并进行合法性检查。总结而言,封装有助于构建清晰、易用且可维护的代码结构,是编写高质量 Java 程序的重要原则。
|
12天前
|
SQL 安全 Java
JAVA代码审计SAST工具使用与漏洞特征
JAVA代码审计SAST工具使用与漏洞特征
33 1
|
14天前
|
安全 Java 开发者
Java修饰符与封装:理解访问权限、行为控制与数据隐藏的重要性
Java中的修饰符和封装概念是构建健壯、易维护和扩展的Java应用程序的基石。通过合理利用访问权限修饰符和非访问修饰符,开发者能够设计出更加安全、灵活且高效的代码结构。封装不仅是面向对象编程的核心原则之一,也是提高软件项目质量和可维护性的关键策略。
13 1
|
14天前
|
Java
接口和抽象类【Java面向对象知识回顾②】
本文讨论了Java中抽象类和接口的概念与区别。抽象类是不能被实例化的类,可以包含抽象和非抽象方法,常用作其他类的基类。接口是一种纯抽象类型,只包含抽象方法和常量,不能被实例化,且实现接口的类必须实现接口中定义的所有方法。文章还比较了抽象类和接口在实现方式、方法类型、成员变量、构造方法和访问修饰符等方面的不同,并探讨了它们的使用场景。
接口和抽象类【Java面向对象知识回顾②】
|
18天前
|
Java 开发者
Java 面向对象
Java 是一种面向对象的编程语言,通过对象与类的概念组织代码和数据。面向对象编程的核心包括类、对象、继承、多态、封装和抽象。类是对象的蓝图,定义了属性和行为;对象则是类的实例。继承允许子类继承父类的属性和方法,增强代码复用性;多态则支持通过相同接口调用不同类型对象的行为,包括方法重载和重写。封装通过公共方法隐藏对象细节,提高安全性;抽象则对对象特征进行提炼,通过抽象类和接口实现。理解这些概念有助于设计高效、可维护的 Java 应用程序。
|
25天前
|
Java 开发者
Java编程之旅:探索面向对象的力量
【9月更文挑战第16天】在编程的世界中,Java以其强大的面向对象编程特性而闻名。本文将带你走进Java的世界,一起探索类与对象的奥秘,学习如何通过封装、继承和多态性构建健壮的软件系统。无论你是初学者还是有经验的开发者,本文都旨在提供实用的代码示例,帮助你提升Java技能。准备好开始这段旅程了吗?让我们启程吧!