一、封装(encapsulation)

封装性就是把类(对象)的属性和行为结合成一个独立的相同单位，并尽可能隐蔽类(对象)的内部细节，对外形成一个边界，只保留有限的对外接口使之与外部发生联系。封装的特性使得类(对象)以外的部分不能随意存取类(对象)的内部数据(属性)，保证了程序和数据不受外部干扰且不被误用。

这个怎么理解呢？首先来看一个列子。

已知一个类Animal，该类的属性和方法如下表所示：

属性

说明

方法

说明

String name

名称

Animal()

无参构造函数，为属性设置初始值

Int  age

年龄

Animal(String name,int age)

有参构造函数，为属性设置变量值

根据该类的定义，编写一个程序，输出该类的初始值以及通过变量设置的初始值，程序代码如下

public class AnimalDemo{

public static void main(Stringargs[]){

Animal  a=new Animal();

Animal  b=new Animal("cat",5);

System.out.println(a.name+"is "+a.age+" years  old");

System.out.println(b.name+"is "+b.age+" years  old");

}

}

程序执行结果：

Dog is 3 years  old

cat is 5 years old

由此可以知道，类Animal的无参构造函数为name属性赋值为“Dog”，为age属性赋值为“3”。因此，可以写出类Animal的代码如下：

class   Animal {

String  name;

int  age;

Animal(){

name="Dog";

age=3;

}

Animal(Stringname,int age){

this.name=name;

this.age=age;

}

}

实际上这就是上一篇文章中的例子，那么封装在这里的含义如下：

l  类本身就实现了封装功能，此处类Animal定义了两个属性，两个构造函数，其只属于Animal类。

l  通过访问修饰符来限制对类的属性和方法的访问，各修饰符含义如下：

Private:成员变量和方法只能在类内被访问，具有类可见性

默认： 成员变量和方法只能被同一个包里的类访问，具有包可见性。

Protected：可以被同一个包中的类访问，被同一个项目中不同包中的子类访问

Public：可以被同一个项目中所有的类访问，具有项目可见性，这是最大的访问权限

l  只能通过类本身定义的方法来对该类所实例化的对象进行数据的访问和处理。比如想对实例化的对象添加其它的一个方法和属性是不可能的。这就体现的类的封装性。这里也可以理解一下为什么类被称之为模板或者蓝图。

二、继承

1、继承是面向对象的三大特征之一，也是实现代码复用的重要手段。Java的继承具有单继承的特点，即只能继承自一个父类，每个子类只有一个直接父类，但是其父类又可以继承于另一个类，从而实现了子类可以间接继承多个父类，但其本质上划分仍然是一个父类和子类的关系。

2、Java的继承通过extends关键字来实现，实现继承的类被称为子类，被继承的类称为父类(有的也称其为基类、超类)，父类和子类的关系，是一种一般和特殊的关系。就像是水果和苹果的关系，苹果继承了水果，苹果是水果的子类，水果是苹果的父类，则苹果是一种特殊的水果。

3、Java使用extends作为继承的关键字，extends关键字在英文是扩展的意思，而不是继承。为什么国内把extends翻译成继承呢？除了与历史原因有关外，把extends翻译成为继承也是有其道理的：子类扩展父类，将可以获得父类的全部属性和方法，这与汉语中得继承(子辈从父辈那里获得一笔财富成为继承)具有很好的类似性。

值得指出的是：Java的子类不能获得父类的构造器。

创建子类一般形式如下：

class 类名 extends 父类名{

子类体

}

4、子类与父类的变量、方法关系

子类可以继承父类的所有特性，但其可见性，由父类成员变量、方法的修饰符决定。对于被private修饰的类成员变量或方法，其子类是不可见的，也即不可访问；对于定义为默认访问(没有修饰符修饰)的类成员变量或方法，只有与父类同处于一个包中的子类可以访问；对于定义为public或protected 的类成员变量或方法，所有子类都可以访问。

子类中可以声明与父类同名的成员变量，这时父类的成员变量就被隐藏起来了，在子类中直接访问到的是子类中定义的成员变量。

子类中也可以声明与父类相同的成员方法，包括返回值类型、方法名、形式参数都应保持一致，称为方法的覆盖。

如果在子类中需要访问父类中定义的同名成员变量或方法，需要用的关键字super。Java中通过super来实现对被隐藏或被覆盖的父类成员的访问。super 的使用有三种情况：

l  访问父类被隐藏的成员变量和成员方法；

super.成员变量名;

l  调用父类中被覆盖的方法，如：

super.成员方法名([参数列]);

l  调用父类的构造函数，如：

super([参数列表]);

super( )只能在子类的构造函数中出现，并且永远都是位于子类构造函数中的第一条语句。

举例：

class BaseClass{

public double weight;

public void info(){

System.out.println("我的体重是"+weight+"千克");

}

}

public class ExtendsDemo001 extends BaseClass{

public static void main(String[]args) {

//创建ExtendsDemo001对象

ExtendsDemo001 ed = new ExtendsDemo001();

//ExtendsDemo001本身没有weight属性，但是ExtendsDemo001的父类有weight属性，也可以访问ExtendsDemo001对象的属性

ed.weight = 56;

//调用ExtendsDemo001对象的info()方法

ed.info();

}

}

举例二：

class  Animal {

String  name="animal";

int  age;

void move(){

System.out.println("animalmove");

}

}

classDog extends Animal{

String  name="dog";    //隐藏了父类的name属性;

float  weight;        //子类新增成员变量

void move(){           //覆盖了父类的方法move()

super.move();       //用super调用父类的方法

System.out.println("Dog Move");

}

}

publicclass InheritDemo{

public static void main(String args[]){

Dog d=new Dog();

d.age=5;

d.weight=6;

System.out.println(d.name+" is"+d.age+" years old");

System.out.println("weight:"+d.weight);

d.move();

}

}

程序运行结果：

dog is5 years old

weight:6.0

animalmove

DogMove

举例三：

classSuperClass {

SuperClass() {

System.out.println("调用父类无参构造函数");

}

SuperClass(int n) {

System.out.println("调用父类有参构造函数：" + n );

}

}

classSubClass extends SuperClass{

SubClass(int n) {

System.out.println("调用子类有参构造函数：" + n );

}

SubClass(){

super(200);

System.out.println("调用子类无参构造函数");

}

}

publicclass  InheritDemo2{

public static void main(String arg[]) {

SubClass s1 = new SubClass();

SubClass s2 = new SubClass(100);

}

}

程序运行结果：

调用父类有参构造函数：200

调用子类无参构造函数

调用父类无参构造函数

调用子类有参构造函数：100

请自行分析程序运行的结果，体会继承的用法。

三、多态(Polymorphism)

多态性是指在继承关系中的父类中定义的属性或方法被子类继承之后，可以具有不同的数据类型或表现出不同的行为。这使得同一个属性或方法在父类及其各子类类中具有不同的含义。

Java引用变量有两个类型：一个是编译时类型，一个是运行时类型。编译时的类型由声明该变量时使用的类型决定，运行时的类型由实际赋给该变量的对象决定。如果编译时类型和运行时类型不一致，就会出现所谓的多态(Polymorphism)

举例1：

class  Animal2  {

void  eat(){

System.out.println("animal eat");

}

}

class Dog extends Animal2  {

void  eat(){

System.out.println("Dog eat bone");

}

}

class Cat extends Animal2  {

void  eat(){

System.out.println("Cat eat fish");

}

}

public class PloyDemo{

public static void main(String args[]){

Animal2  a;

a=newAnimal2 ();   //编译时类型和运行时类型完全一样，因此不存在多态

a.eat();

a=new Dog();   //下面编译时类型和运行时类型不一样，多态发生

a.eat();

a=new Cat();   //下面编译时类型和运行时类型不一样，多态发生

a.eat();

}

}

程序运行结果：

animal eat

Dog eat bone

Cat eat fish

实例2：

class SuperClass{

public int book= 6;

public void base(){

System.out.println("父类的普通方法base()");

}

public void test(){

System.out.println("父类中将被子类覆盖的方法");

}

}

public class PloymorphismTest001 extends SuperClass{

//重新定义一个book实例属性，覆盖父类的book实例属性

public Stringbook = "Java疯狂讲义";

public void test(){

System.out.println("子类中覆盖父类的方法");

}

private void Dmeo() {

System.out.println("子类中普通的方法");

}

//主方法

public static void main(String[]args) {

//下面编译时类型和运行时类型完全一样，因此不存在多态

SuperClass sc = new SuperClass();

System.out.println("book1= "+sc.book);//打印结果为：6

//下面两次调用将执行SuperClass的方法

sc.base();

sc.test();

//下面编译时类型和运行时类型完全一样，因此不存在多态

PloymorphismTest001 pt = new PloymorphismTest001();

System.out.println("book2= "+pt.book);//打印结果为：Java疯狂讲义

//下面调用将执行从父类继承到的base方法

pt.base();

//下面调用将执行当前类的test方法

pt.test();

//下面编译时类型和运行时类型不一样，多态发生

SuperClass sscc = new PloymorphismTest001();

//结果表明访问的是父类属性

System.out.println("book3= "+sscc.book);//打印结果为：6

//下面调用将执行从父类继承到得base方法

sscc.base();

//下面调用将执行当前类的test方法

sscc.test();

//因为sscc的编译类型是SuperClass，SuperClass类没有提供Demo()方法

//所以下面代码编译时会出现错误

//sscc.Demo();

}

}

程序运行结果为：

book1=6

父类的普通方法base()

父类中将被子类覆盖的方法

book2=Java疯狂讲义

父类的普通方法base()

子类中覆盖父类的方法

book3=6

父类的普通方法base()

子类中覆盖父类的方法