多态的应用

多态的应用

方法:
返回值类型 参数列表 方法名
多态的两种实现方式
使用父类作为方法形参实现多态
使用父类作为方法返回值实现多态

当这个作为参数的父类是普通类或者抽象类时，构成继承多态
当这个作为参数的父类是一个接口时，构成接口多态

多态作为形参
形式参数
基本类型(前面讲过，不解释) 满足类型转换的规则
引用类型
普通类
1.当一个形参希望我们传入的是一个普通类时,我们实际上传入的是该类的对象/匿名对象
抽象类
2.当一个形参希望我们传入的是一个抽象类时,我们实际上传入的是该类的子类对象/子类匿名对象
接口
3.当一个形参希望我们传入的是一个接口时,我们实际上传入的是该类的实现类对象/实现类匿名对象

注意: 当一个方法的形参是引用类型的时候,建议养成一个好的习惯: 做非空判断*/

举例代码如下所示：

public class ArgsDemo01 {
	public static void main(String[] args) {
		// 需求: 访问学生类中的 study方法
		Student s = new Student();
		s.study();
		
		new Student().study();
		// 需求: 访问StudentDemo中的method方法
		StudentDemo sd = new StudentDemo();
//		sd.method(null);
		// 当一个形参希望我们传入的是一个普通类时,我们实际上传入的是该类的对象/匿名对象
		// 习惯: 在写方法的时候,如果方法的形参是引用类型,记住要做非空判断,提高程序的安全性
		
		new StudentDemo().method(new Student() {
			@Override
			public void study() {
				System.out.println("Student 子类 study");
			}
		});
	}
}

class Student {
	public void study() {
		System.out.println("Student.study()");
	}
}

class StudentDemo {
	// Student s = null;
	public void method(Student s) {
		// Student s = new Student();
//		if (s != null) {
//			s.study();
//		}
		
		if (s == null) {
			throw new NullPointerException("对象不能够为null");
		}
		
		s.study();
	}
}

子类匿名对象的格式[匿名内部类]:
new 普通类/抽象类/接口(){
重写方法;
}
1.本质是一个对象
2.这个对象是普通类/抽象类/接口的子类
3.这个对象没有名字
4.这个对象只能够访问一次
举例代码如下：

public class ArgsDemo03 {
	public static void main(String[] args) {
		// 访问StudentDemo中的method方法
		new StudentDemo().method(new MiddleStudent());
		
		new StudentDemo().method(new IStudent() {
			
			@Override
			public void study() {
				System.out.println("IStudent接口实现类 study方法");
			}
			
			@Override
			public void show() {
				System.out.println("IStudent接口实现类 show");
			}
		});
	}
}

class StudentDemo {
	 
	public void method(IStudent s) {
		// IStudent s = new MiddleStudent();
		
		 IStudent s = new IStudent() {
			
			@Override
			public void study() {
				System.out.println("IStudent接口实现类 study方法");
			}
			
			@Override
			public void show() {
				System.out.println("IStudent接口实现类 show");
			}
		}
		 
		s.study();
		s.show();
	}
}

interface IStudent {
	public abstract void study();
	public abstract void show();
}

class MiddleStudent implements IStudent {

	@Override
	public void study() {
		System.out.println("中学生学习");
	}

	@Override
	public void show() {
		System.out.println("MiddleStudent.show()");
	}
	
}

匿名对象
new 类名();

匿名子类对象
new 类名() {};
举例代码如下

public class Test {
	public static void main(String[] args) {
		new Student().method();; // 匿名对象
		new Student() {}.method(); // 这是一个对象,是一个继承了Student类的子类对象,没有名字
		Student s =  new Student() {}; // 这是多态
		
		new Student() {
			public void method() {
				System.out.println("Student子类的method方法");
			};
		};  // 这是一个继承了Student的子类匿名对象,并且这个子类还重写method方法
		
		new Student() {
			public void method() {
				System.out.println("Student子类的method方法");
			};
		}.method(); 
		
		new Student() {
			public void method() {
				System.out.println("Student子类的method方法");
			};
		}.show();
		
		// 利用多态
		Student stu = new Student() {
			
			@Override
			public void show() {
				System.out.println("Student子类的show方法");
			}

			public void method() {
				System.out.println("Student子类的method方法");
			}
		};
		
		stu.show();
		stu.method();
		
		AbsStudent absStudent = new AbsStudent() {

			@Override
			public void show() {
				System.out.println("AbsStudent的子类show方法");
			}

			@Override
			public void method() {
				System.out.println("AbsStudent的子类method方法");
			}
			
		};
		
		absStudent.show();
		absStudent.method();
		
		new IStudents() {
			
			@Override
			public void show() {
				System.out.println("IStudents show");
			}
			
			@Override
			public void method() {
				
			}
		}.show();
	}
}

class Student {
	public void show() {
		System.out.println("show");
	}

	public void method() {
		System.out.println("method");
	}
}

abstract class AbsStudent {
	public abstract void show();

	public abstract void method();
}

interface IStudents {
	public abstract void show();
	public abstract void method();
}