ICode9

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

多态的应用 与 内部类

2022-06-19 15:35:39  阅读:113  来源: 互联网

标签:内部 eat 多态 class Person 应用 Student new public


多态的应用

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

多态的实现方法:

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

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

继承多态:参数的父类是普通类或者抽象类时

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

 

多态作为形参

基本数据类型

基本数据类型作为形参,和值传递没什么区别,不涉及到多态

引用类型

普通类

一个形参希望我们传递的是一个普通类时,我们实际传递的是该类的对象或者匿名对象

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

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

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

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

ICode9版权所有