多态的应用 与 内部类
作者：互联网
多态的应用
什么是多态：父类的引用指向了子类的实例
多态的实现方法：
>使用父类作为方法的形参实现多态
>使用父类作为方法的返回值实现多态
继承多态：参数的父类是普通类或者抽象类时
接口多态：参数的父类是一个接口时，构成接口多态
多态作为形参
基本数据类型
基本数据类型作为形参，和值传递没什么区别，不涉及到多态
引用类型
普通类
一个形参希望我们传递的是一个普通类时，我们实际传递的是该类的对象或者匿名对象
public class OOP01 {
public static void main(String[] args) {
Student s = new Student();
Person p = new Person();
p.run(s);
System.out.println("------------");
p.run(new Student());//匿名对象当做实参传递
}
}
class Student{
public void study(){
System.out.println("学习中");
}
}
class Person{
public void run(Student stu){
stu.study();
System.out.println("run方法");
}
}
抽象类
当一个形参希望我们传入的是一个抽象类时，我们实际上传入的是该类的子类对象 或 子类的匿名对象
public class OOP01 {
public static void main(String[] args) {
//多态的体现
Student s = new ABS();
Person p = new Person();
p.run(s);
System.out.println("------------");
p.run(new ABS());//匿名对象当做实参传递
}
}
/**
* 定义的抽象类
*/
abstract class Student{
public abstract void study();
}
class ABS extends Student{
@Override
public void study() {
System.out.println("学习中....");
}
}
class Person{
/**
* 形参要求传递进来一个抽象类型
* @param stu
*/
public void run(Student stu){
stu.study();
System.out.println("run方法");
}
}
接口
当一个形参希望我们传入的是一个接口时，我们实际上传入的是该接口的实现类对象 或 实现类的匿名对象
public class OOP01 {
public static void main(String[] args) {
IStudent s = new Student();
Person p = new Person();
p.run(s);
System.out.println("------------");
p.run(new Student());//匿名对象当做实参传递
IStudent iStudent = new IStudent(){
@Override
public void study() {
System.out.println("接口...");
}
};
p.run(iStudent);
p.run(new IStudent(){
@Override
public void study() {
System.out.println("接口...1");
}
});
}
}
class Student implements IStudent{
public void study(){
System.out.println("学习中");
}
}
interface IStudent{
void study();
}
class Person{
public void run(IStudent stu){
stu.study();
System.out.println("run方法");
}
}
多态作为返回值
基本数据类型
基本数据类型作为返回值，和值传递没什么区别，不涉及到多态
引用数据类型
普通类
当一个方法的返回值是一个普通类，实际返回的就是该类的对象，可以使用该类的对象来接收
public class OOP01 {
public static void main(String[] args) {
Student s = new Student();
Person p1 = s.study();
Person eat = s.eat();
System.out.println(p1);
System.out.println(eat);
}
}
class Person{
}
class Student{
public Person study(){
return new Person();
}
public Person eat(){
Person p = new Person();
return p;
}
}
抽象类
当一个方法返回值是一个抽象类时，实际返回的是该抽象类的子类对象，我们可以使用该抽象类接收。
如果使用该类的子类来接收，需要使用强制类型装换（使用强制类型转换需要注意强制转换的异常）
public class OOP01 {
public static void main(String[] args) {
Student s = new Student();
APerson p1 = s.study();
APerson eat = s.eat();
//自类接收父类发返回需要强制类型转换
Person p3 = (Person) s.study();//强制转换有可能出现异常
if (eat instanceof Person){
Person p4 = (Person)eat;
}
System.out.println(p1);
System.out.println(eat);
}
}
abstract class APerson{
}
class Person extends APerson{
}
class Student{
public APerson study(){
return new Person();
}
public APerson eat(){
return new APerson(){};
}
}
接口
当一个方法返回值是一个接口时，实际返回的是该接口的实现类对象，我们可以使用接口来接收。
如果使用实现类来接收，需要使用强制类型装换（使用强制类型转换需要注意强制转换的异常）
public class OOP01 {
public static void main(String[] args) {
Student s = new Student();
IPerson p1 = s.study();
IPerson eat = s.eat();
//自类接收父类发返回需要强制类型转换
Person p3 = (Person) s.study();//强制转换有可能出现异常
if (eat instanceof Person){
Person p4 = (Person)eat;
}
System.out.println(p1);
System.out.println(eat);
}
}
interface IPerson{
}
class Person implements IPerson{
}
class Student{
public IPerson study(){
return new Person();
}
public IPerson eat(){
return new IPerson(){};
}
}
当方法的返回值类型是引用类型的时候，可以使用链式调用
//链式调用
IPerson p5 = p1.eat().run().sleep();
interface IPerson{
IPerson sleep();
IPerson run();
IPerson eat();
}
class Person implements IPerson{
@Override
public IPerson sleep() {
return this;
}
@Override
public IPerson run() {
return this;
}
@Override
public IPerson eat() {
return this;
}
}
内部类
概念：
将类定义在类的内部，就是内部类
内部类不能被外界直接实例化，还有（抽象类，接口，所有构造方法，被private修饰的类型 ）
为什么要使用内部类
提高类的安全性
内部类的特点
>内部类可以直接访问外部类的所有的成员（变量和方法）
>外部类如果要访问内部类成员，必须创建内部类对象来实现
>内部类编译后的class文件命名有别于普通类：外部类$，内部类.classOu$Inner.class
>访问内部类的成员是非常麻烦的，而且造成程序耦合性增强，可读性降低，所以内部类慎用
搜索
复制
标签：内部,eat,多态,class,Person,应用,Student,new,public 来源： https://www.cnblogs.com/pengtianyang/p/16390547.html