Java--接口和内部类

目录

接口

接口是一种引用数据类型,语法和抽象类类似,只不过需要把abstract换成interface

接口的命名一般以I开头

java 复制代码
//语法格式
public interface 接口名称 {
}

接口的使用

接口不可以直接使用,需要有一个类来实现这个接口,并把接口内的抽象方法全部重写。

java 复制代码
//接口
public interface IRun {
    void run();
}

//类(实现接口)
public class Dog implements IRun{
    @Override
    public void run() {
        System.out.println("狗在跑");
    }
}

类和类之间是继承关系(extends),类和接口之间是实现(implements)

接口的特性

  • 接口是引用类型,但并不可以直接进行实例化(new 接口)。
  • 接口中的每一个方法都是被public abstract修饰,(我们实际编写代码的时候可以不用加上,接口方法会被隐式指定为public abstract,这样也就保持了我们代码的简洁性)
  • 接口中的方法并不会在接口中有实现,而在实现接口的类中实现。
  • 接口中不可以有被实现的方法,等同于只可以有抽象方法,但是两个除外(static和default修饰的)
  • 接口中可以有成员变量,只不过要被public static final修饰,编写代码的时候可以省略修饰,变量也会被隐式指定为public static final。
  • 重写接口方法的时候,不可以用default来修饰。(子类的访问权限要大于等于父类)
  • 接口中不可以有代码块和构造方法。
  • 如果类没有实现接口的抽象方法,那么类也要设置为抽象类。

多继承问题

  • 在Java中没有多继承,但通过接口却可以解决这个问题。我们来进一步理解一下extends和implements。
java 复制代码
//意思为,狗是一个动物具有跑的功能
//!!!当extends和implements同时出现的时候,extends必须在前面
public class Dog extends Animal implements IRun
  • 类不可以多继承,但一个类可以实现多个接口
java 复制代码
public class Dog extends Animal implements IRun,IEat
  • 类和接口之间为Implements,接口和接口之间要用extends,并且接口之间支持多继承
java 复制代码
interface IAmphibious extends IRunning, ISwimming {
}

对象类型进行比较

对于一般类型我们都可以比较出来大小,但我们如何对一个对象进行比较呢?下面我将来讲述两种方法。

1.如果对象对应的类可以进行比较,它需要实现接口Comparable(用来告诉我们这个类可以进行比较),然后我们需要重写实现的接口中的compareTo方法,然后在main方法中通过调用compareTo方法进行比较。

java 复制代码
//Comparable<Student>这个里面尖括号括起来的部分称为泛型,表示可以进行比较的类
class Student implements Comparable<Student>{
    String name;
    int age;
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    //这重写了compareTo,这里我编写的逻辑是根据年龄
    //s.compareTo(s1)===>s调用了方法,s就代表this,s1作为参数传过来,所以s1等同于下面的o
    @Override
    public int compareTo(Student o) {
        //根据年龄比较
        if (this.age > o.age) {
            return this.age - o.age;
        } else {
            return o.age - this.age;
        }
    }
}
public class JavaSE731 {
    public static void main(String[] args) {
        Student student = new Student("lisi",18);
        Student student1 = new Student("zhangsan",22);
        System.out.println(student.compareTo(student1));
    }
}

通过方法一我们可以对对象进行比较,但是有个不好的地方是,我们这次想根据年龄比较,然后把代码写死在了compareTo中,无论什么时候调用,他都是根据年龄去比较,但我们想根据姓名比较的时候呢?我们还需要再去compareTo代码中进行修改,很不方便。所以更推荐方法二。

2.通过比较器来比较。

java 复制代码
import java.util.Comparator;

class Student {
    String name;
    int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }
}
class AgeCompare implements Comparator<Student> {
    @Override
    public int compare(Student o1, Student o2) {
        return o1.age - o2.age;
    }
}
public class JavaSE731 {
    public static void main(String[] args) {
        Student student = new Student("zs",14);
        Student student1 = new Student("ws",22);
        AgeCompare ageCompare = new AgeCompare();
        System.out.println(ageCompare.compare(student,student1));
    }
}

我们通过年龄比较,就可以创建一个类实现接口Comparator接口,后面的泛型填写要比较的那个类。然后重写compare方法,在里面写上比较方法,在main函数中创建创建这个类的对象,将要比较的两个对象传过去。这种方法很灵活。

深拷贝和浅拷贝

Java提供了一个方法clone实现对象的克隆,但是要想调用这个方法必须得实现接口Clonable,否则就会报不支持克隆的异常。那么什么是深拷贝?什么是浅拷贝?

浅拷贝

java 复制代码
class Ban {
    int num = 19;

    @Override
    public String toString() {
        return "Ban{" +
                "num=" + num +
                '}';
    }
}
//浅拷贝
class Student implements Cloneable{
    String name;
    int age;
    Ban ban = new Ban();

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

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                "," + ban +
                '}';
    }
}
public class JavaSE731 {
    public static void main(String[] args) throws CloneNotSupportedException{
        Student student = new Student("zs",14);
        Student student1 = (Student) student.clone();
        student.ban.num = 99;
        System.out.println(student);
        System.out.println(student1);
    }
}

这里需要注意很多易错点:

1.对于要克隆的类必须得实现Cloneable接口,否则会报错(不支持克隆的错误)。

2.我们实现接口后,要将接口中方法clone重写,我们直接输入clone,Idea会给我们提供。此时我们并不需要对Idea写好的clone进行修改。

3.上面我在main中调用的clone方法,所以我们需要在main方法上抛出异常(这部分先照做,后面异常的时候再说为啥)。

4.调用完克隆方法后,我们需要将类型转为我们对应的类,因为clone()返回值为Object类型。

为了方便理解,请欣赏下图。

上面代码中可以看出是一个对象中有另外一个对象,但是浅拷贝就只会拷贝一层,比方说上面部分,并不会再创建一个ban对象,而是将地址直接拷贝过去了,这也正是浅拷贝。

深拷贝

深拷贝则与上面不同代码如下:

java 复制代码
class Ban implements Cloneable{
    int num = 19;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    @Override
    public String toString() {
        return "Ban{" +
                "num=" + num +
                '}';
    }
}
//深拷贝
class Student implements Cloneable{
    String name;
    int age;
    Ban ban = new Ban();

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

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Student student = (Student) super.clone();
        student.ban = (Ban) this.ban.clone();
        return student;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                "," + ban +
                '}';
    }
}
public class JavaSE731 {
    public static void main(String[] args) throws CloneNotSupportedException{
        Student student = new Student("zs",14);
        Student student1 = (Student) student.clone();
        student.ban.num = 99;
        System.out.println(student);
        System.out.println(student1);
    }
}

根据上面代码我们可以看出深拷贝的时候我们对Student的克隆方法进行了修改,并且将Ban类也实现了Cloneable的接口,表示可以进行克隆,并且重写了clone方法。

接口和抽象类区别

核心区别在于抽象类允许存在普通成员方法和成员变量,但是接口只允许存在抽象方法和常量。

Object类

Object类是最高的类,所有类的父类,任何对象都可以用Object接收。同时Object提供了很多方法。比方说toString,equals,hascode方法。当然提供的方法可能我们并不适用,这就需要我们重写这个方法,比方说提供的equals方法,对于引用类型而言,比较的就是地址。这就需要我们根据需要去更改。String类就重写了这个方法,方便字符串之间进行内容的比较。

内部类

内部类包括:实例内部类,静态内部类,局部内部类,匿名内部类

实例内部类

没有被static修饰的成员内部类

java 复制代码
public class JavaSE731 {
    class Student {
        
    }
}
  1. 在实例内部类中可以访问外部类中的任意访问权限的成员
  2. 在内部类中访问的时候,如果外部类和内部类中有相同名称的成员,则会优先访问内部类自己的
  3. 在内部类中访问的时候,如果要访问外部类同名成员时候,必须:外部类名称.this.同名成员名字
  4. 要想访问实例类中的成员,必须先实例化内部类,实例化的语法如下:
java 复制代码
OutClass.InnerClass innerClass1 = new OutClass().new InnerClass();
  1. 实例内部类的非静态方法中包含了外部类的引用。
  2. 实例内部类有两个引用:this表示内部类自己的,OuterClass.this表示外部类的
  3. 创建内部类对象时,必须先创建外部类对象。
  4. 实例内部类也受访问修饰符的限定。

静态内部类

被static修饰的成员内部类称为静态内部类

java 复制代码
public class JavaSE731 {
    static class Student {

    }
}
  1. 在静态内部类中只可以访问外部类的静态成员。
  2. 创建内部类对象时不需要创建外部类
  3. 静态内部类对象的创建:
java 复制代码
OutClass.InnerClass innerClass = new OutClass.InnerClass();

局部内部类

定义在外部类的方法内部或者{}内部的类叫做局部内部类。这个类只可以在定义位置使用。(很少使用)

java 复制代码
public class JavaSE731 {
    public void func() {
        class A {
            
        }
    }
}
  1. 局部内部类不可以被public,static修饰
  2. 只可以在方法内部使用

匿名内部类

创建匿名内部类缩减了我们子类继承父类,再重写父类方法,再创建子类对象的过程,直接一步到位了。

java 复制代码
父类 对象 = new 父类(){   重写父类中的方法   };
class Father {
    public void test() {
        System.out.println("父类");
    }
}
public class JavaSE731 {
    public static void main(String[] args) {
        Father father = new Father(){
            @Override
            public void test() {
                super.test();
            }
        };
    }
}
相关推荐
逊嘘6 分钟前
【Java语言】抽象类与接口
java·开发语言·jvm
Half-up9 分钟前
C语言心型代码解析
c语言·开发语言
morris13113 分钟前
【SpringBoot】Xss的常见攻击方式与防御手段
java·spring boot·xss·csp
龙哥说跨境30 分钟前
如何利用指纹浏览器爬虫绕过Cloudflare的防护?
服务器·网络·python·网络爬虫
Source.Liu30 分钟前
【用Rust写CAD】第二章 第四节 函数
开发语言·rust
monkey_meng31 分钟前
【Rust中的迭代器】
开发语言·后端·rust
余衫马33 分钟前
Rust-Trait 特征编程
开发语言·后端·rust
monkey_meng37 分钟前
【Rust中多线程同步机制】
开发语言·redis·后端·rust
七星静香38 分钟前
laravel chunkById 分块查询 使用时的问题
java·前端·laravel
Jacob程序员39 分钟前
java导出word文件(手绘)
java·开发语言·word