Is it advisable to create an empty POJO class in Java?

Suppose I have a superclass A and it has fields

class A {
    String name; 
    int age;
    setName(String name);
    getName();

    setAge(int age);
    getAge()
}

I have multiple classes that extend A and add more fields along with the getters and setters.
Now there is another class, say B, which requires name and age, which is already provided by class A.
So should I go ahead and create class B without any field and simply it extends class A, or should I directly use class A?

class B extends A {}

P.S - I am using generics, which gives me a warning when I directly use superclass A, but the functionality is working fine. Please suggest.

Mostly the design wont be proper and justified if u just create a Class that do not have its own state, but yes it make sense if

A is abstract class i.e. you want to restrict the users to create an instance of A hence mark it abstract , then by creating B you are creating an implementation of A.
below is the example for the same

abstract class A{
	protected String name;
	protected int age;
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
}

class B extends A{}

also to make code more dynamic at runtime if u want to just use the parent class fields into ur function then probably u can do this

abstract class A{  // you can altogether remove 'abstract' and not create a B class
	protected String name;
	protected int age;
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
}

class B extends A{}

class C extends A{
	protected String location;

	public String getLocation() {
		return location;
	}
	public void setLocation(String location) {
		this.location = location;
	}
}

now see the below method

public static <T extends A> void printName(List<T> list) {
		for (T t : list) {
			System.out.println(t.getName());
		}
	}

this qualifies for List<B>, List<C>

There is really no reason, that I can think of, where you need to extend a class without changing anything. Maybe you feel that you will need it in the future. This violates the YAGNI principal.
Just use Class A. You can make changes when they are needed.

It really is pointless. If it gives you a warning, there is probably a good reason for it. Unless you have a niche use case and know what you are doing, the empty class serves no purpose other than adding useless files to your project