day12接口&引用数据类型做形参和方法返回值&修饰符

于 2022-01-17 20:34:46 发布
阅读量366 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qnmdlzg/article/details/122546043
版权
本文介绍了Java接口的定义、实现方式以及接口中的多态。同时，探讨了引用数据类型作为方法参数和返回值时的情况。此外，还讨论了Java类、抽象类和接口之间的关系，以及修饰符的使用规则。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

        接口：
            1、语句定义格式：接口使用关键：interface表示
                interface 接口名{}
            2、如何实现
                接口不能直接实例化
                 如何表示
                这里需要另外一个关键字供其他类实现该接口：implements
                使用多态的形式进行实现，由具体的子类进行实例化,其实这是多态的一种，叫做接口多态。
            3、也可以用一个抽象类去实现

        三种多态的表现实现：
            1、具体的类中的多态 （最后才是具体类的多态）
            2、抽象类中的多态   （其次是抽象多态）
            3、接口中的多态    （今后大数据开发最常见的是接口多态）

package com.shujia.wyh.day12.ketang.interfacedemo;
abstract class Animal{
    private String name;
    private int age;

    public Animal() {
    }

    public Animal(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public abstract void eat();
}

class Cat extends Animal{

    public Cat() {
    }

    public Cat(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println("猫吃鱼");
    }
}

//定义一个钻火圈的接口
interface ZuanHuoQuan{
    void zuanHuo();
}

class TrainCat extends Cat implements ZuanHuoQuan{

    @Override
    public void zuanHuo() {
        System.out.println("猫钻火圈");
    }
}

public class InterfaceDemo1 {
    public static void main(String[] args) {
        //定义出了一个会钻火圈的猫
        Cat c = new TrainCat();
        TrainCat tc = (TrainCat) c;
        tc.zuanHuo();

    }
}

        接口中成员的特点：
            成员变量：
                只能是常量，并且是静态的
                JVM在真正运行之前会自动补齐修饰符：public static final
            构造方法：
                接口中没有构造方法。
            成员方法：
                接口中的方法只能是抽象方法，没有方法体，连大括号都没有
                JVM在真正运行之前会自动补齐修饰符：public abstract

       注意：
        1、当一个具体的类实现接口的时候，必须实现接口中所有的抽象方法
        2、当一个抽象类实现接口的时候，可以选择不实现接口中的方法，也可以选择性的实现
 

package com.shujia.wyh.day12.ketang.interfacedemo;
interface Inter{
    public static final int a = 10;
    public abstract void fun();
    public abstract void fun2();
}

//虽然接口中没有构造方法，但是多态初始化的时候会先初始化父类再初始化子类
//这里其实继承了一个父类
//java中所有的类都有一个父类叫做Object
//每一个class都有Object作为父类
//那么所有继承Object类的子类都拥有了父类Object类中的方法
class Demo extends Object implements Inter{

    @Override
    public void fun() {
        System.out.println("Demo类中实现玩游戏方法");
    }

    @Override
    public void fun2() {
        System.out.println("Demo类中实现玩游戏方法2");
    }
}

abstract class Demo2 implements Inter{
    @Override
    public void fun() {
        System.out.println("抽象类中实现接口抽象方法");
    }
}

public class InterfaceDemo2 {
    public static void main(String[] args) {
        Inter i = new Demo();
        System.out.println(i.a);
        i.fun();
    }
}

        类与类，类与接口，接口与接口的关系
        类与类：
            存在继承关系，只能进行单继承，不可以进行多继承，但是可以是多层继承
        类与接口：
            实现关系，可以是单实现，也可以是一次性实现多个接口，也可以在继承一个类的同时，实现多个接口
        接口与接口：
            存在的是继承关系，可以进行单继承，也可以进行多继承

package com.shujia.wyh.day12.ketang.interfacedemo;
interface Inter2{}
interface Inter3{}
interface Inter4 extends Inter2,Inter3{}//接口多继承

class Demo3 extends Object implements Inter2,Inter3{}//接口多实现


public class InterfaceDemo3 {
}

将来我们更多的面向接口开发
将代码进行分类开发，会提高我们开发效率和排错效率
通常情况下，常见会4层：
bean: 一般存放的是将来要new的实体类
controller: 一般是数据的入口类
dao: 具体对数据做操作的地方，放在dao层，这一层一般情况下，都是对数据库做操作的
service: 一般在这里面放的是接口，和实现类。

引用数据类型做形参和方法返回值

引用数据类型作为形式参数的时候
    当类作为参数的类型的时候，实际上需要的是该类的对象的地址值
    当抽象类作为参数的类型的时候，实际上需要的是该抽象类的子类的对象的地址值
    当接口作为形式参数的类型的时候，实际上需要的是实现该接口的类的对象的地址值

引用数据类型作为方法的返回值的时候
    当类作为方法的返回值类型的时候，实际上需要的是该类的对象
    当抽象类作为方法的返回值的时候，实际上需要的是该抽象类子类的对象
    当接口作为方法的返回值的时候，实际上需要的是实现该接口具体的类的对象

引用数据类型作为形式参数的时候

类：当类作为方法的形式参数的时候，实际上需要的是该类的对象

package com.shujia.wyh.day12.ketang.interfacedemo.canshu;
class Student{
    public void study(){
        System.out.println("好好学习天天向上");
    }
}

class StudentDemo{
    //但凡今后看到一个方法的参数是一个类的类型进行传参的时候
    //实际上穿传的是该类的对象的地址值
    public void fun(Student student){
        student.study();
    }
}

public class StudentTest {
    public static void main(String[] args) {
        StudentDemo studentDemo = new StudentDemo();
        Student student = new Student();
        studentDemo.fun(student);
    }
}

抽象类：当抽象类作为形式参数传参的时候，实际上需要的时候该类子类实现对象的地址值，利用多态的形式创建

package com.shujia.wyh.day12.ketang.interfacedemo.canshu;
abstract class Person {
    public abstract void study();
}

class Student2 extends Person{
    @Override
    public void study() {
        System.out.println("好好学习天天向上");
    }
}

class PersonDemo {
    //将来你看到当一个抽象类作为参数的类型的时候
    //实际上需要的时候该类子类实现对象的地址值，利用多态的形式创建
    public void fun(Person person) { //Person person = new Student2()
        person.study();
    }
}

public class PersonTest {
    public static void main(String[] args) {
        PersonDemo personDemo = new PersonDemo();
        //抽象类不能被实例化
//        Person person = new Person();

//        Person p = new Student2();
//        personDemo.fun(p);//p指向new Student2()
        //所以可以以下表示
        personDemo.fun(new Student2());
    }
}

 接口：当接口作为形式参数传参的时候，实际上需要的是该接口的实现类对象的地址值，利用接口多态的方式创建

package com.shujia.wyh.day12.ketang.interfacedemo.canshu;
interface Person2 {
    public abstract void study();
}

class Teacher implements Person2{

    @Override
    public void study() {
        System.out.println("好好学习天天赚钱");
    }
}

class TeacherDemo{
    //今后你看到一个方法的参数类型是一个接口的时候，
    //实际上需要的是该接口的实现类对象的地址值，利用接口多态的方式创建
    public void fun(Person2 person2){
        person2.study();
    }
}


public class TeacherTest {
    public static void main(String[] args) {
        TeacherDemo teacherDemo = new TeacherDemo();
        //接口不能实例化
//        Person2 person2 = new Person2();
        Person2 p = new Teacher();
        teacherDemo.fun(p);//teacherDemo.fun(new Teacher())
    }
}

引用数据类型作为方法的返回值的时候

类：当类作为方法的返回值的时候，实际上返回的是该类对象的地址值。

package com.shujia.wyh.day12.ketang.interfacedemo.canshu;
class Student3{
    public void study(){
        System.out.println("好好学习天天向上");
    }
}

class StudentDemo3{
    //今后你看到一个方法的返回值是一个类的类型的时候，
    //实际上返回的是该类对象的地址值。
    public Student3 fun(){
        Student3 s = new Student3();
        return s;//return new Student3()
    }
}

public class StudentTest2 {
    public static void main(String[] args) {
        StudentDemo3 studentDemo3 = new StudentDemo3();
        Student3 s = studentDemo3.fun();//Student3 s = new Student3()
        s.study();
    }
}

抽象类：当抽象类作为返回值的时候，需要返回的是该抽象类的子类对象

package com.shujia.wyh.day12.ketang.interfacedemo.canshu;
abstract class Person3{
    public abstract void study();
}

class Doctor extends Person3{
    @Override
    public void study() {
        System.out.println("好好学习医术");
    }
}

class PersonDemo3{

    //今后当你看到一个方法的返回值是一个抽象类类型的时候
    //需要返回的是该抽象类的子类对象
    public Person3 fun(){
        //抽象类不能实例化
//        Person3 person3 = new Person3();

//        Person3 p = new Doctor();
//        return p;
        //可以以下表示
        return new Doctor();
    }
}

public class PersonTest2 {
    public static void main(String[] args) {
        PersonDemo3 personDemo3 = new PersonDemo3();
        Person3 p = personDemo3.fun(); //Person3 p = new Doctor();
        p.study();


    }
}

接口：当接口作为返回值类型的时候，实际上需要的是实现该接口具体的类的对象

package com.shujia.wyh.day12.ketang.interfacedemo.canshu;
interface PlayGame3{
    public abstract void playLol();
}

class Teacher3 implements PlayGame3{

    @Override
    public void playLol() {
        System.out.println("打英雄联盟");
    }
}

class TeacherDemo3{
    //当接口作为返回值类型的时候，需要的是实现该接口的类的对象
    public PlayGame3 fun(){
        return new Teacher3();
    }
}


public class TeacherTest2 {
    public static void main(String[] args) {
//        TeacherDemo3 teacherDemo3 = new TeacherDemo3();
//        PlayGame3 pg3 = teacherDemo3.fun();//PlayGame3 pg3 = new TeacherDemo3().fun()
//        pg3.playLol();


        //链式编程
        new TeacherDemo3().fun().playLol();
    }
}

修饰符

package,import,class他们三个之间有没有顺序呢？

顺序：package-import-class

        package: 到达的路径，所在文件的路径，它最终以包结束。 
        import: 导入外界你想要使用的类，它最终以你想要导入的那个类/java结束。 
            要想导入某一包下所有的类，.*(开发不推荐)
            只要当你需要导入大于30个类的时候，可以考虑.*
        class: 表示定义一个类，java的最基本的单位 

权限修饰符修饰的在什么时候能被访问

        权限修饰符：         同一类下     同一包子类中，其他类      不同包的子类      不同包的其他类
            public                          √                     √                                   √                              √
            protected                    √                     √                                   √
            默认的                        √                     √
            private                        √

        类及其组成可以用的修饰符：
            修饰符：
                访问权限修饰：public,protected,默认的,private
                状态修饰饰：static,final
                抽象修饰符：abstract

            类：
                访问权限修饰：public,默认的,
                状态修饰饰：final
                抽象修饰符：abstract
            成员变量：
                访问权限修饰：public,protected,默认的,private
                状态修饰饰：static,final
            构造方法：
                访问权限修饰：public,protected,默认的,private
            成员方法：
                访问权限修饰：public,protected,默认的,private
                状态修饰饰：static,final
                抽象修饰符：abstract

           常见的修饰符组合：
                成员变量：public static final 在接口中遇见
                成员方法：
                    1、public abstract
                    2、public static
                    3、public final

qnmdlzg
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值