面向对象(二)

继承

1、概念理解

概念：多个类中存在相同属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需再定义这些属性和行为，只要继承单独的那个类即可。多个类可以称为子类，单独这个类称为父类或者超类。

好处：

提高了代码的复用性。

让类与类之间产生了关系，提供了另一个特征多态的前提。

java语言中只支持单继承，不支持多继承。因为多继承容易带来安全隐患（当多个父类中定义了相同功能，当功能内容不同时，子类对象不确定要运行那一个），但是java保留这种机制，并用另一种体现形式来完成表示——多实现。

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

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

2、继承中各成员的特性

1）成员变量。

     当子父类中出现一样的属性时，子类类型的对象，调用该属性，值是子类的属性值。

     如果想要调用父类中的属性值，需要使用一个关键字：super

     This：代表是本类类型的对象引用。

     Super：代表是子类所属的父类中的内存空间引用。

2）成员函数。

当子父类中出现了一模一样的方法时，建立子类对象会运行子类中的方法。好像父类中的方法被覆盖掉一样。所以这种情况，是函数的另一个特性：覆盖(复写，重写)

什么时候使用覆盖呢？当一个类的功能内容需要修改时，可以通过覆盖来实现。

3）构造函数。

子类的所有构造函数中的第一行，其实都有一条隐身的语句super();

super(): 表示父类的构造函数，并会调用于参数相对应的父类中的构造函数。而super():是在调用父类中空参数的构造函数。

为什么子类对象初始化时，都需要调用父类中的函数？(为什么要在子类构造函数的第一行加入这个super()?)

因为子类继承父类，会继承到父类中的数据，所以必须要看父类是如何对自己的数据进行初始化的。所以子类在进行对象初始化时，先调用父类的构造函数，这就是子类的实例化过程。

继承实列：

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

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

class  ExtendsDemo4
{
	public static void main(String[] args) 
	{
		Zi z = new Zi(0);
		System.out.println(z.num);
	}
}

3、final修饰符

final : 最终。作为一个修饰符，
1）可以修饰类，函数，变量。
2）被final修饰的类不可以被继承。为了避免被继承，被子类复写功能。
3）被final修饰的方法不可以被复写。
4）被final修饰的变量是一个常量只能赋值一次，既可以修饰成员变量，有可以修饰局部变量。
当在描述事物时，一些数据的出现值是固定的，那么这时为了增强阅读性，都给这些值起个名字。方便于阅读。
而这个值不需要改变，所以加上final修饰。作为常量：常量的书写规范所有字母都大写，如果由多个单词组成。
单词间通过_连接。
5）内部类定义在类中的局部位置上是，只能访问该局部被final修饰的局部变量。

使用实例：

class Demo
{
	final int x = 3;
	public static final double PI = 3.14;
	final void show1()
	{}
	void show2()
	{
		final int y = 4;
		System.out.println(3.14);
	}
}
class SubDemo extends Demo
{
	//void show1(){}
}
class FinalDemo 
{
	public static void main(String[] args) 
	{
		System.out.println("Hello World!");
	}
}

4、抽象

 当多个类中出现相同功能，但是功能主体不同，这是可以进行向上抽取。这时，只抽取功能定义，而不抽取功能主体。这是就用到抽象。

特点：

     1）抽象方法一定在抽象类中。

     2）抽象方法和抽象类都必须被abstract关键子修饰。

     3）抽象类不可以用new创建对象。因为调用抽抽象方法没意义。

     4）抽象类中的抽象方法要被使用，必须由子类复写起所有的抽象方法后，建立子类对像调用，如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。

       抽象类和一般类没有太大的不同。该如何描述事物，就如何描述事物，只不过，该事物出现了一些看不懂的东西。这些不确定的部分，也是该事物的功能，需要明确出现。但是无法定义主体。通过抽象方法来表示。
       抽象类比一般类多个了抽象函数。就是在类中可以定义抽象方法。抽象类不可以实例化。抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。

      被final修饰的类不能有子类。而被abstract修饰的类一定是一个父类，会有子类继承它。 抽象类中的私有的抽象方法，不被子类所知，就无法被复写。而抽象方法出现的就是需要被复写。static：如果static可以修饰抽象方法，那么连对象都省了，直接类名调用就可以了。可是抽象方法运行没意义。
      抽象类是一个父类，要给子类提供实例的初始化。子类继承的父类中有抽象方法，就一定要对方法进行覆写。

使用实列：

class Employee
{
	private String name;
	private String id;
	private double pay;

	Employee(String name,String id,double pay)
	{
		this.name = name;
		this.id = id;
		this.pay = pay;
	}
	
	public abstract void work();

}
class Manager extends Employee
{
	private int bonus;
	Manager(String name,String id,double pay,int bonus)
	{
		super(name,id,pay);
		this.bonus = bonus;
	}
	public void work()
	{
		System.out.println("manager work");
	}
}
class Pro extends Employee
{
	Pro(String name,String id,double pay)
	{
		super(name,id,pay);
	}
	public void work()
	{
		System.out.println("pro work");
	}
}
class  
{
	public static void main(String[] args) 
	{
		System.out.println("Hello World!");
	}
}

5、接口：

1）是用关键字interface定义的。

2）接口中包含的成员，最常见的有全局常量、抽象方法。

注意：接口中的成员都有固定的修饰符。

    成员变量：public static final

    成员方法：public abstract

interface Inter{

    publicstatic final int x = 3;

    publicabstract void show();

}

3）接口中有抽象方法，说明接口不可以实例化。接口的子类必须实现了接口中所有的抽象方法后，该子类才可以实例化。否则，该子类还是一个抽象类。

4）类与类之间存在着继承关系，类与接口中间存在的是实现关系。

    继承用extends  ；实现用implements ；

5）接口和类不一样的地方，就是，接口可以被多实现，这就是多继承改良后的结果。java将多继承机制通过多现实来体现。

6）一个类在继承另一个类的同时，还可以实现多个接口。所以接口的出现避免了单继承的局限性。还可以将类进行功能的扩展。

7）其实java中是有多继承的。接口与接口之间存在着继承关系，接口可以多继承接口。