黑马程序员_继承与多态

------- android培训、java培训、期待与您交流！ ----------

一 ,继承

  1.  继承的好处

         (1.)提高了代码的复用性。
         (2).让类与类之间产生了关系，给第三个特征多态提供了前提。

  2.  java中支持单继承，不直接支持多继承，但对c++中的多继承机制进行了改良。

            单继承：一个子类只能有一个直接父类。

            多继承：一个子类可以有多个直接父类（java中不允许，进行改良）

       在java中是通过“多实现”的方式来提现。不直接支持多继承，因为多个父类中有相同成员，会产生调用不确定性

  3. java支持多层（多重）继承。C继承B，B继承A。就会出现继承体系。

      当要使用一个继承体系时

             (1).查看该体系中的顶层类，了解该体系的基本功能。

            ( 2).创建该体系中的最子类对象，完成功能的使用。

  4. 什么时候定义继承呢？

              当类与类之间存在着所属关系的时候，就定义继承。xx是yy中的一种。xx extends yy

              父类中的功能是不是该类都应该具备，是才能继承。

              所属关系： is a 关系

例:

class Person{
	String name;
	int age;
		}
class Student extends Person{
	void study(){
	    System.out.print("Student study"+name);
	
		}
	}
class Worker extends Person{
	void work(){
	System.out.print(name+"is worker work");
	}
	
      }
public class ExtendsDemo{
	public static void main(String args[]){
		Students s = new Student();
		s.name="zhangsan";
		s.age=23;
		s.study();
	}
}

 

二 多态

多态是某一种事物多种不同的具体的体现。

体现：父类引用或者接口的引用指向了自己的子类对象。//Animal a = new Cat();

多态的好处：提高了程序的扩展性。

多态的弊端：当父类引用指向子类对象时，虽然提高了扩展性，但是只能访问父类中具备的

方法，不可以访问子类中特有的方法。(前期不能使用后期产生的功能，即访问的局限性)

多态的前提：

    1：必须要有关系，比如继承、或者实现。

    2：通常会有覆盖操作。

多态的出现思想上也做着变化：以前是创建对象并指挥对象做事情。有了多态以后，我们可

以找到对象的共性类型，直接操作共性类型做事情即可，这样可以指挥一批对象做事情，即

通过操作父类或接口实现。

class Person{

    void say(){

        System.out.println("我是一个人");

    }

    void eat(){

        System.out.println("吃饭");

    }

}

class Teacher extends Person{

    void say(){

        System.out.println("我是一个老师");

    }

    void teaching(){

        System.out.println("我教java");

    }

}

class {

    public static void main(String[] args) {

        Teacher t = new Person(); //Teacher对象被提升为了Person类型。

	  t.sany();

    	 t.teaching(); 

        Teacher y = (Teacher) t; //将Person类型强制转换成Teacher类型。

        y.teaching();//在多态中，自始自终都是子类对象在做着类型的变化。

    }

}

多态在子父类中的成员上的体现的特点：

1，成员变量：在多态中，子父类成员变量同名。

    在编译时期：参考的是引用型变量所属的类中是否有调用的成员。（编译时不产生对象，只检查语法错误）

    运行时期：也是参考引用型变量所属的类中是否有调用的成员。

    简单一句话：无论编译和运行，成员变量参考的都是引用变量所属的类中的成员变量。

    再说的更容易记忆一些：成员变量 --- 编译运行都看 = 左边。

2，成员函数。

    编译时期：参考引用型变量所属的类中是否有调用的方法。

    运行事情：参考的是对象所属的类中是否有调用的方法。

    为什么是这样的呢？因为在子父类中，对于一模一样的成员函数，有一个特性：覆盖。

    简单一句：成员函数，编译看引用型变量所属的类，运行看对象所属的类。

    更简单：成员函数 --- 编译看 = 左边，运行看 = 右边。

3，静态函数。

    编译时期：参考的是引用型变量所属的类中是否有调用的成员。

    运行时期：也是参考引用型变量所属的类中是否有调用的成员。

    为什么是这样的呢？因为静态方法，其实不所属于对象，而是所属于该方法所在的类。

    调用静态的方法引用是哪个类的引用调用的就是哪个类中的静态方法。

    简单说：静态函数 --- 编译运行都看 = 左边。