Java基础（10）接口、方法的参数类型以及返回值类型、权限修饰符

本文介绍了Java中的接口概念，包括接口的定义、实现方式、成员特点，以及类与接口的关系。同时讲解了方法参数类型和返回值类型的选择，特别是类、抽象类和接口在参数和返回值中的使用。最后，详细阐述了Java的四种权限修饰符及其应用范围。

1.接口

1. 接口的由来：为了体现事物功能的扩展性，Java通过接口来定义这些额外的扩展功能。但是并不给出具体实现，需要类来重写
2. 接口的特点
（1）定义接口：interface 定义格式：interface 接口名{}
（2）实现类：implements 定义格式：class 类名 implements 接口名{}
（3）接口不能实例化，需要按照多态的方式实例化
（4）接口的实现类：具体类，类中需要重写接口中所有抽象方法

public class TestDemo01 {
    public static void main(String[] args) {
        rInterface rf1 = new EZ();
        rf1.R();  //精准弹幕
        System.out.println("==============");
        rInterface rf2 = new Gragas();
        rf2.R();  //肉弹冲击
    }
}

interface RInterface{
    public abstract void R();
}

class EZ implements RInterface{
    String name = "伊泽瑞尔";
    public void attack(){
        System.out.println("平A");
    }

    public void magic(){
        System.out.println("放技能");
    }

    @Override
    public void R() {
        System.out.println("精准弹幕");
    }
}

class Gragas implements RInterface{
    String name = "古拉加斯";
    public void attack(){
        System.out.println("平A");
    }

    public void magic(){
        System.out.println("放技能");
    }

    @Override
    public void R() {
        System.out.println("肉弹冲击");
    }
}

3. 接口的成员特点
（1）成员变量：只能是常量，且是静态的。默认用 public static final 修饰
（2）构造方法：接口中没有构造方法
（3）成员方法：只能是抽象方法。默认修饰符 public abstract

public class TestDemo02 {
    public static void main(String[] args) {
        LOLInterface lol = new VN();
        lol.R();  //终极时刻
        System.out.println(lol.NUM);  //199
    }
}

interface LOLInterface{
    public static final int NUM = 199;   //成员变量前面的默认修饰符是  public static final

    public abstract void R();   //方法前面存在默认修饰符 public abstract
}

class VN implements LOLInterface{

    @Override
    public void R() {
        System.out.println("终极时刻");
    }
}

4. 类与类，类与接口，接口与接口之间的关系
（1）类与类：继承关系。只能单继承，可以多级继承
（2）类与接口：实现关系。可以单实现，也可以多实现。而且可以在继承一个类的同时实现多个接口
（3）接口与接口：继承关系。可以单继承，可以多继承

5. 抽象类与接口的区别
（1）成员变量

抽象类：可以是变量，可以是常量
接口：只能是常量

（2）构造方法：抽象类有，接口没有
（3）成员方法

抽象类：可以抽象，也可以非抽象
接口：必须是抽象
（注）在JDK1.8之后，接口中提供了default修饰方法，可以给出功能的具体实现。JDK1.8之后，也可以在接口中定义静态方法

public class TestDemo01 {
    public static void main(String[] args) {
        RInterface ri = new Gragas();
        ri.R();  //肉弹冲击
		
		//静态方法直接通过接口来调用
        RInterface.R2;   //酒桶的肉弹冲击
    }
}

interface RInterface{
	//在JDK1.8之后，接口中提供了default修饰方法，可以给出功能的具体实现
    public default void R(){
        System.out.println("肉弹冲击");
    }
    //JDK1.8之后，也可以在接口中定义静态方法
	public static void R2(){
		System.out.println("酒桶的肉弹冲击");
	}
}

class Gragas implements RInterface{

}

2.方法参数类型以及返回值类型问题

1. 类名
（1）类名作为形式参数：当看到一个方法的参数时一个类类型时，就传递一个该类的对象

public class TestDemo01 {
    public static void main(String[] args) {
        Student student = new Student();
        test(student,30);
        System.out.println(student.num);  //30

       /* 
        test(new Student(),60);
        System.out.println(student.num);  //30
        */

        student.setNum(student,100);
        System.out.println(student.num);   //100
    }

    public static void test(Student student,int num){
        student.num = num;
    }
}

class Student{
    int num = 20;
    public void setNum(Student student,int num){
        student.num = num;
    }
}

（2）类名作为返回值：当看到一个方法的返回值类型是一个类类型时，就返回一个该类的对象

public class TestDemo01 {
    public static void main(String[] args) {
        Student student = test(100);
        int num = student.num;
        System.out.println(num);  //100
    }

    public static Student test(int num){
        Student student = new Student();
        student.num = num;
        return student;
    }
}

class Student{
    int num = 20;
}

2. 抽象类

（1）抽象类作为形式参数：当看到一个方法的形参是一个抽象类类型，就传递一个该抽象类的子类

public class TestDemo02 {
    public static void main(String[] args) {
        MySon myson = new MySon();
        test(myson,1000);
        System.out.println(myson.num);  //200  只改变了父类的num值为1000，子类没有改变
        test(new CC(),2000);
        System.out.println(myson.num);  //200
    }

    public static void test(MyClass myClass,int num){
        myClass.num = num;
    }
}

abstract class MyClass{
    int num = 20;
    public abstract void show(int num);
}

class MySon extends MyClass{
    int num = 200;

    @Override
    public void show(int num) {
        this.num = num;
    }
}

class CC extends MyClass{
    @Override
    public void show(int num) {

    }
}

（2）抽象类名作为返回值类型：看到一个方法的返回值类型是一个抽象类类型时，就返回一个该类抽象类的子类对象

public class TestDemo01 {
    public static void main(String[] args) {
        MyClass myClass = test(800);
        System.out.println(myClass.num);  //200

        MySon mySon = (MySon) myClass;
        System.out.println(mySon.num);  //800
    }

    public static MyClass test(int num){
        MySon mySon = new MySon();
        mySon.num = num;
        return mySon;
    }
}

abstract class MyClass{
    int num = 200;
    public abstract void show(int num);
}

class MySon extends MyClass{
    int num = 2;

    @Override
    public void show(int num) {
        this.num = num;
    }
}