9.3隐藏和封装
Java中的封装
封装是面向对象三大特征之，指将对象的状态信息隐藏在对象内部，不允许外部程序直控访问对象内部信息，而是见通过该类所提供的方法来实现对内部信息的操作和访问。
封装是面向对象编程语言对客观世界的模拟，客观世界里的属性都被隐藏在对象内部，外界无法直接操作和修改。
●隐藏类的实现细节。
●让使用者只能通过事先预定的方法来访问数据，从而可以在该方法里加入控制逻辑，限制对属性的不合理访问。
●进行数据检查，从而有利于保证对象信息的完整性。
●便于修改，提高代码的可维护性。
为了在Java程序中实现良好的封装，需要从如下两个方面考虑。
●将对象的属性和实现细节隐藏起来，不允许外部直接访问。
●把方法暴露出来，让方法来操作或访问这些属性。
封装有两个方面的含义，一是把该隐藏的隐藏起来， 二是把该暴露的暴露出来。这两个含义都需要使用Java提供的访问控制符来实现。
使用访问控制符
在Java程序中提供了三个访问控制符，分别是private、protected和public，分别代表了三个访问控制级别。除此之外，还有一个不加任何访问控制符的访问控制级别default,也就是说，Java一共提供了四个访问控制级别，由小到大分别是private、 default、 protected 和 public.
其中default 并没有对应的访问控制符，当不使用任何访问控来修饰类或类成员时，系统默认使用default访问控制级别。
具体说明如下所示：
- private ：如果类里的一个成员 (包括属性和方法)使用pivate访问控制修饰时，这个成员只能在该类的内部 被访问。很显然，这个访问控制符用于修饰属性最合适。使用private来修饰属性就可以把属性隐藏在类的内部。
- default ：如果类里的一个成员 (包括属性和方法)或者一个顶级类不使用任何访问控制修饰符，我们称他是默认访问控制，default访问控制的成员或顶级类可以被相同包下的其他类访问。。
- protected ：如果类里的一个成员 (包括属性和方法)使用protected，这个成员既可以被同一包中其他类访问，也可以被不同包中的子类访问，不能被其他包中不是子类的访问。。 通常情况下，如果使用protected修饰一个方法，就是希望其子类来重写这个方法。
- public：最宽松的，可以被所有类访问，不管是不是在同一个包中，不管是否有父子继承关系。
注意：顶级类可以使用访问控制修饰符，但只能用public和default（默认），不能用private和protected，因为顶级类不处于任何类的内部，没有外部类的子类，因此没有意义。
例子：
public class Preson {
private String name;
private int age;
public Preson(){
}
public Preson(String name,int age){
this.name=name;
this.age=age;
}
public void setName(String name){
if(name.length()>6||name.length()<2)
{
System.out.println("您设置的人名不符合要求");
return;
}
else{
this.name=name;
}
}
public String getName()
{
return this.name;
}
public void setAge(int age)
{
if(age>100||age<0)
{
System.out.println("您设置的年龄不合法");
return;
}
else{
this.age=age;
}
}
public int getAge()
{
return this.age;
}
}
上述代码定义了Person类、该类的name和age属性只能在Person类内才能操作和访问。 ，在Person类外只能通过各自对应的setter和getter方法来操作和访问他们。
注意:在使用Java中的访问控制符时，应该遵循如下三条基本原则。
(1)类里的绝大部分属性都应该使用private修饰，除了一些static修饰的、类似全局变量的属性，才可能考虑使用publice 修饰。除此之外，有些方法只是用于辅助实现该类的其他方法，这些方法被称为工具方法，工具方法也应该使用private修饰。
(2)如果某个类主要用作其他类的父类，该类里包含的大部分方法可能仅希望被其子类重写，而不想被外界直接调用，则应该使用protected修饰这些方法。
(3)希望暴露出来给其他类自由调用的方法应该使用public修饰。因此，类的构造器通过使用public修饰，暴露给其他类中创建该类的对象。因为顶级类通常都希望被其他类自由使用，所以大部分顶级类都使用public 修饰。
9.4接口
接口一样起着中介的作用。接口定义方法和类的定义方法十分相似，在接口中可以派生出新的类。
定义接口
java程序创建接口后，接口的方法和抽象类中的方法一样，他的方法是抽象的，不具备实现的功能。
一个类只可以继承一个类，但是一个类可以实现多个接口。
接口中只能声明常量，不能声明变量。三个特性：公共性、静态的、最终的。
语法格式如下：
[public] interface<接口名>{
[<常量>]
[<抽象方法>]
}
public ：接口的修饰符只能是public，因为只有这样，接口才能被任何包中的接口或类访问。
interface ：接口的关键字。
定义接口
1.接口里的量
在java程序中，接口中只能声明常量，不能声明变量。这样才能保证接口的所有的类可以访问相同的常量。
例如：
interface Jiechang {
int a = 100;
int b = 200;
int c = 323;
int d = 234;
int f = 523;
void print();
void print1();
}
class Jiedo implements Jiechang {
public void print() {
System.out.println("老二获得的财产是：");
System.out.println(a + b);
}
public void print1() {
System.out.println("老大获得的财产是：");
System.out.println(c + d + f);
}
}
public class Jie {
public static void main(String args[]) {
Jiedo a1 = new Jiedo();
a1.print();
a1.print1();
}
}
输出结果：
老二获得的财产是：
300
老大获得的财产是：
1080
2.接口中方法
接口里的方法都是抽象的或公有的。可以省略public或者abstract。
例子：
interface newjie {
void print();
public void print1();
abstract void print2();
public abstract void print3();
abstract public void print4();
}
class newjie1 implements newjie {
public void print() {
System.out.println("newjie接口里第一个方法没有修饰符");
}
public void print1() {
System.out.println("newjie接口里第二个方法有修饰符public");
}
public void print2() {
System.out.println("newjie接口里第三个方法有修饰符abstract");
}
public void print3() {
System.out.println("newjie接口里第四个方法有修饰符public abstract");
}
public void print4() {
System.out.println("newjie接口里第五个方法有修饰符abstract public");
}
}
public class cuofang {
public static void main(String args[]) {
newjie1 a1 = new newjie1();
a1.print();
a1.print1();
a1.print2();
a1.print3();
a1.print4();
}
}
输出：
newjie接口里第一个方法没有修饰符
newjie接口里第二个方法有修饰符public
newjie接口里第三个方法有修饰符abstract
newjie接口里第四个方法有修饰符public abstract
newjie接口里第五个方法有修饰符abstract public
这五个方法其实是相同的，写的时候建议使用第一种方式编写。
3.实现接口
在接口实现的过程中，能为所有的接口提供实现的功能
例子：
interface Jieone {
int add(int a, int b);
}
interface JieTwo {
int sub(int a, int b);
}
interface JieThree {
int mul(int a, int b);
}
interface JieFour {
int umul(int a, int b);
}
class JieDuo implements Jieone, JieTwo, JieFour, JieThree {
public int add(int a, int b) {
return a + b;
}
public int sub(int a, int b) {
return a - b;
}
public int mul(int a, int b) {
return a * b;
}
public int umul(int a, int b) {
return a / b;
}
}
public class jieshi {
public static void main(String args[]) {
JieDuo a1 = new JieDuo();
System.out.println("a+b= " + a1.add(2400, 1200));
System.out.println("a-b= " + a1.sub(2400, 1200));
System.out.println("a*b= " + a1.mul(2400, 1200));
System.out.println("a/b= " + a1.umul(2400, 1200));
}
}
输出结果：
a+b= 3600
a-b= 1200
a*b= 2880000
a/b= 2
4.引用接口
我们可以创建接口类型的引用变量，能够存储一个指向对象的引用值，这个对象可以实现任何接口的类的实例，用户通过接口调用该类对象的放啊，这些方法在类中必须是抽象方法。
例子：
interface diyijie {
int add(int a, int b);
}
interface dierjie {
int sub(int a, int b);
}
interface disanjie {
int mul(int a, int b);
}
interface disijie {
int umul(int a, int b);
}
class jiekouiu implements diyijie, dierjie, disanjie, disijie {
public int add(int a, int b) {
return a + b;
}
public int sub(int a, int b) {
return a - b;
}
public int mul(int a, int b) {
return a * b;
}
public int umul(int a, int b) {
return a / b;
}
}
public class jieyin {
public static void main(String args[]) {
jiekouiu aa = new jiekouiu();
//接口的引用执行对象的引用
diyijie bb = aa;
dierjie cc = aa;
disanjie dd = aa;
disijie ee = aa;
System.out.println("a+b= " + aa.add(2400, 1200));
System.out.println("a-b= " + aa.sub(2400, 1200));
System.out.println("a*b= " + aa.mul(2400, 1200));
System.out.println("a/b= " + aa.umul(2400, 1200));
System.out.println("a+b= " + bb.add(2400, 1200));
System.out.println("a-b= " + cc.sub(2400, 1200));
System.out.println("a*b= " + dd.mul(2400, 1200));
System.out.println("a/b= " + ee.umul(2400, 1200));
}
}
输出结果：
a+b= 3600
a-b= 1200
a*b= 2880000
a/b= 2
a+b= 3600
a-b= 1200
a*b= 2880000
a/b= 2
5.接口的继承
接口的继承和类的继承不一样，接口支持多继承，即一个接口可以有多个直接父接口，用逗号隔开。
例如：
interface interfaceA {
int PROPA = 5;
void testA();
}
interface interfaceB {
int PROPB = 6;
void testB();
}
interface interfacec extends interfaceA, interfaceB {
int PROPC = 7;
void testC();
}
public class jicheng {
public static void main(String args[]) {
System.out.println(interfacec.PROPA);
System.out.println(interfacec.PROPB);
System.out.println(interfacec.PROPC);
}
}
输出结果：
5
6
7
117
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
