java的三大特性

Java语言的三大特性即是：封装、继承、多态

首先先简单的说一下其3大特性的定义：

封装：隐藏对象的属性和实现细节，仅对外公开接口,控制在程序中属性的读和修改的访问级别。将抽象得到的数据和行为（或功能）相结合，形成一个有机的整体，也就是将数据与操作数据的源代码进行有机的结合，形成“类”，其中数据和函数都是类的成员。封装的目的是增强安全性和简化编程，使用者不必了解具体的实现细节，而只是要通过外部接口，一特定的访问权限来使用类的成员。封装的基本要求是: 把所有的属性私有化，对每个属性提供getter和setter方法，如果有一个带参的构造函数的话，那一定要写一个不带参的构造函数。在开发的时候经常要对已经编写的类进行测试，所以在有的时候还有重写toString方法，但这不是必须的。

继承：通过继承实现代码复用。Java中所有的类都是通过直接或间接地继承java.lang.Object类得到的。继承而得到的类称为子类，被继承的类称为父类。子类不能继承父类中访问权限为private的成员变量和方法。子类可以重写父类的方法，及命名与父类同名的成员变量。但Java不支持多重继承，即一个类从多个超类派生的能力。在开发中尽量减少继承关系，这样做是为了把程序的耦合度降低。

多态：多态又分为设计时多态和运行时多态，例如重载又被称为设计时多态，而对于覆盖或继承的方法，JAVA运行时系统根据调用该方法的实例的类型来决定选择调用哪个方法则被称为运行时多态。总而言之，面向对象的设计的典型特点就是继承，封装和多态，这些特点也是面向对象之所以能如此盛行的关键所在。

以上就是java三大特性的基本含义，大家理解一下就行了，千万别背啊！接下来我们通过一个例子来完美的解释一下java的3大特性。

用java做一个简单计算器；

import java.io.*;

class OperationAttridute

{

       private double numberA=0;

       private double numberB=0;

       private double result=0;

       public double setNumberA(double i)

       {

              return numberA=i;

       }

       public double getNumberA()

       {

              return numberA;

       }

       public double setNumberB(double j)

       {

              return numberB=j;

       }

       public double getNumberB()

       {

              return numberB;

       }

       public double setResult(double z)

       {

              return result=z;

       }

       public double getResult(double a,double b)

       {

              return result;

       }

}

//将要运算的2个数字和运算结果进行封装。

class OperationA extends OperationAttridute

{    

       public double getResult(double a,double b)

       {

              double result=0;

              result=a+b;

              return result;

       }    

}

//加法类：继承OperationAttridute类并且覆盖其getResult方法

class OperationS extends OperationAttridute

{

       public double getResult(double a,double b)

       {

              double result=0;

              result=a-b;

              return result;

       }

}

//减法类：继承OperationAttridute类并且覆盖其getResult方法

class OperationM extends OperationAttridute

{

       public double getResult(double a,double b)

       {

              double result=0;

              result=a*b;

              return result;

       }

}

//乘法类：继承OperationAttridute类并且覆盖其getResult方法

class OperationD extends OperationAttridute

{

       public double getResult(double a,double b)

       {

              double result=0;

              if(b==0)

              {

                     Throw new RuntimeException(“被除数不能为0”);

              }

              result=a/b;

              return result;

       }

}

//除法类：继承OperationAttridute类并且覆盖其getResult方法，除法要对被除数进行判断并抛出异常

class Operationdo

{

       public static Object expression_r(char r)

       {

              OperationAttridute oa=new OperationAttridute();       

              switch(r)

              {

                     case '+':

                     oa=new OperationA();                

                     break;

                     case '-':

                     oa=new OperationS();                 

                     break;

                     case '*':

                     oa=new OperationM();         

                     break;

                     case '/':

                     oa=new OperationD();         

                     break;                  

              }

              return oa;             

       }

}

//运算类：通过传进来的参数，来调用运算方法

class Account

{

       public static void main(String []args)throws Exception

       {

              char r='*';                   

              OperationAttridute oa=(OperationAttridute)Operationdo.expression_r(r);

              double a=oa.setNumberA(9);

              double b=oa.setNumberB(2);

              System.out.println(oa.getResult(a,b));  

       }

}

//主程序

这样，只需要输入运算符号，通过多态，返回父类的方式实现了计算器的结果。

JAVA设计模式五大原则

1、单一职责

不论是在设计类，接口还是方法，单一职责都会处处体现，单一职责的定义：我们把职责定义为系统变化的原因。所有在定义类，接口，方法的时候。定义完以后再去想一想是不能多于一个的动机去改变这个类，接口，方法。如果答案是肯定的，说明定义的类，接口，方法则多于一个职责。故违背单一职责，遇到这种情况应该重新细分职责，直到不会出现多种职责的类，接口方法为止（发现职责，并把那些职责相互分离）。单一职责的为最简单的五种原则之一。在软件设计的过程中处处体现。无处不在。

2、开闭原则

开闭原则是指类、模块、方法是可以扩展的，但不可以修改。开即对扩张开放，闭即对修改关闭。开闭原则的应用体现在，开发人员应该仅仅对程序中频繁出现变化的地方进行抽象（封装变化点）。对变化点的封装即对变化的修改关闭。对于变化的不确定性，可随时扩展。即 继承的使用。抽象类的运用。

3、替换原则(Is-A)

替换原则即是总是保证子类可以替换它的基类。

替换原则的实现。对于一组具有类似属性，方法，变量的类。我们可以提取公共属性，方法，变量做为一个基类（抽象类或者类），使这一组类继承基类，重写虚方法。现在这些继承的类和基类的关系符合Is-A。如基类为鸟，则继承类可以为麻雀，燕子。我们可以说麻雀Is-A鸟，燕子Is-A鸟。

在项目中所有使用子类的地方都可用父类替换，但在调用方法的时候 ，即呈现面向对象编程的多态性。即替换原则，非常重要的原则，也是比较对难的原则。

4、依赖倒置原则

a、高层模块不应该依赖于低层模块。二者都应该依赖于抽象

b、抽象不应该依赖于细节。细节应该依赖于抽象。

在面向过程的开发语言中分析和设计，总是创建一些高层模块去调用低层模块、策略依赖于细节的软件结构。实际上这种方法的目的就是要定义子程序层次结构，该结构 描述了高层模块怎样调用低层模块。而设计良好的面向对象的程序，正好“倒置”了这种依赖关系。高层模块不再依赖于低层模块，从而低层模块的修改不会影响到高层模块，并且高层模块也是能非常容易的被重用，高层模块和低层模块都影响都依赖于抽象。这样也非常符合强内聚松耦合的编程思想。故该原则也是框架设计的核心原则。

使用传统的过程化程序设计所创建出来的依赖关系结构，策略是依赖于细节的，这是糟糕的，因为这样会使策略受到细节改变的影响，面向对象的程序设计倒置了依赖关系结构，全程细节和策略都依赖抽象，并且常常是客户程序拥有服务接口。

事实上，这种依赖关系的倒置正是好的面向对象设计 的标志所在，使用何种语言来编写程序是无关紧要的。如果程序的依赖关系是倒置的，它就是面向对象的设计。如果程序的依赖关系不是倒置的，它就是过程化的设计。

依赖倒置原则是实现许多面向对象技术所宣称的好处的基本低层机制。它的正确应用对于创建可重用的框架来说是必需的。同时它对于构建在变化面前富有弹性的代码也是非常重要的，由于抽象和细节彼此隔离，所以代码也非常容易维护。

5、接口隔离原则

应该说该原则是处理现有“胖”接口所存在的缺点。如果类的接口不是内聚的，就表示该类具有“胖”接口。换句话说“胖”接口可以分解成多组方法。每一组方法都服务于一组不同的客户程序。这样，量引客户程序可以使用一组成员函数，而其他客户程序可以使用其他组的成员函数。

接口隔离的方法有两种（分享客户就是分离接口）：

1、使用委托（此委托非.net委托[delegate]）分离接口

使用委托即，创建一个委托类，用此类去实现分离后的其它接口中的方法。

2、使用多重继承分离接口、

此方法，即将现有“胖”接口分成供不同客户程序调用的两个或多个接口，而需要实现多个接口的客户程序，则使用多重继承来实现。

这两种方法是实现接口隔离的全部方法，其中第二种方法使用较普遍，也比较简单。而第一种方法使用起来相对比较复杂，而且在使用委托的过程中也会产生重复的对象，则占用运行时间和内存开销。有的时候第二种方法是必须的，第一种方法是不能使用的。如：利用委托对象所做的转换是必需的，或者不同的时候会需要不同的转换。