(10)Java学习笔记——面向对象04——继承

继承

继承的好处：

1/提高了代码的复用性

2/提高代码的维护性

3/让类与类之间产生了联系，给第三个特征多态提供了前提。（也是继承的一个弊端：类的耦合性增强）

开发的原则：低耦合，高内聚

耦合：类与类的关系

内聚：就是自己完成某件事情的能力

继承的基本格式（extends关键字）

class  子类名  extends  父类名  {  }

范例1：

class Fu()
{
}

class Zi extends Fu	//通过关键字extends让子类继承父类
{
}

范例2：

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

class Person
{
	String name;
	int age;
}

class Student extends Person	//通过extends集成父类的属性
{
	void study()
	{
		System.out.println(name+"....student study...."+age);
	}
}

class worker extends Person		//通过extends集成父类的属性
{
	void work()
	{
		System.out.println(name+"....worker work...."+age);
	}
}

JAVA中继承的特点：

1 / Java中支持单继承，不直接支持多继承，但对C++中的多继承进行了改良。不直接支持多继承，是因为多个父类中有相同成员，会产生调用的不确定性。

单继承：一个子类只能有一个直接父类。

2 / Java支持多层（多重）继承。（C继承B,B继承A），就会出现继承体系。

继承的注意事项：

1 / 子类只能集成父类所有非私有的成员（包括成员变量和成员方法）

2 / 子类不能继承父类的构造方法，但是可以通过super来访问父类的构造方法。

3 / 不要为了部分功能去继承

4 / 

当要使用一个继承体系时：

1/查看该体系中的顶层类，了解该体系的基本功能。

2/创建体系中的最子类对象，完成功能的使用。

什么时候定义继承呢？

当类与类之间存在所属关系的时候，就定义继承。XXX是YYY中的一种，XXX extends YYY

————————————————————————————————————————————————————————————

继承中 成员（成员变量，构造方法，成员方法）的关系

继承者成员变量的关系：

a / 子类中的成员变量和父类中成员变量名称不一致。

b / 子类中的成员变量和父类中成员变量名称一样，会采用就近原则（就近原则的的先后顺序：先子类局部——>子类成员——>父类成员）。

调用成员变量的范例：

class Father	//父类
{
	int num = 10;
}

class Son extends Father	//子类继承父类
{
	int num = 20;

	public void show()
	{
		int num = 30; 
		System.out.println(num);	//采取的是就近原则。
	}
}

class ExtendsDemo 
{
	public static void main(String[] args) 
	{
		Son s = new Son();
		s.show();
	}
}

/*
结果是30
*/

this 和 super 的区别和应用

区别：

this 代表本类对应的引用。

super代表父类存储空间的标识（可以理解为父类引用，可以操作父类的成员）

如何调用：

a / 调用成员变量：

this . 成员变量 （表示调用本类的成员变量）

super . 成员变量 （表示调用父类的成员变量）

调用成员变量范例：

class Father	//父类
{
	int num = 10;
}

class Son extends Father	//子类继承父类
{
	int num = 20;

	public void show()
	{
		int num = 30; 
		System.out.println(num);	//采取的是就近原则。
		System.out.println(this.num);	//this访问的就是本类的成员（int num = 20;
		System.out.println(super.num);	//super访问的是父类存储空间的标识（可以理解为父类引用，可以操作父类的成员）
	}
}

class ExtendsDemo 
{
	public static void main(String[] args) 
	{
		Son s = new Son();
		s.show();
	}
}

/*
结果是30，20，10
*/

b / 调用构造方法

this (...)   (表示调用本类的构造方法）

super(....)   (表示调用父类的构造方法）

继承中构造方法的关系：

1 / 子类中所有的构造方法默认都会访问父类中空参数的构造方法

2 / 子类初始化之前，一定要先完成父类数据的初始化。然后才能继承父类中的数据。

3 / 子类的每一个构造方法的第一条语句默认都是：super();

调用构造方法的范例：

class Father
{
	public Father()	//Father无参构造方法
	{
		System.out.println("Father的无参构造方法");
	}

	public Father(String name)	//Father带参构造方法
	{
		System.out.println("Father的带参构造方法");
	}
}

class Son extends Father
{
	public Son()	//son的无参构造方法
	{
		System.out.println("son的无参构造方法");
	}

	public Son(String name)	//son的带参构造方法
	{
		System.out.println("son的带参构造方法");
	}
}


class ExtendsDemo2 
{
	public static void main(String[] args) 
	{
		Son s = new Son();
		System.out.println("------------------------");
		Son s1 = new Son("阿紫");
		
	}
}

/*
结果
Father的无参构造方法
son的无参构造方法
-------------------------
Father的无参构造方法	//说明子类默认访问父类空参数的构造方法
son的带参构造方法
*/

c / 调用成员方法

this . 成员方法  （表示调用本类的成员方法）

super . 成员方法  （表示调用父类的成员方法）

继承中成员方法的关系：

a / 子类中的方法和父类中的方法声明不一样。

b / 子类中的方法和父类中的方法声明一样。

通过子类对象调用方法的顺序：

---1 / 先找子类中看有没有这个方法，有就调用

---2 / 再看父类中有没有这个方法，有就调用，都没有就报错。

——————————————————————————————————————————————————————

方法重写：

子父类中的成员方法的特点：

当子父类中出现成员方法声明一模一样的情况（方法名，参数列表都一样），会运行子类的方法。

这种现象称为方法重写。这是方法在字符类中的特性。

方法的两个特性（仅方法有）

1/重载。同一个类中。（同一个类中，出现的方法名一样，参数列表不同的方法，且与返回值无关。）

2/重写。子类中。覆盖也称为重写，覆写。override  (当子父类中出现成员方法声明一模一样的情况（方法名，参数列表都一样）)

方法重写注意事项：

1/子类方法覆盖父类方法是，子类权限必须要大于等于父类权限。

2/静态函数只能覆盖静态函数，或被静态函数覆盖。

什么时候使用覆盖操作？（方法重写的应用）

当对一个类进行子类的扩展是，子类需要保留父类的功能声明，

但是要定义子类中该功能的特有内容时，就使用覆盖操作完成。

范例：

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

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

class NewPhone extends Phone	//子类内容是对父类的扩展
{
	void show()
	{
	System.out.println("name");
	System.out.println("pic");
	super.show();	//调用了父类的show方法
	}
}

方法重写的注意事项：

a / 父类中的私有方法不能被重写。

b / 子类重写父类方法是，访问权限不能更低。

c / 父类静态方法，子类也必须通过静态方法重写。

练习01：

使用继承前的学生和老师的案例：

/*
老师和学生案例

分析：
学生：
成员变量：名字，年龄
构造函数：无参，有参
成员方法：getXxx（） / setXxx（）

老师
成员变量：名字，年龄
构造函数：无参，有参
成员方法：getXxx（） / setXxx（）

*/

//定义学生类
class Student
{
	String name;
	int age;

	public Student()	//无参构造方法
	{
	}

	public Student(String name ,int age)	//带参构造方法
	{
		this.name = name;
		this.age = age;
	}

	public void setName(String name)
	{
		this.name = name;
	}

	public String getName()
	{
		return name;
	}

	public void setAge(int age)
	{
		this.age = age;
	}

	public int getAge()
	{
		return age;
	}
}

//定义一个老师类
class Teacher	
{
	String name;
	int age;

	public Teacher()
	{
	}

	public Teacher(String name ,int age)
	{
		this.name = name;
		this.age = age;
	}

	public void setName(String name)
	{
		this.name = name;
	}

	public String getName()
	{
		return name;
	}

	public void setAge(int age)
	{
		this.age = age;
	}

	public int getAge()
	{
		return age;
	}
}


class  ExtendsTest_01
{
	public static void main(String[] args) 
	{
		Student s1 = new Student();	//无参构造方法的方式
		s1.setName("阿朱");
		s1.setAge(26);
		System.out.println(s1.getName()+"----"+s1.getAge());

		System.out.println("-------------------------------");

		Student s2 = new Student("阿紫",27);	//带参构造方法的调用方式
		System.out.println(s2.getName()+"----"+s2.getAge());


	}
}

使用继承的学生和老师的案例：

/*
老师类和学生类相同部分向上抽取成person类，然后再继承person类

成员变量：名字，年龄
构造函数：无参
成员方法：getXxx()  /  setXxx()

*/

//定义一个person父类
class Person
{
	private String name;
	private int age;

	public Person()
	{
	}

	public void setName(String name)
	{
		this.name = name;
	}

	public String getName()
	{
		return name;
	}

	public void setAge(int age)
	{
		this.age = age;
	}

	public int getAge()
	{
		return age;
	}
}

//定义一个Student子类继承person父类
class Student extends Person
{
}

//定义要给Teacher子类继承Person父类
class Teacher extends Person
{
}

class ExtendsTest_02 
{
	public static void main(String[] args) 
	{
		Student s = new Student();
		s.setName("自尊宝");
		s.setAge(27);

		System.out.println(s.getName()+"----"+s.getAge());

		System.out.println("----------------------------");

		Teacher t = new Teacher();
		t.setName("紫霞仙子");
		t.setAge(26);

		System.out.println(t.getName()+"----"+t.getAge());

	
	}
}

练习02：

猫狗案例

/*
猫狗案例

猫有自己的特性playGame
狗友自己的特性lookHome

分析：
猫狗具有一致的特性，吃睡，可以定义一个父类进行继承

成员变量：吃，睡
构造函数：带参
成员方法：getXxx()  / setXxx()

不同的特性：

猫有自己的特性playGame
狗友自己的特性lookHome

*/

//定义一个父类，放置相同的共性
class Animal
{
	private String eat;
	private String sleep;

	public Animal(String eat, String sleep)	//定义了一个带参构造方法
	{
		this.eat = eat;
		this.sleep = sleep;
	}

	public void setEat(String eat)
	{
		this.eat = eat;
	}

	public String getEat()
	{
		return eat;
	}

	public void setSleep(String sleep)
	{
		this.sleep = sleep;
	}

	public String getSleep()
	{
		return sleep;
	}
	
}

//定义一个猫的类，继承animal
class Cat extends Animal
{
	public Cat(String eat,String sleep)	//定义了一个带参构造方法
	{
		super(eat,sleep);	//通过super指向父类的带参构造方法
	}

	public void playGame()	//定义一个方法，显示小猫特有的个性
	{
		System.out.println("小猫玩耍");
	}
}

//定义个一个狗的类，继承animal
class Dog extends Animal
{
	public Dog(String eat,String sleep)
	{
		super(eat,sleep);
	}

	public void lookHome()
	{
		System.out.println("小狗看家");
	}
}

class ExtendsTest_03 
{
	public static void main(String[] args) 
	{
		Cat c = new Cat("睡觉","吃鱼");
		System.out.println(c.getEat()+"----"+c.getSleep());
		c.playGame();

		System.out.println("----------------------------");

		Dog d = new Dog("睡觉","吃骨头");
		System.out.println(d.getEat()+"----"+d.getSleep());
		d.lookHome();
	}
}

一个对象的实例化过程：

Person p = new Person();

1/jvm会读取指定路径下的Person.class文件并加载进内存，并会先加载Person的父类（如果有直接父类的情况下）。

2/在对内存中开辟空间，分配地址值。

3/并在对象空间中，对对象中的属性进行默认初始化。

4/调用对应的构造函数进行初始化。

5/在构造函数中，第一行会先调用父类中的构造函数进行初始化。

6/父类初始化完毕后，再对子类的属性进行显示初始化。

7/再进行子类构造函数的特定初始化。

8/初始化完毕后，将地址值赋值给引用变量。