java学习基础课之面向对象继承（渡一教育）（七）多态和内部类

最新推荐文章于 2022-02-11 13:48:15 发布
最新推荐文章于 2022-02-11 13:48:15 发布
阅读量473 收藏 4
点赞数 1
分类专栏： java学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43384257/article/details/103445853
版权

Java面向对象的四大特性
继承 封装 多态 (抽象)

一 多态

同一个对象， 体现出来的多种不同形态(身份) ， 将一种行为表现出不同的效果。
要想实现多态的效果 ，需要现有继承关系。
体现:

  1. 父类类型的引用 指向 子类的对象
    Person p = new Teacher();

  2. 该引用只能调用父类中定义的属性或方法

  3. 如果子类中将父类的方法重写，那么调取方法后执行的结果是子类重写之后的那个结果。

    如果父类与子类有同名的属性---------执行父类的属性
    如果父类与子类有同名的方法(重写)----执行子类重写之后的方法

  4. 若想要调用子类中独有的成员
    (强制类型转化) 造型 铸型 (向上/向下转型)
    Teacher tt = (Teacher)p;

  5. 造型时(强制向下转型时) 可能会出现一个运行时异常
    ClassCastException 造型 铸型 异常
    可能因为同级别强制类型转换，就会异常，只有父类和子类才可以造型强制类型转换。
    如果想要避免造型的异常，可以用instance of关键字来进行判断
    对象 instanceof 类

if(o instanceof Person){//对象是否属于后面类型
            System.out.println("类型匹配  可以造型");
            Student s = (Student)o;//运行时异常 ClassCastException
            s.study();
        }else{
            System.out.println("对不起 类型不匹配 不帮您造型啦 否则会出问题");
        }

多态例子：
Person类：

public class Person {
    public String name = "person的name属性";

    public void eat(){
        System.out.println("person的吃饭方法");
    }
    public void sleep(){
        System.out.println("人类的睡觉方法");
    }
    public void talk(){
        System.out.println("人类的说话方法");
    }
}

Teacher类：

public class Teacher extends Person {
    public String name = "teacher的name属性";
    public void eat(){  // 重写
        System.out.println("做老师的通常不按时吃饭");
    }

    public void teach(){  // 独有方法
        System.out.println("做老师的独有方法 一般人不会讲课 我会");
    }
}

主方法：

public class Test {
    public static void main(String[] args){
        // Teacher 对象
        Teacher t=new Teacher();
        t.sleep();
        t.talk();
        t.eat(); //重写的方法
        t.teach(); //独有的方法
        System.out.println("----------------------------");
        /*
        人类的睡觉方法
		人类的说话方法
		做老师的通常不按时吃饭
		做老师的独有方法 一般人不会讲课 我会
		----------------------------
		*/

        // 多态，让老师作为另一种身份-------人类的方法
        Person p = new Teacher();  //此时，这个老师体现的是一个人的身份，不能使用老师的重写和独有方法了
        p.talk();
        p.sleep();
        p.eat();  // 做老师的通常不按时吃饭
        // 如果子类中将父类的方法重写，那么调取方法后执行的结果是子类重写之后的那个结果
        //p.teach();  //报错，不能使用，老师独有的方法了
        System.out.println(p.name);
        //如果父类与子类有同名的属性-----执行父类的属性
        System.out.println("----------------------------");
        /*
        人类的说话方法
		人类的睡觉方法
		做老师的通常不按时吃饭
		person的name属性
		----------------------------
        */

        //如果想要调用子类独有的属性或方法
        //需要将类型还原会真实类型    强制类型转化  造型  向上转型  向下转型
        Teacher tt = (Teacher)p;  //这次还是那个人，只不过，现在体现的是老师的身份
        tt.teach();
        System.out.println(tt.name);
        /*
        做老师的独有方法 一般人不会讲课 我会
		teacher的name属性
        */
    }
}

输出结果：

人类的睡觉方法
人类的说话方法
做老师的通常不按时吃饭
做老师的独有方法 一般人不会讲课 我会
----------------------------
人类的说话方法
人类的睡觉方法
做老师的通常不按时吃饭
person的name属性
----------------------------
做老师的独有方法 一般人不会讲课 我会
teacher的name属性

多态实例：

银行Bank
		设计一个方法 等待用户来办理业务
		profession(需要一个人)
			叫一个号码-->排队
			去窗口办理-->办理
			办理完毕离开->离开
	老人   年轻   土豪

首先分析两者之间的关系，

  • A is-a B 继承
  • A has-a B 包含， 整体和部分的关系。通过一个类的对象当做另一个类的属性来存储。一个类当中有另一个类作为属性。车有轮子。
  • A use-a B 依赖，不是整体和部分的关系。某一件事情产生了关系；临时组合在一起，这件事情一旦做完关系即解散。某一种方法使用另一个类的对象。农夫养猪。

银行处理业务的方法，需要人来介入其中，所以是某种方法将他们组合在了一起，是一种依赖关系。
先根据依赖关系写一下各个类以及方法：

  • OldMan的类：
package Bank;

public class OldMan {
    private String name;
    //两个构造方法
    public OldMan(){}
    public OldMan(String name){
        this.name=name;
    }
    public void setName(){
        this.name = name;
    }
    public String getName(){
        return this.name;
    }

    //1.进银行 叫一个号码 排队
    public void callNumber(){
        System.out.println("年事已高 不知道在哪儿叫号 请求大堂经理的帮忙");
    }
    //2.去窗口办理
    public void transact(){
        System.out.println("到窗口 掏出手绢儿 拿出存折 取钱");
    }
    //3.办理完毕离开啦
    public void leave(){
        System.out.println("办理完毕 慢慢的离开啦");
    }
}

Bank类：

package Bank;

public class Bank {
    //开门 等待用户进来办理业务
    public void profession(OldMan om) {  //某一个方法使用了另一个类的对象
        System.out.println(om.getName() + "客户进入银行啦");
        om.callNumber();
        om.transact();
        om.leave();
    }
}
  • 主方法测试一下：
package Bank;

public class Test {
    public static void main(String[] args){
        Bank bank = new Bank();
        OldMan om = new OldMan("长者");
        bank.profession(om);//银行欢迎长者进来办理业务
    }
}
  • 结果：
长者客户进入银行啦
年事已高 不知道在哪儿叫号 请求大堂经理的帮忙
到窗口 掏出手绢儿 拿出存折 取钱
办理完毕 慢慢的离开啦

所以年轻人和土豪也同样是这三个方法，只不过具体里面可能有所不同。

  • YounMan类会变为：
package Bank;

public class YoungMan {
    private String name;
    //两个构造方法
    public YoungMan(){}
    public YoungMan(String name){
        this.name=name;
    }
    public void setName(){
        this.name = name;
    }
    public String getName(){
        return this.name;
    }

    //1.进银行 叫一个号码 排队
    public void callNumber(){
        System.out.println("自己知道在门口按按钮 拿到号码小票");
    }
    //2.去窗口办理
    public void transact(){
        System.out.println("去窗口 汇款");
    }
    //3.办理完毕离开啦
    public void leave(){
        System.out.println("办理完迅速离开啦");
    }
}
  • 同样，Bank类也要添加新的方法：
// 为年轻人添加的方法
public void profession(YoungMan ym) {
        System.out.println(ym.getName() + "客户进入银行啦");
        ym.callNumber();
        ym.transact();
        ym.leave();
    }
  • 主方法测试一下
package Bank;

public class Test {
    public static void main(String[] args){
        Bank bank = new Bank();

        OldMan om = new OldMan("长者");
        bank.profession(om);//银行欢迎长者进来办理业务


        YoungMan ym = new YoungMan("年轻");
        bank.profession(ym);//银行欢迎长者进来办理业务
    }
}

结果：

长者客户进入银行啦
年事已高 不知道在哪儿叫号 请求大堂经理的帮忙
到窗口 掏出手绢儿 拿出存折 取钱
办理完毕 慢慢的离开啦
年轻客户进入银行啦
自己知道在门口按按钮 拿到号码小票
去窗口 汇款
办理完迅速离开啦

土豪同理。不在赘述。
按照刚才的设计可能的问题：
1.三个不同的人类方法名不一致(可以)
2.银行办理业务的方法写了三个
解决如上所述的问题，可以在三个人类之上创建一个父类
可以解决的问题：
1.解决三个人类中的相同代码 比如name属性 比如get方法之类的
2.父类定义的三个方法可以是抽象，解决了子类命名不一致的问题 子类执行也不一致。
3.父类可以作为参数传入银行，然后通过多态调用，执行子类中重写的方法。

  • Person基类的代码：
package Bank;

public abstract class Person {
    protected String name;

    public void setName(){
        this.name = name;
    }
    public String getName(){
        return this.name;
    }

    // 三个抽象的方法，子类可以去重写
    //1.进银行 叫一个号码 排队
    public abstract void callNumber();
    //2.去窗口办理
    public abstract void transact();
    //3.办理完毕离开啦
    public abstract void leave();
}
  • OldMan子类的代码：
package Bank;

public class OldMan extends Person{

    public OldMan(){}
    public OldMan(String name){
        this.name=name;
    }
    //1.进银行 叫一个号码 排队
    public void callNumber(){
        System.out.println("年事已高 不知道在哪儿叫号 请求大堂经理的帮忙");
    }
    //2.去窗口办理
    public void transact(){
        System.out.println("到窗口 掏出手绢儿 拿出存折 取钱");
    }
    //3.办理完毕离开啦
    public void leave(){
        System.out.println("办理完毕 慢慢的离开啦");
    }

}

YoungMan：

package Bank;

public class YoungMan extends Person {
    public YoungMan(){}
    public YoungMan(String name){
        this.name=name;
    }
    //1.进银行 叫一个号码 排队
    public void callNumber(){
        System.out.println("自己知道在门口按按钮 拿到号码小票");
    }
    //2.去窗口办理
    public void transact(){
        System.out.println("去窗口 汇款");
    }
    //3.办理完毕离开啦
    public void leave(){
        System.out.println("办理完迅速离开啦");
    }
}
  • 主方法测试一下
package Bank;

public class Test {
    public static void main(String[] args){
        Bank bank = new Bank();
        Person p = new OldMan("长者");  
        //多态的使用，父类的引用指向一个子类的使用，
        //表示这个Person的身份现在是他的子类，老人这一个具体的类别
        //调用方法的时候是看父类中是如何定义的，四个方法定义了，就能调得到，但是执行的结果是看方法有没有被重写
        //执行重写之后的结果
        bank.profession(p);//银行欢迎长者进来办理业务
    }
}
  • 结果：
长者客户进入银行啦
年事已高 不知道在哪儿叫号 请求大堂经理的帮忙
到窗口 掏出手绢儿 拿出存折 取钱
办理完毕 慢慢的离开啦

调用一个方法 名字一样 传递参数却不同
1.利用方法重载—静态加载
2.利用多态效果—动态加载

二 内部类

指的是在Java中可以将一个类定义在另一个类的内部

  • 内部类可以定义在 ，类的内部 (与类成员层次一致)
  • 内部类可以定义在 ，方法/块内部 (与类成员相差一个层次 方法的局部变量一个层次)

1.成员内部类
2.局部内部类
3.匿名内部类
4.静态内部类

  1. 成员内部类
  • 将一个类直接定义在类的里面，作为成员，与属性或方法层次一致
  • 成员内部类可以与正常类一样 使用不同的修饰符来修饰
  • 好处1.省略了一个.java文件
    好处2.成员内部类中可以访问外部类的所有成员 包括私有的
  • 若想要在内部类中通过对象.调用外部类成员 外部类.this.外部类成员;
    Demo类
package innerclass;

public class Demo {
    private String name = "这是正常类中的属性";
    public void testDemo(){
        System.out.println("这是正常类中的方法");
    }

    //成员内部类
    public class InnerDemo{
        private String name="我是内部类的属性";
        public void testInnerDemo(){
            System.out.println("我是成员内部类的方法:"+this.name);  //this.是自己
            System.out.println("我是成员内部类的方法:"+Demo.this.name);  //Demo.this是外部
            Demo.this.testDemo();
            //testDemo();  //或者写这个，
            //this.testDemo();  //但是不能写这个，因为InnerDemo类中的对象只能是InnerDemo的对象，然而InnerDemo类中没有testDemo这个函数
        }
    }
}

主方法测试：

package innerclass;
import innerclass.Demo.InnerDemo;

public class TestMain {
    public static void main(String[] args){
        //内部类属于外部类的(相当于是一个成员) 需要外部类对象才能操作
        //创建内部类的对象---调用内部类的方法
        Demo demo = new Demo();
        InnerDemo innerDemo = demo.new InnerDemo();
        //调用内部类的方法
        innerDemo.testInnerDemo();

    }
}

结果：

我是成员内部类的方法:我是内部类的属性
我是成员内部类的方法:这是正常类中的属性
这是正常类中的方法
  1. 局部内部类【不常用】
  • 将一个类定义在方法/块里面，作为成员的内部结构，与临时的局部变量一个层次。
  • 局部内部类像是一个局部的变量一样，不能用public protected private及static，他们是修饰成员的
  • 只能用abstract或final
  1. 匿名内部类
    成员匿名内部类
    局部匿名内部类
public interfase Test{
			public void test();
		}
		Test t = new Test(){
			public void test(){
			}
		};
  • 通常接口或抽象类的具体子类这样写
  • 开发中为了省略一个类文件 上述写法比较常见
  • 匿名内部类很特殊 只有类体 没有类的所有结构( 修饰符 名字 继承 实现)
  • 不能用任何修饰符来修饰 匿名内部类也没有构造方法
  1. 静态内部类
    成员静态内部类
    不需要外部类对象，通过正常的方式直接创建内部类
    静态元素不能访问非静态成员(自己类和外部类)
dlut_yan
关注
  • 1
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
java基础之3-01继承和多态 Person p = new Teacher()；
qq_44849626的博客
02-12 796
继承和多态 java的三大特征：封装，继承，多态 继承： Person–父类 Teacher–子类 Student–子类 然后在我们的主类中如何创建一个teacher对象呢？ 然后我们也可以这样子去创建一个teacher对象 利用父类来声明，利用子类来进行构造 为什么呢？ 因为在继承中，子类继承自父类，我们就可以说子类是父类 就比如：老师继承自人，就可以说老师是人 多态:利用父类来声明对象，利用子类来进行构造 这里我们可以发现上面的对象 **“p”**既可以是teacher，也可以是stude
多态Person p=new Student();
好学而不勤问非真好学者
12-17 2400
如果有两个类，一个类是Person类是父类，然后有一个类是子类Student类。 Person p=new Student(); 那么请问上面的这句话，在干什么？ 这很明显是一个里氏转换，对吧。但是为什么要用里氏转换，你明明可以写成下面这个东西用。想用谁的方法就实例化谁 Person p =new Person(); Student S =new Student(); 回到第一句话上...
【多态】深入理解向上转型&向下转型
Josvin
01-28 328
预备知识 面向对象编程--------理解多态 面向对象编程-------多态 向上转型 示例一 目录结构 原理&实现代码 老师专用门禁卡和学生专用门禁卡都继承了门禁卡。 AccessCard（父类：门禁卡） package learn_extends.e1; public class AccessCard { public void entrance() { System.out.println("验证身份，进出大门"); } } StudentAcces
C#里氏转换原则
好学而不勤问非真好学者
08-15 687
显示转换：父类对象转换为子类类型必须使用强制转换 Person p = new Teacher(); Teacher t = (Teacher)p; //如果new的时候是new的是子类，那么在转换这个子类的时候可以 t.SayHi(); Person p = new Teac...
深入理解利用new创建对象的执行过程以Person p=new Person("张三",20);为例
weixin_30268071的博客
01-21 1046
代码如下： class Person { private String name="haha"; private int age; private static String country="cn"; Person(String name,int age) { this.name=name; this.age=age; } <span style="white...
java面向对象基础笔记
05-28
java语言概述，java语言基础，程序的控制语句，数组，面向对象基础，继承，多态，抽象类，接口，异常处理，集合类，输入输出流，多线程，JDBC连接数据库等简单的java基础知识。 适合想学习java语言的同学们下载。 ...
面向对象程序设计-Java(张白一)
03-15
面向对象程序设计-Java(张白一) 第1章 Java系统环境概述 第2章 Java语言基础 第3章 程序流程控制 第4章 类与对象 第5章 消息、继承与多态 第6章 数组 第7章 字符串类 第8章 文字与图形GUI设计 第9章 常用组件GUI设计...
java基础（韩顺平）视频 教学
04-18
java 面向对象 构造方法 封装 继承 多态
《面向对象程序设计java)》课程整体教学设计.docx
05-30
掌握Java类的概念、定义及创建类对象的方法，掌握面向对象编程的 基本方法、类的定义和对象创建、方法重载的概念、类的继承概念、多态的概念、理解抽象类与接口的相关概念等相关概念。 4. 掌握Java图形界面程序的...
java零基础入门-最新版2019（600元的课）
05-02
在本步骤中，我们将带你逐步认识如何通过Java语言实现面向对象的三大特征继承、封装、多态，并编写具有面向对象思想的Java程序 3: Java常用工具类 在本步骤中，将会介绍最常用的Java工具类，包括异常、包装器类、...
java继承
weixin_39999734的博客
10-27 167
一. 类的继承格式： class 父类 { } class 子类 extends 父类 { } 二.继承类型 三. 继承的特性 子类拥有父类非 private 的属性、方法。 子类可以拥有自己的属性和方法，即子类可以对父类进行扩展。 子类可以用自己的方式实现父类的方法。 Java 的继承是单继承，但是可以多重继承，单继承就是一个子类只能继承一...
JS__继承模式,命名空间,对象枚举__渡一
Renee的博客
02-11 306
继承发展史 传统形式 ——>原型链 过多的继承了没用的属性 Grand.prototype.lastName = "Ji"; function Grand() { } var grand = new Grand(); Father.prototype = grand; function Father() { this.name = 'hehe'; } var father = new Father(); Son.prototype = father; function Son() { } v
《Java零基础入门到精通（集合，泛型，IO，反射，JVM， 源码）【渡一教育】》思维导图版笔记（完结）
Panda颜的博客
07-30 4216
历史及特点及开发环境 数据类型 类型转换 运算与进制转换 语法结构与修饰符 数组 面向对象 类 Object类 工具类 包装类（封装类） 数学相关类 日期相关类 String类 StringBuilder类 其他工具类 正则表达式 集合 错误与异常 File类 Swing 流 线程 反射 注解 ...
剑指offer刷题
DLUT_yan的博客
06-15 2414
一. 链表 一. 链表 JZ3 从尾到头打印链表 JZ14 链表中倒数第k个结点 JZ15 反转链表 链表 JZ16 合并两个排序的链表 JZ25 复杂链表的复制 JZ26 二叉搜索树与双向链表 JZ36 两个链表的第一个公共结点 JZ46 孩子们的游戏(圆圈中最后剩下的数) JZ55 链表中环的入口结点 JZ56 删除链表中重复的结点 3. 从尾到头打印链表 【链表】【栈】 牛客剑指offer题目 思路： 只是需要将链表的值打印出来，所以没那么复杂，涉及到反转，只需要利用Stack就
java学习基础课（渡一教育）（一）
DLUT_yan的博客
10-18 2330
记录自己看渡一教育免费java基础课的学习过程。 第四课：基本数据类型 数据类型：分为基本数据类型和引用数据类型 基本数据类型 8个 4整型 byte short int long64 2浮点型 float 32 double 64 1字符型 char 16bit 2字节 Unicode编码 0-65535 1布尔型 boolean 1bit tru...
java学习基础课之数组（渡一教育）（二）
DLUT_yan的博客
11-01 1489
记录自己看渡一教育免费java基础课的学习过程。 int score = 90; 根据score成绩来进行区间的判定 不及格 及格 中等 良好 优秀 满分… score是一个变量空间(小容器)—一个学生的成绩 变量 类型定义int 空间内的内容只能存放一份 5个同学成绩都存起来???----5个变量【以往的学习】 数组(容器) 数组是一组数据类型相同的数据的组合，将这...
java学习基础课之面向对象（渡一教育）【属性；方法；重载】（三）
DLUT_yan的博客
11-06 1407
记录自己看渡一教育免费java基础课的学习过程。 面向过程的编程思想 VS 面向对象的编程思想： 面向过程的编程思想 解决问题的时候按照一定的过程(流程) 钟点工—> 大象装冰箱 总共分几步 1.开门 2.大象装里面 3.关门 以过程为本–复用–增加了很多冗余 大段的过程 拆分成小段 — 到底是哪一个实体来做的 面向对象的编程思想 解决问题的时候按照现实生活中的规律来...
java学习基础课之List集合工具包（渡一教育）（十一）
DLUT_yan的博客
02-16 1222
变量—容器：存储一个元素 数组—容器：一组具有某种特性的数据存放在一起；存储一组元素(数据类型一致) 长度固定自己定义了Box（ArrayBox LinkedBox）----容器：用来存储一组元素，长度可变 集合—容器：与数组类似，集合的长度存储之后还能改变集合是用来存储一组元素可以理解为集合是我们封装的Box ，只不过比我们写的更加的优秀 ，更多的方法 集合 1.集合需要导包：java....
java面向对象-封装、继承和多态头歌
最新发布
11-02
Java作为一种面向对象的编程语言，具有封装、继承和多态这三个重要概念。 首先，封装是指将数据和对数据的操作封装在一个类中，隐藏了实现的细节。通过封装，我们可以将数据的访问权限进行控制，从而保证数据的安全...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值