Classe abstraite
Revue
package org.westos.demo;
/**
* @author lwj
* @date 2020/4/20 16:46
*/
public class MyDemo {
public static void main(String[] args) {
Panda panda = new Panda();
//抽象类AbstractAnimal初始化
//Panda构造方法执行了
System.out.println(panda.num);
//20
}
}
abstract class AbstractAnimal {
/** 抽象类不能直接实例化，但是抽象类存在构造方法，目的是子类在创建对象时需要初始化父类（抽象类）的数据 */
public AbstractAnimal() {
System.out.println("抽象类AbstractAnimal初始化");
//1
}
public void sleep() {
System.out.println("睡觉");
}
/**
* 抽象方法eat
*/
protected abstract void eat();
}
class Panda extends AbstractAnimal {
{
num = 20;
}
int num;
public Panda() {
System.out.println("Panda构造方法执行了");
//2
}
@Override
protected void eat() {
System.out.println("大熊猫吃竹子");
}
}
class Cat extends AbstractAnimal {
public Cat() {
System.out.println("Cat构造方法执行了");
}
@Override
protected void eat() {
System.out.println("猫咪吃小鱼干");
}
}
Caractéristiques des membres de la classe abstraite
- Variables membres: peuvent être des variables ou des constantes
- Constructeur: existe, utilisé pour initialiser les données de la classe parent lorsque la classe enfant crée un objet
- Méthode membre: elle peut être abstraite ou non abstraite.
- Méthodes abstraites: forcer les sous-classes à implémenter des méthodes abstraites
- Méthodes non abstraites: les sous-classes peuvent remplacer les méthodes de la classe parente ou non
package org.westos.demo;
/**
* @author lwj
* @date 2020/4/20 17:14
*/
public class MyDemo2 {
public static void main(String[] args) {
Student student = new Student(2);
System.out.println(student.nation);
//中国
student.show();
//我是父类
//子类重写父类的show()方法
student.abstractMethod();
//我是子类
}
}
abstract class AbstractPerson {
public int id = 1;
/** final类型变量在定义后，1、在定义声明时初始化，2、在构造代码块中初始化，3、在构造方法中初始化 */
public final String nation;
{
nation = "中国";
}
public AbstractPerson(int id) {
this.id = id;
}
/** 抽象方法 */
public abstract void abstractMethod();
public void show() {
System.out.println("我是父类");
}
}
class Student extends AbstractPerson {
/*由于父类的构造方法只有一个有参构造，而子类默认无参构造，调用父类的无参构造失败，所以报错，
解决：子类生成一个有参构造，并且显式调用父类有参构造 */
public Student(int id) {
super(id);
}
@Override
public void abstractMethod() {
System.out.println("我是子类");
}
@Override
public void show() {
super.show();
System.out.println("子类重写父类的show()方法");
}
}
Questions d'entretien dans la classe abstraite
1. S'il n'y a pas de méthode abstraite pour une classe, peut-elle être définie comme une classe abstraite? Si oui, quel est l'intérêt?
Oui, vous ne pouvez pas créer de tels objets.
2. Avec quels mots-clés l'abrégé peut-il coexister?
-
Méthode de modification abstraite, les sous-classes doivent remplacer cette méthode, méthode de modification privée, la sous-classe ne peut pas hériter, elle ne peut pas être remplacée, donc en conflit;
-
Classe modifiée abstraite, représentant la classe abstraite, la sous-classe hérite de la classe abstraite, conflit avec final (la classe modifiée, la classe modifiée ne peut pas être héritée);
-
Les méthodes de décoration abstraite, représentant les méthodes abstraites dans les classes abstraites, les sous-classes héritant des classes abstraites, doivent implémenter des méthodes abstraites dans les classes abstraites et entrer en conflit avec les méthodes finales (les méthodes de décoration, les méthodes modifiées ne peuvent pas être remplacées par les sous-classes);
-
Méthode de modification abstraite, représentant la méthode abstraite, sans corps de méthode, la méthode de modification statique représente la méthode statique, avec le corps de méthode, ne participe pas à la réécriture, ne peut pas coexister, n'a pas de sens.
Interface
Caractéristiques de l'interface
- L'interface est représentée par le mot clé interface, le nom de l' interface d'interface {}
- La classe implémente l'interface en utilisant le mot clé implements, la classe class implémente le nom de l'interface {}
- L'interface ne peut pas être instanciée, instanciée de manière polymorphe
- Sous-classe d'interface
- Classe abstraite, nom de classe de classe abstraite implémente le nom d'interface {}
- Classe concrète, pour remplacer toutes les méthodes abstraites de l'interface, le nom de classe de classe implémente le nom d'interface {}
package org.westos.demo2;
/**
* @author lwj
* @date 2020/4/20 17:33
*/
public class MyDemo {
}
interface IExpandMethod {
/**
* 打电话
*/
public abstract void call();
}
abstract class AbstractAnimal implements IExpandMethod {
}
class Animal implements IExpandMethod {
@Override
public void call() {
System.out.println("具体类必须实现接口中所有方法");
}
}
Caractéristiques des membres de l'interface
- Variables membres: ne peuvent être que des constantes et public static, le modificateur par défaut: public static final
- Constructeur: Il n'y a pas de constructeur dans l'interface
- Méthode membre: ne peut être qu'une méthode abstraite, le modificateur par défaut: résumé public
Classe et classe, Classe et interface, Interface et interface
- Classe et classe: relation d'héritage, seulement héritage unique, héritage multiple;
- Classe et interface: relation d'implémentation, peut être implémentée une ou plusieurs, plusieurs interfaces sont
,séparées et plusieurs interfaces peuvent être implémentées tout en héritant d'une classe; - Interface et interface: relation d'héritage, peut être un héritage unique ou un héritage multiple.
//类与类：extends，单继承
//类与接口：implements，单实现，多实现
public final class Integer extends Number implements Comparable<Integer> {}
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable{}
//接口与接口：extends，单继承，多继承
public interface List<E> extends Collection<E> {}
public interface SortedMap<K,V> extends Map<K,V> {}
La différence entre les classes abstraites et les interfaces
Différences entre les membres:
- Classe abstraite:
- Variables membres: variable, constante
- Constructeur: il y a un constructeur
- Méthodes membres: peut être abstrait, peut être non abstrait
- Interface:
- Variables membres: seules les constantes
- Constructeur: Il n'y a pas de constructeur
- Méthodes membres: uniquement résumé
Différence de relation:
- Classe et classe
- Héritage
- Classes et interfaces
- Réalisez, réalisez seul, réalisez plusieurs
- Interfaces et interfaces
- Héritage, héritage simple, héritage multiple
Différences dans les concepts de conception:
- Classe abstraite
- Ce qui est hérité est la relation "est un". La classe abstraite définit les fonctions communes de la classe héritée
- Interface
- Ce qui est réalisé reflète la relation "like a", et les fonctions étendues du système d'héritage sont définies dans l'interface
Remarque: Après JDK 1.8, une méthode décorée avec défaut est fournie dans l'interface , qui peut donner l'implémentation spécifique de la fonction, et la sous-classe peut en hériter.
package org.westos.demo3;
/**
* @author lwj
* @date 2020/4/20 20:09
*/
public interface IExpandMethod {
int NUMBER = 10;
/**
* 1、jdk1.7 公共静态常量和public abstract抽象方法
* 钻火圈
*/
void fire();
/**
* 2、jdk1.8 增加default关键字修饰方法，可以存在方法体，默认权限修饰符为public
* 展示
*/
default void show() {
System.out.println("展示");
}
/**
* 3、jdk1.8 增加static静态方法，默认权限修饰符为public
* 测试
*/
static void test() {
System.out.println("静态方法");
}
}
class ExpandMethodImpl implements IExpandMethod {
@Override
public void fire() {
System.out.println("钻火圈");
}
}
class MyDemo {
public static void main(String[] args) {
IExpandMethod test = new ExpandMethodImpl();
test.fire();
//钻火圈
test.show();
//展示
System.out.println(IExpandMethod.NUMBER);
//10
IExpandMethod.test();
//静态方法
}
}
Exercices de classe et d'interface abstraits
Classe abstraite
package org.westos.demo3;
/**
* @author lwj
* @date 2020/4/20 20:36
*/
public abstract class Animal {
public String name;
public int age;
/**
* 吃饭
*/
public abstract void eat();
/**
* 睡觉
*/
public abstract void sleep();
}
Classe d'implémentation
package org.westos.demo3;
/**
* @author lwj
* @date 2020/4/20 20:38
*/
public class Cat extends Animal{
@Override
public void eat() {
System.out.println("猫吃鱼");
}
@Override
public void sleep() {
System.out.println("猫睡觉");
}
}
Fonctions étendues
package org.westos.demo3;
/**
* 扩展功能
* @author lwj
* @date 2020/4/20 20:42
*/
public interface IHighJump {
/**
* 动物跳高
*/
void highJump();
}
Garfield
package org.westos.demo3;
/**
* 加菲猫
* @author lwj
* @date 2020/4/20 20:40
*/
public class Garfield extends Cat implements IHighJump{
@Override
public void eat() {
System.out.println("加菲猫吃鱼排");
}
@Override
public void sleep() {
System.out.println("加菲猫睡在沙发上");
}
@Override
public void highJump() {
System.out.println("加菲猫学会了跳高");
}
}
Chat civette
package org.westos.demo3;
/**
* 狸花猫
* @author lwj
* @date 2020/4/20 20:44
*/
public class CivetCat extends Cat {
@Override
public void eat() {
System.out.println("狸花猫吃鱼翅");
}
@Override
public void sleep() {
System.out.println("狸花猫睡在摇篮里");
}
public void catchMouse() {
System.out.println("狸花猫抓老鼠");
}
}
Méthode d'essai
package org.westos.demo3;
/**
* @author lwj
* @date 2020/4/20 20:46
*/
public class MyTest {
public static void main(String[] args) {
Garfield garfield = new Garfield();
Cat cat = garfield;
cat.name = "波斯猫";
cat.age = 2;
cat.eat();
cat.sleep();
IHighJump jump = garfield;
jump.highJump();
System.out.println("===============");
CivetCat civetCat = new CivetCat();
cat = civetCat;
cat.name = "狸花猫";
cat.age = 3;
cat.eat();
cat.sleep();
CivetCat civetCat1 = (CivetCat) cat;
//执行CivetCat的特有方法，需要向下转型
civetCat1.catchMouse();
}
}