Android温习之路之继承

　　首先说一下继承的好处：

　　1.提高了代码的复用性

　　2.让类和类之间产生了关系（关系是多态的前提）

　　将对像中的内容不断的向上抽取，就形成了关系，就有了继承，就有父子类，提高了代码的复用性。

　　继承的特点：

　　java语言当中的继承只能单继承

　　单继承：一个类只能有一个父类，可以理解为一个儿子只能有一个父亲。

　　多继承：一个类可以有多个父类，一个儿子有多个父亲

　　下面简单用个例子来解释一下：

　　class A{

　　void show（）{

　　System.out.println（“show a.。。”）;

　　}

　　}

　　class B{

　　void show（）{

　　System.out.println（“show b.。。.。”）;

　　}

　　}

　　class C extends A{} //这就是单继承

　　class D extends A，B{

　　//这就是多继承

　　D d = new D（）;

　　d.show（）;

　　}1234567891011121314151617

　　接下来来说一下java不支持多继承的原因：会产生调用的不确定性说完了java不支持多继承的原因再说一下多继承的好处：

　　同时继承几个类，就会有几个类的方法

　　java改良了多继承，虽然不支持多继承，但是支持多重继承，这样就形成了继承体系，如下所示

　　class A extends B{}

　　class B extends C{}

　　C

　　-----|B

　　-----|A12345

　　* 如何去使用一个继承体系当中的成员？*

　　1.查阅该体系顶层类的内容，因为通过该类能够了解到该继承体系的基本功能

　　2.创建该子类的对象，既可以得到共性的功能，同时也包含子类特有的功能，简单的来说：看父类内容，创建子类的对象

　　什么时候定义继承？

　　1.不许是事务之间存在着所属关系时，才能定义继承。

　　2.所属关系：xxxx是zzzz当中的一种，例如： 学生是人类当中的一种，用英文翻译就是 is a 的关系

　　误区：不要仅仅为了复用，为了获得其他类当中的内容就去继承

　　继承在成员中的特点：

　　1.成员变量

　　2.成员方法

　　3.构造方法

　　继承在成员变量中的用法

　　1.父类当中包含的公有的属性，子类都可以调用。

　　2.如果父类当中包含的属性的名称和子类当中包含的属性的名称相同了，并且在需要调用的方法中也有同名的变量名称。

　　正常情况下，方法中会采用就近原则去获取变量的值，如果想获得子类的对象的属性的值，就通过this调用，如果想获得父类的属性的值，就通过super来调用。

　　接下来说一下super这个关键字：

　　super代表父类，它和this的用法是比较相似的。

　　this代表本类当中对象的引用，super则代表父类所属的空间。

　　一般情况下，如果父类中定义了一个属性，子类中就不需要定义同名的属性了，直接继承就可以了。

　　子类只能直接的访问父类非私有的内容，如果想要访问私有的内容，就使用其他的方法。子类能访问的空间至少是两片。

　　继承在成员函数中的特点：

　　* 当父子类出现了一模一样的方法时，会产生一个函数的特性，名字叫做重写（复写，覆盖）。

　　* 英文 Override

　　重写的注意事项：

　　* 1.子类重写父类时，必须要保证重写方法的权限必须大于等于被重写方法的权限。

　　* 权限修饰符权限的顺序： private default protected public

　　* 2.重写方法有静态修饰时，静态只能重写静态，或者被静态重写。

　　*

　　重写和重载的区别

　　* 1.重写override 重载是overload

　　* 2.重载要求在同一个类当中。

　　* 重写要求在父子类继承关系中。

　　* 3.重载方法名相同，参数列表不同，返回值没要求

　　* 重写方法方法名相同，参数列表相同，返回值类型也相同

　　* 4.重载权限修饰符没要求

　　* 重写权限的要求：重写方法的权限必须大于等于被重写的方法的权限。

　　当重写一个方法时，想保留原来的功能的同时还想新增加功能，

　　这时可以在重写的方法中加入一句代码：super.Xxx（）—-》保留父类这个方法中的功能。

　　继承在构造函数当中的特点：

　　子类实例化的过程：

　　其实子类所有的构造函数，都有一条默认的隐式语句，这个隐式语句就是super（）;

　　也就是说子类的构造函数，都会默认访问父类的空参的构造函数。

　　为什么子类的构造函数都要去默认访问父类的空参的构造函数？

　　因为子类继承了父类，可以访问父类当中的一些属性，在子类在进行实例化的时候就必须为父类包含的属性分配空间。

　　并且还要进行初始化，所以就必须访问一次父类的构造函数，看看父类是如何对其属性进行初始化的。

　　所以子类要实例化对象时，必须要先看看父类的初始化过程。

　　结论：父类的构造函数，既可以给本类的对象初始化，也可以给子类的对象初始化。

　　注意：如果父类中没有空参数的构造函数，子类中的构造函数必须手动用super指定要访问的父类的构造函数。

　　或者用this访问本类中的构造函数。

　　this和super只能定义在构造函数的第一行，而且不能同时出现。

　　说完了super这个关键字，接下来再来说一个关键字 final 这个关键字，

　　继承的弊端：打破了封装性。

　　final的特点：

　　1.final是一个修饰符，它能够修饰类，修饰方法，修饰变量。

　　2.final修饰的类不能被继承

　　3.final修饰的方法不可以被重写。

　　4.final修饰的变量是一个常量，只能被赋值一次。

　　举个栗子：

　　final double PI = 3.1415;

　　final int ERROR = 1;

　　//标识符中的规则：

　　被final修饰的变量的名称一般采用全大写1234

　　final和static通常是一起使用的。一旦成员变量设置为固定值，不可能因为对象的改变而改变了，

　　通常就用static来修饰，final可以修饰局部变量，但是static只能修饰成员变量。

　　最后上张图说一下权限修饰符：

　　

　　好了今天的内容就讲完了，完了咱们今天来做个小练习：

　　首先说一下需求：

　　写一个person类，属性包括 姓名、年龄、性别、书

　　方法：读书

　　写一个book类，属性包括：书名、坐着、出版社、价格

　　写一个测试类，创建一个person对象，执行读书的方法，查看结果

　　需要打印出来这个人读的是什么书

　　例如：旺财正在读一本由二狗子出版社出版的由张三写的价值为50元的《java基础》

　　package cxy;

　　//Book类

　　public class Book {

　　private String bookName;

　　private String author;

　　private String pressName;

　　private double price;

　　public String getBookName（） {

　　return bookName;

　　}

　　public void setBookName（String bookName） {

　　this.bookName = bookName;

　　}

　　public String getAuthor（） {

　　return author;

　　}

　　public void setAuthor（String author） {

　　this.author = author;

　　}

　　public String getPressName（） {

　　return pressName;

　　}

　　public void setPressName（String pressName） {

　　this.pressName = pressName;

　　}

　　public double getPrice（） {

　　return price;

　　}

　　public void setPrice（double price） {

　　this.price = price;

　　}

　　public Book（String bookName， String author， String pressName， double price） {

　　super（）;

　　this.bookName = bookName;

　　this.author = author;

　　this.pressName = pressName;

　　this.price = price;

　　}

　　public Book（）{

　　super（）;

　　}

　　}

　　1234567891011121314151617181920212223242526272829303132333435363738394041424344

　　Person 类

　　package cxy;

　　public class Person {

　　private String name;

　　private int age;

　　private String sex;

　　private Book book;

　　public void read（）{

　　System.out.println（name+“正在读一本由”+book.getPressName（）+“出版的，由”+book.getAuthor（）+“编写的，价值为”+book.getPrice（）+“元的《”+book.getBookName（）+“》”）;

　　}

　　public Book getBook（） {

　　return book;

　　}

　　public void setBook（Book book） {

　　this.book = book;

　　}

　　public String getName（） {

　　return name;

　　}

　　public void setName（String name） {

　　this.name = name;

　　}

　　public int getAge（） {

　　return age;

　　}

　　public void setAge（int age） {

　　this.age = age;

　　}

　　public String getSex（） {

　　return sex;

　　}

　　public void setSex（String sex） {

　　this.sex = sex;

　　}

　　public Person（String name， int age， String sex） {

　　super（）;

　　this.name = name;

　　this.age = age;

　　this.sex = sex;

　　}

　　public Person（）{

　　super（）;

　　}

　　}

　　Test测试类

　　package cxy;

　　public class Test {

　　public static void main（String［］ args） {

　　Book book = new Book（“java基础”，“张三”，“二狗子教育出版社”，128.88）;

　　Person person = new Person（）;

　　person.setName（“旺财”）;

　　person.setBook（book）;

　　person.read（）;

　　}

　　}

　　12345678910111213

　　最后是运行结果：