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

本文链接：https://blog.csdn.net/Z0412_J0103/article/details/141464855

重点掌握重写的适用性？重写的语法?
重点掌握多态是什么？多态-向上造型的语法?多态的意义?
重点掌握接口是什么?接口如何语法如何定义?
重点掌握引用类型转换有哪些？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个数组用一个数组来表示，基于这些类都有一个父类的情况下才可以。

向上造型：

声明父类型 new 子对象的语法就叫做向上造型.
父类型大子类型小
好处：一个父类型,可以代表不同的子类型！

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)

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

若子类重写实现了父类的方法,在编译期间调用父类的,运行期间执行的则是子类的,具体执行谁看对象是谁!
向上造型的情况下,且子类还实现了重写,才会有调用父执行子的概念.
重写也可以遵循两同两小一大原则.

两同:子类重写父类方法时, 方法名和参数列表要相同.
两小:子类重写父类方法时,返回值类型等于或小于父类中的那个方法,异常要等于或小于父类中那个方法。
一大:子类重写父类方法时,访问权限要等于或大于父类中的那个方法。

学生类：
   void sayHi(){
        System.out.println("大家好我叫:" + name + "我的年龄是:" + age + "我的性别" + sex+"学号是"+stuID);
    }
老师类：
     @Override
    void sayHi() {
        System.out.println("大家好我叫:" + name + "我的年龄是:" + age + "我的性别" + sex+"工资是"+salary);
    }
医生类:
  @Override
    void 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(); //调用父 执行子...
        }

接口

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

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

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

接口是一种数据类型（引用类型）
接口是通过interface来进行定义。
接口中只能放常量和抽象方法。 JDK1.8以后还可以放静态方法。
接口是抽象的！（接口不能被创建对象）需要实现类来重写接口中抽象的行为
一个类要实现某个接口时,语法：类名 implements 接口名即可。一个实现类可以实现多个接口.
一个类要继承类也要实现接口,语法：类名 extends 父类名 implements 接口
接口之间是可以继承的。例如：B接口继承了 A接口 , 那么C这个类在实现B接口时,也需要将B接口继承得来的抽象内容一并实现才可以！
类快捷实现接口中抽象方法的快捷键：选中错误行 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{ //一个类实现多个接口  接口名之间用逗号隔开。
    @Override
    public void fun() {
    }
    @Override
    public void fun2() {
    }
    @Override
    public void fun3() {
    }
    @Override
    public 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 讲师, 其它老师同事{
    授课(){  }	
    互相卷(){  }
}

向上造型 / 引用类型中的自动类型转换

父大子小 ------ 声明父类型 = new 子对象（);
能够向上造型例如：父 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{
}