javaSE-面向对象-继承

继承的概述

l多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承那个类即可。

l多个类可以称为子类，单独这个类称为父类或者超类。

l子类可以直接访问父类中的非私有的属性和行为。

l通过 extends关键字让类与类之间产生继承关系。

•classSubDemo extendsDemo{}

l继承的出现提高了代码的复用性。

l继承的出现让类与类之间产生了关系，提供了多态的前提。

继承的特点

lJava只支持单继承，不支持多继承，通过另一个方式体现。

•一个类只能有一个父类，不可以有多个父类。

•class SubDemo extends Demo{} //ok

•class SubDemo extendsDemo1,Demo2...//error

lJava支持多层继承(继承体系)

•class A{}

•class B extends A{}

•class C extends B{}

l定义继承需要注意：

•不要仅为了获取其他类中某个功能而去继承

•类与类之间要有所属( " is a ")关系，xx1是xx2的一种。

因为多继承容易出现问题。

两个父类中有相同的方法。子类到底要执行哪一个是不确定的。

所以java不支持多继承，但将这种机制换了另一个种安全的方式来体现，多实现。

多次继承出现的继承体系中，通常看父类中的功能，了解该体系的基本功能，建立子类对象即可使用该体系功能。

/*
继承：
	好处：1，提高了代码的复用性。
	      2，让类与类之间产生了关系，为多态特征提供了前提。
			
子类可以直接访问父类中的非私有的成员，间接访问私有成员通过方法的形式。

Java中继承的特点：
	Java中只支持单继承。并不直接支持多继承。
	单继承：一个子类只能有一个父类。 
	多继承：一个子类可以有多个父类。不直接支持，对其进行改良。 

	class Fu1
	{
		void show()
		{
			sop("fu1 show run");	
		}
	}
	class Fu2
	{
		void show()
		{
			sop("fu2 show run");	
		}
	}

	class Zi extends Fu1,Fu2//多继承，不支持。
	{
		
	}

	main()
	{
		Zi z = new Zi();
		z.show();//调用的不确定性。

	}


	Java中还支持多层继承。
	class A{}

	class B extends A{}

	class C extends B{}


	继承层次多了，就形成了继承体系。
	体系就是不断向上抽取而来的。

	在使用一个体系的时候，先参阅最顶层类，了解体系的最基本功能。
	使用时，创建该体系最底层类的对象。
	看顶层，用底层。



什么时候使用继承呢？
当一个事物是另一个事物的一种时。
当XXX是ZZZ中的一种，这时XXX继承ZZZ。

比如猫时猫科中的一种。



class Demo
{
	void metho1()
	{
	
	}
}


class DemoA extends Demo
{
	
	void method2()
	{}
}

class DemoB extends Demo//extends DemoA
{
	
	void method3()
	{}
}

*/

class Person
{
	String name;
	int age;
}


class Student/*子类 subclasss*/ extends/*继承*/ Person/*supclass父类，超类，基类*/
{
//	String name;
//	int age;

	void study()
	{
		System.out.println("name="+name+",age="+age);
	}
}

class Worker extends Person
{
//	String name;
//	int age;
	void work()
	{
		
	}
}


class ExtendsDemo 
{
	public static void main(String[] args) 
	{
		Student s = new Student();
		s.name="张三";
		s.age = 30;
		s.study();
	}
}

继承中子父类成员的特点

super关键字

lsuper和this的用法相像

lthis代表本类对象的引用

lsuper代表父类的内存空间的标识。

l当子父类出现同名成员时，可以用super进行区分

l子类要调用父类构造函数时，可以使用super语句。

/*
继承中子父类成员的特点：

1，成员变量。

2，成员函数。

3，构造函数。


super:代表的就是父类。

super的用法和this很相似。
用法 super.父类成员。  super(实际参数);
this:代表的是本类型对象的引用。
super：代表的是父类的内存空间。


子父类中出现同名成员变量时用super区分出父类变量。
但是这种情况很少出现。


*/


//成员变量。
class Fu
{
	private int num = 4;
	public int getNum()
	{
		return this.num;
	}
}
class Zi extends Fu
{
	private int num = 6;

	void show()
	{
		int num = 8;
		System.out.println("num="+this.num);
		System.out.println("num="+super.getNum());
	}

}


class ExtendsDemo2 
{
	public static void main(String[] args) 
	{
		Zi z = new Zi();
		z.show();
		
	}
}

函数覆盖(Override)   

l子类中出现与父类一模一样的方法时，会出现覆盖操作，也称为重写或者复写。

l父类中的私有方法不可以被覆盖。

l在子类覆盖方法中，继续使用被覆盖的方法可以通过super.函数名获取。

l覆盖注意事项：

•覆盖时，子类方法权限一定要大于等于父类方法权限

•静态只能覆盖静态。

l覆盖的应用：

•当子类需要父类的功能，而功能主体子类有自己特有内容时，可以复写父类中的方法，这样，即沿袭了父类的功能，又定义了子类特有的内容。

/*
继承中成员函数的特点。

当子父类中出现一模一样的函数时。
出现了另一个函数特性：覆盖，复写，重写。
overload(重载)：只关注本类中同名函数的参数列表。不关注返回值类型。
override(覆盖)：子父类中一模一样的函数，才会覆盖。




覆盖注意事项：

1，子类覆盖父类方式，必须要保证子类方法权限大于等于父类方法权限。
2，静态只能覆盖静态，或者被静态覆盖。


*/

class Fu
{
	static void show()
	{
		System.out.println("fu show run");
	}
}


class Zi extends Fu
{
	static void show()
	{
		System.out.println("zi show run");
	}
}
class ExtendsDemo3 
{
	public static void main(String[] args) 
	{
//		Zi z = new Zi();
//		z.show();


//		NewPhone p = new NewPhone();
//		p.show();

		Zi.show();
	}
}


/*
覆盖的应用：
*/
class Phone
{
	void call()
	{
	}
	void show()
	{
		System.out.println("number");
	}
}

class NewPhone extends Phone
{
	/*
	保留父类功能声明，建立子类功能内容。
	这就是传说中的覆盖。 
	*/
	void show()
	{
		System.out.println("name");
		super.show();
	}
}

子类的实例化过程

子类中所有的构造函数默认都会访问父类中空参数的构造函数
因为每一个构造函数的第一行都有一条默认的语句super();
子类会具备父类中的数据，所以要先明确父类是如何对这些数据初始化的。
当父类中没有空参数的构造函数时，子类的构造函数必须通过this或者super语句指定要访问的构造函数。

/*
子父类中构造函数的特点：

子类的实例化过程：
子类的所有构造函数中的第一行都有一条默认的隐式语句 super();
super():用来调用父类中的空参数的构造函数。

为什么子类中都要有默认super语句呢？
因为子类对象中会存储父类中的属性数据，必须要子类对象初始化时，
先执行父类的初始化动作，看看父类是如何对自己的属性数据进行初始化的。

所以呢，子类的所有构造函数默认第一行(因为初始化动作要先执行，所以定义在第一行)
都有一条默认的super()语句。 

如果父类中没有定义空参数的构造函数，子类构造函数必须通过super语句或者this语句指定要访问的构造函数。



*/
class Fu extends Object
{
//	int num=9;
//	Fu(){}
	Fu(int x)
	{
		//super();
		System.out.println("fu .."+x);
	}
}

class Zi extends Fu
{
	Zi()
	{
		super(5);
		//super();
		System.out.println("zi run");
	}
	Zi(int x)
	{
		this();
		System.out.println("zi...."+x);
	}


}


class ExtendsDemo4 
{
	public static void main(String[] args) 
	{
		new Zi(5);
	}
}

class Demo
{
}