ICode9

精准搜索请尝试: 精确搜索
首页 > 其他分享> 文章详细

多态的应用和内部类讲解

2022-06-19 15:36:01  阅读:124  来源: 互联网

标签:study 多态 System Person 应用 讲解 println public out


多态的应用

什么是多态:父类的引用指向了子类的实例

 

多态的实现方法:

1.使用父类作为方法的形参实现多态

2.使用父类作为方法的返回值实现多态

 

 

继承多态:当这个作为参数的父类是普通类或者抽象类时

接口多态:当这个作为参数的父类是一个接口时,构成接口多态

 

多态作为行参

 1、普通类

 当一个行参希望我们传递的是一个普通类时,我们实际传递的是该类的对象/匿名对象

public class OOPDemo01 {
    public static void main(String[] args) {
        Student student = new Student();
        Person person = new Person();
        person.run(student);
        System.out.println("=====");
        person.run(new Student());
    }
}
class Student{
    public void study(){
        System.out.println("学习");
    }
}
class Person{
    public void run(Student s){
        s.study();
        System.out.println("run");
    }
}

 2、抽象类

  当一个参数希望我们传入的是一个抽象类时,我们实际上传入的是该类的子类对象或者子类的匿名对象

package com.example.ObjectOriented.Interface1.pp9;

public class OOPDemo01 {
    public static void main(String[] args) {
        //多态的体现
        AbsStudent student = new Student();
        Person person = new Person();
        person.run(student);
        System.out.println("======");
        person.run(new Student());
        System.out.println("=======");
        AbsStudent absStudent = new AbsStudent(){
            @Override
            public void study() {
                System.out.println("xxxxxxxx");
            }
        };
        person.run(absStudent);
        System.out.println("=======");
        //匿名内部类
        person.run(new AbsStudent(){
            @Override
            public void study() {
                System.out.println("xxxxxxxx");
            }
        });
    }
}
abstract class AbsStudent{
    public abstract void study();
}
class Student extends AbsStudent{

    @Override
    public void study() {
        System.out.println("学习");
    }
}
class Person{
    public void run(AbsStudent s){
        s.study();
        System.out.println("run");
    }
}

 

 3、接口

 当一个参数希望我们传入的是一个接口时,我们实际上传入的是该接口的实现类对象或者实现类匿名对象

public class OOPDemo01 {
    public static void main(String[] args) {
        //多态的体现
        IStudent student = new Student();
        Person person = new Person();
        person.run(student);
        System.out.println("======");
        person.run(new Student());
        System.out.println("=======");
        IStudent absStudent = new IStudent(){
            @Override
            public void study() {
                System.out.println("xxxxxxxx");
            }
        };
        person.run(absStudent);
        System.out.println("=======");
        //匿名内部类
        person.run(new IStudent(){
            @Override
            public void study() {
                System.out.println("xxxxxxxx");
            }
        });
    }
}
class Student implements IStudent{
    public void study(){
        System.out.println("学习");
    };
}
interface IStudent{
    void study();
}
class Person{
    public void run(IStudent s){
        s.study();
        System.out.println("run");
    }
}

 

多态作为返回值

1、普通类

当一个方法的返回值是一个普通类,实际返回的就是该类的对象,我们可以使用该类的对象类接收

public class OOPDemo02 {
    public static void main(String[] args) {
        Studnet studnet = new Studnet();
        Person study = studnet.study();
        System.out.println(study);
        Person eat = studnet.eat();
        System.out.println(eat);
    }
}
class Person{

}
class Studnet{
    public Person study(){
        return new Person();
    }
    public Person eat(){
        Person person = new Person();
        return person;
    }
}

 

2、抽象类

当一个方法的返回值是一个抽象类时,实际返回的是该抽象类的子类对象,我们可以使用该抽象类接收。

package com.example.ObjectOriented.Interface1.ppp9;

public class OOPDemo02 {
    public static void main(String[] args) {
        Studnet studnet = new Studnet();
        AbsPerson study = studnet.study();
        //子类的接收,父类的返回,那么就需要强制类型转换
        Person study1 = (Person) studnet.study();

        System.out.println(study);
        AbsPerson eat = studnet.eat();
        if (eat instanceof Person){
            Person p4 = (Person) eat;
        }
        System.out.println(eat);
    }
}
abstract class AbsPerson{

}
class Person extends AbsPerson{

}
class Studnet{
    public AbsPerson study(){
        return new Person();
    }
    public AbsPerson eat(){
//        Person person = new Person();
        return new AbsPerson(){};
    }
}

 

3、接口

当一个方法的返回值是一个接口时,实际返回是该接口的实现类对象,我们可以使用接口来接收,

同样的如果我们使用实现类来接收的,那么同样有可能出现异常的问题,也就是强制类型转换的异常

package com.example.ObjectOriented.Interface1.ppp9;

public class OOPDemo02 {
    public static void main(String[] args) {
        Studnet studnet = new Studnet();
        IPerson study = studnet.study();
        IPerson eat = studnet.eat();
        //子类的接收,父类的返回,那么就需要强制类型转换
        IPerson study1 = (Person) studnet.study();
        if (eat instanceof Person){
            Person p4 = (Person) eat;
        }
        System.out.println(study);
        System.out.println(eat);
    }
}
interface IPerson{

}
class Person implements IPerson{

}
class Studnet{
    public IPerson study(){
        return new Person();
    }
    public IPerson eat(){
        return new IPerson(){};
    }
}

 

 

内部类讲解

相关概念

将类定义在类的内部,那么该类就称为内类

注意:内部类是一个相对的概念,如果Qutter类中有一个类Inner类,那么Otter类相对于Inner类来说就外部类,而inner相对于Outter来说就是内部类

内部类不能让外界进行实例化

 

特点:

1、内部类可以直接访问外部类的所有成员(变量和方法)

2、外部类如果要内部类成员,必须创建内部类对象来实现

3、内部类编译后的class文件命名有别于普通类:外部类$内部类.class

4、要访问内部类的成员是非常麻烦的,而且造成程序耦合性增强,可读性降低,所以内部类慎用

 

内部类分为:成员内部类、局部内部类、静态内部类、匿名内部类

 

标签:study,多态,System,Person,应用,讲解,println,public,out
来源: https://www.cnblogs.com/xjw12345/p/16390545.html

本站声明: 1. iCode9 技术分享网(下文简称本站)提供的所有内容,仅供技术学习、探讨和分享;
2. 关于本站的所有留言、评论、转载及引用,纯属内容发起人的个人观点,与本站观点和立场无关;
3. 关于本站的所有言论和文字,纯属内容发起人的个人观点,与本站观点和立场无关;
4. 本站文章均是网友提供,不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属;如您发现该文章侵犯了您的权益,可联系我们第一时间进行删除;
5. 本站为非盈利性的个人网站,所有内容不会用来进行牟利,也不会利用任何形式的广告来间接获益,纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

专注分享技术,共同学习,共同进步。侵权联系[81616952@qq.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有