java的三大特性

ava三大特性： 
封装:

抽象:处理各类问题的第一步，把具体的问题与解决问题的方法结合起来，这就是抽象的过程.

Java常见的访问控制修饰符:

Public ：处处均可以访问，不受包和父子类关系的限制 

默认: 只在同包内能够访问，不受父子类关系限制

Protected: 不一样包的子类和同包的类中访问，这是一种继承访问。

Private：只有本身类内部能访问，其余部分不管包内外，父子类都不能访问

Final:修饰属性：常量，值不能被修改

              要么在声明时候赋值，要么在构造方法中赋值，两次机会只能选取一次。

修饰方法 ：final方法子类不能将其重写



     修饰类：该类不能有子类

Static：修饰属性:静态属性是类全部实例共有，能够用”类名.属性”的方式访问,对于数值型变量，系统会给定初始值，不强制要求赋初始值.

      方法：能够用”类名.属性”的方式访问,方法也为类的全部实例所共有

      代码块 : 加载的优先级最高，甚至比主方法的加载还要早.

对于由final static共同修饰的变量，赋值的机会有两个，一是在声明的时候，二是在静态代码块中，两次机会有且只能有一次被选择.



继承: 

容许存在父子类的关系，一个子类有且只有一个直接的父类(Java中的继承是类之间的单继承.)

     当在内存造成类的信息绑定的时候不会出现多个交叉点，结构的清晰程度较高.Java自己的运行效率较低，只能达到C语言的五分之一.Java语言舍弃效率的完美要求，换来学习和使用的简单.

     属性的遮盖: Father f = new Son(); 属性访问到的是父类的，方法访问到的是子类的.

     方法的重载 :在类的内部一种方法出现多种表达方式，如参数表的不一样,构造方法的重载

     方法的重写:发生在父子类之间，子类方法对父类的方法有新的实现方法，但两个方法定义部分彻底一致.



     继承的目的: 实现代码的复用.理顺类型对象之间的结构关系.

     构建一个父类的时候，要求他的子类与父类必须有理论上的确实的继承关系

     代码复用的方法： 

继承复用,彻底的将父类非私有部分做为子类的内容，若需变化，子类只要重写父类的同名方法便可。

     组合复用：选取某个类型中的一个对象的方法实现做为该类的方法实现过程，这两个类也称为理论父类和理论子类. 程序中是不出现extends关键字对两个类关系的描述的.



经过具体实例抽象出父类的过程称为泛化

经过父类来确认子类的过程称为特化.

在代码的类之间关系的设计阶段，理论上要求父子类之间没有相同的同名方法.但语法容许子类重写父类的方法.要求子类当中只有本身特有的方法和属性，其余部分与父类和其余同级子类相同的部分都从父类继承得来.

有关抽象类:

抽象类是用于描述天然界中层级较高的对象类，人们没法对一个抽象类实例化，如动物。只能用一个动物类的子类对抽象类的对象进行实例化。

抽象修饰符abstract 能够修饰类，修饰方法。

抽象类中能够定义非抽象的方法，但若是一个类中有抽象方法，则这个类必须被定义成抽象类。抽象类中有构造方法，可是没有抽象的构造方法。构造方法的存在彻底是为了继承关系而存在。

与之造成对比的就是接口，接口中的全部方法要求定义成公开抽象方法，由于这些方法所表示的就是标准，标准的信息必须作到公开化，透明化，例如体育竞赛中的规则。

抽象类与接口之间的对比：接口与抽象类本质上是两个概念，但能够将接口看做是一个抽象层级比抽象类更高的特殊类。因为接口的信息中只有已知不可变
值以及抽象方法，因此信息的绑定方式单一，从实现上能够知足继承但也不会出现网状的信息绑定效果，不会增长访问时的节点数。所以接口容许多继承。

对于类的内容，不容许多继承，一个子类只能有一个直接的父类，信息绑定的复杂性加上Java自己运行原理的限制，使它不能像C语言同样高效的运行，若绑定的信息复杂度较高，数据的访问过程更加复杂，影响运行效率。

抽象类就是类，接口就是接口，都处于较抽象的层级而使它们具备相近的特性。(接口能够当作是一个特殊的抽象类)

多态: 一个接口多种实现,能够理解为一种语法上的容许，表现形式多样。如下的代码表达均可以认为是Java多态性的具体表现:

IA ia = new TestIA(); 其中IA为定义的接口，TestIA为接口的实现类

Father f = new Son()  其中Father为父类，Son为子类

Animal a = new Dog() 其中Animal为抽象类,Dog为Animal类的子类.

父子类中的方法重写

一个类中的方法重载



Java中的多态基本上是由接口实现的，抽象类与子类之间的多态只占一少部分，接口是在Java中抽象层级最高的一类,其内部的定义是纯抽象的，属性的定义是公开静态常量,纯抽象的方法和常量属性构成一个标准，其全部的实现类，包括抽象类都要遵照接口中定义的规则。

Java类中的通讯方式最好是以接口的形式进行值或对象的传递，如灯泡与台灯的关系。不管将何种类型的对象做为参数，只要是接口对象的一个实现类，就能够成为一个合理的参数。

将两个模块的内容以接口的方式进行通讯，可使两个模块的开发方式相对独立，不依赖于任何一个模块的已实现的信息。造成在代码设计中要求的松藕合状态。

对于多态没必要要下明确的定义，只须要理解它的表现形式以及意义，代码中彻底实现松藕合的接口方式通讯的可能性基本为零，但要求尽可能实现。

接口的存在表面上是实现一种多态语法，其实是实现了Java中的多继承方式，一个类能够同时继承一个类，并实现另外一个或多个接口，以同时得到多个类型的信息（包括属性和方法）。

   其余的边缘知识点:

有关Java的垃圾回收机制:

虚拟机给程序员提供一个统一的编程接口（API），程序员只需按API中的规定进行编程。与C和C++最大的不一样是，Java中不须要考虑内存的回收，虚拟机会以延时的方式对垃圾进行回收，以达到对内存空间的最大利用。

Java中有多种垃圾回收的方法，但每一中方法都只是对要回收的内容进行提醒式的说明，并不是操做虚拟机进行回收.如System.gc()方法，
是系统提供的回收垃圾的常见方式，但当对象的取值为null的时候，gc（）方法并非当即将内存空间释放，只是null的取值提醒虚拟机，该对象的内容
能够被回收。

程序员没法控制Java虚拟机的垃圾回收时间点，只能尽到提示的责任，但多数状况下，虚拟机的垃圾回收区的自动运行可以知足系统运行的须要。

在程序运行的过程当中，能够会报出与虚拟机堆栈溢出的相关信息，此类错误都是与虚拟机运行过程当中的数据结构有关，是人力不能保证不发生的错误,多数
状况下，程序中抛出虚拟机异常后，只需从新启动虚拟机或从新编译相对应的Java代码便可，只有少数状况须要重启PC以及其它相关部件。
----------------------------

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

       }

}

//主程序

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