java面向对象编程

java面向对象的三大特性，封装，继承，多态。

1.封装是基础，目的是保证数据的安全性，保证外部类不可以随意访问，修改数据，必须按本部类要求的规范进行访问

利用private进行封装，然后可以提供一些方法根据自己的规范进行数据访问。

2. 继承是桥梁，目的是为了更好地利用父类的代码，为了多态做准备。

Java语言中：java只支持单继承，不支持多继承。

因为多继承容易带来安全隐患:当多个父类中定义了相同功能，

当功能内容不同时，子类对象不确定要运行哪一个。

但是java保留这种机制。并用另一种体现形式来完成表示。多实现。

继承父类的代码，实例化子类对象后调用方法会先执行子类的重写方法，若子类没有重写则调用父类方法。

代码演示

public class TongJi {

protected int number_num;
protected double sum;

public void showResult(){
System.out.println("数字个数"+number_num+","+"数字之和"+sum);
}
public void add(double d){
number_num++;
sum+=d;
}
public void clear(){
number_num=0;
sum=0;
}
}
public class TongJi2 extends TongJi{

private int old_num;
private double old_sum;

public void back(){
number_num = old_num;
sum = old_sum;
}

public void save(){
old_num = number_num;
old_sum = sum;
}

public void add(double v){
save();
super.add(v);
}
}

public class App {

/**
* @param args
*/
public static void main(String[] args) {

TongJi2 tj = new TongJi2();
tj.add(2);
tj.add(2.3);
tj.add(4.2);
tj.showResult();
tj.back();
tj.showResult();
tj.clear();
tj.showResult();
}

3. 多态是华丽篇章，父类进行引用，多个子类可以进行实例化，这种现象称为多态。

1，多态的体现

父类的引用指向了自己的子类对象。

父类的引用也可以接收自己的子类对象。

2，多态的前提

必须是类与类之间有关系。要么继承，要么实现。

通常还有一个前提：存在覆盖。

3，多态的好处

多态的出现大大的提高程序的扩展性。

4，多态的弊端：

提高了扩展性，但是只能使用父类的引用访问父类中的成员。

5.在多态中非静态成员函数的特点：

在编译时期：参阅引用型变量所属的类中是否有调用的方法。如果有，编译通过，如果没有编译失败。

在运行时期：参阅对象所属的类中是否有调用的方法。

简单总结就是：成员函数在多态调用时，编译看左边，运行看右边。

在多态中，成员变量的特点：

无论编译和运行，都参考左边(引用型变量所属的类)。

在多态中，静态成员函数的特点：

无论编译和运行，都参考做左边。

4. 抽象类，父类的方法经过子类重写，父类不方便进行对此类方法进行实现，则可以把这种抽象的概念定义为抽象

的方法，此类就成为抽象类。

当多个类中出现相同功能，但是功能主体不同，

这是可以进行向上抽取。这时，只抽取功能定义，而不抽取功能主体。

抽象：看不懂。

抽象类的特点：

1，抽象方法一定在抽象类中。

2，抽象方法和抽象类都必须被abstract关键字修饰。

3，抽象类不可以用new创建对象。因为调用抽象方法没意义。

4，抽象类中的抽象方法要被使用，必须由子类复写起所有的抽象方法后，建立子类对象调用。

如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。

5.抽象类中可以有抽象方法，但不能有函数体，也可以一般方法，含有函数体，继承抽象类的一般类

必须复写所有的抽象方法，不然该类也要定义为抽象类。

抽象类和一般类没有太大的不同。

该如何描述事物，就如何描述事物，只不过，该事物出现了一些看不懂的东西。

这些不确定的部分，也是该事物的功能，需要明确出现。但是无法定义主体。

通过抽象方法来表示。

抽象类比一般类多个了抽象函数。就是在类中可以定义抽象方法。

抽象类不可以实例化。

特殊：抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。

举个具体例子，习主席在十八届五中全会提出大众创新万众创业理念，

但是他并没有提出如何进行创新，而这一个抽象的概念则可定义为抽象类，具体的实现则有各个部门去实施。

无法具体实现的概念性方法则可以封装在抽象类中，由子类继承抽象类具体实现抽象方法的实现细节。

5.接口：

1.接口是对外提供的一种规则

2.接口是对功能的一种扩展

3.接口和实现此接口的类是一种Like-A的关系，是一种行为关系

4.接口可以实现多个实现：因为接口中的方法全都是抽象的，不含函数体，不会造成和多继承那样的安全隐患

5.接口定义时，格式特点：

1，接口中常见定义：常量，抽象方法。

2，接口中的成员都有固定修饰符。

常量：public static final

方法：public abstract

记住：接口中的成员都是public的。

接口：是不可以创建对象的，因为有抽象方法。

需要被子类实现，子类对接口中的抽象方法全都覆盖后，子类才可以实例化。

否则子类是一个抽象类。

接口可以被类多实现，也是对多继承不支持的转换形式。java支持多实现。

6.接口之间可以实现多继承。

6. 接口和抽象类的比较

1.语法层面上讲

1）一个类只能继承一个抽象类，而一个类却可以实现多个接口

因为抽象类是提供其他类继承的，反应的是两个类之间的IS-A的关系，不可能和多个类发生关系。

而接口则是定义一个行为，一个类可以有多个行为，即可以实现多个接口。

2）抽象类可以含有静态代码块和静态方法，而接口不可以

3）抽象类中的变量可以是任意类型的，

4）两者都不可以被实例化。

2.从设计方面考虑。

抽象类是对一种事物的抽象，即对类抽象，而接口是对行为的抽象。抽象类是对整个类整体进行抽象，

包括属 性、行为，但是接口却是对类局部（行为）进行抽象。

举个例子，飞机可以定义为一个抽象类，而战斗机，客机等可以继承此抽象类。和鸟相比他们还有共同的

的行为，即飞行，而这一行为不可能看做一个类，即不能作为抽象类，所以设计为借口供鸟类和飞机类实现。

3.具体实例解释：抽象类是共性，接口是个性。抽象类是子类共性行为的集中抽取，继承此抽象类的子类

必须拥有次抽象类中的所有抽象方法行为，而接口是个性行为，如：

Employee雇员抽象类拥有work(),eat()等抽象方法，继承此类的子类必须有这样的行为，

只是具体实现不同罢啦，而smoking(),playball()等抽象方法不可以抽取到Employee类中，

这不是共性的东西，这只是个别人的行为，所以要定义为接口，让有这方面需要的人来实现这些接口。

下面看一个网上流传最广泛的例子：门和警报的例子：门都有open( )和close( )两个动作，此时我们可以定义通过抽象类和接口来定义这个抽象概念：

　　或者：

　　但是现在如果我们需要门具有报警alarm( )的功能，那么该如何实现？下面提供两种思路：

　　1）将这三个功能都放在抽象类里面，但是这样一来所有继承于这个抽象类的子类都具备了报警功能，但是有的门并不一定具备报警功能；

　　2）将这三个功能都放在接口里面，需要用到报警功能的类就需要实现这个接口中的open( )和close( )，也许这个类根本就不具备open( )和close( )这两个功能，比如火灾报警器。

　　从这里可以看出， Door的open() 、close()和alarm()根本就属于两个不同范畴内的行为，open()和close()属于门本身固有的行为特性，而alarm()属于延伸的附加行为。因此最好的解决办法是单独将报警设计为一个接口，包含alarm()行为,Door设计为单独的一个抽象类，包含open和close两种行为。再设计一个报警门继承Door类和实现Alarm接口。

参考http://www.cnblogs.com/dolphin0520/p/3811437.html