面向对象三大特性一一封装（encapsulation）

为什么要封装？

我们看电视，只要按一下开关和换台就行了。有必要了解电视的内部结构吗？有必要了解显像管吗？

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

我们设计程序要追求：“高内聚，低耦合”。

高内聚：就是类的颞部数据的操作细节自己完成，不允许外部干涉；

低耦合：仅仅暴露少量的方法给外部使用

哪些应该封装，哪些不应该封装？

类无非就是属性和方法。对他们进行约束行了。

使用访问控制符，现实封装！

首先 private

1 package com.bjsxt.oop.encapsulation01;
2
3 public class Test01 {
4     private String str;
5     private void print(){
6         System.out.println("Test01.print()");
7     }
8 }

在同一个包的另外一个类，调用test01();

 1 package com.bjsxt.oop.encapsulation01;
 2
 3 public class Test02 {
 4
 5     /**
 6      * @param args
 7      */
 8     public static void main(String[] args) {
 9         Test01 t = new Test01();
10         t.print();//报错 The method print() from the type Test01 is not visible
11     }
12
13 }

换成default 默认（不用写）

1 package com.bjsxt.oop.encapsulation01;
2
3 public class Test01 {
4     private String str;
5     /*private*/ void print(){
6         System.out.println("Test01.print()");
7     }
8 }

同一个包

 1 package com.bjsxt.oop.encapsulation01;
 2
 3 public class Test02 {
 4
 5     /**
 6      * @param args
 7      */
 8     public static void main(String[] args) {
 9         Test01 t = new Test01();
10         t.print();//可以用！
11     }
12
13 }

private和default 看看不同包可以调用吗？

private 同一个包的肯定不行上面已经试了

1 package com.bjsxt.oop.encapsulation01;
2
3 public class Test01 {
4     private String str;
5     private void print(){
6         System.out.println("Test01.print()");
7     }
8 }

不同包

 1 package com.bjsxt.oop.encapsulation02;
 2
 3 import com.bjsxt.oop.encapsulation01.Test01;
 4
 5 public class test03 {
 6
 7     /**
 8      * @param args
 9      */
10     public static void main(String[] args) {
11         // TODO Auto-generated method stub
12         Test01 t = new Test01();
13         t.print();//报错The method print() from the type Test01 is not visible
14     }
15
16 }

试试 default 同包的肯定可以上面试了

1 package com.bjsxt.oop.encapsulation01;
2
3 public class Test01 {
4     private String str;
5     /*private*/ void print(){
6         System.out.println("Test01.print()");
7     }
8 }

不同包

 1 package com.bjsxt.oop.encapsulation02;
 2
 3 import com.bjsxt.oop.encapsulation01.Test01;
 4
 5 public class test03 {
 6
 7     /**
 8      * @param args
 9      */
10     public static void main(String[] args) {
11         // TODO Auto-generated method stub
12         Test01 t = new Test01();
13         t.print();//报错The method print() from the type Test01 is not visible
14     }
15
16 }

不可以报错

public 就不用试了都可以

那么

protected

首先在同一个包下创建一个子类，然后在别的包再创建一个子类

 1 package com.bjsxt.oop.encapsulation01;
 2
 3 public class Test01 {
 4     private String str;
 5     /*private*//*public*/protected void print(){
 6         System.out.println("Test01.print()");
 7     }
 8 }
 9 class Test001 extends Test01{
10     public void pp(){
11         super.print();
12     }
13 }

 1 package com.bjsxt.oop.encapsulation02;
 2
 3 import com.bjsxt.oop.encapsulation01.Test01;
 4
 5 public class Test0001 extends Test01{
 6     public static void main(String[] args) {
 7         Test0001 t = new Test0001();
 8         t.print();
 9     }
10 }

 1 package com.bjsxt.oop.encapsulation02;
 2
 3 import com.bjsxt.oop.encapsulation01.Test01;
 4
 5 public class Test03 {
 6
 7     /**
 8      * @param args
 9      */
10     public static void main(String[] args) {
11         // TODO Auto-generated method stub
12         Test01 t = new Test01();
13         t.print();//报错The method print() from the type Test01 is not visible
14     }
15
16 }

发现他的子类是可以的

不是子类的就不行了

总之，记住上面的图，或者下面的话就行。

封装要点：

1.类的属性的处理

一般(成员变量)使用private 常量或者static变量的话用public (除非本属性确定会被子类继承)

提供相应get/set方法(public) 从而对属性进行操作（boolean类型的get方法变成了is）

2.类的方法的处理

一些只用于本类的辅助方法可以用 private

希望其他类调用的方法用public

下面是一般建类时属性和方法的设置

 1 package com.bjsxt.oop.encapsulation01;
 2 /**
 3  * 一般这么定义类的访问权限
 4  *
 5  * @author Administrator
 6  *
 7  */
 8 public class Man {
 9     //成员变量私有
10     private String name;
11     private int id;
12     //静态变量公开
13     public static int cc;
14     //常量可以公开 也可以不公开 看需求
15     public static final int MAX_SPEED =120;
16     public boolean man;
17
18
19
20     //设置set、get方法  直接 Source里的set get方法创建就可以
21     public String getName() {
22         return name;
23     }
24     public void setName(String name) {
25         this.name = name;
26     }
27     public int getId() {
28         return id;
29     }
30     public void setId(int id) {
31         this.id = id;
32     }
33     public boolean isMan() {
34         return man;
35     }
36     public void setMan(boolean man) {
37         this.man = man;
38     }
39
40 }

注意设置set/get方法时，没必要手写，可以右键source 找到 Generate Getters and Setters...

注意设置boolean布尔类型变量的set/get 变成了is/get 自己写可能会忘，用source里面的Generate Getters and Setters...创建自动添加，选上即可

转载于:https://www.cnblogs.com/PoeticalJustice/p/7617783.html

面向对象三大特性一一封装（encapsulation）相关推荐

大数据必学Java基础（三十九）：面向对象三大特性之一封装(Encapsulation)
文章目录面向对象三大特性之一封装(Encapsulation) 一.生活案例二.Java中封装的理解
面向对象三大特性：封装，继承，多态
面向对象的三大特性:封装,继承,多态. 一.封装:目的:如何做类,让类更安全. 让一些成员变量不能被外界直接被访问. 方法: 1.将成员变量变为private. 2.在类里面做一个成员方法来间接访问. ...
面向对象编程(十三)——面向对象三大特性之封装
面向对象第二大特征:封装/隐藏一.隐藏/封装(encapsulation) 为什么需要封装?封装的作用和含义? 比如:①我要看电视,只需要按一下开关和换台就可以了.有必要了解电视机内部的结构吗?有必 ...
python 封装_Python 面向对象三大特性之封装
封装定义:隐藏对象的属性和实现细节,仅对外提供公共访问方式. [好处] 将变化隔离: 便于使用: 提高复用性: 提高安全性: [封装原则] 将不需要对外提供的内容都隐藏起来: 把属性都隐藏,提供公共 ...
C# 面向对象三大特性：封装、继承、多态
面向对象有封装.继承.多态这三个特性,面向对象编程按照现实世界的特点来管理复杂的事物,把它们抽象为对象,具有自己的状态和行为,通过对消息的反应来完成任务.这种编程方法提供了非常强大的多样性,大大增加了 ...
java面向对象三大特性：封装、继承、多态——举例说明
概念封装:封装就是将客观的事物抽象成类,类中存在属于这个类的属性和方法. 继承:继承就是把父对象继承过来,这样子类就存在了父类的操作方法,java是单继承,就是只能继承一个父对象. 多态:多态就是程 ...
java 面向对象三大特性之封装万字详解（超详细）
目录前言 : 一.为什么需要封装 : 前言 : 1.封装的好处 : 2.java中的常见封装体: 二.封装简介 : 1.封装的概念 : 2.封装的关键 : 三.private关键字(重要) : 1. ...
面向对象三大特性（封装，继承，多态）之多态
在面向对象语言中,接口的多种不同的实现方式即为多态. 多态性是指相同的操作或函数.过程可作用于多种类型的对象上并获得不同的结果.不同的对象,收到同一消息将可以产生不同的结果,这种现象称为多态性. 多态 ...
面向对象三大特性一一多态（polymorphism）
1 package com.bjsxt.oop.polymorphism; 2 3 public class Animal { 4 public void voice(){ 5 System.out. ...

面向对象三大特性一一封装（encapsulation）

面向对象三大特性一一封装（encapsulation）相关推荐

最新文章

热门文章