多态和抽象类

多态

1.要实现多态，那么必须存在父子关系（继承关系或者实现接口）
2.实现多态的方式：将父类对象的声明指向子类对象，例如Pet pet = new Dog();

例如：

/*
	这是一个类名为Pet的父类
*/
public class Pet {
	public void print() {
		System.out.println("----调用Pet父类的print方法-----");
	}
}

/*
	这是类名为Dog的第一个子类
*/
public class Dog extends Pet{
	public void print() {
		System.out.println("-----调用Dog子类的print方法-----");
	}
}

/*
	这是类名为Cat的第二个子类
*/
public class Cat extends Pet{
	public void print() {
		System.out.println("-----调用Cat子类的print方法----");
	}
}

/*
	这是类名为Test的测试类
*/
public class Test {
	public static void main(String[] args) {
		
		Dog dog = new Dog();
		dog.print();
		//这里的输出结果为：（-----调用Dog子类的print方法-----）
		Cat cat = new Cat();
		cat.print();
		//这里输出的结果为：（-----调用Cat子类的print方法----）
		Pet pet = new Pet();
		pet.print();
		//这里输出的结果为：（-----调用Pet父类的print方法----）

		//这里使用多态方法，将父类对象的声明指向子类对象
		Pet pet1 = new Dog();
		pet1.print();
		//这里输出的结果为：（-----调用Dog子类的print方法-----）
	}
}

3.向上转型：向上转型就是将子类对象赋值给父类对象的过程
4.实现多态以后，从表面上看调用的是父类的方法，实际调用的是子类覆盖掉父类的方法

public class Test {
	public static void main(String[] args) {
		//这就是向上转型
		Pet pet1 = new Dog();
		//实现多态以后，从表面上看调用的是父类的方法，实际调用的是子类覆盖掉父类的方法
		
		pet1.print();
		//这里输出的结果为：（-----调用Dog子类的print方法-----）
	}
}

5.向下转型：向下转型就是将多态的父类对象强制转换成子类对象的过程
6.当需要调用子类独有的方法和属性的时候，必须向下转型

public class Cat extends Pet{
	public void print() {
		System.out.println("-----调用Cat子类的print方法----");
	}
	//这是一个子类独有的方法
	public void printCat() {
		System.out.println("----我是一只猫----");
	}
}

public class Test {
	public static void main(String[] args) {
		//这就是向上转型
		Pet pet2 = new Cat();
		//这就是向下转型
		Cat cat2 = (Cat)pet2;
		//当需要调用子类独有的方法和属性的时候，必须向下转型
		
		cat2.printCat();
		//输出的结果为：（----我是一只猫----）
		cat2.print();
		//输出的结果为：（-----调用Cat子类的print方法----）
	}
}

注意：

7.通过instanceof判断当前的pet2对象是否是Dog对象，如果是返回值为true，否则返回值为false
8.报错信息为：（Exception in thread “main” java.lang.ClassCastException: com.four.Pet cannot be cast to com.four.Cat at com.four.Test.main(Test.java:18))

这是当时遇到的一个报错，需要特别注意。解决方法如下：

错误代码为：

public class Test {
	public static void main(String[] args) {
	Pet pet2 = new Cat();
	Dog dog2 = (Dog)pet2;
	dog2.print();
	}
}	

修改后的正确代码为：

public class Test {
	public static void main(String[] args) {
		Pet pet2 = new Cat();
		
		//通过instanceof判断当前的pet2对象是否是Dog对象，如果是返回值为true，否则返回值为false
		if(pet2 instanceof Dog) {
			Dog dog2 = (Dog)pet2;
			dog2.print();
		}else if(pet2 instanceof Cat) {
			Cat cat2 = (Cat)pet2;
			cat2.print();
		}
	}
}	

抽象类

1.抽象类的语法格式：修饰符 abstract class 类名{类体}
2.定义抽象方法的格式：修饰符 abstract 返回值类型 方法名（参数列表）
3.抽象类中可以定义普通方法，也可以定义抽象方法，普通类中不能定义抽象方法
4.抽象类中可以定义构造方法，普通类也可以，当一个普通类继承了抽象类之后，该普通类必须实现抽象类中的抽象方法

/*
	这是一个类名为Animal的抽象类
*/
public abstract class Animal {
	//这是定义的一个变量
	public String name;
	//这是一个名为print的普通方法
	public void print() {
		System.out.println("-----我的print方法-----");
	}
	//这是一个名为method的抽象方法
	public abstract void method();
	//这是一个无参的构造函数
	public Animal() {
		
	}
	//这是一个有参的构造函数
	public Animal(String name) {
		this.name = name;
	}
}

5.抽象类不能直接创建对象，如果要创建对象，则必须是多态的方式创建。

例如

错误案例，这样写会直接报错。

/*
	这是一个类名为Test的测试类
*/
public class Test {
	public static void main(String[] args) {
		Animal animal = new Animal();
	}
}

真确案例：

/*
	创建一个类名为Bird
*/
public class Bird extends Animal{

	public void method() {
		System.out.println("-----我是一只小鸟，我会飞------");
	}
	
}

public class Test {
	public static void main(String[] args) {
		//利用多态的方式创建抽象类的对象
		Animal animal = new Bird();
		animal.method();
	} 
}

6.抽象类中的方法不能用private、final修饰，因为抽象类中的方法是用来被继承的。

总结

抽象类的目的就是：抽象类的作用类似于“模板”，其目的是方便开发人员根据抽象类的格式来修改和创建新类。抽象类主要用于继承，有利于程序的扩展。