什么是继承

继承类似Adobe After Effects“父级”关系，是上下级关系，父级是顶层类似根目录，子类承上启下。
多个子类可以继承同一个父类，但只能继承一个父类，像金字塔关系。

继承书写格式

关键字：extends
在子类名称的后面写extends在加上父类名称

//子类
public class F22 extends Air{//声明继承Air为父类

}

//父类
public class Air {
	String sort;
	String use;
	public void run() {
	//方法体
	}
}

//main类
public class main {
	public static void main(String[] args) {
		F22 f22 = new F22();//实例化子类
		f22.sort = "喷气式";//可以写入父类数据
		f22.run();//可以调用父类方法
		System.out.println(f22.sort);//可以读取父类数据
	}
}

继承方法重写

当父类里的数据类型或方法与子类重名或相同，以子类的数据或方法为准。

继承里的一些关键字和类的应用

1、super关键字

父类里有有参方法时，无法通过子类向上传入数据，需要通过super关键字上传，
super需要写在子类构造方法里的第一行

//Air父类
public class Air {
	
	public Air(String sort, String use) {
		super();
		System.out.println("访问到了");
	}
}

//F22子类
public class F22 extends Air{

	public F22(String sort, String use) {
		super(sort, use);//super修饰
	}
	
}

//main类
public class main {
	public static void main(String[] args) {
		Air f22 = new Air(null, null);
	}
}

2、final关键字

父类中的 final 不能被继承，不能被子类重写，不能改变值。
声明 final 方法的主要目的是防止该方法的内容被修改。

final dounle a = 3.14;//只能调用，不能重新和更改

3、Object类

Object类中的.equals方法和"=="意义相同
String字符串也是一个类，也有.equals方法，但是字符串类对.equals方法实现了重写

//F22类
public class F22{
	String nick;
	int age;
	String color;
	
	public F22(String nick, int age, String color) {
		this.nick = nick;
		this.age = age;
		this.color = color;
	}
	public boolean equals(F22 d) {//重写.equals方法
		if(this.nick.equals(d.nick) && this.color.equals(d.color) && age == d.age) {
			//在重写的Obj.equals方法进行String的.equals方法比较
			//this.nick.equals(d.nick)含义是对象d1的nick String值与d2的nick String值比较
			return true;
		}else {
			return false;
		}
	}
}

//main方法
public class main {
	public static void main(String[] args) {
		F22 d1=new F22("小黑",2,"黑色");
		F22 d2=new F22("小黑",2,"黑色");
		
		System.out.println(d1.equals(d2));//将d1对象和d2对象传入重写的.equals方法
	}
}

4、抽象类 abstract

抽象类只能被继承，不能被实例化，不能创建对象
抽象类里可以有普通方法，也可以有抽象方法

//F22子类
public class F22 extends Air{
	
	public F22(String nick, int age, String color) {
		this.nick = nick;
		this.age = age;
		this.color = color;
	}
	@Override
	public void Air() {
		//必须在子类实现方法
	}
}

//Air父类
public abstract class Air {
	//抽象类。抽象方法没有方法体
	public abstract void Air();
}

抽象类和抽象方法目的
使得父类更加简洁纯粹，只做规范不做涉及具体内容
方便统一管理，协同开发
抽象类专门为继承而生

接口 interface

属性是全局静态常量
方法必须是public抽象方法
没有构造方法
无法实例化

//Missile接口类
public interface Missile {
	public abstract void fire();//public抽象方法
}

//F22子类
//多接口接入，用","隔开，如：implements Missile,...,...
public class F22 extends Air implements Missile{
	
	@Override
	public void qifei() {//重写抽象父类方法
		System.out.println("起飞");
	}
	@Override
	public void fire() {//重写接口方法
		System.out.println("发射制导导弹");
	}
}

//Air父类
public abstract class Air {//抽象父类
	public abstract void qifei();//抽象方法
}

//main方法
public class main {
	public static void main(String[] args) {
		F22 f22 =new F22();
		f22.qifei();
		f22.fire();
	}
}

多态向上转型和向下转型

多态，简而言之就是同一个行为具有多个不同表现形式或形态的能力。比如说，有一杯水，我不知道它是温的、冰的还是烫的，但是我一摸我就知道了。我摸水杯这个动作，对于不同温度的水，就会得到不同的结果。这就是多态。

向上转型

向上转型是将子类对象转为父类对象使用；实例对象向上传

//F22子类
public class F22 extends Air{
	public void fire() {//2、通过子类重写发射的导弹种类
		System.out.println("发射空空导弹");
	}
}

//J20子类
public class J20 extends Air{
	public void fire() {//2、通过子类重写发射的导弹种类
		System.out.println("发射空地导弹");
	}
}

//Z10类
public class Z10{	
	public void fire(Air fire) {
		System.out.println("开始预警");
	}
}

//Air父类
public abstract class Air {
	public abstract void fire();//1、发射方法可能多态
}

//main方法
public class main {
	public static void main(String[] args) {
		Z10 z10 = new Z10();
		F22 f22 = new F22();
		J20 j20 = new J20();

		z10.fire(f22);
		z10.fire(j20);
	}
}

instanceof和向下转型

向下转型是将父类对象转为子类对象使用；
instanceof判断一个对象是否为一个类的实例
实例对象向下传

//F22子类
public class F22 extends Air{
	public void fire() {
		System.out.println("发射空空导弹");
	}
	public void load() {
		System.out.println("开始装弹");
	}
}

//J20子类
public class J20 extends Air{
	public void fire() {
		System.out.println("发射空地导弹");
	}
}

//Z10类
public class Z10{	
	public void fire(Air fire) {
		System.out.println("开始预警");
		
		if(fire instanceof F22) {//判断传入对象是否正确
			System.out.println("传进来的是F22");
			((F22) fire).load();//拿到对象特有方法
			F22 f22 = (F22)fire;//((F22) fire).load();方法实现过程1
			f22.load();//((F22) fire).load();方法实现过程2
		}else {
			System.out.println("传进来的不是F22");
		}
	}
}

//Air父类
public abstract class Air {
	public abstract void fire();
}

//main方法
public class main {
	public static void main(String[] args) {
		Z10 z10 = new Z10();
		F22 f22 = new F22();
		J20 j20 = new J20();
		
		z10.fire(f22);//1、向下传入实例对象
	}
}