day07

多个类中存在相同的属性和行为时，将这些内容抽取到单独一个类中，那么多个类无需在定义这些属性和行为，只要继承那个类即可

public class 子类名 extends 父类名{}

（1）好处：提高代码的复用性；提高了代码的维护性；让类与类直接产生了关系，是多态的前提
（2）坏处：让类与类产生了关系，增加了耦合
开发的原则：低耦合高内聚，内聚就是自己完成某件事情的能力

（1） java中的继承不支持多继承只支持单继承，即：
public class Son extends Father,Grandfather{} //报错
（2）java中的继承支持多层继承，即：
Father先继承Grangdfather，然后Son再继承Father

当子类的成员变量和父类的成员变量名字相同时，就近原则，此时：
A、在方法的局部范围找，如果有就使用
B、在子类的成员范围找，如果有就使用
C、在父类的成员范围找，如果有就使用
d、如果还找不到，就报错
public class Student extends Father{
	public int age = 14;
	public void printAge(){
	int age = 10;
	system.out.println(age) //此时age先在printAge()方法内找，若没找到age，则在class Student类找，若还是找不到，则在Father里找。
	}
}

有几种情况：
1、父类有无参构造方法，子类不管有没有构造方法，此时在main函数中使用子类的成员方法会先执行父类的无参构造方法
2、父类只有有参构造方法，子类不管有没有构造方法，此时在main函数中使用子类的成员方法会报错
3、子类和父类都不写构造方法，不报错

java继承中构造方法的访问特点：
（1）子类构造方法执行之前，会先执行父类的无参构造方法
	原因：因为子类继承父类，会继承父类的非私有成员。而子类在初始化的时候，可能会使用父类的数据，如果父类数据没有先初始化，子类就不能使用这些数据，所以，在子类初始化之前，一定要先完成父类数据的初始化。
问题：假如父类中没有无参构造方法但是有有参构造方法，怎么办呢?
	A:在父类中添加一个无参构造方法。
	B:可以通过super去访问父类的带参构造方法。
	public Son(){
		super(15); //父类的有参构造方法：public Father(int age){}
		System.out.println("son的无参构造方法");
	}
	建议使用第一种解决方案，其实就是要求我们写代码的时候，每次都手动的给出无参构造方法。

a:在子类中找，有就使用
b:在父类中找，有就使用
c:如果没有就报错

public class Teacher {
public int age = 48;}
public class Student extends Father{
	public int age = 14;
	public void printAge(){
	int age = 10;
	system.out.println(this.age) //我想打印出14，不想打印出10
	system.out.println(super.age) //我想打印出48，不想打印出10

this和super均可如下使用：
A 访问成员变量
	this.成员变量
	super.成员变量
B 访问构造方法
	this(...)
	super(...)
C 访问成员方法
	this.成员方法()
	super.成员方法()

1、定义：子类中出现了和父类中一模一样的方法声明的情况
2、应用场景：
当子类需要父类的功能，而功能主体子类有自己特有的内容时，
可以重写方法，如下例中newphone的call既保证了phone中的功能，又有自己独特的功能
3、注意事项
--父类中私有方法不能被重写；
--子类重写父类方法时，访问权限不能更低，建议访问权限一摸一样
--@Override表示这个方法是重写父类的方法
注：访问权限 private < 默认修饰符 < public 
private void show() < void show() < public void show()
//父类
public class Phone {
	public void call(String name){
		System.out.println("给"+name+"打电话");
	}
}
//子类
public class Newphone extends Phone{
	public void call(String name){
		System.out.println("开启视频功能");
		super.call(name); //重写父类的打电话功能
	}
}

某一个事物，在不同时刻表现出来的不同状态，如水在不同温度下，有不同的形态

–有继承关系
–有方法重写
–有父类引用指向子类对象
Fu f = new Fu(); 左边叫引用，右边叫对象
Zi z = new Zi();
Fu f = new Zi(); 

成员变量访问特点：
——编译看左边，执行看左边，编译的意思是还没运行代码
成员方法访问特点：
——编译看左边，执行在右边
为什么成员变量和成员方法的访问不一样呢?
因为成员方法有重写，而变量没有。
Animal a = new Cat();
System.out.println(a.age); 输出的是animal中的age
System.out.println(a.weight); 因animal中没有weight成员变量，所以编译时报错
a.eat(); 输出的时cat中的eat
a.playGame(); 因animal中没有playgame方法，所以编译时报错

多态的好处：提高了程序的扩展性
具体体现：定义方法的时候，使用父类型作为参数，将来在使用的时候，使用具体的子类型参与操作。
public class Animal{ //父类animal
	public void eat(){
	system.out.println("animal eat")
	}
}
public class Cat extends Animal{ //子类cat
	public void eat(){
	system.out.println("cat eat")
	}
}
public class Animaloperate(){
	public void useanimal(cat c){ //Cat c = new Cat()
	c.eat();
	}
	public void useanimal(dog d){ //dog d = new Dog()
	d.eat();
	} 
	// 如果我有很多给子类，那我需要创建很多个这个,只需写以下方法即可无需重复写以上内容
	public void useanimal(Animal a){ //Animal a = new Dog()
	a.eat();
}
测试类：
Animaloperate a = new Animaloperate()
Cat c = new Cat()
Dog d = new Dog()
a.useanimal(c); // cat eat
d.useanimal(d);// dog eat
多态的弊端：不能使用子类的特有功能

多态的弊端：无法访问子类特有方法
要想访问需要多态转型

向上转型
	从子到父
		父类引用指向子类对象
向下转型
	从父到子
		父类引用转为子类对象
Animal a = new Cat(); //向上转型
Cat c = (Cat)a; //向下转型

main函数：
//向上转型
Animal a = new Cat();
a.eat(); //猫吃鱼
//向下转型
Cat c = (Cat) a;
c.eat() //猫吃鱼
c.palyGame() //猫捉迷藏
//向上转型
a = new Dog();
a.eat() //狗吃骨头
//向下转型
Cat cc = (Cat) a; //ClassCastException类型转化异常
cc.eat()
cc.palyGame()