《抽象类和接口与深拷贝，几个重要的接口》

最新推荐文章于 2024-11-04 22:26:34 发布

学习代码的懒羊羊

最新推荐文章于 2024-11-04 22:26:34 发布

阅读量412

点赞数 1

分类专栏： JAVA SE 文章标签： java java-ee android

本文链接：https://blog.csdn.net/qq_62741582/article/details/124909208

版权

JAVA SE 专栏收录该内容

10 篇文章 1 订阅

订阅专栏

这里写目录标题

抽象类

1.1概念：在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的。
如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类

比如把狗，猫，这两个不同的动物有不同的行为，但他们有共同的属性可以继承动物，然后通过父类定义抽象方法用子类来实现，那么父类就可以被设为抽象类


/**
 *抽象类（abstract)
 * 1.被abstract修饰的类为抽象类
 * 2.被abstract修饰的方法也被称为抽象类
* 3.抽象类是不能进行实例化的
*4.抽象类和普通类一样可以定义成员变量和方法
*5.抽象方法不能被static private final 
 */
abstract class Shape{
    public abstract void draw();//抽象方法
}

1.2抽象类就是为了被继承继承

abstract class Shape{
    public abstract void draw();
}
class Rect extends Shape{
 //抽象类的出现可以说就是为了被继承的，
 //但当继承后，抽象类的抽象方法就一定要重写。

    @Override
    public void draw() {//重写抽象方法
        
    }
}

1.3抽象类继承抽象类

abstract class Shape{
    public abstract void draw();
}
abstract  class A extends Shape{
 //抽象类继承抽象类可以不重写draw方法
    public abstract void func1();
}
class B extends A{
//但当普通类继承A后要重写A和A父类的所有抽象类
    @Override
    public void draw() {
        
    }

    @Override
    public void func1() {

    }
}
class Rect extends Shape{

    @Override
    public void draw() {

    }
}

1.4抽象类虽然不能实例化但可以被继承间接实现

abstract class Shape{
    public abstract void draw();
}

class Rect extends Shape{

    @Override
    public void draw() {
        System.out.println("✔");
    }
}
public class Test {
    public static void main(String[] args) {
        Rect rect=new Rect();
        rect.draw();
    }
}

在这里插入图片描述

接口

/**
 * （interface）接口！！！（接口不能被实例化）
 *
 * 1.接口当中的成员变量，默认都是public static final 修饰的
 * 2.接口当中的方法是不能被实现的，想要实现可以加 default修饰（从jdk8才有）
 * 3.接口当中可以有静态的方法，但不管是静态的方法还是普通方法都是被public修饰的
 *4.子类重写父类子类方法，子类的修饰符必须大于等于父类
 *5.接口当中不能有静态，实例代码块，构造方法。
 */
interface IShape{

    public static final int a=10;//变量默认是被 public static final 修饰的（变量要初始化）
    public abstract void func1();//方法默认是被 public abstract修饰的

}

1.2接口和类是被implements 来连接的

interface IShape{

     int a=10;
     default void func(){
         System.out.println("✔");
     }
     void draw();

}
class Flower implements IShape{
//必须重写接口的抽象方法
    @Override
    public void draw() {
        func();//可以调用父类的方法
         System.out.println("✔");
    }
}

public class Test {
    public static void func1(IShape iShape){
        iShape.draw();//可以引用向上转型来具体实现
    }

    public static void main(String[] args) {
        func1(new Flower());
    }

}

1.3实现多个接口

abstract class Animal{
    public String name;
    public int age;

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

}

interface IFly{
    
    void fly();//飞
}
interface IRun extends IFly{//IRun 继承 IFly
//通过接口来实现多个行为
    void run();//跑
}

class Bird extends Animal implements IRun{//也可以通过 IFly，IRun......连接很多接口
//链接了两个接口
    public Bird(String name, int age) {
        super(name, age);
    }

    @Override
    public void eat() {
        System.out.println(name+"正在吃鸟粮！！！");
    }

    @Override
    public void fly() {//重写接口中的方法
        System.out.println(name+"小鸟正在飞！！！");

    }

    @Override
    public void run() {//重写接口中的方法
        System.out.println(name+"小鸟正在蹦着跑！！！");
    }
}

public class Test {
    public static void func2(IRun iRun){//通过的引用来访问不同的行为
        iRun.run();
        iRun.fly();
    }

    public static void main(String[] args) {
        func2(new Bird("小鸟",4));//把子类的对象给接口的引用
    }
}

在这里插入图片描述

1.4接口功能的扩展

interface A{
    void date1();
}
interface B{
    void date2();
}
interface C extends A,B{
    void date3();
}
class T implements C {
    /**
     * 接口功能的扩展
     */
    @Override
    public void date1() {
        
    }

    @Override
    public void date2() {

    }

    @Override
    public void date3() {

    }
}

接口（1.Comparable）

mport java.util.Arrays;

class Student implements Comparable<Student> {
    public String name;
    public int age;
    public double score;

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

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

    @Override
    public int compareTo(Student o) {
        return this.age-o.age;
    }
}

public class Test {
    public static void main2(String[] args) {
        Student[] students=new Student[3];
        students[0] =new Student("abc",23,44.4);
        students[1] =new Student("ert",18,99.4);
        students[2] =new Student("qwe",28,97.4);
        System.out.println("排序前"+Arrays.toString(students));
        Arrays.sort(students);//用sort方法排序
        System.out.println("排序后"+Arrays.toString(students));

    }
}

在这里插入图片描述

总结：如果以后是自定义类型的数据，牵扯到大小的比较，需要进行一些设计

的，比如实现这个接口

2.Comparator(比较器)

class Student  {
    public String name;
    public int age;
    public double score;

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

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


}

直接定义用Comparator接口来实现多个比较

class AgeComparator implements Comparator<Student>{

    @Override
    public int compare(Student o1, Student o2) {
        return o1.age-o2.age;//比较整数
    }
}
class ScoreComparator implements Comparator<Student>{

    @Override
    public int compare(Student o1, Student o2) {
        return (int)(o1.score-o2.score);//比较小数
    }
}
class NameComparator implements Comparator<Student>{
//比较年龄会有一个默认的Comparator放法
    @Override
    public int compare(Student o1, Student o2) {
        return o1.name.compareTo(o2.name);
    }
}

单个比较

public class Test {
    public static void main(String[] args) {
        Student student1=new Student("abc",23,44.4);
        Student student2=new Student("ert",18,99.4)
 //这样非常的灵活，你想比较什么只需要写一个这个比较的类，在通过这个类的引用调用就行了
            
    AgeComparator ageComparator=new AgeComparator();
  int ret1 =ageComparator.compare(student1,student2);
        System.out.println(ret1);
 ScoreComparator scoreComparator=new ScoreComparator();    int ret2= scoreComparator.compare(student1,student2);
        System.out.println(ret2);


    }

多个比较

public class Test {
    public static void main(String[] args) {
        Student[] students=new Student[3];
        students[0] =new Student("abc",23,44.4);
        students[1] =new Student("ert",18,99.4);
        students[2] =new Student("qwe",28,97.4);
        System.out.println("排序前"+Arrays.toString(students));
        //这样更灵活可以比较数组内的多个数据
        AgeComparator ageComparator=new AgeComparator();
        Arrays.sort(students,ageComparator);
        ScoreComparator scoreComparator=new ScoreComparator();
        Arrays.sort(students,scoreComparator);
        System.out.println("排序后"+Arrays.toString(students));
        
    }
}

深拷贝

class Money implements Cloneable{
    public int money=20;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();//克隆的是money
    }
}


class Person implements Cloneable{//是个空接口表示可以被克隆
    public int age=10;
    public Money m=new Money();

    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                '}';
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
      Person tmp= (Person) super.clone();//克隆Person的对象
        tmp.m= (Money) this.m.clone();//克隆的是Money的内容
        return tmp;//这个克隆的是Person和Money两个

    }
}

public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person person1=new Person();
       Person person2= (Person) person1.clone();//克隆产生一个新的对象
        System.out.println("克隆前 "+person1.m.money);
        person2.m.money=199;
        System.out.println("克隆后"+person2.m.money);
//此时修改money的值不会影响person1的money（完成了深拷贝）


    }
}