类实现接口，并且对象转型引用，接口引用实现类，抽象类实现接口且被子类继承返回抽象类的值给接口对象转型父类引用子类

news2024/11/14 17:47:15

类实现接口，并且对象转型引用

接口：最最特殊的抽象类。声明行为
当多个类有共同的属性和方法用抽象类
当符合什么是什么？用继承；继承抽行类
当描述能干嘛？用接口
接口的方法都是抽象方法的声明
接口和抽象类的区别
以人的信息为例
- 图例
- 1.创建接口声明抽象类的方法（可能含有访问抽象类的成员变量）
- 2.创建抽象类声明变量和方法实现（或部分）接口的方法
- 3.创建继承抽象类的子类并调用抽象类中的方法
- 4.方法的重写
- 5.成员变量的隐藏
- 6.对象转型转变类型
- 7.super

接口：最最特殊的抽象类。声明行为

当多个类有共同的属性和方法用抽象类

当符合什么是什么？用继承；继承抽行类

当描述能干嘛？用接口

接口的方法都是抽象方法的声明

接口和抽象类的区别

在这里插入图片描述

以人的信息为例

图例

在这里插入图片描述

1.创建接口声明抽象类的方法（可能含有访问抽象类的成员变量）

注意观察接口中声明的方法 void getInfo是没有返回值，此方法的作用是给抽象中的成员变量赋值这里成员变量的赋值只是一种举例，实际情况可能会有其他函数的处理作用大致相当功能，但是可以通过声明的下面的三个方法实现对抽象类中的成员变量属性值的访问

public interface PersonInfo {
//void getInfo是没有返回值，
//此方法的作用是给抽象中的成员变量赋值
    void getInfo(String name, String age, String sex,String address,String phone);
    //声明此方法访问目的访问抽象类中的属性值
    String getPerName11();
    String getPerAge11();
    String getPerSex11();
    String getPerMessage();
}

2.创建抽象类声明变量和方法实现（或部分）接口的方法

因为不是普通的类，普通类实现接口必须实现所有的方法。

public abstract class Person implements PersonInfo{
    private  String name;
    private  String age;
    private  String sex;
    private  String address;
    private  String phone;
    private  String message ="访问到抽象类Person类中的成员变量";
    public Person (){
        super();
    }
   
    public void getInfo(String name, String age, String sex,String address,String phone){
        this.name =name;
        this.age =age;
        this.sex =sex;
        this.address =address;
        this.phone =phone;
    }
    //实现接口方法的同时候又访问了抽象类的成员变量name的值
    //抽象类实现接口	没有  @Override
    public String getPerName11() {
        return name;
    }
    //实现接口方法的同时候又访问了抽象类的成员变量age的值
    //抽象类实现接口	没有  @Override
    public String getPerAge11() {
        return age;
    }
    //实现接口方法的同时候又访问了抽象类的成员变量sex的值
    //抽象类实现接口	没有  @Override
    public String getPerSex11() {
        return sex;
    }
    //实现接口方法的同时候又访问了抽象类的成员变量message的值
    //抽象类实现接口	没有  @Override
    public String getPerMessage() {
        return message;
    }
    
    @Override
    public String toString() {
        return "Person{" + "name='" + name + '\'' + ", age='" + age + '\'' + ", sex='" + sex + '\'' + ", address='" + address + '\'' + ", phone='" + phone + '\'' + '}';
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getAge() {
        return age;
    }
    public void setAge(String age) {
        this.age = age;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    public String getPhone() {
        return phone;
    }
    public void setPhone(String phone) {
        this.phone = phone;
    }
}

3.创建继承抽象类的子类并调用抽象类中的方法

注意 PersonInfo p，声明接口的一个实例p,子类重写父类方法时，如果需要调用父类被隐藏的方法，使用super.方法名();，这个 . 不能丢

//继承 实现接口的抽象类
public class Student extends Person{

    public  Student(String name,String age,String sex,String address,String phone){
    //super.   super()是调用父类的
        super.getInfo(name,age,sex,address,phone);
    }

    public static void main(String[] args) {
        PersonInfo  p = new Student("小明","15","男","中国北京市","1234");
        //注意 观察p的对象值是抽象类中的成员变量的值
        System.out.println(p);//Person{name='小明',age='15',sex='男',address='中国北京市', phone='1234'}
        System.out.println(p.getPerMessage());//Person类中的成员变量
        System.out.println(p.getPerName11());//小明
        System.out.println(p.getPerSex11());//男
        System.out.println(p.getPerAge11());//15

    }
}

4.方法的重写

Override Overwirter / overload
重写的规则：
（1）子类中重写的方法应该与父类的被重写的方法，具有同名、同参、同返回类型，但执行的方法体不同。
（2）子类重写的方法不能降低父类被重写方法的访问的控制权限。
父类 Public Protected 缺省 Private
子类 Public Protected或public 缺省或Protected或public Private或缺省或Protected或public
（3）子类重写方法所声明的异常不能比父类被重写方法的异常更宽泛（相同类，或父类异常类的子类）、或超过父类异常类的数量。
（4）子类重写父类方法时，如果需要调用父类被隐藏的方法，使用super.方法名();
（5）不能重写父类的final最终方法。
（6）不要指望重写父类的static静态方法，但是子类的该方法也必须是static的，子类有自己的类方法，父类也有属于它自己的类方法；如果没有，子类和父类都没有

5.成员变量的隐藏

变量的隐藏：子类中定义了与父类成员变量同名的属性，与属性类型无关、与访问控制修饰符也无关。
注意：
(1)实例变量可以隐藏，只与变量名有关，与其他无关，子类方法中 this或不用this表示子类的变量，自动隐藏父类的同名变量，想要调用父类的，使用super关键字
(2)类变量或静态变量，也可以变量隐藏，也是子类是子类的，父类是父类。
(3)如果想要调用被隐藏的变量，使用super关键字即可