java的封装继承和多态

面向对象编程有三大特性：封装、继承、多态。

【执行顺序的优先级：this.show（O）、super.show（O）、this.show（（super）O）、super.show（（super）O），重载［一个类中］和重写【父子类中】】，

封装隐藏了类的内部实现机制，可以在不影响使用的情况下改变类的内部结构，同时也保护了数据。对外界而已它的内部细节是隐藏的，暴露给外界的只是它的访问方法。

继承是为了重用父类代码。两个类若存在IS-A的关系就可以使用继承。，同时继承也为实现多态做了铺垫。那么什么是多态呢？多态的实现机制又是什么？请看我一一为你揭开：

所谓多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法，必须在由程序运行期间才能决定。因为在程序运行时才确定具体的类，这样，不用修改源程序代码，就可以让引用变量绑定到各种不同的类实现上，从而导致该引用调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时所绑定的具体代码，让程序可以选择多个运行状态，这就是多态性。

比如你是一个酒神，对酒情有独钟。某日回家发现桌上有几个杯子里面都装了白酒，从外面看我们是不可能知道这是些什么酒，只有喝了之后才能够猜出来是何种酒。你一喝，这是剑南春、再喝这是五粮液、再喝这是酒鬼酒…。在这里我们可以描述成如下：

酒 a = 剑南春

酒 b = 五粮液

酒 c = 酒鬼酒

…

这里所表现的的就是多态。剑南春、五粮液、酒鬼酒都是酒的子类，我们只是通过酒这一个父类就能够引用不同的子类，这就是多态——我们只有在运行的时候才会知道引用变量所指向的具体实例对象。相当于一个父亲可以由多个儿子，但是，一个儿子只会有一个父亲。【多态】

补充：为了更好的理解多态，我们就必须要明白什么是“向上转型”。在继承中我们简单介绍了向上转型，这里就在啰嗦下：在上面的喝酒例子中，酒（Win）是父类，剑南春（JNC）、五粮液（WLY）、酒鬼酒（JGJ）是子类。我们定义如下代码：

JNC a = new JNC（）;

对于这个代码我们非常容易理解无非就是实例化了一个剑南春的对象嘛！但是这样呢？

Wine a = new JNC（）;

在这里我们这样理解，这里定义了一个Wine 类型的a，它指向JNC对象实例。由于JNC是继承与Wine，所以JNC可以自动向上转型为Wine，所以a是可以指向JNC实例对象的。这样做存在一个非常大的好处，在继承中我们知道子类是父类的扩展，它可以提供比父类更加强大的功能，如果我们定义了一个指向子类的父类引用类型，那么它除了能够引用父类的共性外，还可以使用子类强大的功能。

但是向上转型存在一些缺憾，那就是它必定会导致一些方法和属性的丢失，而导致我们不能够获取它们。所以父类类型的引用可以调用父类中定义的所有属性和方法，对于只存在与子类中的方法和属性它就望尘莫及了---1。

java的封装继承和多态

this

在每个类的内部，都有一个隐含的成员变量，该类的类型就是该类的类型，该成员变量的名称是this，this是一个引用，指向自身的对象。

this的用法：

1、this调用本类中的属性，也就是类中的成员变量

2、this调用本类中的其他方法

3、this调用本类中的其他构造方法，调用时要放在构造方法的首行

面向对象特征之封装（Encapsulation）

为什么要使用封装？

1、比如打电话，我们只要按键拨打就可以，不需要知道手机的内部结构，也不需要知道怎么打出去

2、比如给手机充电，只要通过手机提供的接口，就可以，不需要知道怎么把电冲进去的

封装的含义？

1、隐藏对象内部的复杂性，只对外公开简单的接口，便于外界使用，从而提高系统的扩展性、可维护性

使用访问权限修饰符，实现封装

Java用于限定其他对象对该类内部定义的访问权限

有public、protected 、private、default（不写）四个

对于class的权限只能使用public 或 default （不写）

如何实现封装？

修改属性的可见性来限制对属性的访问。为每个属性创建一对赋值方法和取值方法，用于对这些属性的访问。

在赋值和取值方法中，加入对属性的存取的限制

public class Person {

private String name;

private int age;

public String getName（） {

return name;

}

public void setName（String name） {

this.name = name;

}

public int getAge（） {

return age;

}

public void setAge（int age） {

if（age 》 200）{

throw new RuntimeException（“老妖怪。。.。”）;

}

this.age = age;

}

}

面向对象特征之二 继承（extends）

继承：是面向对象的最显著的一个特征。继承是从已有的类中派生出新的类，新的类能吸收已有类的数据属性和行为，并能扩展新的能力

比如上面的动物类，每一个动物都有名字和年龄，都能叫，都会吃。但是具体每一种动物，又有自己特有的属性和行为，甚至相同的行为，也有千差万别。

继承是对某一批类的抽象，从而实现对现实世界更好的建模

提高代码的复用性

子类继承父类的语法格式如下：

修饰符 class subclass extends superclass {…。。}

public class Animal {

private String name;

private int age;

public void shout（）{

System.out.println（“我的叫声很好听。。”）;

}

//省略get、set方法

}

public class Dog extends Animal{

public void eat（） {

System.out.println（“我吃骨头。..”）;

}

}

Java继承：

1、Java只支持单继承，也就是只能继承一个类

2、如果一个类没有声明继承关系，默认继承Object类

3、子类继承父类全部的操作（除了构造方法），如果父类中的属性是private的，属于隐

式继承，不能直接 操作，可以通过set、get方法进行操作

在子类中，可以根据需要对从基类中继承来的方法进行重写

重写方法必须和被重写方法具有相同的方法名称、参数列表、和返回类型

重写方法不能使用比被重写方法更更严格的访问权限

public class Animal {

private String name;

private int age;

public void shout（）{

System.out.println（“动物会叫。.”）;

}

}

public class Dog extends Animal{

public void eat（） {

System.out.println（“我吃骨头。..”）;

}

@Override

public void shout（） {

System.out.println（“汪汪。。汪汪。。。”）;

}

}

Super：是直接父类对象的引用可以通过super访问父类汇中被子类覆盖的方法或属性

普通方法：没有顺序，任意调用

构造方法：任何类的构造方法中，如果构造方法中没有显示的调用super（…），那么Java 会默认调

用super（）作为父类的初始化方法，所以在写不写super（）方法，没 有关系

面向对象特征之三-多态（Polymorphism）：多态性是指允许不同软件元素对同一消息作出响应

把不同的子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，以适应需求的不断变化。

赋值之后，父类型的引用就可以根据当前赋值给它的子对象的特性以不同的方式运作。也就是说，父亲的行为像儿子，而不是儿子的行为像父亲

执行期间（非编译期）判断所引用的实际类型，根基其实际类型调用相应的方法

父类方法&子类方法都在code Segment中

实际运行调用父类/子类方法？

即由实际运行期创建的对象类型来决定

前提条件：

继承

复写

父类引用指向子类

有多态，就可以升高代码的可扩展性！

class Animal{

public String name;

public Animal（String name）{

this.name = name;

}

}

class Dog extends Animal{

public String folorColor;

public Dog（String name，StringfolorColor）{

super（name）; this.folorColor = folorColor;

}

}

class Cat extends Animal{

public String eyesColor;

public Cat（String name，String eyesColor）{

super（name）; this.eyesColor = eyesColor;

}

}

public class TestCasting{

public static void main（String args［］）{

Animal a = new Animal（“a”）;

Cat c = new Cat（“c”，“cEyesColor”）;

Dog d = new Dog（“d”，“dForlorColor”）;

System.out.println（a instanceof Animal）; //true

System.out.println（c instanceof Animal）; //true

System.out.println（d instanceof Animal）; //true

System.out.println（a instanceof Dog）; //false

a = new Dog（“d2”，“d2ForlorColor”）; //父类引用指向子类对象，向上转型

System.out.println（a.name）; //可以访问

//System.out.println（a.folorColor）;

//！error 不可以访问超出Animal自身的任何属性

System.out.println（a instanceof Animal）; //是一只动物 System.out.println（a instanceof Dog）; //是一只狗，但是不能访问狗里面的属性

Dog d2 = （Dog）a; //强制转换

System.out.println（d2.folorColor）; //将a强制转换之后，就可以访问狗里面的属性了

}

}