继承、多态——成员变量、成员函数、构造函数（this、super）

继承

1、继承使用原因：

1、提高了代码的复用性

2、让类与类之间产生了关系，有了这个关系，才有了多态的特性

2、继承注意事项：

千万不要为了获取其他类的功能，简化代码而继承。

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

类的继承是不断抽象出来的，不能继承不该继承的东西，例如：人不能继承毛

class C
{
	void demo1(){}
}
class A extend C
{
	//void demo1(){}
	void demo2(){}
}

class B extends c
{
	//void demo1(){}
	void dmeo3(){}
}

3、Java只支持单继承原因：

java语言中：java只支持单继承，不支持多继承

因为多继承容易带来安全隐患,当父类中定义了相同功能，但功能内容不同时，子类对象不确定要运行哪一个。

但是java保存了这种机制，并利用另一种体现形式来完成表示，多实现（实现多个接口）。

4、java支持多层继承：

java支持多层继承。也就是一个继承体系。

如何使用一个继承体系中的功能？

想要使用体系，先查阅体系中父类的描述，因为父类中定义的是该体系中的共性功能。

通过了解共性功能，就可以知道该体系的基本功能。

这个体系已经基本可以使用了。

那么在具体调用时要创建最子类的对象。

为什么创建最子类对象？

一是因为有可能父类不能创建对象；

二是因为创建子类对象可以使用更多的功能，包括基本的，也包括特有的。

简单一句话就是查阅父类功能，创建子类对象的功能。

5、聚集：has a

按事物紧密联系程度划分为两种：聚合、组合。

6、子父类出现后，类中成员的变化【3种】

类中成员：

1、变量

2、函数

3、构造函数

1、变量

如果子父类中出现了非私有的同名成员变量时

子类要访问本类中的变量时，用this

子类要访问父类中的同名变量，用super

super的使用和this的使用基本一致

this代表的是本类对象的引用

super代表的是父类对象的引用

class Fu
{
	int num=4;
	public void setNum(int num)]
	{
		this.num=num;
	}
	public int getNum()
	{
		return this.num;
	}
	public void show()
	{
		System.out.println("fu show");
	}
}

class Zi extents Fu
{
	//int num=5;
	void show()
	{
	//System.out.println(super.num);//打印父类的num
	System.out.println("zi show");//子类中的num
	}
}
class
{
	public static void main(String[] args)
	{
		Zi z=new Zi;
		//System.out.println(z.num);
		z.show();

	}
}

2、子类中的函数

当子类中出现和父类一模一样的函数时，当子类对象调用该函数，会运行子类的内容，如同父类函数被覆盖一样。

这种情况是函数的里一个特性：重写（覆盖）

当子类继承了父类，沿袭了父类的功能到子类中，

但子类虽具备该功能，但子类的功能的内容却和父类不一致

这时，没有必要定义新功能，而是使用覆盖特性，保留父类的功能定义并保留父类内容

覆盖注意事项：

1、子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败

2、静态只能覆盖静态

3、如果父类中是private的方法，子类中是public的同名方法，不能称作覆盖，因为父都看不到父类，怎么可能称作覆盖。

注意：

重载：只看同名函数的参数列表

重写：子父类方法一模一样，包括返回值，编译报错

class Fu
{
	int num=4;
	public void setNum(int num)
	{
		this.num=num;
	}
	public int getNum()
	{
		return this.num;
	}
	public void show()
	{
		System.out.println("fu show");
	}
	void speak()
	{
		System.out.println("VB");
	}
}

class Zi extends Fu
{
	//int num=5;
	void speak()
	{
		System.out.println("java");
	}
	public void show()
	{
	//System.out.println(super.num);//打印父类的num
	System.out.println("zi show");//子类中的num
	}
}
class ExtendsDemo3
{
	public static void main(String[] args)
	{
		Zi z=new Zi();
		//System.out.println(z.num);
		//z.show();
		z.speak();
	}
}

class Tel
{
	void show()
	{
		System.out.println("number");
	}
}
class NewTel extends Tel
{
	void show()
	{
		super.show();//System.out.println("number");
		System.out.println("name");
		System.out.println("picture");

	}
}

3、子类中的构造函数

在对子类对象进行初始化时，父类的构造函数也会运行，

那是因为子类的构造函数默认第一行有一条隐式的语句super（）；

super();会访问到父类中空参数的构造函数，而且子类中所有的构造函数默认的第一行都是super();

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

因为父类中的数据子类可以直接获取，所以子类对象在建立时需要查看父类是如何对这些数据进行初始化的，

所以子类在对这些对象进行初始化时，要先访问以下父类中的构造函数

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

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

结论：

子类所有的构造函数默认都会访问父类中空参数的构造函数

因为子类每一个构造函数内的第一行都有一句隐式的super()

当父类中没有空参数的构造函数时，子类必须手动通过super()语句形式来指定要访问的父类中的构造函数

当然：子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数

这样的话，子类中也至少会有一个构造函数会访问父类中的构造函数。

class Fu //extends Object
{

	int num=2;
	Fu()
	{	//super();
		System.out.println("fu run");
	}
	Fu(int s )
	{
		System.out.println("fu..."+s);
	}
}

class Zi extends Fu
{
	Zi()
	{
		//super();//这里面相当于省略了super（）；
		super(4);  //如果父类中定义了非空参数的构造函数，那么这里面就不能隐式，必须写出与之对应的调用
		System.out.println("zi run");
	}
	Zi(int x)
	{
		this();//如果有this()语句那么就没super()了，通过其他构造函数访问
		//super();
		//super(4);
		System.out.println("zi..."+x);
	}
}
class ExtendsDemo4
{
	public static void main(String[] args)
	{
		Zi z=new Zi();
		System.out.println(z.num);
	}
}

/*
class Person
{
	private String name;
	Person(String name)
	{
		this.name=name;
	}
}
class Student extends Person
{
	Student(string name);
	{
		super(name);
	}
	void method()
	{
		super.show();
	}
}
*/

7、this，super具体用法区分

this.name=name;表示把函数参数name赋值给当前对象的属性name；

this.print();调用当前对象的打印方法，this可省略。

this(name);表示调用本类的含一个参数的构造函数。

super(name):调用父类的构造函数

super.print();调用父类的打印方法