一:接口和抽象类
①接口的定义:
声明方式:
接口使用interface
关键字来声明,后跟接口的名称和接口体(包含常量和方法声明的代码块)
java
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关键字实例化一个对象。
java
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操作符,但是语法更加动态。
java
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()方法更加灵活,因为可以选择不同的构造函数。
java
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()方法来实现深克隆。
java
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. 使用反序列化
反序列化是将对象从字节流中恢复的过程。通过序列化后,可以把对象存储到文件或网络中,然后再通过反序列化的方式恢复成对象。
java
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. 使用工厂模式
工厂模式可以将对象的创建和使用解耦。通过定义一个对象工厂,可以更加灵活地产生对象。
java
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注意事项
- 抽象类不能创建对象,如果创建,编译无法通过而报错。只能创建其非抽象子类的对象。
理解:假设创建了抽象类的对象,调用抽象的方法,而抽象方法没有具体的方法体,没有意义。
- 抽象类中,可以有构造方法,是供子类创建对象时,初始化父类成员使用的。
理解:子类的构造方法中,有默认的super(),需要访问父类构造方法。
- 抽象类中,不一定包含抽象方法,但是有抽象方法的类必定是抽象类。
理解:未包含抽象方法的抽象类,目的就是不想让调用者创建该类对象,通常用于某些特殊的类结构设 计。
- 抽象类的子类,必须重写抽象父类中所有的抽象方法,否则,编译无法通过而报错。除非该子类也是抽象类。
理解:假设不重写所有抽象方法,则类中可能包含抽象方法。那么创建对象后,调用抽象的方法,没有意义。
四.接口和抽象类的区别
相似点:
(1)接口和抽象类都不能被实例化
(2)实现接口或继承抽象类的普通子类都必须实现这些抽象方法
不同点:
(1)抽象类可以包含普通方法和代码块,接口里只能包含抽象方法,静态方法和默认方法,
(2)抽象类可以有构造方法,而接口没有
(3)抽象类中的成员变量可以是各种类型的,接口的成员变量只能是 public static final 类型的,并且必须赋值