入门Java编程的知识点—＞重写（day010）

2024-08-27 12:20
文章标签 java 知识点 入门 重写 编程 day010

本文主要是介绍入门Java编程的知识点—＞重写（day010），希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

  • 重点掌握重写的适用性？重写的语法?
  • 重点掌握多态是什么？多态-向上造型的语法?多态的意义?
  • 重点掌握接口是什么?接口如何语法如何定义?
  • 重点掌握引用类型转换有哪些？instanceOf关键字如何用?
回顾

在昨天的ExtendsDemo测试类中,我们如果想要表示多个学生对象,多个老师对象,多个医生对象,则需要使用数组来完成

Student[] students = new Student[3];
students[0] = new Student("小张某", 18, '男', 1001);//创建一个学生类对象
students[1] = new Student("张某", 22, '男', 1002);//创建一个学生类对象
students[2] = new Student("大张某", 25, '男', 1003);//创建一个学生类对象
for (int i = 0; i < students.length; i++) {students[i].sayHi();
}
Teacher[] teachers = new Teacher[3];
teachers[0] = new Teacher("张X", 31, '男', 999999999);
teachers[1] = new Teacher("闫X", 36, '男', 999999999);
teachers[2] = new Teacher("李X", 30, '男', 999999999);
for (int i = 0; i < teachers.length; i++) {teachers[i].sayHi();
}
Doctor[] doctors = new Doctor[3];
doctors[0] = new Doctor("李X", 60, '男', 99);
doctors[1] = new Doctor("王X", 50, '男', 99);
doctors[2] = new Doctor("小宇", 40, '女', 99);
for (int i = 0; i < doctors.length; i++) {doctors[i].sayHi();
}

问题：在测试的代码过程中,因为有三个数组,学生数组,老师数组,医生数组,那么如果需要调用这三个数组中的每个对象的sayHi()。就需要写3个for循环。

解决：把3个数组 用一个数组来表示，基于这些类都有一个父类的情况下才可以。

向上造型：

  1. 声明 父类型 new 子对象 的语法就叫做向上造型.

  2. 父类型 大 子类型小

  3. 好处：一个父类型,可以代表不同的子类型！

class Animal{ //动物类}
class Tiger extends Animal{ //老虎类}main{类型		      对象Animal a =  new Animal();//动物 是 动物    语义通.程序不报错Tiger t  =  new Tiger(); //老虎 是 老虎    语义通.程序不报错	Animal a1 = new Tiger(); //老虎 是 动物 	语义通.程序不报错 Tiger t1 = new Animal(); //动物 是 老虎    不通,报错}
  //向上造型：  声明父类型  new 子对象Person[] pp = new Person[9];pp[0] =new Student("大张三", 58, '男', 1001);pp[1] =new Student("张三", 38, '男', 1002);pp[2] =new Student("小张三", 18, '男', 1003);pp[3] =new Teacher("大李四", 78, '男', 1000000000);pp[4] =new Teacher("李四", 58, '男', 1000000);pp[5] =new Teacher("小李四", 48, '男', 10000);pp[6] =new Doctor("大老王", 60, '男', 38);pp[7] =new Doctor("老王", 40, '男', 28);pp[8] =new Doctor("小老王", 20, '男', 18);for (int i = 0; i < pp.length; i++) {pp[i].sayHi();}

问题:运行测试后,当前打印输出的信息不明确,不清楚到底是谁的信息.

解决:可以通过方法的重写来解决.

重写(Override)

适用性:当实现继承后,子类无法复用父类中提供的方法时,子类可以通过重写父类的方法,来实现自己的逻辑.

  1. 若子类重写实现了父类的方法,在编译期间调用父类的,运行期间执行的则是子类的,具体执行谁看对象是谁!

  2. 向上造型的情况下,且子类还实现了重写,才会有调用父执行子的概念.

  3. 重写也可以遵循两同两小一大原则.

  • 两同:子类重写父类方法时, 方法名和参数列表 要相同.

  • 两小:子类重写父类方法时,返回值类型等于或小于父类中的那个方法,异常要等于或小于父类中那个方法。

  • 一大:子类重写父类方法时,访问权限要等于或大于父类中的那个方法。

学生类：void sayHi(){System.out.println("大家好我叫:" + name + "我的年龄是:" + age + "我的性别" + sex+"学号是"+stuID);}
老师类：@Overridevoid sayHi() {System.out.println("大家好我叫:" + name + "我的年龄是:" + age + "我的性别" + sex+"工资是"+salary);}
医生类:@Overridevoid sayHi() {System.out.println("大家好我叫:" + name + "我的年龄是:" + age + "我的性别" + sex+"职称是"+level);}
-------------//向上造型：  声明父类型  new 子对象Person[] pp = new Person[9];pp[0] =new Student("大张三", 58, '男', 1001);pp[1] =new Student("张三", 38, '男', 1002);pp[2] =new Student("小张三", 18, '男', 1003);pp[3] =new Teacher("大李四", 78, '男', 1000000000);pp[4] =new Teacher("李四", 58, '男', 1000000);pp[5] =new Teacher("小李四", 48, '男', 10000);pp[6] =new Doctor("大老王", 60, '男', 38);pp[7] =new Doctor("老王", 40, '男', 28);pp[8] =new Doctor("小老王", 20, '男', 18);for (int i = 0; i < pp.length; i++) {//编译期间调用则是父类的方法!  因为受类型制约.//运行期间调用则是子类的方法!  具体要看对象是谁。pp[i].sayHi(); //调用父 执行子...}
接口

定义：接口是一组行为的规范,接口不关心多个类之间是否是一种的关系,只关心多个类之间的行为是否统一。

一个类可以实现多个接口, 所以接口可以多实现。

接口在定义时,一半要求做小而精的接口,不做大而全的接口。

  1. 接口是一种数据类型 （引用类型）
  2. 接口是通过interface来进行定义。
  3. 接口中只能放常量 和 抽象方法。 JDK1.8以后 还可以放静态方法。
  4. 接口是抽象的！（接口不能被创建对象） 需要实现类来重写接口中抽象的行为
  5. 一个类要实现某个接口时,语法： 类名 implements 接口名 即可。一个实现类可以实现多个接口.
  6. 一个类要继承类也要实现接口,语法： 类名 extends 父类名 implements 接口
  7. 接口之间是可以继承的。例如：B接口 继承了 A接口 , 那么C这个类在实现B接口时,也需要将B接口继承得来的抽象内容 一并实现才可以！
  8. 类快捷实现接口中抽象方法的快捷键： 选中错误行 alt + Enter(回车) --->implement methods ---->选择重写实现的方法。
class Aoo{ //类的定义}interface Boo{// 接口的定义}
package oo.day05;/*** 接口测试类：*/
public class InterfaceDemo {public static void main(String[] args) {
//        Aoo a = new Aoo(); 接口是抽象的不能创建对象。}
}
interface Aoo{ //一个接口的定义//接口中内容  默认都是公开的！static final int A = 100; // 常量abstract void fun(); // 抽象方法void fun2();void fun3();static void fun1(){} // 可以存放静态方法
}
class super1{//父类
}
interface Doo{void test();//抽象方法
}
interface Coo extends Doo{
}
class Boo extends super1 implements Aoo,Coo{ //一个类实现多个接口  接口名之间用逗号隔开。@Overridepublic void fun() {}@Overridepublic void fun2() {}@Overridepublic void fun3() {}@Overridepublic void test() {}
}
/****  类 与  类 之间  可以实现继承关系*  接口 与 接口之间 可以实现继承关系   : 可以通过继承得到代码上的内容**  类  与 接口 直接 只能是实现关系   ：类需要重写实现接口中所有抽象内容*/
多态

人类的对象在睡觉的行为上实现多态：有的人右侧睡,有的人左侧睡,有的人平躺着睡....

在程序中的多态指的是一个父类的行为 子类有不同的逻辑实现.

人类	r1 = new 理发师();//向上造型   声明父 new 子
人类	r2 = new 医生类();
人类	r3 = new 园丁类();
r1.cut();//编译期调用父  运行期执行理发师对象的cut行为
r2.cut();//编译期调用父  运行期执行医生类对象的cut行为
r3.cut();//编译期调用父  运行期执行园丁类对象的cut行为class 人类{void cut(){ }
}class 理发师 extedns 人类 {void cut(){sout("剪发");	}
}
class 医生类 extedns 人类{void cut(){sout("手术");	}
}
class 园丁类 extedns 人类{void cut(){sout("剪草");	}
}
  • 当一个对象被造型为不同的接口类型时,具有不同的行为！
我 w = new 我();
w. 授课();
w. 互相卷();讲师  j = new 我();  //向上造型
j.授课行为();其它老师同事 q = new 我();
q.互相卷();
interface 讲师{授课();
}
interface 其它老师同事{互相卷();
}class 我 implments 讲师, 其它老师同事{授课(){  }	互相卷(){  }
}
向上造型 / 引用类型中的自动类型转换

  1. 父 大 子 小 ------ 声明父 类型 = new 子对象（);

  2. 能够向上造型 例如： 父 new 子 , 接口 new 实现类

向下转型 / 引用类型中的强制类型转换

能否强转成功,要看对应下面的条件：

条件一：要强转的引用类型变量中的对象 就是要转换的这个类型

条件二: 要强转的引用类型变量中的对象 实现了要转换的这个接口类型.

子类或实现类之间,是无法互相转换的!!

在引用类型转换的工作之前,应该使用 instanceOf 关键字 来判断是否可以强转成功.

main{Aoo a1 = new Boo();//声明父 new 子Boo b1 = (Boo)a1;//强转成功,符合条件一    强转语法：在需要强转的变量前写一组小括号(要转换的类型)Inter1 i1 = (Inter1)a1;//强转成功, 符合条件二 Coo c1 = (Coo)a1;//	报错 ....类型转换失败异常
}class Aoo{//父类}
interface Inter1{//接口}
class Boo extends Aoo implements Inter1{ // 子类}
class Coo extends Aoo{}---package oo.day06;/*** 类型转换的使用演示类:* 能否强转成功,要看对应下面的条件：条件一：要强转的引用类型变量中的对象  就是要转换的这个类型条件二:  要强转的引用类型变量中的对象 实现了要转换的这个接口类型.*/
public class ClassCastDemo {public static void main(String[] args) {Aoo a1 = new Boo();//向上造型if(a1 instanceof Boo){ //判断a1中的对象 是否是 Boo类型Boo b1 = (Boo)a1;//可以强转完成 符合条件一}if(a1 instanceof Inter1){//判断a1中的对象 是否实现了 Inter1接口Inter1 i1 = (Inter1) a1; //可以强转完成 符合条件二}if(a1 instanceof Coo){Coo c1 = (Coo) a1;//运行时异常:  class cast Exception	  类型转换异常!}else {System.out.println("a1不是Coo类型,强转失败!");}//在引用类型转换的工作之前,应该使用 instanceOf 关键字 来判断是否可以强转成功.}
}
class Aoo{//父类
}
interface Inter1{//接口
}
class Boo extends Aoo implements Inter1{ // 子类
}
class Coo extends Aoo{
}

这篇关于入门Java编程的知识点—＞重写（day010）的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1111657。

相关文章

JVM 的类初始化机制

JVM 的类初始化机制

前言 当你在 Java 程序中new对象时，有没有考虑过 JVM 是如何把静态的字节码（byte code）转化为运行时对象的呢，这个问题看似简单，但清楚的同学相信也不会太多，这篇文章首先介绍 JVM 类初始化的机制，然后给出几个易出错的实例来分析，帮助大家更好理解这个知识点。 JVM 将字节码转化为运行时对象分为三个阶段，分别是：loading 、Linking、initialization
阅读更多...
Spring Security 基于表达式的权限控制

Spring Security 基于表达式的权限控制

前言 spring security 3.0已经可以使用spring el表达式来控制授权，允许在表达式中使用复杂的布尔逻辑来控制访问的权限。 常见的表达式 Spring Security可用表达式对象的基类是SecurityExpressionRoot。 表达式描述hasRole([role])用户拥有制定的角色时返回true （Spring security默认会带有ROLE_前缀）,去
阅读更多...
浅析Spring Security认证过程

浅析Spring Security认证过程

类图 为了方便理解Spring Security认证流程，特意画了如下的类图，包含相关的核心认证类 概述 核心验证器 AuthenticationManager 该对象提供了认证方法的入口，接收一个Authentiaton对象作为参数; public interface AuthenticationManager {Authentication authenticate(Authenti
阅读更多...
Spring Security--Architecture Overview

Spring Security--Architecture Overview

1 核心组件 这一节主要介绍一些在Spring Security中常见且核心的Java类，它们之间的依赖，构建起了整个框架。想要理解整个架构，最起码得对这些类眼熟。 1.1 SecurityContextHolder SecurityContextHolder用于存储安全上下文（security context）的信息。当前操作的用户是谁，该用户是否已经被认证，他拥有哪些角色权限…这些都被保
阅读更多...
Spring Security基于数据库验证流程详解

Spring Security基于数据库验证流程详解

Spring Security 校验流程图 相关解释说明（认真看哦） AbstractAuthenticationProcessingFilter 抽象类 /*** 调用 #requiresAuthentication(HttpServletRequest, HttpServletResponse) 决定是否需要进行验证操作。* 如果需要验证，则会调用 #attemptAuthentica
阅读更多...
Spring Security 从入门到进阶系列教程

Spring Security 从入门到进阶系列教程

Spring Security 入门系列 《保护 Web 应用的安全》 《Spring-Security-入门（一）：登录与退出》 《Spring-Security-入门（二）：基于数据库验证》 《Spring-Security-入门（三）：密码加密》 《Spring-Security-入门（四）：自定义-Filter》 《Spring-Security-入门（五）：在 Sprin
阅读更多...
Java架构师知识体认识

Java架构师知识体认识

源码分析 常用设计模式 Proxy代理模式Factory工厂模式Singleton单例模式Delegate委派模式Strategy策略模式Prototype原型模式Template模板模式 Spring5 beans 接口实例化代理Bean操作 Context Ioc容器设计原理及高级特性Aop设计原理Factorybean与Beanfactory Transaction 声明式事物
阅读更多...
Java进阶13讲__第12讲_1/2

Java进阶13讲__第12讲_1/2

多线程、线程池 1.  线程概念 1.1  什么是线程 1.2  线程的好处 2.   创建线程的三种方式 注意事项 2.1  继承Thread类 2.1.1 认识  2.1.2  编码实现  package cn.hdc.oop10.Thread;import org.slf4j.Logger;import org.slf4j.LoggerFactory
阅读更多...
基本知识点

基本知识点

1、c++的输入加上ios::sync_with_stdio(false);  等价于 c的输入，读取速度会加快（但是在字符串的题里面和容易出现问题） 2、lower_bound()和upper_bound() iterator lower_bound( const key_type &key ): 返回一个迭代器，指向键值>= key的第一个元素。 iterator upper_bou
阅读更多...
JAVA智听未来一站式有声阅读平台听书系统小程序源码

JAVA智听未来一站式有声阅读平台听书系统小程序源码

智听未来，一站式有声阅读平台听书系统 🌟&nbsp;开篇：遇见未来，从“智听”开始 在这个快节奏的时代，你是否渴望在忙碌的间隙，找到一片属于自己的宁静角落？是否梦想着能随时随地，沉浸在知识的海洋，或是故事的奇幻世界里？今天，就让我带你一起探索“智听未来”——这一站式有声阅读平台听书系统，它正悄悄改变着我们的阅读方式，让未来触手可及！ 📚&nbsp;第一站：海量资源，应有尽有 走进“智听
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2