面向对象总结-03-----黑马程序员

<面向对象总结-03>
     (继承的含义及使用方法)

 

1. java中的继承的好处

  * 代码减少

  * 继承的出现，使类与类之间，产生的了关系，正是因为这个关系的存在

      就导致了面向对象的第三个特征，多态

2. java中，只支持单继承，类与类之间，不支持多继承

  * 一个类，只能继承一个类

  * 支持多层继承，多重继承

3. 什么时候使用继承呢

  * 当你发现，一个事物，属于另一个事物中的一种

      可以使用继承关系

  * 继承一个事物的时候，发现这个事物中的功能，都应该具备，继承有效

  * 继承一个事物的时候，发现这个事物中的功能，一部分具有，继承无效

  * 实例

      咖啡，酱油

      共性：流动性，黑色

      特性：饮料，调味品

      饮料体系：

        解渴，冰镇，流动，液体

      副食体系：

        调味道

4. 继承关系后，子类，父类中 成员变量，成员方法和构造方法的特点 ******

  * 子类父类中成员变量的特点

  * 新的关键字super.成员变量名，调用的父类中的成员变量

  * this表示本类对象的引用，super表示的父类的存储位置

  * 建立对象的时候，父类中的成员变量，也在子类对象存储的堆中

  * 子类有，就运行子类，子类没有，运行父类的

  * 子类有，变量前，省去了this ，父类有，省去了super

  * 静态变量，子类有，省去了子类类名，父类有，省去了父类类名

  * 子类父类成员方法的特点

  * 当子类中，和父类中出现了一模一样的方法的时候，子类重写父类方法(override)覆盖，复写

  * 子类覆盖父类中方法的时候，必须保证权限大于或者等于父类

  * 非静态覆盖非静态，静态覆盖静态

  

  * 子类父类构造方法的特点

  * 子类构造方法，都要去访问父类中无参数的构造方法，这是默认的

  * 无论子类的构造方法，有几个，都会默认的访问父类空参数的构造方法

  * 子类的构造方法之间的调用用的this，必须第一行，第一行是super还是this

     * 只要保证子类构造方法，直接还是间接的可以访问到父类的构造方法就可以了

下面是关于继承的使用方法代码体现

class Fu
{
static{
System.out.println("父类静态代码块1");//1
}
{
System.out.println("父类构造代码块3");//3
}

Fu(){
System.out.println("父类构造方法4");//4
}

}
class Zi extends Fu
{

static{
System.out.println("子类静态代码块2");//2
}

{
System.out.println("子类构造代码块5");//5
}

Zi(){

System.out.println("子类构造方法6");//6
}
}
class ExtendsDemo6
{
public static void main(String[] args)
{
new Zi();
}
}

/*
子类，父类构造方法的特点
*/
class Fu
{

Fu(int x){
super();
System.out.println("fu...run");
}
}
class Zi extends Fu
{
Zi(){
//子类的构造方法，第一行，默认的隐式代码，不写，有super()调用父类构造方法，空参数的
this(4);
System.out.println("zi...run");
}
Zi(int y){
this(3,4);
System.out.println("zi...run.......y");
}
Zi(int z,int a){
super(1111);
}
}
class ExtendsDemo5
{
public static void main(String[] args)
{
new Zi().hashCode();
}
}

 

 

7 final关键字

  * 被final修饰的方法，最终方法，不能被覆盖的

  * 被final修饰的类，不能再派生子类 (String)

  * 被final修饰的变量，其实是一个常量了，只能赋值一次

  * 被final修饰的变量，变量名，全部大写，规范，不是强制

  * public static final int X = 10;

  * 类中，永恒不变的数据，写成final形式：public static final double PI = 3.1415926

  * private static final Single s = new Single();

8 对象的多态性

  * 我，在生活中，具备多种形态

    * 传智，我是员工

    * 家庭，户主

    * 朋友，小弟

  * 宠物猫

    * 咪咪猫

    * 小宠物真漂亮

    * 老鼠面前，舞伴

  * 现实生活中的多态：一个事物具备的多种形态

  * 面向对象中的对象的多态

    * 父类或者是接口的引用，指向自己的子类对象

      父类 f = new 子类();

9 多态的好处和弊端

  * 好处：代码的复用性提高，扩展性增强，后期维护性增强，代码量也减少

  * 弊端：多态中，只能调用子父类中的公共方法，不能调换子类的特有方法

10 多态中的细节问题：

  * 非静态成员变量的特点：

    * 编译时期，参考引用型变量中，是否有这个变量

    * 运行时期，参考引用型变量中的变量的值

  * 静态成员患变量特点

    * 编译时期，参考引用型变量中，是否有这个变量

    * 运行时期，参考引用型变量中的变量的值

 * 静态成员方法的特点

    * 编译时期，参考引用型变量中，是否有这个方法

    * 运行时期，参考引用型变量中的方法

 * 非静态成员方法的特点

    * 编译时期，参考引用型变量中，是否有这个方法

    * 运行时期，参考子类对象中的方法

 在编译时期,JVM静态的绑定在父类的引用变量中

 只要在非静态成员方法运行的时候，JVM动态的绑定到子类对象中

 * 简单的说：

   除了非静态成员方法以外，编译看左边，运行看左边

   只有在非静态方法中，编译看左边，运行看右边

 下面是关于继承的综合应用的代码练习

/*

  利用继承中子类覆盖父类方法的特点

  演示，程序的扩展性

  需求：

   手机来电话

   第一代手机 板砖 只显示号码

   5年以后

   第二代手机 显示姓名和号码

   5年以后

   第三代手机 显示姓名和号码，特有音乐

   5年以后

   智能手机上市 显示姓名和号码，特有音乐，显示来电者归属地

  

*/

/*

  实现步骤：

    描述手机  class 手机{

    public void incoming(){

    System.out.println("来电的号码");

    }

 }

   描述手机，class 第二代的手机{

      来电的功能，比上一代进行了增强

   第二代手机，沿袭了第一代手机的功能，号码显示

   并且自己有多了一个功能，姓名的现实

   }

*/

 

class Phone//第一代手机
{
//手机的来电，显示对方的手机号
public void incoming(){
System.out.println("来电的号码");
}
}
class SecondPhone extends Phone//第二代手机
{
//手机的来电功能
public void incoming(){
//沿袭父类的功能，调用第一代手机的来电号码显示功能
//子类调用父类中的方法，用super
super.incoming();
System.out.println("来电人的姓名");
}
}

class ThirdPhone extends SecondPhone//第三代手机
{
//手机的来电功能
public void incoming(){
//二代手机，已经完成了，号码和姓名的显示，第三代来说，拿来用
super.incoming();
System.out.println("特有音乐");

}
}

class FourthPhone extends ThirdPhone//第四代智能机
{
//手机的来电功能
public void incoming(){
super.incoming();
System.out.println("来电归属地");
}
}
class ExtendsTest
{
public static void main(String[] args)
{
Phone p = new Phone();
p.incoming();

SecondPhone  s = new SecondPhone();
s.incoming();

ThirdPhone t = new ThirdPhone();
t.incoming();

FourthPhone f = new FourthPhone();
f.incoming();
}
}