How to understand abstraction in java

Extract and summarize their common aspects, essential attributes and relationships from specific things, and discard individual, non-essential aspects, attributes and relationships. This kind of The thought process is called abstraction.

Abstract class:

Classes that cannot be instantiated using the new method, that is, classes that do not have specific instance objects, can only derive new ones through abstract classes subclasses, and then their subclasses create objects;

Abstract methods:

Abstract methods are methods modified with abstract. This method only declares the returned The data type, method name and required parameters have no method body, which means that the abstract method only needs to be declared. When a method is an abstract method, it means that this method must be overridden by the method of the subclass, otherwise the method of the subclass The method is still abstract;

Characteristics of abstract classes:

A: Abstract classes and abstract methods must be modified with the abstract keyword;

B: There may not be abstract methods in abstract classes, but classes with abstract methods must be defined as abstract classes;

C: Abstract classes cannot be instantiated directly; (can be through subclasses (subclasses after overriding methods) Class) is instantiated in a polymorphic way);

• It is not concrete;

• Abstract classes have constructors for subclass access Initialization of parent class data;

D: Subclass of abstract class;

• If you do not want to override abstract methods, the subclass must be Abstract class;

• To become a concrete class, all abstract methods must be rewritten;

The following is an example of an abstract class :

public class AbstractDemo {
    public static void main(String[] args) {
        //Tree t = new Tree();//抽象的子类不能实例化;Error!
        Grass g = new Grass();//非抽象类的子类实例化
        g.grow();
        System.out.println("-------------");
        Plant p = new Grass();//多态的方式
        p.grow();
    }
}
abstract class Plant{
    public abstract void grow();
}

/*
 * 1.子类是抽象类;
 */
abstract class Tree extends Plant{
    Tree(){
        System.out.println("tree");
    }
}

/*
 * 2.子类不是抽象类,则必须重写所有抽象方法;
 */
class Grass extends Plant{
    Grass(){
        System.out.println("grass");
    }
    public void grow(){
        System.out.println("grass growing");
    }
}

Characteristics of members of abstract classes:

A: Member variables

can be either variables or constants;

B: Constructor method

is used for initialization of subclass access to parent class data;

C: Member method

can be either abstract or Can be non-abstract;

Abstract class member method characteristics:

A: Abstract method

Mandatory requirements for subclasses to do;

B: Non-abstract method

Inherits things from subclasses to improve code reusability;

The following is an example of a member of an abstract class:

public class AbstractMember {
    public static void main(String[] args){
        
        Phone p = new Vivo();    //这里是多态;(用来实例化抽象类)
        p.height = 1460;        //1600 -> 1460
        System.out.println(p.height);
        System.out.println(p.width);
        System.out.println("-----------");
        p.call();        //vivo call
        p.method();        //vivo method
        
        
        
    }
}

abstract class Phone{
    public int height = 1600;
    public final int width = 960;
    public Phone(){}
    public Phone(String name,int count){}
    /*成员方法*/
    public abstract void call();//抽象成员方法;
    public void method(){        //非抽象成员方法;
        System.out.println("phone method");
    }
    
}
//非抽象子类，重写抽象父类的抽象方法：
class Vivo extends Phone{
    
    public void call(){
        System.out.println("vivo call");
    }
    public void method(){
        System.out.println("vivo method");
    }
    
}

Related learning recommendations: java basic tutorial

The above is the detailed content of How to understand abstraction in java. For more information, please follow other related articles on the PHP Chinese website!