JAVA基础第七天学习日记_继承、重写、final关键字、抽象、接口

本文链接：https://blog.csdn.net/zorroblood/article/details/7659420

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

继承：

提高了代码的复用性。

让类与类产生了关系，有了这个关系，才有了多态的特性。

JAVA语言中：对于类来说，只支持单继承，不支持多继承。（因为多继承会带来安全隐患：当多个父类中定义了相同功能，当功能内容不同时，不确定要运行哪一个。）

JAVA支持多层继承（继承体系）。

首先查阅体系父类的描述，因为父类中定义的是该体系中共性功能。通过了解共性功能，就可以知道该体系的基本功能。

创建最子类的对象。①父类有可能不能创建对象②创建最子类对象可以使用更多的功能，包括基本的也包括特有的。

①不要为了获取其他类的功能，简化代码而继承；必须是类与类之间有所属关系才可以继承。

②加载子类会先加载父类，所以父类的变量会被保存在子类对象的堆内存空间中。

Super关键字：在子类中使用父类的成员，使用super关键字

public class SuperDemo {
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Zi zi=new Zi();
		zi.show();
	}

}
class Fu
{
	int num=4;
}
class Zi extends Fu
{
	int num=5;
	public void show()
	{
		System.out.println(super.num);
	}
}

在对子类对象进行初始化时，父类的构造函数也会运行，因为子类的构造和你熟默认第一行有一条隐式的语句super（）；其会访问父类中空参数的构造函数。而求子类中所有的构造函数默认第一行都是super（）；当父类中的构造函数有参数时，子类必须手动调用父类中的构造函数。因为父类中的和数据子类可以直接获取，所以子类对象在建立时，需要先查看父类是如何对这些数据进行初始化的。所以子类在对象初始化是，要先访问一下父类中的构造函数。Super语句一定定义在子类构造函数的第一行。

class Test14 extends Super
{
	public Test14(String s)
	{
		super(s);//此处需加这个构造函数，否则发生异常。或者在超类中加入一个空参数的构造函数。
		i=2;
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Test14 t=new Test14("yes");
		System.out.println(t.i);
	}
}
class Super
{
	int i=0;
	public Super(String s)
	{
		i=1;
	}
}

---------------------------------------------------------------------------

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

使用需求：当子类继承父类，沿袭了父类的功能到子类中，子类虽具备该功能，但是功能的内容却和父类不同。这时没有必要定义新功能，而是使用覆盖特殊，保留父类功能定义，并重写功能内容。

使用规则：①父类的私有权限方法子类无法继承覆盖，但是语法上可以通过。

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

③静态只能覆盖静态。

---------------------------------------------------------------------------------

final关键字：最终关键字。

①　可以修饰类，函数，变量。

②　被final修饰的类不可以被继承，为了避免被继承，被子类复写功能。

③　被final修饰的方法不可以被复写。

④　被final修饰的变量是一个常量只能赋值一次，既可以修饰成员变量，也可以修饰局部变量。（当在描述事物时，一些数据的出现值是固定的，那么这时为了增强阅读性，都给这些值起个名字，方便与阅读，而这个值不需要改变，所以加上final修饰。作为常量，常量的书写规范，所有字母都大写，如果由多个单词组成，单词间通过_连接。）

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

-------------------------------------------------------------------------------------

抽象：

需求分析：当多个类中出现相同功能，但是功能主体不同，这时可以进行向上抽取。只抽取功能定义，而不抽取功能主体。

抽象类特点：

①　抽象方法一定在抽象类中。

②　抽象类和抽象方法必须被abstract修饰。

③　抽象类不能用new创建对象，因为用抽象方法没有意义。

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

⑤　抽象类中可以不定义抽象方法，这样做仅仅是不让该类建立对象。

模版方法设计模式：在定义功能时，功能的一部分是确定的，但是有一部分是不确定的，而确定的部分在使用不确定的部分，那么这时就将不确定的部分暴露出去，由子类完成（定义一个抽象类，由子类去覆盖复写方法）。

class AbstractDemo
{
	public static void main(String[] args)
	{
		SubTime st=new SubTime();
		st.getTime();
	}
}	
abstract class GetTime 
	{
		public final void getTime()
		{
			long start=System.currentTimeMillis();
			runcode();
			long end=System.currentTimeMillis();
			System.out.println(end-start);
		}
		public abstract void runcode();//对外暴露不确定方法
	}
class SubTime extends GetTime
	{   	
		public void runcode()//由子类重写
		{
			for (int i = 0; i < 500; i++) 
			{
				System.out.println(i);
			}
		}	
	}

------------------------------------------------------------------------------------

接口：格式：interface｛｝

接口中的成员修饰符是固定的。

成员常量：public static final

成员函数：public abstract

接口的出现将多继承通过另一种形式体现出来，即多实现。

接口可以被理解为一个特殊的抽象类。当抽象类中的方法都是抽象时，那么该类可以通过接口的形式来表示。

不可以创建对象，因为有抽象方法。需要被子类实现，子类被接口中的方法全部覆盖后，子类才可以实例化。否则子类是一个抽象类。

接口可以实现多继承。在同一个子类实现的多个接口中不能定义方法名相同但是返回值不同的方法。

接口的特点：

①　接口是对外暴露的规则。

②　接口是程序的功能扩展。

③　接口可以用来多实现。

④　类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口。

⑤　接口与接口之间可以有继承关系。

abstract class Student
{
	abstract void study();
	void sleep()
	{
		System.out.println("sleep");
	};
}
interface Smoking
{
	void smoke();
}
class ZhangSan extends Student implements Smoking
{
	void study(){};
	public void smoke(){};//此处必须有public，为什么？注意接口成员默认的修饰。方法修饰publi abstract
}
class Lisi extends Student
{
	void study(){};
}

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