面向对象的三大特性，动态绑定，抽象，接口

面向对象有三大特性：继承，封装，多态

继承：继承是一种由已有的类创建新类的机制。利用继承，可以先创建一个共有属性的一般类，根据该一般类再创建具有特性属性的

新类，新类会继承一般类的状态和行为，并根据需要增加自己的新的状态和行为。由继承而得到的类是子类，被继承的类称为父类。

子类可以通过关键字extends 来继承父类，从而得到父类的成员变量和方法，而不需在重新写这些代码。但是子类也可以根据自己的

特性重写父类继承下来的方法。如：

上图中子类B重写了父类的方法f，执行了“print（”B：f（）”这条语句。

但是当子类的构造方法创建一个子类的对象时，子类的构造方法总是先调用父类的某个构造方法，但是子类的构造方法带有

参数或者类型与父类的不同，则不会调用父类的方法。而图中B b = new B()时，则是先调用父类的的构造方法，再调回使用

自己的构造方法，因为此时的构造方法是无参数的！也体现了面向对象的多态。

在讲继承时，时常会用到子类方法的重写，如上图中的b.f()；就是重写。方法重写是指：子类中定义了一个方法，并且这个

方法的名字、返回类型、参数的个数和类型与父类继承的方法完全相同，而子类通过这种方式可以改变自身的属性和状态。

在继承中，经常会用到关键字super，一般有二种用法：一种是子类调用super调用父类的构造方法，在引用的时候，

super必须为子类构造方法的都一条语句另一种是子类使用。

super调用被子类隐藏的成员变量和方法。如：

final的理解：在Java中，final关键字可以用来修饰类、方法和变量（包括成员变量和局部变量）。final类不能被继承固不能

有子类。如果有 一个方法被修饰为final方法，则这个方法不能被重写。还有被final修饰的变量是首先分配地址到数据区，直

到程序结束，才被释放，所以被修饰的值不能发生改变。

封装：简单的解释就是：合理隐藏和合理的暴露。

private 私有的。在同一个类里能被访问。
default 默认的。包访问权限
protected 受保护的。子类中也能访问
public 公共的。在任何地方都可以访问

所以类中的变量应该默许用private私有保护起来；防止程序中值不经意发生变化。若要使用要用get方法返回值，用set方法取值。如

多态：多态是面向对象的重要特性,简单点说:“一个接口，多种实现”，就是同一种事物表现出的多种形态。比如：

abstract class Animal{//含有抽象方法时，必须为抽象类
private String name;
Animal(String name){
this.name =name;
}

public abstract void enjoy();//抽象方法

/*public void enjoy(){//这种方法只有定义的必要
System.out.println("叫声。。。。");
}*/
}
interface Enjoy{
public void enjoy();
}


class Cat extends Animal implements Enjoy{
private String eyesColor;
Cat(String n,String c){
super(n);//由父类执行
eyesColor = c;
}
public void enjoy(){
System.out.println("喵。喵。喵。");
}
public String getEyesColor(){
return eyesColor;
}
}


class Dog extends Animal{
private String furColor;
Dog(String n,String f){
super(n);//由父类执行
furColor = f;
}
public void enjoy(){//抽象方法必须重写
System.out.println("汪汪。。汪汪");
}
}


class Lady{
private String name;
private Animal pet;//定义为父类的引用
Lady(String name,Animal pet){
this.name =name;
this.pet  =pet;
}
public void myPetEnjoy(){
pet.enjoy();
}
public Cat getPetCat(){
Cat c = (Cat)pet;
return c;
}

public Animal getPet(){
return pet;
}
}


public class Test{
public static void main (String args[]){
Cat c =new Cat("catname","blue");
Dog d =new Dog("dogname","black");
//Animal an = new Animal("cccc");无法对其实例化

Lady l1 = new Lady("l1",c);//传的是String和对象
System.out.println(l1.getPet().getEyesColor());
Lady l2 = new Lady("l2",d);
l1.myPetEnjoy();//调用的为Cat的enjoy方法
l2.myPetEnjoy();//调用的为Dog的enjoy方法
}
}

而上述方法用了动态绑定，l1.myPetEnjoy()实际传的是cat，调用方法却是父类方法，但是却实现了Can.enjoy（）的方法的实现

当程序运行并且使用动态绑定来调用一个方法时，那么虚拟机必须调用对象的实际类型相匹配的方法版本，是一种多态的表现。

在继承中经常会用到用abstract修饰的类，即为抽象类，如 abstract class A{······}，有如下几个特点：A：含有抽象方法的类必

须被声明为抽象类，抽象类必须被继承，抽象方法必须被重写B：抽象类不能被实例化 C：抽象方法只需声明，而不需实现。

当父类的方法经常被许多子类重写时，而父类的方法所以不需要实现，如： public abstract  void enjoy（）；，其中就没有任何

方法实现，总体上使程序更加简洁，效率。如面中的代码：

在设计程序的时候，往往会用到继承。但是经常要实现多种继承的关系，但是Java中不能出现多重继承的关系，即一个子类

只能有一个父类。如：金丝猴又继承与动物，也可以继承于受保护类。固这里要引用接口来实现java中的继承关系。

接口：用关键字interface来定义一个接口，如：interface 接口的名字。接口中包含常量的定义和方法的定义两个部分，相当于一个

没有实例变量的抽象类。接口的使用时通过关键字implements，一个类通过implements声明自己实现一个或者多个接口，多个接口

之间用“  ， ”隔开。如： class A implements B  ,  C 。当类实现接口时，那么该类必须实现接口中所有的方法，且方法的名字，返回

类型，参数类型和参数的个数必须与接口中完成一致。如：

抽象类和接口比较：

1，抽象类和接口都有抽象方法，而抽象类可以用实例变量和常量，接口中指拥有常量。

2，抽象类中可以有非抽象的方法，而接口是个纯抽象类。

在程序的设计上，二者本质上都是让设计忽视细节，将重心放在整个系统的设计上。抽象类提供了重要的子类去实现重要的抽象

方法和一些关键的变量及非抽象方法。但是在多个子类继承同一父类时，某些子类的关键特性必须要表达出来时，父类将此特性

当成抽象类时，会使其他子类必须重写或者再次声明抽象时，会导致代码臃肿。而接口更方便的解决了此类问题，可以将这些

特有的性质当成接口，某些子类若要表达出此特性时，只需实现该这些接口。也可以像上图中，同时继承与父类，又实现多接口

，使程序更加有扩展性和简便性。

instanceof 的用法，此关键字是用来判断一个对象是否属于某个基类。如：

总结：要明白面向对象和面向接口的设计思路。