编程语言
首页 > 编程语言> > 面向对象编程----封装

面向对象编程----封装

作者:互联网

隐藏/封装( encapsulation )

为什么需要封装?封装的作用和含义?

我要看电视,只需要按一下开关和换台就可以了。有必要了解电视机内部的结构吗?有必要碰碰显像管吗!

我要开车,...... 

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

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

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

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

        使用访问控制符,实现封装

 

同一个类

同一个包中

子类

所有类

Private

 

 

 

default

 

 

protected

 

public

 

Private私有的意思

如果一个属性或者方法被private修饰的话,意味着它是私有的,它这在自己类里面可以看得见。

Default 属性或者方法前面什么都不写就是default默认

如果一个属性或者方法被Default修饰的话,它这在自己类里面可以看得见。同一个包里面可以看得到。

protected 受保护的

如果一个属性或者方法被protected修饰的话,它这在自己类里面可以看得见。同一个包里面可以看得到。子类里面也可以看得到。

Public 公开的

如果一个属性或者方法被public修饰的话,它这在自己类里面可以看得见。同一个包里面可以看得到。子类里面也可以看得到,,不同的包,不同的类,不同包的子类都可以看得到。

封装要点:

类的属性的处理:

在开发中使用记住这几点:

一般情况下属性不管三七二十一全部private私有,成员变量全部私有,如果是常量的话或者static变量的话public公开,static变量可以被所有对象共享.

  1. 一般使用private。(除非本属性确定会让子类继承)
  2. 提供相应的get/set方法来访问相关属性,这些方法通常是public,从而提供对属性的读取操作。(注意:boolean变量的get方法是用:is开头!)

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

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

package cn.bjsxt.oop.encapsulation;

public class Test1 {
private String str;
private void print() {
// private 修饰的方法或变量在自己的方法里面自己可以调
String s=str;
System.out.println("test1.print(a)");
}
// 属性或者方法前面什么都不写就是default默认
void printl() {
// private 修饰的方法或变量在自己的方法里面自己可以调
String s=str;
System.out.println("test1.print(b)");
}
/**
* 如果一个属性或者方法被public修饰的话,它这在自己类里面可以看得见。
同一个包里面可以看得到。子类里面也可以看得到,
不同的包,不同的类,不同包的子类都可以看得到。
*
*/
public void printll() {
String s=str;
System.out.println("test1.print(c)");
}
// 它这在自己类里面可以看得见。
// 同一个包里面可以看得到。子类里面也可以看得到。
protected void printlll() {
String s=str;
System.out.println("test1.print(d)");
}
}
class Test01 extends Test1{
public void pp() {
printl();
super.printl();
}
}

package cn.bjsxt.oop.encapsulation;

public class Test2 {
public static void main(String[] args) {

Test1 t = new Test1();

// 它是私有的,它这在自己类里面可以看得见。
// private类型中的print()方法不可见
// t.print();

// default 自己类里面可以看得见。同一个包里面可以看得到。
t.printl();
// public 自己类里面可以看得见。同一个包里面可以看得到。
t.printll();
// protected 自己类里面可以看得见。同一个包里面可以看得到。
t.printlll();
}
}

package cn.bjsxt.oop.encapsulation0;
//在这里需要导入我们的包
//这里用import加包名加文件名,导入包文件
import cn.bjsxt.oop.encapsulation.Test1;
public class Test3 {
public static void main(String[] args) {
Test1 t = new Test1();
// Test1类型中的print()方法不可见
// 不同的包里面不可见
// private 私有的
// t.print();
// default默认
// t.printl();
// protected 受保护的
// t.printlll();


// 不同的包里面可见
// public 公共的
t.printll();
}
}

 

package cn.bjsxt.oop.encapsulation0;
import cn.bjsxt.oop.encapsulation.Test1;
//Test001继承不同包下面的类Test1
public class Test001 extends Test1 {
public void ttt() {
// Private私有的 不同包下面的子类不可见
// super.print();
// print();

// protected 受保护的 不同的包子类里面也是可见的
// 自己子类继承的也是可以直接用的
printlll();
// super.父类方法()可以不在第一行,在哪一行都行。
super.printlll();

// default默认 不同的包里面的子类不可见
// printl();
// public 公共的 不同的包子类里面也是可见的
// super.父类方法()可以不在第一行,在哪一行都行。
super.printll();
// 自己子类继承的也是可以直接用的
// printll();

}
public static void main(String[] args) {
Test001 t = new Test001();
// 被Public修饰的类 公开的
// t.printll();
// protected 受保护的
// t.printlll();
t.ttt();
}
}

package cn.bjsxt.oop.encapsulation0;

public class Man {
private String name;
private String id;
private boolean man;

public static int cc;

// 常量也可以公开,但不是绝对的
public static final int XAM_SEF=120;
/** 通过它可以统一的设置它的属性
* @return
* 如果开发的话没有必要一个一个的敲,
* 通过先有的命令可以直接添加:
* 空白处右键选择Source

然后选择Generate getters and setters
在 Select getters and setters to create: 里面选择对应的属性
然后ok就可以了。*/
// 针对这些私有的属性,可以提供相应的set/get方法
// public String 以get开头,后面根属性名称,首字母大写
public String getName() {
// this可加可不加
return this.name;
}
// 如果设置呢 public void 以set开头,后面根属性名称,首字母大写,
// 括号里面加局部变量String name
public void setName(String name) {
this.name=name;
}
// 私有的布尔类型加对应的方法加的是isMan和setMan没有getMan
public boolean isMan() {
return man;
}
public void setMan(boolean man) {
this.man = man;
}
}

标签:里面,String,子类,void,private,----,面向对象编程,封装,public
来源: https://www.cnblogs.com/fantasticDream/p/16321752.html