黑马程序员--java基础--类的继承与接口的实现

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

                                                                 继承

        当多个类中存在共性时，将这些共性抽取到单独一个类中，继承这个类，这时，多个类可以称为子类，单独的这个类称为父类或者超类。

        类与类之间就存在了继承的关系。通过extends关键字表示继承关系

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

如图

           必须是类与类之间有所属关系才可以继承。这种所属关系的表示为is a。

书写格式

 

class Fu
{


}

class Zi extends Fu//继承了上面的类
{
	void show()
	{
		System.out.println("this:"+super);
	}
}

在内存中的加载先后 顺序

特点

Java语言中

 

多层继承

        Java类中虽然不支持多继承，但可以多层继承，也就是一个继承体系。

            class A{}
           class B extendsA{}
           class C extendsB{}

查阅父类功能，创建子类对象使用功能。

继承后，类成员的特点：

成员变量

       子类中出现非私有的同名成员变量时，子类要访问本类中的变量，用this。

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

       super的使用和this的使用几乎一致，且两者都存在于方法区中。
              this表示本来对象的引用。    
              super表示父类对象的引用。
成员函数——覆盖
       子类出现和父类一样的函数时，子类对象调用该函数，会运行子类函数的内容。这种情况是函数的另一个特性：重写（覆盖）。
       子类继承父类，沿袭了父类的功能到子类中。可以用super.方法();
 

class Fu
{
	Fu()
	{
		show();
		return;
	}

	void show()
	{
		System.out.println("fu show");
	}
}
class Zi extends Fu
{
	int num = 8;
	Zi()
	{
		System.out.println("zi cons run...."+num);
		return;
	}
	void show()
	{
		System.out.println("zi show..."+num);//覆盖了父类的方法
	}
}
class ExtendsDemo5 
{
	public static void main(String[] args) 
	{
		Zi z = new Zi();
		z.show();
	}
}

注意

         1、子类覆盖父类，必须保证子类权限大于等于父类权限，才可以覆盖，否则编译失败。
         2、静态只能覆盖静态。
         3、父类中的私有方法不能被重写。
 

构造函数

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

在子类构造对象时，发现，访问子类构造函数时，父类也运行了。
为什么呢？
原因是：在子类的构造函数中第一行有一个默认的隐式语句。 super();

子类的实例化过程：子类中所有的构造函数默认都会访问父类中的空参数的构造函数。
	
			
为什么子类实例化的时候要访问父类中的构造函数呢？
那是因为子类继承了父类，获取到了父类中内容(属性)，所以在使用父类内容之前，
要先看父类是如何对自己的内容进行初始化的。

所以子类在构造对象时，必须访问父类中的构造函数。 
为什么完成这个必须的动作，就在子类的构造函数中加入了super()语句。

如果父类中没有定义空参数构造函数，那么子类的构造函数必须用super明确要调用
父类中哪个构造函数。同时子类构造函数中如果使用this调用了本类构造函数时，
那么super就没有了，因为super和this都只能定义第一行。所以只能有一个。
但是可以保证的是，子类中肯定会有其他的构造函数访问父类的构造函数。


注意：supre语句必须要定义在子类构造函数的第一行。因为父类的初始化动作要先完成。





*/

class Fu
{
	int num ;
	Fu()
	{
		num =10;
		System.out.println("A fu run");
	}
	Fu(int x)
	{
		System.out.println("B fu run..."+x);
	}
}
class Zi extends Fu
{
	int num;
	Zi()
	{
		//super();//调用的就是父类中的空参数的构造函数。
		
		System.out.println("C zi run"+num);
	}
	Zi(int x)
	{
		this();
		//super();
//		super(x);
		System.out.println("D zi run "+x);
	}
}

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

扩展

                                        final关键字

 当一些数据的出现值是固定的，为了增强阅读性，给这些值起个名字，而这个值不需要改变，所以加上final修饰作为常量。

常量的书写规范所有字母都大写，如果由多个单词组成，单词间通过_连接。

class Fu
{
	void method()
	{
		//调用了底层系统的资源。
	}
}
class Zi extends Fu
{
	public static final double MY_PI = 3.14;//常量的书写规范
	static final int x = 7;//final的使用

	void method()
	{
		final int NUMBER = 9;
		
		System.out.println(MY_PI);
	}
}

注意：内部类定义在类中的局部位置上时，只能访问该局部被final修饰的局部变量。
 
                                            抽象类

抽象类特点：

1，方法只有声明没有实现时，该方法就是抽象方法，需要被abstract修饰。
抽象方法必须定义在抽象类中。该类必须也被abstract修饰。
2，抽象类不可以被实例化。为什么？因为调用抽象方法没意义。
3，抽象类必须有其子类覆盖了所有的抽象方法后，该子类才可以实例化。
否则，这个子类还是抽象类。

抽象类中的小问题

1，抽象类中有构造函数？
有，用于给子类对象进行初始化。


2，抽象类可以不定义抽象方法吗？
可以的。 但是很少见，目的就是不让该类创建对象。AWT的适配器对象就是这种类。
通常这个类中的方法有方法体，但是却没有内容。

abstract class Demo
{
void show1()
{}


void show2()
{}
}

3，抽象关键字不可以和那些关键字共存?
private 不行
static 不行
final 不行

4，抽象类和一般类的异同点。
相同点：
抽象类和一般类都是用来描述事物的，都在内部定了成员。
不同：
1，一般类有足够的信息描述事物。
  抽象类描述事物的信息有可能不足。
2，一般类中不能定义抽象方法，只能定非抽象方法。
  抽象类中可定义抽象方法，同时也可以定义非抽象方法。
3，一般类可以被实例化。
  抽象类不可以被实例化。

5，抽象类一定是个父类吗？
是的。因为需要子类覆盖其方法后才可以对子类实例化。 

下面我们用一个小例子说明一下

abstract class 犬科//<span style="font-family: Arial, Helvetica, sans-serif;">抽象类需要用abstract修饰</span>
{
	abstract void 吼叫();<span style="font-family: Arial, Helvetica, sans-serif;">//抽象方法也需要用abstract修饰</span>
}

class 狗 extends 犬科
{
	
	void 吼叫()//抽象方法需要被覆盖，子类才能被实例化
	{
		System.out.println("汪汪");
	}
}
class 狼 extends 犬科
{
	void 吼叫()
	{
		System.out.println("嗷嗷");
	}
}

雇员示例：
需求：公司中程序员有姓名，工号，薪水，工作内容。
项目经理除了有姓名，工号，薪水，还有奖金，工作内容。
对给出需求进行数据建模。

分析：
在这个问题领域中，先找出涉及的对象。
通过名词提炼法。
程序员：
	属性：姓名，工号，薪水、
	行为：工作。
经理：
	属性：姓名，工号，薪水，奖金。
	行为：工作。


程序员和经理不存在着直接继承关系，

但是程序员和经理却具有共性内容。
可以进行抽取。因为他们都是公司的雇员 

可以将程序员和经理进行抽取.建立体系.
	
*/

//描述雇员。

abstract 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 Programmer extends Employee
{
	Programmer(String name,String id,double pay)
	{
		super(name,id,pay);
	}
	public void work()
	{
		System.out.println("code...");
	}
}

//描述经理。 
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("manage");
	}
}

抽象类与一般类的区别

        1、抽象类和一般类没有太大的不同。该如何描述事物，还是如何描述事物。只不过，该事物中出现了一些不知道具体内容的方法部分。这些不确定的部分，也是该事物的功能，需要明确出来，但是无法定义主体。通过抽象方法来表示。
        2、抽象类比一般类多了个抽象函数。就是在类中可以定义抽象方法。
        3、抽象类不可以实例化。
        4、抽象类虽然不能创建对象，但是也有构造函数。供子类实例化调用。

                                                       接口

定义接口使用的关键字不是class，是interface.

对于接口当中常见的成员：而且这些成员都有固定的修饰符。
1，全局常量: public  static final 


2，抽象方法。public abstract 


由此得出结论，接口中的成员都是公共的权限.

 
接口特点
        1、接口是对外暴露的规则。
        2、接口是程序的功能扩展。
        3、接口的出现降低耦合性。
        4、接口可以用来多实现。这也是对多继承不支持的转换形式。java支持多实现。
        5、类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口。
        6、 接口与接口之间可以有继承关系。而且可以多继承。

        7、接口不可以创建对象的，因为有抽象方法。

        8、需要被子类实现（implements），子类对接口中的抽象方法全都覆盖后，子类才可以实例化，否则子类是一个抽象类。

        9、实现多个接口时，接口中不可以有返回不同类型的同名抽象函数。这样子类实现时将不能复写。

 

以电脑主板为图例说明接口的优点

接口与抽象类区别
      共同点：都是不断向上抽取出来的抽象的概念。
      不同点：
                1、抽象类体现继承关系，一个类只能单继承。
                    接口体现实现关系，一个类可以多实现。同时接口与接口之间有继承关系。
                2、抽象类是继承，是 "is a "关系。
                    接口是实现，是 "like a"关系。
                3、抽象类中可以定义非抽象方法，供子类直接使用。
                    接口的方法都是抽象，接口中的成员都有固定修饰符。
                4、抽象类中可以私有变量或方法。
                    接口中的常量和方法都是public修饰的权限。

interface Demo
{
	public static final int NUM = 4;

	public abstract void show1();
	public abstract void show2();
}
//类与类之间是继承关系，类与接口直接是实现关系。 
/*
接口不可以实例化。

只能由实现了接口的子类并覆盖了接口中所有的抽象方法后，该子类才可以实例化。
否则，这个子类就是一个抽象类。

*/


class DemoImpl implements /*实现*/Demo
{
	public void show1()
	{}

	public void show2()
	{
	
	}
}


/*
在java中不直接支持多继承，因为会出现调用的不确定性。
所以java将多继承机制进行改良，在java中变成了多实现。

一个类可以实现多个接口。 

*/

interface A
{
	public void show();
}

interface Z
{
	public int add(int a,int b);
}




class Test implements A,Z//多实现
{
	
	public int add(int a,int b)
	{
		return a+b+3;	
	}
	/**/
	public void show(){}
	
}





/*
一个类在继承另一个类的同时，还可以实现多个接口。



*/
class Q
{
	public void method()
	{}
}

abstract class Test2 extends Q implements A,Z
{

}
/*
接口的出现避免了单继承的局限性。

*/


interface CC
{
	void show();
}
interface MM
{
	void method();
}

interface QQ extends  CC,MM//接口与接口之间是继承关系，而且接口可以多继承。 
{
	void function();
}

class WW implements QQ
{
//覆盖3个方法。
	public void show(){}
	public void method(){}
	public void function(){}
}