Java基础--继承和多态

Java的面向对象对象思想有三大特性：封装、继承、多态。

第一节   继承

1. 继承的概念

继承是类与类之间的关系。在继承中，被继承的类叫做父类或者超类，继承的类叫做子类。子类继承父类后，子类中拥有父类中的成员，包括变量和方法，子类可以直接使用这些成员。在子类中可以添加自己的成员，也可以对父类成员进行覆盖（或重写）。

2. 继承的特点

a) 提高了代码的复用性

b) 让类于类之间产生了关系，有了这个关系，才有了多态的特性

c) 必须是类与类之间有所属关系才可以继承，所属关系 is a 

d) Java中只支持单继承 

因为多继承容易带来安全隐患：当多个父类中定义了相同功能，当功能内容不同时，子类不确定该调用哪一个，但是java保留了这种机制，并用另一种体现形式来完成表示：多实现。

3. 继承体系的使用

想要使用继承体系，先查阅体系父类的描述，因为父类中定义的是该体系中共性的功能，一般类越往上共性越高，通过了解共性功能，就可以知道该体系的基本功能。那么这个体系已经可以基本使用了。

附上代码：  定义了一个Animal父类，再定义一个Cat子类继承Animal父类

class Animal
{
	String name="动物类";
	void show()
	{
		System.out.println("父类调用");
	}
}
class Cat extends Animal
{
	String name="猫类";
	void show()
	{
		System.out.println("子类调用");
		System.out.println(this.name);
		System.out.println(super.name);
		//super 对父类（超类）的用
	}
}

4. 创建子类对象的流程

创建对象就是调用类的构造函数，当在类中没有定义构造函数时，系统会给出默认的构造函数。在继承的类中，创建子类对象不仅仅是调用了子类的构造函数，而是如下代码所示：

附上代码：

Cat c=new Cat();  //通过调用构造函数创建了一个新的Cat类对象

5. this 和 super在继承的使用

this 是表示对象本身的引用，super 是表示父类对象的引用。

用法：当成员变量和局部变量重名时，就必须使用this 关键字来区分成员变量和局部变量。当父类和子类具有相同名称的成员时，就必须使用super关键字来区分。

class Person
{
      String name;
      void setName(String name)
      {
            this.name = name;
      }
}

this()关键字super()的区别，super()代表调用父类的构造函数，需要注意的是，如果不使用super()时，系统也会默认的给出super()来隐式调用父类的无参构造函数，当然也可以自己指定调用父类的哪一个构造函数。

问题：为什么子类一定要访问父类中的构造函数？

因为父类中的数据子类可以直接获取。所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的，所以子类在对象初始化时，要先访问一下父类中的构造函数.

 如果要访问父类中指定的构造函数，可以通过手动定义super语句的方式来默认设置要访问父类中的构造函数

注意：super语句一定要定义在子类构造函数的第一行

总结：子类中所有的构造函数默认都会父类中空参数的构造函数，因为每一个构造函数内的第一行都有一句隐式super();当父类中没有空参数的构造函数时，子类必须手动通过super语句形式来指定要访问父类中的构造函数。当然，子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数。 子类中至少会有一个构造函数会访问父类中的构造函数。

附上代码：

class Tel
{
	void show()
	{
		System.out.println("number");
	}
}
class NewTel extends Tel
{
	void show()//覆盖父类方法
	{
		super.show();	//访问父类中指定的构造函数
		System.out.println("and name");
	}
}

6.继承中的访问控制

访问包括两种操作，调用和继承。关于继承中的访问控制，整理了课堂笔记图：

注意：在调用访问中，保护访问和默认访问控制符是没有区别的，但是在继承的访问中则是不同的：当子类和父类在同一个包下，保护访问和默认访问控制符是相同的，但是当子类和父类不在同一包中时，保护访问修饰符的成员时可以被继承的，而默认访问修饰符是不能被继承的。

private-》default--》protected--》public

 

第二节  多态

多态是指拥有名称相同，但根据不同情况拥有不同操作的性质，其中最常见的就是方法，当方法名相同时，在不同调用的情况下，它拥有不同的功能，方法的重载和重写都属于多态。

多态：也可以理解为事物存在的多种体现形态。 

     1,多态的体现

父类的引用指向了自己的子类对象。

父类的引用也可以接收自己的子类对象。

      2,多态的前提

      必须是类与类之间有关系，要么继承，要么实现

      通常还有前提：存在覆盖。

      3,多态的好处

多态的出现大大的提高了程序的扩展性。

      4,多态的弊端

提高了扩展型，但是只能使用父类的引用访问父类中的成员 

public class Demo {
/**
 * 多态性
 * 
 * @param args
 */
public static void main(String[] args) {
// A a1 = new A();
// a1.i = 9; // a1属于父类对象，只能调用父类自己的对象
// B b1 = new B();
// b1.i = 1;
// b1.j = 1;// b1属于子类对象，能调用父类也能调用自己新增的属性
//
// A a2 = new B();
// a2.i = 3;
// // a2.j=0; //a2是以父类的身份访问，所以不能调用子类
// B b2 = (B) a2;// 向下转型，通过转为子类B
// b2.i = 0;
// b2.j = 0; // 能调用自己新增的属性
//
// B b3 = new B();
// A a3 = b3;// 向上转型(直接转型)
// a3.i = 0;
// // a3.j=0;//向上转型后，隐藏了自身的新增特性
// B b4 = (B) a1; // A是父类对象，在堆内存中开辟了一个空间，存放有i
// b4.i = 0; // 转换为子类B后，以子类的身份去访问，
// b4.j = 0; // 可是堆内存中并未开辟子类对象空间存放j,运行时报错
// B b5 = new A(); //父类对象不能给子类引用赋值， 如：人 不一定是学生
AA a = new AA();
AA a1 = new BB();
// instanceof来判断该引用类型变量所“指向”的对象是否属于该类或该类的子类
System.out.println(a instanceof AA);
System.out.println(a1 instanceof AA); // true //子类就是父类
System.out.println(a1 instanceof BB); // true
}
}
class AA { // 定义父类i
int i;
}
class BB extends AA {// 继承于父类A的子类B
int j; // 子类新增属性
}

A：父类：1,2,3

B：子类：重写2,3，新增4,5

A a = new B();

a:父类中的1,子类重写后的2,3(子类重写)

A a = new A();

B b = new B();

=的左边：什么类型的引用：就能调用相应类中的方法。

=的右边：什么类型的对象：子类对象就调用重写后的方法。

 

对象的多态性：

对象：new 构造函数：堆。

栈：引用

instanceof：判断该引用是否属于某类，返回boolean类型。

对象的转型：

父类：A，子类：B

一个父类引用，可以指向父类对象，可以指向子类对象。

A a = new A();

A a = new B();  //父类引用指向子类对象

一个子类引用，指向子类对象，

B b = new B();

对象转型：

向上转型：子类类型--》父类类型

向下转型：父类类型--》子类类型：前提，向上转型

子类--》父类--》子类

A：父类，B，C，子类

B --》A--》B

C--》A--》C

B--》A---》C：错误。

引用是否属于某个类

instanceof：

引用  instanceof  类---》boolean

A a = new A();

a instanceof A-->true

a instanceof B-->false

a instanceof C-->false


B b = new B();

b instanceof A-->true

b instanceof B-->true

b instanceof C-->false

 

 

在多态中成员函数的特点：（重点掌握）

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

如果有，编译通过，如果没有则编译失败。

在运行时期：参阅对象所属的类中是否有调用的方法。

***简单总结就是：成员函数在多态调用时，编译看左边，运行看右边。*** 

在多态中，成员变量的特点：

无论编译和运行，都参考左边(引用型变量所属类型)

 

在多态中，静态成员函数的特点：

无论编译和运行，都参考左边(引用型变量所属类型)。