详解Java抽象类与普通类的区别

public abstract class AbstractObject{
	// 普通属性
    String name;
	// 构造方法
    public AbstractObject(String name) {
        this.name = name;
    }
    // 静态方法 - 类名访问
    public static void staticMethod(){
        System.out.println("抽象类可以有静态方法.");
    }
	// 抽象方法
    public abstract void move();
	// 普通方法
    public void commonMethod(String food){
        System.out.println("抽象类可以有普通方法.");
    }
}

public abstract class Animal {
    String name;
    public Animal(String name) {
        this.name = name;
    }
    public abstract void move();
}

public class Test {
    public static void main(String[] args) {
    	// 抽象类不能实例化!会直接报编译期错误!
        //标红信息: 'Animal' is abstract; cannot be instantiated
        Animal animal = new Animal("小猫");
        // 第二种情况
        Animal animalObjcet = new Animal("小猫") {
            @Override
            public void move() {
                System.out.println("我开始移动了!");
            }
        };
    }
}

new 类名或者接口名(){
	重写方法;
}
// 放到一起对比看,很明显后面的是一个匿名内部类
new Animal("小猫") {
    @Override
    public void move() {
        System.out.println("我开始移动了!");
    }
};

public class AnimalObject extends Animal{
    public AnimalObject(String name) {
        super(name);
    }
    @Override
    public void move() {
        System.out.println("我是一只能动的动物!");
    }
}

public class Test {
    public static void main(String[] args) {
        AnimalObject animalObject = new AnimalObject("我是动物抽象类的子类");
        animalObjcet.move();	// 我是一只能动的动物!
    }
}

public abstract class AbstractCat extends Animal{
    Integer weight;
    public AbstractCat(String name, Integer weight) {
        super(name);    // 继承父类的名称
        this.weight = weight; // 猫咪的年龄
    }
    // 这个是没有重写,依旧是了抽象方法
    public abstract void move();
    // 注意:下面这种写法是重写过之后的!只是方法体为空.
    // public void move(){};
}

public class Cat extends AbstractCat{
    public Cat(String name, Integer weight) {
        super(name, weight);
    }
    @Override
    public void move() {
        System.out.println("一只奔跑的重达" + weight + "kg的" + name);
    }
}

public class Test {
    public static void main(String[] args) {
        Cat cat = new Cat("橘猫", 20);
        cat.move();	// 一只奔跑的重达20kg的橘猫
    }
}

public abstract class Animal {
    String name;
    public Animal(String name) {
        System.out.println("我是动物的构造方法!");
        this.name = name;
    }
    // 多添加几个抽象方法
    public abstract void move();
    public abstract void eat();
    public abstract void sleep();
}

// 不添加 abstract 关键字会报错
// Class 'AbstractCat' must either be declared abstract or implement abstract method 'move()' in 'Animal'
public abstract class AbstractCat extends Animal{
    Integer weight;
    public AbstractCat(String name, Integer weight) {
        super(name);
        System.out.println("我是抽象猫咪的构造方法!");
        // 继承父类的名称
        this.weight = weight; // 猫咪的年龄
    }
    @Override
    public void eat() {
        System.out.println(this.name + "在吃猫粮");
    }
    @Override
    public void sleep() {
        System.out.println(this.name + "睡觉了!");
    }
}

public class Cat extends AbstractCat{

    public Cat(String name, Integer weight) {
        super(name, weight);
    }
    /*
    sleep方法和eat方法已经在父类中实现过了,所以这里只剩下最后一个 move 是需要实现的抽象方法.
	*/
    @Override
    public void move() {
        System.out.println("重达" + weight + "kg的" + this.name + "在懒洋洋的跑");
    }
}