Java 的三大特性

java 的三大特性:

封装：把属于同一类事物的共性（包括属性与方法）归到一个类中，以方便使用。
1: 概念:指利用抽象数据类型将数据和基于数据的操作封装在一起，使其构成一个不可分割的独立实体，数据被保护在抽象数据类型的内部，尽可能地隐藏内部的细节，只保留一些对外接口使之与外部发生联系.
2: 好处:(1)实现了专业的分工。将能实现某一特定功能的代码封装成一个独立的实体后，各程序员可以在需要的时候调用，从而实现了专业的分工。(2)隐藏信息，实现细节。通过控制访问权限可以将可以将不想让客户端程序员看到的信息隐藏起来，如某客户的银行的密码需要保密，只能对该客户开发权限。

继承：个性对共性的属性与方法的接受，并加入个性特有的属性与方法。
1.概念：一个类继承另一个类，则称继承的类为子类，被继承的类为父类。
2.目的：实现代码的复用。
3.理解：子类与父类的关系并不是日常生活中的父子关系，子类与父类而是一种特殊化与一般化的关系，是is-a的关系，子类是父类更加详细的分类。如class dog extends animal,就可以理解为dog is a animal.注意设计继承的时候，若要让某个类能继承，父类需适当开放访问权限，遵循里氏代换原则，即向修改关闭对扩展开放，也就是开-闭原则。
4.结果：继承后子类自动拥有了父类的属性和方法，但特别注意的是，父类的私有属性和构造方法并不能被继承。
另外子类可以写自己特有的属性和方法，目的是实现功能的扩展，子类也可以复写父类的方法即方法的重写。

多态：多态的概念发展出来，是以封装和继承为基础的。

多态就是在抽象的层面上实施一个统一的行为，到个体（具体）的层面上时，这个统一的行为会因为个体（具体）的形态特征而实施自己的特征行为。（针对一个抽象的事，对于内部个体又能找到其自身的行为去执行。）
1.概念：相同的事物，调用其相同的方法，参数也相同时，但表现的行为却不同。
2.理解：子类以父类的身份出现，但做事情时还是以自己的方法实现。子类以父类的身份出现需要向上转型(upcast)，其中向上转型是由JVM自动实现的，是安全的，但向下转型(downcast)是不安全的，需要强制转换。子类以父类的身份出现时自己特有的属性和方法将不能使用。

用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));  
   }

}

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

猜你喜欢