JAVA语法四：抽象类和接口

最新推荐文章于 2024-08-26 16:40:46 发布

崽_85

最新推荐文章于 2024-08-26 16:40:46 发布

阅读量164

点赞数 6

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

本文链接：https://blog.csdn.net/qq_56701924/article/details/126317441

版权

java 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

2.1：接口的概念-------使用interface来修饰

2.6:Comparable接口和Comparator

1.抽象类

1.1：抽象类概念

如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

包含抽象方法的类我们称为抽象类。

1.2：抽象类特性

public abstract class shape//这就是抽象类，被abstract修饰的类

abstract  void draw()//被abstract修饰的方法，没有方法体，不能被实例化

注意：抽象类也是类，内部可以包含普通方法和属性，甚至构造方法，抽象类存在的最大意义就是继承，不能实例化抽象类。

1.抽象方法不能是private , static, final的，要满足重写的规则。

2.抽象类必须被继承，并且继承后子类要重写父类中的抽象方法，否则子类也是抽象类，

3.抽象类中不一定包含抽象类，但是又抽象方法的类一定是抽象类。

4.抽象类中可以有构造方法，供子类创建对象时，初始化父类的成员变量。

2.接口

2.1：接口的概念-------使用interface来修饰

接口可以看出是：多个类的公共规范，是一种引用数据类型。

2.2：语法规则

public interface ioperation{}//将class关键字换成interface关键字。

2.3：接口使用

类与接口之间是implements实现关系

接口不能直接使用，必须要用一个"实现类"来实现该接口，实现接口中的所有抽象方法。

2.4:接口特性

1.接口类型是一种引用类型，但不能直接new接口对象。

2.接口中每一个方法都是public的抽象方法，及接口中的方法会被隐式的指定为public abstract，其他修饰符都会报错。

3.接口中的方法是不能在接口中实现，只能由实现接口的类来实现。

4.接口可以含有变量，但是接口中的变量会被隐式的指定为public static final变量。

6.接口中不能由静态代码块和构造方法。

7.如果类没有实现接口中的所有抽象方法，则类必须设置为抽象类。

2.5：实现多个接口

注意：

一个类实现多个接口时，每个接口的抽象方法都要实现，否则类必须设置为抽象类。

2.5.1：接口之间的继承

接口可以继承一个接口，达到复用的效果，使用extends 关键字。

2.6:Comparable接口和Comparator

2.6.1：Compareable接口

class student implements Comparable<student>{
    public String name;
    public int age;
    public student(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public int compareTo(student o) {//这里是对compareTo的重写
        if(this.age>o.age){//这里是根据年龄大小进行比较
            return 1;
        }else if(this.age<o.age){
            return -1;
        }else{
            return 0;
        }
    }


    @Override
    public String toString() {
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }

public class Test1 {
    public static void main(String[] args) {
        student s1=new student("wangming",16);
        student s2=new student("ab",18);
        if(s1.compareTo(s2)>0){
            System.out.println("s1>s2");
        }else if(s1.compareTo(s2)<0){
            System.out.println("s1<s2");
        }else{
            System.out.println("s1=s2");
        }
    }
}

这里就是对Comparable接口，并实现其中的compareTo方法

1.第一个数大于第二个数，返回值大于零。

2.第一个小于第二个数，返回值小于零。

3.两个数相等，返回值是零。

比较的是ASCII值。

2.6.2：Comparator接口

  class AgeCompara implements Comparator<student>{
        @Override
        public int compare(student o1, student o2) {
            return o1.age-o2.age;
        }
    }
    class NameCompara implements  Comparator<student>{
        @Override
        public int compare(student o1, student o2) {
            return o1.name.compareTo(o2.name);//这里
            //返回的是不相等的字符的ASCII值。
        }
    }
public class Test1 {
    public static void main(String[] args) {
        student s1=new student("wangming",16);
        student s2=new student("ab",18);
        AgeCompara ageCompara=new AgeCompara();
        if(ageCompara.compare(s1,s2)>0){
            System.out.println("s1>s2");
        }else if(ageCompara.compare(s1,s2)<0){
            System.out.println("s1<s2");
        }else {
            System.out.println("s1=s2");
        }
        NameCompara nameCompara=new NameCompara();
        int flag= nameCompara.compare(s1,s2);
        System.out.println(flag);

3：接口和抽象类的区别

抽象类中可以包含普通方法和普通字段，这样的普通方法和字段可以被子类直接使用，不必重写，而接口中不能包含普通方法，子类必须重写所有的抽象方法。

4.浅拷贝和深拷贝----针对与引用对象

所谓的拷贝，就是把变量的内容进行拷贝，把一个对象的值赋给另外一个对象，就是把一个对象拷贝一份，创建一个完全一样的对象。

要讲深浅拷贝，我们要了解到一个函数clone函数。

4.1:clone 函数

首先分配一个和源对象同样大小的空间。在这个空间创建一个与源对象内容一样的新对象。

4.2：浅拷贝和深拷贝

4.2.1：浅拷贝

class Money {
    public double m = 200.0;
}
class Person implements Cloneable{
    public String name="张三";
    public Money money = new Money();

    @Override
    protected Object clone() throws CloneNotSupportedException {
                           //没有对Cloneable的接口实现，就会抛出CloneNotSupportedException
        Person tmp = (Person) super.clone();
        tmp.money = (Money) this.money;
        return tmp;
    }

    @Override
    public String toString() {//对toString的重写
        return "Person{" +
                '}';
    }
}
public class Main {
    public static void main(String[] args) throws
            CloneNotSupportedException{
        Person person = new Person();

        Person person2 = (Person)person.clone();
        person2.money.m = 1999;

        System.out.println(person.name+" "+person.money.m);

        System.out.println(person2.name+" "+person2.money.m);
    }

4.2.2：深拷贝

对与这个来说，我们需要把person中的money对象进行拷贝，这样叫做深拷贝

class Money implements Cloneable{//你要进行拷贝，就要实现Cloneable
    public double m = 200.0;

    @Override
    protected Object clone() throws CloneNotSupportedException {
                                   //要对clone()接口进行重写
        return super.clone();
    }
}
class Person implements Cloneable{
    public String name="张三";
    public Money money = new Money();

    @Override
    protected Object clone() throws CloneNotSupportedException {
        Person tmp = (Person) super.clone();
        tmp.money = (Money) this.money.clone();
        return tmp;
    }