Day12 Java 接口、引用数据类型作为形式参数

Tian-Ys

已于 2022-02-12 13:46:19 修改

阅读量456

点赞数

分类专栏：笔记 Java 文章标签： java 开发语言

于 2022-01-16 20:41:17 首次发布

本文链接：https://blog.csdn.net/m0_64350718/article/details/122524117

版权

笔记同时被 2 个专栏收录

51 篇文章 2 订阅

订阅专栏

Java

30 篇文章 0 订阅

订阅专栏

对于package，import和class的解释：

接口：

接口的特点：

1、使用interface关键字修饰：public interface 接口名{}

2、类实现接口使用implement表示：public class implement 接口名{}

3、接口不能实例化，接口实例化要参照多态，通过对象进行实例化，称之为：接口多态

多态分为：具体类多态，抽象类多态，接口多态（大数据开发最为常见）

多态的前提：有继承或者实现关系；有方法重写；有父(类/接口)引用指向(子/实现)类对象

4、接口的实现类：如果是一个具体的实现类，需要重写接口中所有的抽象方法，或者是一个抽象类，可以不用重写

接口的成员特点：

1、成员变量：只能是常量，且是静态的，JVM在真正运行之前会自动补齐修饰符：public static final。

2、构造方法：

接口没有构造方法，接口主要是对行为进行抽象的，没有具体的存在，一个类如果没有父类，默认继承自Object类

3、成员方法：

只能是抽象方法，没有方法体，连大括号都没有，

默认修饰符：public abstract

接口版猫狗案例：

public interface Test1 {//接口Test1
    public abstract void jump();
}

abstract class Animal {//抽象类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 implements Test1 {//猫类继承动物，实现Test1

    public Cat() {
    }

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

    @Override
    public void jump() {
        System.out.println("🐱可以跳高了");
    }

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

class Dog extends Animal implements Test1 {//狗类继承动物,实现Test1
    public Dog() {
    }

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

    @Override
    public void jump() {
        System.out.println("🐕可以跳墙了");
    }

    @Override
    public void eat() {
        System.out.println("🐕吃骨头");
    }
}

class Demo {
    public static void main(String[] args) {
        Animal a = new Cat("加菲",4);
        System.out.println(a.getName() + "," + a.getAge());
        a.eat();
        Cat c=(Cat) a;//向下转型
        c.jump();
        System.out.println("===========");
        Animal a2 = new Dog("阿拉斯加", 6);
        System.out.println(a2.getName() + "," + a2.getAge());
        ((Dog) a2).jump();//采用链式编程
    }
}

当一个具体的类实现接口的时候，必须实现接口中所有的抽象方法；当一个抽象类实现接口的时候，可以选择不实现接口中的方法，也可以选择性的实现。

抽象类与接口之间的区别：

1、成员区别：

抽象类有变量，常量；有构造方法，抽象方法，也有非抽象方法

接口只有常量和抽象方法

2、关系区别：

类与类之间的关系：继承，单继承

类与接口之间的关系：实现，单实现，也可以多实现，还可以在继承一个类的同时实现多个接口

接口与接口之间的关系：继承，可以单继承，也可以多继承。

3、设计理念区别：

抽象类是对类抽象，包括属性、行为

接口是对行为抽象，主要是行为

老师学生案例：

interface Smoke {
    public abstract void smoke();
}
 abstract class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(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();
    public abstract void sleep();
}
class Teacher extends Person{

    public Teacher() {
    }

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

    @Override
    public void eat() {
        System.out.println("老师吃大餐");
    }

    @Override
    public void sleep() {
        System.out.println("老师睡水床");
    }
}
class Student extends Person{
    public Student() {
    }

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

    @Override
    public void eat() {
        System.out.println("学生吃菜");
    }

    @Override
    public void sleep() {
        System.out.println("学生睡觉");
    }
}
class SmokeStudent extends Student implements Smoke {
    public SmokeStudent() {
    }

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

    @Override
    public void smoke() {
        System.out.println("学会抽烟了");
    }
}
class SmokeTeacher extends Teacher implements Smoke{
    public SmokeTeacher() {
    }

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

    @Override
    public void smoke() {
        System.out.println("学会抽烟了");
    }
}
public class Test2 {
    public static void main(String[] args) {
//        Person s1=new Student("小王",20);
        new Student("小王",20).eat();
        new Student("小王",20).sleep();
        System.out.println("-------------------");
//        Person s2=new Teacher("小虎",30);
        new Teacher("小虎",30).eat();
        new Teacher("小虎",30).sleep();
        System.out.println("-------------------");
//        Person s3=new SmokeStudent("灰宾",22);
        new SmokeStudent("灰灰",22).eat();
        new SmokeStudent("灰灰",22).sleep();
        ((SmokeStudent)new SmokeStudent("灰灰",22)).smoke();
        System.out.println("-------------------");
        new SmokeTeacher("王老师",56).eat();
        new SmokeTeacher("王老师",56).sleep();
        ((SmokeTeacher)new SmokeTeacher("王老师",56)).smoke();

    }
}

分层开发：

将来我们将面临更多的面向接口开发

将代码进行分类开发，会提高我们开发效率和排错效率，通常情况下，常见会有四层：

bean: 一般存放的是将来要new的实体类

controller: 一般是数据的入口类，可以理解为main方法或者测试类

dao: 具体对数据做操作的地方，放在dao层，这一层一般情况下，都是对数据库做操作的

service: 一般在这里面放的是接口，和实现类。

利用上述分类实现教练运动员学习英语案例：

bean中存放抽象类Person，其子类抽象类CoachMan和抽象类SportMan，以及不需要学习英语的篮球运动员和篮球教练类：

//抽象类Person
public abstract class Person {
    private String name;
    private int age;

    public Person() {
    }

    public Person(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 void show() {
        System.out.println("姓名：" + name + "，年龄：" + age);
    }
}

接下来是其两个子类：

//教练类
public abstract class CoachMan extends Person{
    public CoachMan() {
    }

    public CoachMan(String name, int age) {
        super(name, age);
    }
}
//这是两个Java文件，没有写在同一Java文件中

//运动员类
public abstract class SportMan extends Person{
    public SportMan() {
    }

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

篮球运动员类与篮球教练类：

//篮球教练
public class BasketballCoachMan extends CoachMan{
    public BasketballCoachMan() {
    }

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

//篮球运动员
public class BasketballMan extends SportMan{
    public BasketballMan() {
    }

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

接下来实现接口类与其实现类，放在service中：

//学习英语接口
public interface PingPang {
    public abstract void studyEnglish();
}


//乒乓球运动员
import test.Test.src.com.Test3demo.bean.SportMan;

public class PingpangManImpl extends SportMan implements StudyEnglish{
    public PingpangManImpl() {
    }

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

    @Override
    public void eat() {
        System.out.println("乒乓球运动员吃饭");
    }

    @Override
    public void sleep() {
        System.out.println("乒乓球运动员睡觉");
    }

    @Override
    public void study() {
        System.out.println("乒乓球运动员学英语了");
    }
}



//乒乓球教练
import test.Test.src.com.Test3demo.bean.CoachMan;

public class PingpangCoachImpl extends CoachMan implements StudyEnglish{

    public PingpangCoachImpl() {
    }

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

    @Override
    public void study() {
        System.out.println("乒乓球教练学英语了");
    }

    @Override
    public void eat() {
        System.out.println("乒乓球教练吃饭");
    }

    @Override
    public void sleep() {
        System.out.println("乒乓球教练睡觉");
    }
}

最后是测试类，测试类放在controller中：

import test.Test.src.com.Test3demo.bean.CoachMan;
import test.Test.src.com.Test3demo.bean.SportMan;
import test.Test.src.com.Test3demo.service.PingpangCoachImpl;
import test.Test.src.com.Test3demo.service.PingpangManImpl;


public class Test3 {
    public static void main(String[] args) {
        SportMan sm=new PingpangManImpl("小王",29);
        sm.eat();
        sm.sleep();
        ((PingpangManImpl)sm).study();

        CoachMan cm=new PingpangCoachImpl("老王",56);
        cm.eat();
        cm.sleep();
        ((PingpangCoachImpl)cm).study();
    }
}

实现结果：

对于package，import和class的解释：

包：在这里就是文件夹的意思

package: 到达的路径，所在文件的路径，它最终以包结束。（在最前面）

import: 导入外界你想要使用的类，它最终以你想要导入的那个类/java结束。（在package与class之间）要想导入某一包下所有的类，.*(开发不推荐) 只要当你需要导入大于30个类的时候，可以考虑.*

class: 表示定义一个类，java的最基本的单位（在import后面）

权限修饰符：

权限修饰符共有四种：public，protected，默认修饰符，private

四种修饰符可以被访问的范围是:同一类下; 同一包子类中，其他类；不同包的子类；不同包的其他类。

这四种从左到右可以被访问的范围依次减小:

权限修饰符：   同一类下     同一包子类中，其他类      不同包的子类      不同包的其他类
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

将来开发中，除了封装必须使用private以外，如果实在不知道用谁，就用public

有关形式参数的问题：

基本数据类型：byte,short,int,long,float,double,char,boolean

引用数据类型：

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

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

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

有关方法返回值的问题：

基本数据类型：byte,short,int,long,float,double,char,boolean

引用数据类型：

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

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

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

有关接口作为形式参数以及返回值案例描述：

//定义一个接口
interface PlayGame3{
    public abstract void playLol();
}
//定义实现类：
class Teacher3 implements PlayGame3{

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

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

    public TeacherDemo3() {
    }

    public TeacherDemo3(PlayGame3 playGame3) {
        this.playGame3 = playGame3;
    }

}

public class TeacherTest2 {
    public static void main(String[] args) {
//      使用无参构造方法进行创建对象
       TeacherDemo3 teacherDemo4=new TeacherDemo3();
        PlayGame3 pg3 = teacherDemo4.fun();
        pg3.playLol();
        System.out.println("==========================");
        //链式编程（今后所学的spark,flink都是这样的写代码方式）
        // scala
       new TeacherDemo3().fun().playLol();
        System.out.println("============================");
//      使用带参构造方法，接口的实现类作为参数，进行创建对象，实际需要的是接口实现类对象的地址值
       Teacher3 teahcer3=new Teacher3();
       TeacherDemo3 teacherDemo3 = new TeacherDemo3(teahcer3);
//      使用链式编程，通过访问接口实现类对象的地址值完成对接口中方法的访问
        teacherDemo3.playGame3.playLol();
    }
}

有关通过接口的实现类对象访问换成通过带参成员方法访问举例：

//定义一个接口
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);
        System.out.println("=================");
//    链式编程：
        (new TeacherDemo()).fun(new Teacher());
    }
}

其他对于类和抽象类作为形参和返回值的问题类似：

类作为参数和类作为方法返回值：

class Student{
    public void study(){
        System.out.println("好好学习天天向上");
    }
}

class StudentDemo{
   //一个方法的参数是一个类的类型进行传参时
    //实际上传的是该类的对象的地址值
    public void fun(Student student){
        student.study();
    }
//    类作为方法的返回值，实际上传的是该类的对象的地址值
    public Student fun2(){
        Student s = new Student();
        return s;
    }
}

public class StudentTest {
    public static void main(String[] args) {
        StudentDemo studentDemo = new StudentDemo();
//        类作为形参，创建类对象传入方法中        
        Student student = new Student();     
        studentDemo.fun(student);
//        类作为返回值，定义Student类对象接收
        Student s = studentdemo.fun2();
        s.study();
    }
}

抽象类作为参数和抽象类作为方法的返回值：

//定义一个抽象类
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 void fun2(Person3 person3){
        person3.study();
    }
}

public class PersonTest2 {
    public static void main(String[] args) {
        PersonDemo3 personDemo3 = new PersonDemo3();
//        抽象类作为方法返回值
        Person3 p = personDemo3.fun(); //Person3 p = new Doctor();
        p.study();
//       抽象类作为形式参数
        Person3 p2=new Doctor();
        personDemo3.fun2(p2);
    }
}