Java面向对象5

继承

继承的好处：
1，提高了代码的复用性。
2，让类与类之间产生了关系，给第三个特征多态提供了前提.

java中支持单继承。不直接支持多继承，但对C++中的多继承机制进行改良。（接口）

单继承：一个子类只能有一个直接父类。
多继承：一个子类可以有多个直接父类(java中不允许,进行改良)
不直接支持，因为多个父类中有相同成员，会产生调用不确定性。
在java中是通过"多实现"的方式来体现。

java支持多层(多重)继承。
C继承B，B继承A。
就会出现继承体系。

当要使用一个继承体系时，
1，查看该体系中的顶层类，了解该体系的基本功能。
2，创建体系中的最子类对象，完成功能的使用。

class Demo{
	void show1(){  }
}

class DemoA extends Demo{
//	void show1(){}
	void show2(){}
}
class DemoB extends Demo{
//	void show1(){}
	void show3(){}
}

什么时候定义继承呢？
当类与类之间存在着所属关系的时候，就定义继承。xxx是yyy中的一种。 xxx extends yyy

所属关系： is a 关系。

class Person{
	String name;
	int age;
}
class Student extends/*继承*/ Person{
//	String name;
//	int age;
	void study(){
		System.out.println(name+"...student study.."+age);
	}
}
class Worker extends Person{
//	String name;
//	int age;
	void work(){
		System.out.println("worker work");
	}
}

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

在子父类中，成员的特点体现。
1，成员变量。
2，成员函数。
3，构造函数。

成员变量

当本类的成员和局部变量同名用this区分。
当子父类中的成员变量同名用super区分父类。

this和super的用法很相似。

this:代表一个本类对象的引用。
super：代表一个父类空间。

class Fu{
	private int num = 4;
	public int getNum(){
		return num;
	}
}

class Zi extends Fu{
	private int num = 5;
	void show(){
		System.out.println(this.num+"....."+super.getNum());
	}
}

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

成员函数

当子父类中出现成员函数一模一样的情况，会运行子类的函数。
这种现象，称为覆盖操作。这时函数在子父类中的特性。
函数两个特性：
1，重载。同一个类中。overload
2，覆盖。子类中。覆盖也称为重写，覆写。override

覆盖注意事项：
1，子类方法覆盖父类方法时，子类权限必须要大于等于父类的权限。
2，静态只能覆盖静态，或被静态覆盖。

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

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

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

/*
 * 什么时候使用覆盖操作?
 * 当对一个类进行子类的扩展时，子类需要保留父类的功能声明， 但是要定义子类中该功能的特有内容时，就使用覆盖操作完成.
 */

class Phone {
	void call() {
		System.out.println("call");
	}
	void show() {
		System.out.println("number");
	}
}

class NewPhone extends Phone {
	void show() {
		System.out.println("name");
		System.out.println("pic");
		super.show();
	}
}

class PersonDemo1 {
	public static void main(String[] args) {
		NewPhone p = new NewPhone();
		p.show();
		p.call();
	}
}

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

子类的实例化过程：子类中所有的构造函数默认都会访问父类中的空参数的构造函数。

为什么子类实例化的时候要访问父类中的构造函数呢？
那是因为子类继承了父类，获取到了父类中内容(属性)，所以在使用父类内容之前，
要先看父类是如何对自己的内容进行初始化的。
所以子类在构造对象时，必须访问父类中的构造函数。
为了完成这个必须的动作，就在子类的构造函数中加入了super()语句。

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

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

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

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 Demo// extends Object
{
	/*
	 * Demo() { super(); return; }
	 */
}

一个对象实例化过程：
Person p = new Person();
1，JVM会读取指定的路径下的Person.class文件，并加载进内存，
并会先加载Person的父类(如果有直接的父类的情况下).
2，在堆内存中的开辟空间，分配地址。
3，并在对象空间中，对对象中的属性进行默认初始化。
4，调用对应的构造函数进行初始化。
5，在构造函数中，第一行会先到调用父类中构造函数进行初始化。
6，父类初始化完毕后，在对子类的属性进行显示初始化。
7，在进行子类构造函数的特定初始化。
8，初始化完毕后，将地址值赋值给引用变量.

class Fu {
	Fu() {
		super();
		show();
		return;
	}
	void show() {
		System.out.println("fu show");
	}
}

class Zi extends Fu {
	int num = 8;
	Zi() {
		super();
		// -->通过super初始化父类内容时，子类的成员变量并未显示初始化。等super()父类初始化完毕后，
		// 才进行子类的成员变量显示初始化。
		System.out.println("zi cons run...." + num);
		return;
	}
	void show() {
		System.out.println("zi show..." + num);
	}
}

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

输出结果：
zi show...0
zi cons run....8
zi show...8

继承弊端：打破了封装性。
.

final关键字

1，final是一个修饰符，可以修饰类，方法，变量。
2，final修饰的类不可以被继承。
3，final修饰的方法不可以被覆盖。
4，final修饰的变量是一个常量，只能赋值一次。
为什么要用final修饰变量。其实在程序如果一个数据是固定的，
那么直接使用这个数据就可以了，但是这样阅读性差，所以它该数据起个名称。
而且这个变量名称的值不能变化，所以加上final固定。

写法规范：常量所有字母都大写，多个单词，中间用_连接。

class Fu {
	void method() {
		// 调用了底层系统的资源。
	}
}
class Zi extends Fu {
	public static final double MY_PI = 3.14;
	static final int x = 7;
	void method() {
		// final int x = 9;
		// x = 9;
		final int NUMBER = 9;
		System.out.println(MY_PI);
	}
}
class PersonDemo1 {
	public static void main(String[] args) {
		Zi z=new Zi();
		z.method();
	}
}

抽象类

抽象：笼统，模糊，看不懂！不具体。

特点：
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 犬科 {
	abstract void 吼叫();
}
class 狗 extends 犬科 {
	void 吼叫() {
		System.out.println("汪汪");
	}
}
class 狼 extends 犬科 {
	void 吼叫() {
		System.out.println("嗷嗷");
	}
}

abstract class Demo {
	abstract /* 抽象 */ void show();
}

class DemoA extends Demo {
	void show() {
		System.out.println("demoa show");
	}
}
class DemoB extends Demo {
	void show() {
		System.out.println("demob show");
	}
}

class PersonDemo1 {
	public static void main(String[] args) {
		DemoA a = new DemoA();
		a.show();
		DemoB b = new DemoB();
		b.show();
	}
}

.
.
雇员示例：

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


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

程序员和经理不存在着直接继承关系，但是程序员和经理却具有共性内容。
可以进行抽取。因为他们都是公司的雇员 

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

//描述雇员。
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");
	}
}

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

接口

当一个抽象类中的方法都是抽象的时候，这时可以将该抽象类用另一种形式定义和表示，就是 接口 interface。

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

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

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

类与类之间是继承关系，类与接口直接是实现关系。

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

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() {}
}

class PersonDemo1 {
	public static void main(String[] args) {
		 DemoImpl d = new DemoImpl();
		 System.out.println(d.NUM);
		 System.out.println(DemoImpl.NUM);
		 System.out.println(Demo.NUM);
	}
}

在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 PersonDemo1 {
	public static void main(String[] args) {
		Test t = new Test();
		t.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() {
	}
}

抽象类和接口的异同点：

相同点：
	都是不断向上抽取而来的。
	
不同点：
	1，抽象类需要被继承，而且只能单继承。
	   接口需要被实现，而且可以多实现。 
	2，抽象类中可以定义抽象方法和非抽象方法，子类继承后，可以直接使用非抽象方法。
	   接口中只能定义抽象方法，必须由子类去实现。 
	3，抽象类的继承，是is a关系，在定义该体系的基本共性内容。
	   接口的实现是 like a 关系，在定义体系额外功能。

犬按功能分：有导盲犬，搜爆犬。

abstract class 犬{
	abstract void 吼叫();
}
//abstract class 导盲
interface 导盲{
	abstract void 导盲();
}

class 导盲犬 extends 犬 implements 导盲{
	public void 吼叫(){
	}
	public void 导盲(){}
}