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));
}
}
//主程序
这样，只需要输入运算符号，通过多态，返回父类的方式实现了计算器的结果。