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);}

二、接口的特点

抽象性：接口中的所有方法都是抽象的，即它们只有方法签名，没有实现体。接口中的方法默认是public abstract的，但这两个关键字可以省略。
不能实例化：接口不能实例化，即不能使用new关键字来创建接口的对象。但是，可以使用接口类型的变量来引用实现了接口的类的实例。
多继承：一个类可以实现多个接口，这是Java中实现多重继承的一种方式（Java不允许多重类继承，但允许多重接口继承）。
常量：接口中可以定义常量，这些常量默认是public static final的，但通常省略这些修饰符。
默认方法和静态方法（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;}@Overrideprotected 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 {@Overridepublic String getName() {return "Cat";}
}public class Dog implements Animal {@Overridepublic 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");