------ android培训、java培训、期待与您交流！ ----------
一、继承 extends
1. 继承的概念:
继承就是把两个存在关系的类,把里面共有特性提取出来,形成一个父类,
或者跟据自已的特性派生出来一个子类,然后子类通过继承拥有父类的所有属性和方法,
子类可以可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。
继承分为普通继承和多重继承.
普通继承 A 继承B
多重继承 C继承B, B又继承A. 那么C中具有A和B的所有属性.----这个不是多继承,要区分开来
2. 继承的用处:
复用性强,子类通过继承就拥有了父类的所有属性和方法,子类可以直接使用这些方法,
也可对在此基础上增加新的数据或新的功能,若类B继承类A，
那么建立类B时只需要再描述与基类(类A)不同的少量特征(数据成员和成员方法)即可。
这种做法能减小代码和数据的冗余度，大大增加程序的重用性,使得复用以前的代码非常容易，
能够大大缩短开发周期，降低开发费用。
比如可以先定义一个类叫车，车有以下属性：
车体大小，颜色，方向盘，轮胎，而又由车这个类派生出轿车和卡车两个类，
为轿车添加一个小后备箱，而为卡车添加一个大货箱。
继承通过增强一致性来减少模块间的接口和界面，大大增加了程序的易维护性。
通过继承可以展现多态,Java中的多态的两种最基本表现形式:重载与重写
3. 继承的用法:
子类类名后加上extends 父类名,就实现在继承
继承属性:
继承属性时,子类拥有父类除private修饰外的所有变量
通过super可以调用子类中隐藏的父类属性.
当子类有同名变量的话,
用this和super来区分子类成员和父类成员. super.变量名 super.方法名();
如果无同名变量,那么也可以用this来调用父类属性.
但一般不在父类中定义类变量,,因为类变量可以直接用类名访问,如果定义了,那么一般是对子类做一些限制
继承方法
继承方法可以对方法什么也不做,也可以对方法进行重写
重写就是让方法名一样,但里面给其在原有基础上进行扩展或重新定义新的功能.
重写时需要注意的是权限修饰符，子类不可以使用比父类更严格的权限修饰符.
也就是子类的权限只能更宽泛,不能更严格,public>protected >什么都不写>private
重写的目的，两个目的，一个是对被重写的方法进行功能性扩展, 另一个是重新建立新的功能行为.
也可以通过super来调用被隐藏的行为.同样,如果没有重写,那么也可以用this调用.
继承在构造函数中的用法
在构造函数中,默认在第一行调用super(),父类的无参构造,一旦我们指定后,super(参数),或this(),后,就不会再自动调用了.
4. 继承什么时候用?
如果类中的特性或行为与被继承类中的行为，特性功能相同，可以使用继承。不可以为了去使用其某个行为而继承
父类是将所有子类*性的行为抽象出来的。
5. 继承有什么特点?
一个子类中只能有一个父类,就是只能单继承
java中支持多重继承,就是B继承A,C又继承B,那么C拥有A和B的所有成员
java中继承能继承父类的除private外所有的成员.不包括构造函数.
二：多态
（1）多态的概念：
某一类事物的多种存在形态。
**方法重载(静态多态)
**方法重写(动态多态,对象多态)
（2）对象多态的前提
A：类与类(或接口)要有继承(或实现)关系。
B：一定要有方法的重写。
C：一定要有父类或者接口的引用指向子类的对象。
（3）多态思想：
可以指挥同一类型的一批对象做事情。多态的出现让我们复杂的问题简单化了。
A：Animal Cat Dog
**method(Animal a){a.eat();}
B：同学们吃饭
C：士兵打仗(抬枪，瞄准，射击)。
（4）多态中成员的特点：
(我们只研究特殊的，就是说名字一样的东西)
Fu f = new Zi();
A：成员变量：编译和运行都看Fu。
B：非静态方法：编译看Fu，运行看Zi。
C：静态方法：编译和运行都看Fu。
举例： 动物的例子：
向上转型
Animal a = new Cat();
a.eat();
//a.catchMouse();
向下转型
Cat c = (Cat)a;
c.eat();
c.catchMouse();
//向上转型
Animal a = new Dog();
//向下转型 转换异常
//Cat c = (Cat)a;
Dog d = (Dog)a;
孔爹的例子：
孔爹:教课(Java)
孔子:教课(论语),看小说(),打游戏()。
孔爹 k = new 孔子();//穿上他爹衣服,就跟着去了
k.教课(论语)。
//k.看小说();
孔子 kz = (孔子)k;//把衣服脱了
kz.教课(论语);
kz.看小说();
kz.打游戏();
记住: 在多态中, 只有非静态成员函数，编译看左边，运行看右边 (等于号) 其他情况，编译看左边，运行看左边.
三、封装
（1）封装简述
封装就是隐藏实现细节,提供公共的访问方式,
开发中常用的是用private饰类的成员,让其只在本类是有效,再提供公共的方法让外部访问被private修饰的成员属性.
（2）封装的用处
提高类成员安全性,使用方便,复用性高,可以控制其变化
（3）封装的用法
在变量类型前和方法的返回值类型前加上private,就可以私有化这个变量或方法.
然后再提供getName方法获得变量的值,用setName方法给变量赋值.
private修饰的方法放于开放的方法中,这样才能让外部访问
（4）什么时候用封装?
私有的使用。
当我们要对一个成员变量或方法进行改变和调用控制时,我们就用private私有.
（5） 封装的特点:
封装可以修饰类的成员属性和方法,当一个成员被私有化后,只能在类中使用,不能够直接通过创建对象调用,而要通过其它公共访问方法,让外部去访问.
四：接口(interface)
(1)接口的由来：
当一个类中的方法都是抽象的时候，
你没必要定义为抽象类， 定义为接口就可以了。
(2)接口的用处
解决了java中只能单继承的问题。(对多继承进行了优化)
A：类与类：只能是单继承。
B：接口与接口：可以是单继承，也可以是多继承。
C：类与接口：可以是单实现，也可以是多实现。
(3)接口成员特点：
A：只有成员变量和成员方法。
B：成员变量 默认修饰符 public static final
**int x = 20;
**其实是这样的 public static final int x = 20;
C：成员方法 默认修饰符 public abstract
**void show();
**其实是这样的 public abstract void show();
建议：自己手动加上修饰符。
(4)接口的思想：
A：接口是对外暴露的规则
B：接口是功能的扩展
C：接口降低了程序的耦合性。
**内聚(自己实现功能的能力)
**高内聚，低耦合。
举例：主板和CPU,USB接口,电源插座。
D：扩展说了下接口的理解
**狭义的理解就是java中的接口。
**广义的理解就是：任何定义的规范都是接口。
(5)接口和抽象类的区别：
A：抽象类只能被单继承；接口可以被多实现。
B：抽象类中的成员：成员变量:可以是常量，也可以是变量。
成员方法:可以是抽象的，也可以是非抽象的。
构造方法:虽然不可以创建对象，但是可以给子类实例化用。
接口中的成员：成员变量：只能是常量。默认修饰符 public static final
成员方法：只能是抽象的。默认修饰符 public abstract
C：抽象类中定义的是体系结构中的共性的内容。
接口中定义的是对象的扩展功能。
D：抽象类被继承表示的是："is a"的关系。xx是yy中的一种。
接口被实现表示的是: "like a"的关系。xx像yy中的一种。
(6)举例 学生的例子
A：属性：学号,姓名,年龄
B：方法：学习(study),吃饭(抽象eat),抽烟或者不抽烟?(合适吗)
发现：在学生中定义抽烟的方法不合适。所以呢，我们另外用一个类来定义抽烟的方法。
但是发现，如果用一个类描述抽烟的功能后，SmokeStudent是不能继承多个类的。
这个时候，我们又得重写思考了。发现，抽烟的学生像一个抽烟的机器，所以，
我们定义一个接口来放抽烟这个功能。
interface Smoking
{
public abstract void smoking();
}
描述的是抽烟的学生：SmokeStudent extends Student implements Smoking
SmokeStudent ss = new SmokeStudent();
ss.eat();
ss.study();
ss.smoking();
老师：Teacher
A：属性 教师编号,姓名,年龄
B：方法 教书(teach),吃饭(吃饭eat),抽烟或者不抽烟?(合适吗)
发现：在老师中定义抽烟的方法不合适。所以呢，我们另外用一个类来定义抽烟的方法。
但是发现，如果用一个类描述抽烟的功能后，SmokeTeacher是不能继承多个类的。
这个时候，我们又得重写思考了。发现，抽烟的老师像一个抽烟的机器，所以，
我们定义一个接口来放抽烟这个功能。
interface Smoking
{
public abstract void smoking();
}
描述的是抽烟的老师：SmokeTeacher extends Teacher implements Smoking
SmokeTeacher st = new SmokeTeacher();
st.eat();
st.teach();
st.smoking();
最后，我们发现，这个代码还是存在着重复，比如说学生类和教师类中的属性姓名，年龄及方法吃饭。
所以，我们进一步向上抽取。来了一个Person类
Person：属性：姓名，年龄
行为：吃饭(抽象eat)
------ android培训、java培训、期待与您交流！ ----------
**方法重载(静态多态)
**方法重写(动态多态,对象多态)
（2）对象多态的前提
A：类与类(或接口)要有继承(或实现)关系。
B：一定要有方法的重写。
C：一定要有父类或者接口的引用指向子类的对象。
（3）多态思想：
A：Animal Cat Dog
**method(Animal a){a.eat();}
B：同学们吃饭
C：士兵打仗(抬枪，瞄准，射击)。
（4）多态中成员的特点：
Fu f = new Zi();
A：成员变量：编译和运行都看Fu。
B：非静态方法：编译看Fu，运行看Zi。
C：静态方法：编译和运行都看Fu。
举例： 动物的例子：
向上转型
Animal a = new Cat();
a.eat();
//a.catchMouse();
向下转型
Cat c = (Cat)a;
c.eat();
c.catchMouse();
//向上转型
Animal a = new Dog();
//向下转型 转换异常
//Cat c = (Cat)a;
Dog d = (Dog)a;
孔爹的例子：
孔爹:教课(Java)
孔子:教课(论语),看小说(),打游戏()。
孔爹 k = new 孔子();//穿上他爹衣服,就跟着去了
k.教课(论语)。
//k.看小说();
孔子 kz = (孔子)k;//把衣服脱了
kz.教课(论语);
kz.看小说();
kz.打游戏();