抽象类与子类（白马非马，离坚白）

本文主要是介绍抽象类与子类（白马非马，离坚白），对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

白马非马，是公孙龙提出的一个逻辑问题。感兴趣的可以点击链接视频 https://www.bilibili.com/video/BV1vp4y147sM?from=search&seid=17824925906438171091&spm_id_from=333.337.0.0

主要论证的是白马非马这个观点。

那么从集合的角度看这个问题：

马是概念（抽象类），定义有属性形态、颜色。
白马是马的子类，具有马特有的颜色（定义了颜色为白）。
白马属于马，白马不是马，马包含白马。
人们把白马、黑马、黄马等具有相似形态的一类事物统称为马，颜色定义了，没有初始化。好了，白马符合马所具有的形态，颜色为白，属于马的范畴。

A==B的充分必要条件是：A∈B && B∈A     或者A∩B = A   &&  A∩B = B

这里白马属于马，但马不属于白马，所以白马与马不相等。

白马 == 马  false

白马 != 马  true

 下面是代码的：

public abstract class Horse {
    //马的颜色
    String color;

    //马所具有的的特征
    protected void feature(){
        System.out.println("马是一种生物，四条腿走，跑的快，吃草......");
    }

    public String getColor() {
        return color;
    }

    //初始化颜色属性
    public Horse(String color) {
        this.color = color;
    }

    @Override
    public boolean equals(Object obj) {
        return color.equals(((Horse)obj).color);
    }
}

public class WhileHorse extends Horse {
    //初始化颜色
    public WhileHorse(String color) {
        super(color);
    }

    public void fly(){
        System.out.println("白马特殊技能，会飞.......");
    }

}

public class BlackHorse extends Horse {
    //初始化颜色
    public BlackHorse(String color) {
        super(color);
    }

    public void swing(){
        System.out.println("黑马特殊技能，会游泳.......");
    }

}

public class testHorse {
    public static void main(String[] args) {
        Horse horse1 = new BlackHorse("black");
        horse1.feature();
        System.out.println(horse1.getColor());
        specialSkill(horse1);

        System.out.println("--------------------------------------------------------");
        Horse horse2 = new WhileHorse("while");
        horse2.feature();
        System.out.println(horse2.getColor());
        specialSkill(horse2);

        System.out.println("----------------------------------");
        //马是抽象，概念，没法直接初始化，需要具体的指向一种类。
        //Horse horse = new Horse();         //wrong, can not be instantiated,白马与马没法比较
        System.out.println(horse1.equals(horse2));
        System.out.println(horse2.equals(new WhileHorse("while")));
    }

    private static void specialSkill(Horse horse1) {
        if (horse1 instanceof BlackHorse) {
            ((BlackHorse) horse1).swing();
        }else if (horse1 instanceof WhileHorse) {
            ((WhileHorse) horse1).fly();
        }
    }
}

　　结果：

马是一种生物，四条腿走，跑的快，吃草......
black
黑马特殊技能，会游泳.......
--------------------------------------------------------
马是一种生物，四条腿走，跑的快，吃草......
while
白马特殊技能，会飞.......
----------------------------------
false
true

离坚白

顺便也看了下离坚白。

公孙龙在《坚白论》中的核心论点是“离坚白”，即“坚”与“白”两种属性是分离的，不依赖于具体事物而存在，独立自藏。“离也者，藏也。”

一块石头，用手触碰感觉硬则是坚石，藏了白，为硬石。

一块石头，通过眼睛视觉可以看到白色，藏了硬，为白石。

坚白石，不可三分“坚”、“白”、“石”；可二分“坚石”、“白石”。

理解应该不到位，下面代码就当看下吧

public abstract class Stone {
    private String color;
    private String hardness;

    public Stone(String color, String hardness) {
        this.color = color;
        this.hardness = hardness;
    }

    @Override
    public String toString() {
        return "Stone{" +
                "color='" + color + '\'' +
                ", hardness='" + hardness + '\'' +
                '}';
    }

}

public class ConcreteStone extends Stone{
    public ConcreteStone(String color, String hardness) {
        super(color, hardness);
    }

    static class Builder{
        private String color;
        private String hardness;

        public Builder seeColor(String color){
            this.color = color;
            return this;
        }

        public Builder touchHardness(String hardness){
            this.hardness = hardness;
            return this;
        }

        public Stone buildStone(){
            return new ConcreteStone(this.color, this.hardness);
        }

    }
}

public class StoneTest {

    public static void main(String[] args) {
        Stone whileStone = new ConcreteStone.Builder().seeColor("while").buildStone();
        Stone hardStone = new ConcreteStone.Builder().touchHardness("hard").buildStone();
        Stone hardWhileStone = new ConcreteStone.Builder().touchHardness("hard").seeColor("while").buildStone();
        System.out.println(whileStone);
        System.out.println(hardStone);
        System.out.println(hardWhileStone);
        Stone concreteStone = new ConcreteStone.Builder().buildStone();
        System.out.println(concreteStone);
    }
}

最后：代码其实也是一种语言，反映了事物的属性、行为，还有逻辑。

这篇关于抽象类与子类（白马非马，离坚白）的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！