In this example of printing graphics , We found , Parent class Shape Medium draw The method seems to have no practical work , The main graphics are drawn by various subclasses of Shape draw Method to complete . A method like this that doesn't actually work , We can design it into a Abstract method (abstract method) , Classes that contain abstract methods are called abstract class (abstract class)

stay draw Add method before abstract keyword , Indicates that this is an abstract method . At the same time, abstract methods have no method body ( No, { }, Cannot execute specific code) For classes that contain abstract methods, Must add abstract Keyword indicates that this is an abstract class

Therefore, the above code for printing graphics can be optimized as follows:

abstract class Shape{
   public abstract void draw();
}
class Rect extends Shape{
   @Override
   public void draw(){
      System.out.println("♦");
   }
}
class Flower extends Shape{
   @Override
   public void draw(){
      System.out.println("❀");
   }
}
public class Test{
   public static void drawMap(Shape shape){
      shape.draw();//Dynamic binding
   } 
   public static void main(String[] args){
      Shape shape1 = new Rect();//Upward transformation
      Shape shape2 = new Flower();//Upward transformation
      drawMap(shape1);
      drawMap(shape2);
   }
}

3. Some precautions

(1) Abstract classes cannot be instantiated. Therefore, abstract classes can only be inherited

(2) Abstractions can also contain the same members and methods as ordinary classes

abstract class Shape{
   public int a;
   public void func(){
      System.out.println("Common test methods!");
   }
   public abstract void draw();//Abstract method
}

(3) If an ordinary class inherits an abstract class, all abstract methods of the abstract class need to be overridden in the ordinary class

abstract class Shape{
   public int a;
   public void func(){
      System.out.println("Common test methods!");
   }
   public abstract void draw();//Abstract method
}
class Rect extends Shape{
   @Override
   public void draw(){
      System.out.println("♦");
   }
}

(4) If an abstract class a inherits an abstract class B, the abstract class A may not implement the abstract method of the abstract parent class B; However, after a is inherited by an ordinary class again, the abstract methods in the two abstract classes a and B must be overridden (they must always be returned if they are mixed)

abstract class Shape{
   public int a;
   public void func(){
      System.out.println("Common test methods!");
   }
   public abstract void draw();//Abstract method
}
abstract class A extends Shape{
   public abstract void funcA();
}
class B extends A{
   @Override
   public void funcA(){
      ......
   }
   @Override
   public abstract void draw(){
      ......
   }
}

(5) Abstract classes cannot be modified by final, and abstract methods cannot be modified by final (the function of final is to restrict classes from being inherited, but the function of abstract classes is to be inherited. The two contradict each other)

(6) Abstract methods cannot be private

4. Role of abstract classes

2, Interface

1. Elaboration

2. Grammar rules

(1) When we create an interface, the name of the interface usually starts with the capital letter I

(2) Interface naming generally uses the word of "adjective"

(3) Alibaba coding specification stipulates that methods and attributes in the interface should not be decorated with any symbols to keep the code concise

Sometimes we need to make a class inherit from multiple parent classes at the same time . This thing is passed in some programming languages Multiple inheritance The way to achieve However, Java Only single inheritance is supported in , A class can only extends A parent class . However, multiple interfaces can be implemented at the same time , It can also achieve the similar effect of multi inheritance

class Animal{
    protected String name;

    public Animal(String name){
        this.name = name;
    }
}
interface IFlying{
    void flying();
}
interface IRunning{
    void running();
}
class Duck extends Animal implements IFlying,IRunning{
    public Duck(String name){
        super(name);
    }
    @Override
    public void flying(){
        System.out.println(this.name+" Flying!");
    }
    @Override
    public void running(){
        System.out.println(this.name+" Running!");
    }
}
class Cat extends Animal implements IRunning {
    public Cat(String name) {
        super(name);
    }
    @Override
    public void running() {
        System.out.println(this.name + " Running");
    }
}
public class TestDemo{
    public static void runFunc(IRunning iRunning){
        iRunning.running();
    }
    public static void main(String[] args){
        runFunc(new Duck("haha"));
        runFunc(new Cat("hehe"));
    }
}

Compile and run the program, and the output is as follows:

haha is running

hehe is running

Object There is one in the class clone method , Call this method to create an object " Copy ". But if you want to call it legally clone method , Clonable must be implemented first Interface , Otherwise, it will be thrown CloneNotSupportedException abnormal

Cloneable interface is an empty interface, which is a flag interface, representing that the current class can be cloned

s Person implements Cloneable{
    public int age;

    public void eat(){
        System.out.println("Eat!");
    }

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

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
public class TestDemp  {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person person = new Person();
        person.age = 99;
        Person person2 = (Person)person.clone();//Person inherits Object by default. In theory, it can call the cloning method, but it is also special. After calling the cloning method, you have to rewrite the cloning method
        System.out.println(person2);
        System.out.println("------------------");
        person2.age = 100;
        System.out.println(person);
        System.out.println(person2);
    }
}

Compile and run the code, and the output is as follows:

Judging from the code implementation, it is a deep copy, but we should know that deciding whether to make a deep copy or a shallow copy is not the purpose of the method, but the implementation of the code. Let's take a look at the memory distribution diagram of this code

Let's take another look at the code:

class Money{
    public double m = 12.3;
}
class Person implements Cloneable{
    public int age;
    public Money money = new Money();

    public void eat(){
        System.out.println("Eat!");
    }

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

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
public class TestDemp  {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person person = new Person();
        Person person2 = (Person)person.clone();//Person inherits Object by default. In theory, it can call the cloning method, but it is also special. After calling the cloning method, you have to rewrite the cloning method
        System.out.println(person.money.m);
        System.out.println(person2.money.m);
        System.out.println("------------------");
        person2.money.m = 99.99;
        System.out.println(person.money.m);
        System.out.println(person2.money.m);
    }
}

Compile and run the code, and the output is as follows:

From the implementation of this code, it is a shallow copy. Let's take a look at the memory distribution diagram of this Code:

So now we want to turn it into a deep copy. How do we achieve it? You only need to clone a copy of Money, as follows:

class Money implements Cloneable{
    public double m = 12.3;

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
class Person implements Cloneable{
    public int age;
    public Money money = new Money();

    public void eat(){
        System.out.println("Eat!");
    }

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

    @Override
    protected Object clone() throws CloneNotSupportedException {
        //return super.clone();
        //Equivalent to:
        //Person tmp = (Person)super.clone();
        //return tmp;
        Person tmp = (Person)super.clone();
        tmp.money = (Money) this.money.clone();
        return tmp;
    }
}
public class TestDemp  {
    public static void main(String[] args) throws CloneNotSupportedException {
        Person person = new Person();
        Person person2 = (Person)person.clone();
        System.out.println(person.money.m);
        System.out.println(person2.money.m);
        System.out.println("------------------");
        person2.money.m = 99.99;
        System.out.println(person.money.m);
        System.out.println(person2.money.m);
    }
}

Compile and run the code, and the output is as follows:

Let's take a look at the memory distribution diagram of this code

Summary: deciding whether to copy deep or shallow is not the purpose of the method, but the implementation of the code

8. Differences between interface abstraction and class abstraction

No	difference	abstract class	Interface
1	Structural composition	Ordinary class + abstract method	Abstract method + global variable
2	jurisdiction	Various permissions	public
3	Subclass use	Use the extends keyword to inherit abstract classes	Use the implements keyword to implement the interface
4	relationship	An abstract class can implement several interfaces	Interfaces cannot inherit abstract classes, but interfaces can inherit multiple parent interfaces using the extends keyword
5	Subclass restrictions	A subclass can only inherit one abstract class	A subclass can implement multiple interfaces