抽象类、接口和多态

1.abstract:抽象的，扩展修饰符。修饰类，方法。
1.1：抽象类：用abstract修饰的类叫抽象类。
1.1.1：抽象类的适用场景：当一个类创建对象没有任何意义时，这个类就可以定为抽象 类；当类中有一个方法无法确定具体实现时，这个方法就可以定为抽象方法，这 个类只能定为抽象类。
1.1.2：抽象类的特征：
1.1.2.1：抽象类不能实例化（抽象类不能New对象）。
1.1.2.2：抽象类有构造方法，作用是为了让子类去调用。
1.1.2.3：抽象类中可以有0个到多个抽象方法，也可以有0个到多个实例方法。
1.1.3：抽象类的作用：作为父类，实现代码复用；通过抽象方法规定子类必须拥有的行 为。

1.2：抽象方法：用abstract修饰的方法叫抽象方法。
1.2.1：抽象方法适用场景：当一个方法无法确定具体实现时，这个方法就可以定为抽象方 法。
1.2.2：抽象方法的特征：
1.2.2.1：抽象方法没有方法体，连方法的大括号都没有。
1.2.2.2：抽象方法必须被子类重写，除非子类也是抽象类。
1.2.2.3：抽象方法必须写在抽象类中。
1.2.3：抽象方法的作用：规定子类必须拥有的行为。

	eg:/**
 * 宠物类，抽象类
 * @author sx
 * @version 1.0 2019年6月27日
 */
public abstract class Pet{
	/**
	 * 昵称
	 */
	public String nickName;
	/**
	 * 性别
	 */
	public char sex;

	/**
	 * 抽象方法
	 */
	public abstract void wow() ;
	
	/**
	 * 自我介绍的方法，实例方法
	 * 方法
	 */
	public void showMyself() {
		System.out.println("昵称："+nickName+",性别为："+sex);
	}
}

/**
 * 狗类，继承宠物类
 * @author sx
 * @version 1.0 2019年6月27日
 */
public class Dog extends Pet{
	/**
	 * 重写父类叫声的抽象方法
	 */
	@Override
	public void wow() {
		System.out.println("狗在旺旺旺的叫");
		
	}
}

2.接口：是一种特殊的抽象类。表示一种约定，也表示一种扩展功能。
2.1：接口的作用：提高程序的可扩展性。
2.2：声明接口的关键字：interface
实现接口的关键字：implements
2.3：接口的特征：
2.3.1：接口不能实例化（接口不能New对象）。
2.3.2：接口中没有构造方法。
2.3.3：接口中方法全是抽象方法，接口中变量全是静态常量。（在jdk1.8后，接口中可以 有静态方法）
2.3.4：接口中方法默认会加上public abstract,接口中所有的变量会默认加上public static final.
2.3.5：类与类之间是继承的关系，类与接口之间是实现关系，接口与接口之间是继承关 系，一个接口可以继承多个接口。
如果一个类既有父类又有父接口，先继承父类再实现父接口。
一个类只能继承一个父类，但是可以实现多个接口（从这个角度来说，接口在某 种程序上弥补Java单继承的缺陷）。
2.3.6：接口中所有的方法必须让子类去重写，除非子类也是抽象类或接口。

	eg:/**
 * 宠物类，抽象类
 * @author sx
 * @version 1.0 2019年6月27日
 */
public abstract class Pet{
	/**
	 * 昵称
	 */
	public String nickName;
	/**
	 * 性别
	 */
	public char sex;

	/**
	 * 抽象方法
	 */
	public abstract void wow() ;
	
	/**
	 * 自我介绍的方法，实例方法
	 * 方法
	 */
	public void showMyself() {
		System.out.println("昵称："+nickName+",性别为："+sex);
	}
}

/**
 * 爬树的接口
 * @author sx
 * @version 1.0 2019年6月27日
 */
public interface ClimpTree {
	/**
	 *  爬树的抽象方法
	 */
	public void cilmpTree2();
}

/**
 * 玩球的接口
 * @author sx
 * @version 1.0 2019年6月27日
 */
public interface PlayBall {
	/**
	 * 	 玩球的方法
	 */
	public void playBall2();
}

/**
 * 猫类，继承宠物类
 * @author sx
 * @version 1.0 2019年6月27日
 */
public class Cat extends Pet  implements ClimpTree,PlayBall{
	/**
	 * 重写父类叫声的抽象方法
	 */
	@Override
	public void wow() {
		System.out.println("猫在喵喵的叫");
	}

	/**
	 * 实现父接口中爬树的功能
	 */
	@Override
	public void cilmpTree2() {
		System.out.println("猫在爬树");
	}

	/**
	 * 重写父接口玩球的 方法
	 */
	@Override
	public void playBall2() {
		System.out.println("猫在玩球");
	}
}

练习一：诺基亚手机，打电话，接电话
华为手机，打电话，接电话，听音乐，
小米手机，打电话，接电话，听音乐，玩游戏
苹果手机， 打电话，接电话，上网，玩游戏
在测试类中创建每个手机的对象调用方法

练习二：门类有开和关的功能
木门：用脚揣开，用脚勾一下关
铁门：用钥匙打开，用钥匙关
防盗门：用钥匙打开，用钥匙关 ，指纹识别
超级防盗门：用钥匙打开，用钥匙关 ，指纹识别，人脸识别

3.接口 VS 抽象类
3.1：相同点：
3.1.1：都不能实例化。
3.1.2：都可以有抽象方法。

3.2：不同点：
3.2.1：作用不同：接口的作用提高程序可扩展性。抽象类的作用实现代码复用，规定子类 必须拥有的行为。
3.2.2：接口没有构造方法，抽象类有构造方法。
3.2.3：接口中方法全是抽象方法，接口中变量全是静态常量；
抽象类中可以0到多个抽象方法也可以有0到多个实例方法，抽象类中变量可以是普 通变量，也可以静态常量。
3.2.4：一个类只能继承一个抽象类；但是一个类可以实现多个接口。
3.2.5：接口中抽象方法可以不写abstract关键字;抽象类中抽象方法必须写abstract;

4.接口隔离原则（ISP）：一个接口只被设计一种功能。

5.多态：
5.1：多态的定义：
5.1.1：生活中多态：同一种事物，由于外界条件不同，而产生不同操作。
5.1.2：程序中多态：用父类或父接口作为数据类型，指向不同的子类而执行不同的操作就 叫多态。
5.2：多态的应用：
5.2.1：用父类或父接口作为数据类型，创建一个子类对象，调用子类对象重写的父类的方 法，执行不同的操作。

	eg:public static void main(String[] args) {
		//第一种：创建对象,用父类作为数据类型，创建子类对象，调用重写的方法，执行不同的操作，这就是多态
		Pet p1=new Dog();
		p1.wow();
		
		Pet p2=new Cat();
		p2.wow();
}

		5.2.2：用父类或父接口作为方法的形参，实参传递是子类对象，执行不同操作。
			eg：/**
 * 主人类
 * @author sx
 * @version 1.0 2019年6月27日
 */
public class Master {
	/**
	 * 主人给宠物喂食方法，用父类作为方法的形参，实参传递不同的子类对象，而执行不同吃的方法，这就是多态
	 * @param p
	 */
	public void feed(Pet p) {
		System.out.println("主人在喂食");
		p.eat();
	}
}

	public static void main(String[] args) {
		//第二种：用父类作为方法的形参，实参传递不同的子类对象，而执行不同吃的方法，这就是多态
		//创建对象
		Dog d1=new Dog();
		Cat c1=new Cat();
		
		Master m=new Master();
		m.feed(d1);
		System.out.println("----------------------");
		m.feed(c1);				
	}

		5.2.3：用父类或父接口作为方法返回值类型，实际返回的是不同子类对象，而执行不同的					认操作。
				eg:/**
	 * 主人领宠物给客人看的方法
	 * 用父类作为方法返回值类型，实际返回的子类的对象，而执行不同的操作，这就是多态
	 * @param type
	 * @return
	 */
	public Pet getPet(String type) {
		//声明变量
		Pet p1=null;
		if (type.equals("猫")) {
			p1=new Cat();
		}else if(type.equals("狗")) {
			p1=new Dog();
		}
		return p1;
  }

5.3：多态的作用：提高程序的可扩展性，可维护性。

6.引用数据类型的转换
6.1：向上转型：将小类型转换为大类型或将子类转换为父类型，自动转换，叫作向上转型。

eg://创建对象,将小类型的狗和猫类转换成大类型的宠物类。
			Pet p1=new Dog();
			Pet p2=new Cat();

6.2：向下转型：将父类类型的数据转换为数据原本子类类型。
	6.2.1：语法：子类数据类型 变量名=（子类数据类型）父类对象；
	6.2.2：向下转型的适用场景：用父类或父接口作为数据类型，存子类对象时，
				这个对象只能调用从父类或父接口继承过来或重写的方法，
				不能调用子类独有方法，如果想调用子类独有方法，就需要向下转型。
			eg:Pet p1=new Dog();
			   	 Dog d1=(Dog)p1;
				d1.lookDoor();
	6.2.3：向下转型有风险：必须将父类转换成原来的子类类型，如果转换为其他的子类类型						就会类型转换异常。
		   解决向下转型的风险：在向下转换前对变量或对象作数据类型判断
		   语法： boolean result= 对象名 instanceof 数据类型
		   eg：//创建对象,将小类型的狗和猫类转换成大类型的宠物类。
				Pet p1=new Dog();
			  Pet p2=new Cat();
				//如果想调用子类独有方法，将父类型的对象转换为子类本身类型
	//对引用数据类型作判断 boolean result= 对象名 instanceof 类型
	if(p1 instanceof Dog) {
		Dog d1=(Dog)p1;
		d1.lookDoor();
	}else if(p1 instanceof Cat) {
		Cat c1=(Cat) p1;
		c1.climpTree();
	}