java基础，接口和抽象类

一：接口和抽象类

 

①接口的定义：

声明方式：

接口使用interface关键字来声明，后跟接口的名称和接口体（包含常量和方法声明的代码块）

public interface ObjectService extends IService<ObjectDO> {

 /**
     * 创建扶优对象信息
     *
     * @param createReqVO 创建信息
     * @return 编号
     */
    Long createObject(@Valid ObjectSaveReqVO createReqVO);

    /**
     * 更新扶优对象信息
     *
     * @param updateReqVO 更新信息
     */
    void updateObject(@Valid ObjectSaveReqVO updateReqVO);

    /**
     * 删除扶优对象信息
     *
     * @param id 编号
     */
    void deleteObject(Long id);

    /**
     * 获得扶优对象信息
     *
     * @param id 编号
     * @return 扶优对象信息
     */
    ObjectDO getObject(Long id);


}

二、接口的特点

1. 抽象性：接口中的所有方法都是抽象的，即它们只有方法签名，没有实现体。接口中的方法默认是public abstract的，但这两个关键字可以省略。
2. 不能实例化：接口不能实例化，即不能使用new关键字来创建接口的对象。但是，可以使用接口类型的变量来引用实现了接口的类的实例。
3. 多继承：一个类可以实现多个接口，这是Java中实现多重继承的一种方式（Java不允许多重类继承，但允许多重接口继承）。
4. 常量：接口中可以定义常量，这些常量默认是public static final的，但通常省略这些修饰符。
5. 默认方法和静态方法（Java 8及以上）：除了抽象方法外，接口中还可以包含默认方法和静态方法。这些方法有具体的实现体，可以在接口中直接定义。

2.1对象的实例化：

1.new关键字是Java中最常用的创建对象的方式。通过调用类的构造函数，new关键字实例化一个对象。

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

Person person = new Person("小明", 18);

 

2.Class的newInstance()方法可以在运行时创建一个类的新实例。它等效于使用new操作符，但是语法更加动态。

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

try {
    Person person = Person.class.newInstance();
    person.name = "小明";
    person.age = 18;
} catch (Exception e) {
    e.printStackTrace();
}

3. 使用Constructor的newInstance()方法

Constructor的newInstance()方法可以在运行时创建一个类的新实例，并且可以传入构造函数的参数。这种方式比Class的newInstance()方法更加灵活，因为可以选择不同的构造函数。

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

try {
    Constructor<Person> constructor = Person.class.getConstructor(String.class, int.class);
    Person person = constructor.newInstance("小明", 18);
} catch (Exception e) {
    e.printStackTrace();
}

4.使用clone()方法

clone()方法可以创建对象的一个副本，并且可以重写clone()方法来实现深克隆。

public class Person implements Cloneable {
    String name;
    int age;

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

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

Person person = new Person("小明", 18);
Person clone = null;
try {
    clone = (Person) person.clone();
} catch (CloneNotSupportedException e) {
    e.printStackTrace();
}

5. 使用反序列化

反序列化是将对象从字节流中恢复的过程。通过序列化后，可以把对象存储到文件或网络中，然后再通过反序列化的方式恢复成对象。

public class Person implements Serializable {
    String name;
    int age;

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

Person person = new Person("小明", 18);

try {
    ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("person.dat"));
    oos.writeObject(person);
    oos.close();
    
    ObjectInputStream ois = new ObjectInputStream(new FileInputStream("person.dat"));
    Person clone = (Person) ois.readObject();
    ois.close();
} catch (Exception e) {
    e.printStackTrace();
}

6. 使用工厂模式

工厂模式可以将对象的创建和使用解耦。通过定义一个对象工厂，可以更加灵活地产生对象。

public interface Animal {
    String getName();
}

public class Cat implements Animal {
    @Override
    public String getName() {
        return "Cat";
    }
}

public class Dog implements Animal {
    @Override
    public String getName() {
        return "Dog";
    }
}

public class AnimalFactory {
    public Animal createAnimal(String type) {
        switch (type) {
            case "Cat":
                return new Cat();
            case "Dog":
                return new Dog();
            default:
                throw new IllegalArgumentException("Unsupported animal type: " + type);
        }
    }
}

AnimalFactory factory = new AnimalFactory();
Animal cat = factory.createAnimal("Cat");
Animal dog = factory.createAnimal("Dog");

 

 

2.2、接口的使用

• 实现接口：一个类使用implements关键字来实现一个或多个接口。实现接口的类必须提供接口中所有抽象方法的具体实现（除非该类也是抽象类）。
• 接口回调：接口常被用于回调机制中，允许将实现接口的类的实例传递给其他对象，以便在适当的时候调用这些实现的方法。
• 标记接口：一种特殊的接口，不包含任何方法或常量，仅用于标记实现了该接口的类具有某种特定的属性或功能。

2.3、接口的作用

• 定义规范：接口定义了类必须遵循的规范，即类必须实现接口中定义的方法。
• 解耦：接口的使用降低了类之间的耦合度，提高了系统的灵活性和可扩展性。
• 多态：接口是实现多态的一种方式，通过接口类型的变量可以引用实现了接口的类的实例。

三，抽象类

1 概述

父类中的方法，被他的子类们重写，子类各自的实现都不尽相同。那么父类的方法声明和方法主体，只有声明还有 意义，而方法主体则没有存在的意义了。我们把没有方法主体的方法称为抽象方法。Java语法规定，包含抽象方法 的类就是抽象类。

总的来说就是：

抽象方法：没有方法体的方法
抽象类：包含抽象方法的类

2 abstract的使用格式

2.1抽象方法

使用abstrct关键字修饰的方法就是抽象方法，值得注意的是，抽象方法只包含一个方法名，没有方法体。

定义格式为：

修饰符 abstract 返回值类型 方法名 (参数列表)；
代码举例：

public abstract void run()；

 

2.2 抽象类

如果一个类包含抽象方法，那么该类必须是抽象类。

定义格式：

abstract class 类名字 {
}
代码举例：

public abstract class Animal {
    public abstract void run()；
}

2.3 抽象类的使用

继承抽象类的子类必须重写父类所有的抽象方法。否则，该子类也必须声明为抽象类。最终，必须有子类实现该父类的抽象方法，否则，从最初的父类到最终的子类都不能创建对象，失去意义。

继承抽象类的子类必须重写父类所有的抽象方法！！！！！！！！！！！。

 

3注意事项

1. 抽象类不能创建对象，如果创建，编译无法通过而报错。只能创建其非抽象子类的对象。

理解：假设创建了抽象类的对象，调用抽象的方法，而抽象方法没有具体的方法体，没有意义。
2. 抽象类中，可以有构造方法，是供子类创建对象时，初始化父类成员使用的。

理解：子类的构造方法中，有默认的super()，需要访问父类构造方法。

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

理解：未包含抽象方法的抽象类，目的就是不想让调用者创建该类对象，通常用于某些特殊的类结构设 计。
4. 抽象类的子类，必须重写抽象父类中所有的抽象方法，否则，编译无法通过而报错。除非该子类也是抽象类。

理解：假设不重写所有抽象方法，则类中可能包含抽象方法。那么创建对象后，调用抽象的方法，没有意义。

四.接口和抽象类的区别

相似点：

（1）接口和抽象类都不能被实例化

（2）实现接口或继承抽象类的普通子类都必须实现这些抽象方法

不同点：

（1）抽象类可以包含普通方法和代码块，接口里只能包含抽象方法，静态方法和默认方法，

（2）抽象类可以有构造方法，而接口没有

（3）抽象类中的成员变量可以是各种类型的，接口的成员变量只能是 public static final 类型的，并且必须赋值