黑马程序员_面向对象03

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

现在我们来看看面向对象的继承。

继承是从已有的类中派生出新的类新的类能吸收已有类的数据属性和行为，并能扩展新的能力。Java继承是使用已存在的类的定义作为基础建立新类的技术，新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类。这种技术使得复用以前的代码非常容易，能够大大缩短开发周期，降低开发费用。比如可以先定义一个类叫车，车有以下属性：车体大小，颜色，方向盘，轮胎，而又由车这个类派生出轿车和卡车两个类，为轿车添加一个小后备箱，而为卡车添加一个大货箱。

继承：

1、提高了代码的复用性。

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

注意：

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

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

我们来看一个简单的继承关系

class Person //父类是是人，都具有名字与年纪。
{
	String name;
	int age;
}

class Student extends Person//继承自父类Person不用在声明变量name，与age.
{
	//String name;
	//int age;
	void study
	{
		System.out.println("good study");
	}
}

class Worker extends Person
{
	//String name;
	//int age;
	void work()
	{
		System.out.println("good work");
	}
}

class ExtendsDemo
{
	public static void main(String[] args) 
	{
		System.out.println("Hello World!");
	}
}

JAVA语言中只支持单继承，不支持多继承。

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

但是java保留这种机制，并用另一种体现形式来完成表示，多实现。

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

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

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

通过了解共性功能，就可以知道该体系的基本功能，那么这个体系就可以基本使用了。

那么在具体使用时，要创建最子类的对象，为什么呢？

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

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

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

子父类出现后，类成员的特点:

类中成员：

1、变量

2、函数

3、构造函数

1、变量

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

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

super的使用与this的使用几乎一致。

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

class Fu
{
	//int num1 = 4;
	int num = 4;
}
class Zi extends Fu
{
	//int num2 = 5;
	int num = 5;
	void show()
	{
		System.out.println(super.num);
	}
}
class ExtendsDemo2 
{
	public static void main(String[] args) 
	{
		Zi z = new Zi();
		z.show();//打印的是4
		//System.out.println(z.num1 + "..." + z.num2);//打印的是4...5
		System.out.println(z.num + "..." + z.num);//打印的是5...5
	}
}

2、函数

当子类出现和父类一模一样的函数时。

当子类兑现调用该函数，会运行子类函数的内容。

如同父类的函数被覆盖。

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

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

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

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

覆盖：

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

静态只能覆盖静态。

记住

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

重写：子父类方法要一模一样。

class Fu
{
	void show()
	{
		System.out.println("fu show");
	}
	void speak()
	{
		System.out.println("vb");
	}
}
class Zi extends Fu
{
	void show()
	{
		System.out.println("zi show");
	}
	void speak()
	{
		System.out.println("java");
	}
}
class ExtendsDemo3 
{
	public static void main(String[] args) 
	{
		Zi z = new Zi();
		z.show();
		z.speak();
		System.out.println("Hello World!");
	}
}

3、构造函数

子父类中的构造函数。

特点：

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

那是因为子类的构造函数默认第一行有一条隐式的语句super()。

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

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

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

所有在子类对象初始化时，需要先访问一下父类中的构造函数。

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

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

结论：子类的所有构造函数，默认都会访问父类中空参数的构造函数。

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

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

当然子类的构造函数第一行也可以手动指定this语句来访问本类中的构造函数，子类中至少会有一个构造函数会访问父类中的构造函数。

class Fu
{
	int num = 2;
	Fu()
	{
		num = 60;
		System.out.println("fu run");
	}
	Fu(int x)
	{
		System.out.println("fu run");
	}
}
class Zi extends Fu
{
	Zi()
	{
		//系统自动在该处加上了super()；
		//当父类中没有空构造函数时，必须手动添加super（参数）。
		System.out.println("zi run");
	}
	Zi(int x)
	{
		//系统自动在该处加上了super();
		System.out.println("zi..."+ x);
	}
}
class ExtendsDemo4 
{
	public static void main(String[] args) 
	{
		Zi z = new​ Zi();//所以此处打印出来就是fu run，zi run.
		Zi z1 = new Zi(4);//答应的是fu run,zi run,fu run,zi....4;
		System.out.println(z.num);//打印出来是60，
	}
}

final关键字：

final(最终):作为一个修饰符。

1、可以修饰类，函数，变量。

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

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

4、被final修饰的变量是一个常量只能赋值一次，既可以修饰成员变量，也可以修饰局部变量。

当在描述事物时，一些数据的出现是固定的，那么这时为了增强阅读性，都给这些值起个名字，方便与阅读。

而这个值不需要改变，所以加上final修饰。z作为常量：常量的书写规范所有字母都大写，

如果有由多个单词组成，单词间通过_连接。

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

class Demo
{
	final int x = 3;
	public static final double pai = 3.14;//全局常量,不能被重新赋值。
	final void show1(){}
	void show2()
	{
		final int y = 4;
		System.out.println();
	}
}
class subDemo extends Demo
{//此时在子类中不能对final修饰过的任何变量进行任何变动
}
class FinalDemo 
{
	public static void main(String[] args) 
	{
		System.out.println("Hello World!");
	}
}

说完final我们继续说说继承里面的一个常用字。

抽象类（abstract）：

​当多个类中出现相同功能，但是功能主题不同，

这时也可以进行向上抽取，这时只抽取功能定义，而不抽取功能主体。

抽象类的特点：

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

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

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

4、抽象类中的方法要被使用，必须由子类复写起所有的抽象方法后，建立子类对象调用。

如果子类只覆盖了部分抽象方法，那么该子类还是一个抽象类。

我们来看看它的具体应用。

package com.itheima;
abstract class Student//抽象类。
{
	abstract void study();//抽象方法。
	void sleep()
	{
		System.out.println("躺着");
	}
	//abstract void study1();
}
class ChongCiStudent extends Student
{
	void study()
	{
		System.out.println("chongci study");
	}
}
class BaseStudent extends Student
{
	void study()
	{
		System.out.println("base study");
	}
}
abstract class OldPerson extends Student
{
	void sleep()
	{
		System.out.println("大床躺着");
	}
}
class  AbstractDemo
{
	public static void main(String[] args) 
	{
		System.out.println("Hello World!");
	}
}

练习：

假如我们在开发一个系统是需要对员工进行建模，员工包含三个属性：

姓名，工号，工资。经理也是员工，除了含有员工属性外，另外还有一个奖金属性，

请问使用继承的思想设计出员工类和经理类，要求类提供必要方法进行属性访问。

//基本员工类
abstract class Employee
{
	private String name;
	private String id;
	private double pay;
	Employee(String name,String di,double)
	{
		this.name = name;
		this.id = id;
		this.pay = pay;
	}
	public abstract void work();//一个工作的抽象方法。
}
//经理类
class Manager extends Employee
{
	private int bonus;
	Manager(String name,String di,double)
	{
		super(name,id,pay);
		this.bonus = bonus;
	}
	//复写的工作抽象方法。
	public void work()
	{
		System.out.println("manager work");
	}
}
//普通员工类。
class Pro extends Employee
{
	Pro(String name,String di,double)
	{
		super(name,id,pay);
	}
	//复写的工作抽象方法。
	public void work()
	{
		System.out.println("pro work");
	}
}
class AbstractTest 
{
	public static void main(String[] args) 
	{
		System.out.println("Hello World!");
	}
}

需求：获取一段程序运行的时间。

原理：获取程序开始和结束的时间并相减即可。

获取时间：System.currentTimeMillis();

当代码完成优化后，就可以解决这类问题了。

这种方式：模板方法设计模式。

什么是模板呢？

在定义功能时，功能的一部分是确定的，但是有一部分是不确定的，而确定的部分在使用不确定的部分，

那么这时就将不确定的部分暴露出去，由该类的子类去完成。

abstract class GetTime
{
	public final void getTime()//获取时间的不能复写所以定义为final。
	{
		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 x=0;x<1000 ;x++ )
		{
			System.out.print(x+" ");
		}
	}
}
class TemplateDemo 
{
	public static void main(String[] args) 
	{
		SubTime gt = new SubTime();
		gt.getTime();
		System.out.println("Hello World!");
	}
}

我们来看看全是抽象方法的类。这时候该方法就成为了另外一种体现形式Interface(接口)。

接口：​

格式：

    interface{}

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

    成员变量：public static final

    成员函数：public abstract

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

接口：初期理解，可以认为是一个特殊的抽象类

当抽象类中的方法都是抽象方法的时候，那么该类可以通过接口的形式来表示

class用于定义类

interface 用于定义接口

接口定义时，格式特点：

1、接口中常见定义：常量，抽象方法。

2、接口中的成员都有固定的修饰符。

常量：public static final

方法：public abstract

记住：接口中的成员都是public

接口：是不可以创建对象的，因为有抽象方法，

  需要被子类实现，子类对接口中的抽象方法全部覆盖后，子类才可以实例化。

  否则子类也是一个抽象类。

接口可以被类多实现，也是对多继承不支持的转换形式，java支持多实现。

interface inter
{
	public abstract static final int NUM = 3;
	public abstract void show();
}
interface interA
{
	public abstract void method();
}
class Demo
{
	public void function(){}
}
class Test extends Demo implements Inter,InterA//实现Inter接口implements关键字用来实现接口。
{
	public void show(){}
	public abstract void method(){}
}
interface A
{
	void methodA();
}
interface B //extends A 当B继承A的时候C继承B也就间接的从B出继承了A里面的方法methodA（）
{
	void methodB();
}
interface C extends B,A//接口与接口可以实现多继承。因为他们没有方法体。
{
	void methodC();
}
class D implements C
{
	public void methodA(){}
	public void methodB(){}
	public void methodC(){}
}
class InterfaceDemo 
{
	public static void main(String[] args) 
	{
		Test t = new Test();
		System.out.println("Hello World!");
	}
}

接口的特点：

    接口是对外暴露的规则。

    接口是程序的功能扩展。

    接口是可以用来多实现。

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

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

继承与接口的示例。

abstract class Student 学生类
{
	abstract void study();
	void sleep()
	{
		System.out.println("sleep");
	}
}
interface Smoking 抽烟的接口
{
	public abstract void smoke();
}
class ZhangSan extends Student implements Smoking 张三是学生而且抽烟
{
	void study(){}
	public void smoke(){}
}
class LiSi extends Student 李四是学生但是不抽烟
{
	void study(){}
}
class  InterfaceTest
{
	public static void main(String[] args) 
	{
		System.out.println("Hello World!");
	}
}

这段代码中毕向东老师把接口与继承的实际应用体现的淋漓尽致。

简单来说下接口和抽象类的区别：
接口是公开的，里面不能有私有的方法或变量，是用于让别人使用的，而抽象类是可以有私有方法或私有变量的，
另外，实现接口的一定要实现接口里定义的所有方法，而实现抽象类可以有选择地重写需要用到的方法，一般的应用里，最顶级的是接口，然后是抽象类实现接口，最后才到具体类实现。
还有，接口可以实现多重继承，而一个类只能继承一个超类，但可以通过继承多个接口实现多重继承，接口还有标识（里面没有任何方法，如Remote接口）和数据共享（里面的变量全是常量）的作用.

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

详细请查看：www.itheima.com