精华内容
下载资源
问答
  • 抽象与具体实际例子
    千次阅读
    2017-10-14 23:52:35

    看了一篇电影评析,想谈一下”抽象”

    马克思指出:抽象与具体的辩证法应是”具体-抽象-具体”的方法,是从具体上升到抽象与从抽象上升到具体的内在统一。

    在高中数学课上,我也在数列章节中熟练的运用了假设,验证的方法,在导数中用抽象来求瞬时速度。

    然而,当在生活实践中时,抽象却感觉是如此的难。

    突然觉得,抽象和具体是一种极高的个人能力,它影响你的幸福感,你的人生高度,工作前景,生活品质等。当我们始终着眼于当前的琐碎事情时,其实已经故步自封,坐井观天了。因为你只是完成了这件琐事,没有去升华它。

    • 比如我要开发一个小系统,如果仅仅是为了完成领导布置的所谓功能,其实不是什么难事,难就难在你从领导的角度思考这个系统为什么要有这个功能;用户使用会有什么反馈;与这个系统对接的是哪些系统;对接遇到哪些问题;这个系统在行业内有什么口碑;目前各大公司开发进度如何。
      一旦你用这种思想去考虑了,那么才算真正的了解你做的东西。我想这也是为什么好的销售员的待遇那么高的原因吧,因为他们会站在高处去俯视产品,这种俯视,即为抽象。

    c++中有一种抽象数据类型(ADT, Abstract data type),它就是通过类来表示更通用的类型。

    举个例子:
    写一个具体类:

    typedef unsigned long Item;
    class Stack
    {
    private:
        enum {MAX=10;};
        Item item[MAX];
        int top;
    public:
        Stack();
        bool isEmpty() const;
        bool isFull() cosnt;
        bool push(const Item& item);
        bool pop(Item& item);
    };
    • 这是一个栈的实现,c++用栈管理自动变量的,从业务上讲,栈实现的功能如下:
      (1)创建空栈
      (2)添加数据到栈,即压入栈
      (3)栈顶删除数据,即弹出栈
      (4)查看是否填满/为空
      分析这种业务需求比单纯的关注技术实现要有意义的多。

    当然,实际上栈同时又是一种容器,继续抽象分析上层业务,其实list,vector等都属于一种容器,只是功能稍有差别而已。

    所以关系就是:容器->栈/列表/map->各自类实现

    这种既有的概念仅仅是举个示例而已。

    总结:

    • 1.一个人应该抽象出上层业务逻辑,而不应该仅仅抱着技术细节不放,不然会让思维受到禁锢,无法上升一个层面,容易坐井观天。
    • 2.其实知识最初是没有边界的,由于社会的具体分工才会有专业出现,如果你不能做到将学到的东西融会贯通,那么就属于片面的,断层的,缺少骨骼的。
    • 3.一个人的格局决定了你的抽象能力,科比能带湖人队多次问鼎,退役后在商界当然也能如此。
    更多相关内容
  • 抽象方法指没有方法体的方法,具体就是在方法声明的时候没有 {} 括弧以及其中的内容,而是直接在声明时在方法名后加上分号结束。 abstract 关键字用于定义抽象方法,语法: abstract function function_name(); ...
  • Java中的抽象类和接口

    千次阅读 多人点赞 2022-04-08 15:17:42
    各位铁汁们大家好呀!今天让我们继续学习java,看看java中的抽象类和接口到底是什么? 里面也会讲到多态呀,一起来看看吧

    目录

    什么是抽象类

    抽象类再实现多态中的意义 

    接口是什么


     各位铁汁们大家好呀😊

    😎今天让我们继续学习java,看看java中的抽象类和接口到底是什么🤔? 

    什么是抽象类

    🍑我们之前学过什么是类,那么抽象类是不是也是类的一种呢?

    听名字就感觉好抽象呀!说对了,他就是抽象的,不是具体的。在类中没有包含足够的信息来描绘一个具体的对象,这样的类称为抽象类。

    🌰来看一个抽象类的例子

    // 抽象类和抽象方法需要被 abstract 关键字修饰
    abstract class Shape {
        // 抽象类中的方法一般要求都是抽象方法,抽象方法没有方法体
        abstract void draw();
    }

    大家觉得这个抽象类是不是什么也没干,他唯一的方法draw()还是空的。

    像这样的类是不是就没有包含足够的信息来描绘一个具体的对象,自然也就不能实例化对象了。不信你看:

    🍑那既然一个类不能实例化,那这种抽象类存在的意义是什么呀🤔?别急,存在即合理,听我慢慢道来。


    抽象类在实现多态中的意义 

    🍑抽象类存在的一个最大意义就是被继承,当被继承后就可以利用抽象类实现多态。

    来看一段代码

    // 抽象类和抽象方法需要被 abstract 关键字修饰
    abstract class Shape {
        // 抽象类中的方法一般要求都是抽象方法,抽象方法没有方法体
        abstract void draw();
    }
    // 当一个普通类继承一个抽象类后,这个普通类必须重写抽象类中的方法
    class Cycle extends Shape {
        @Override
        void draw() {  // 重写抽象类中的draw方法
            System.out.println("画一个圆圈");
        }
    }
    
    public class Test4 {
        public static void main(String[] args) {
            //Shape shape = new Shape();  抽象类虽然不能直接实例化
            // 但可以把一个普通类对象传给一个抽象类的引用呀,即父类引用指向子类对象
            Shape shape = new Cycle(); // 这称作:向上转型
            
            /*Cycle cycle = new Cycle();
              Shape shape = cycle // 这是向上转型的另一种写法
             */
            shape.draw();         // 通过父类引用调用被子类重写的方法
        }
    }
    

    运行之后你就会发现神奇的一幕:

     

    大家在看完了代码可能会有很多疑问,别急咱们一个一个的说,

    📝什么是向上转型:一句话总结就是“父类引用指向子类对象”

    向上转型后的变化

    1. 🏀关于方法:父类引用可以调用子类和父类公用的方法(如果子类重写了父类的方法,则调用子类的方法),但子类特有的方法无法调用。
    2. 🏀关于属性: 父类引用可以调用父类的属性,不可以调用子类的属性

    向上转型的作用

    1. 🐟减少一些重复性的代码
    2. 🐟对象实例化的时候可以根据不同需求实例化不同的对象

    🌰这样的话就我们上面的代码就可以理解了

    ​ 

    📝看来,我们可以通过子类对抽象类的继承和重写,抽象类还真有点用呀!

    🍑但这和多态有什么关系呢,抽象类用起来这么麻烦,我还不如直接用普通类,也能达到这样的效果,还不用再写一个子类呢😫?

    🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟

    🌰那行,你再看看下面的代码,你就知道抽象类在实现多态时的好处了。 

    abstract class Shape {
        public abstract void draw(); // 抽象方法不能里有具体的语句
    }
    // 当一个普通类继承一个抽象类的时候,再这个子类中必须重写抽象类中的抽象方法
    class Cycle extends Shape {  
        @Override              // 如果不重写会报错,但如果继承的是普通类则不会报错,用抽象类更安全
        public void draw() {
            System.out.println("画一个圆圈");
        }
    }
    class Flower extends Shape { // 不同的子类对父类的draw方法进行了不同的重写
        @Override
        public void draw() {
            System.out.println("画一朵花");
        }
    }
    class Square extends Shape {
        @Override
        public void draw() {
            System.out.println("画一个正方形");
        }
    }
    
    public class Test4 {
        public static void main(String[] args) {
            Cycle cycle = new Cycle();   // 子类引用cycle
            Flower flower = new Flower(); // 子类引用flower
            Square square = new Square();
            
            // 数组的类型是Shape,即数组中每一个元素都是一个父类引用
            // 在这个过程其实也发生了向上转型,对抽象类中的方法进行了重写
            Shape[] shapes = {cycle, flower, square};  // 父类引用引用不同的子类对象
            for (int i = 0; i < shapes.length; i++) {
                Shape shape = shapes[i]; // 父类引用shape指向—>当前所对应的子类对象
    
                shape.draw();  // 通过父类引用调用子类重写的draw方法
            }
    
        }
    }
    

    🍑调用同一个方法竟然打印出了不同的结果😮,这难道就是所谓的多态🤔 

     是不是有点懵😂,下面我们来解释一下😉

    // 对上面的代码补充一下
    // 可能你对 Shape[] shapes = {cycle, flower, square};不太理解
    // 但上面的代码就相当于 
    
     Shape[] shapes1 = new Shape[3]; // 有三个不同的子类对象呀!数组大小为3
    
    // (将指向->子类对象)的子类引用赋值给父类对象,不就相当于该夫类引用指向->所对应的子类对象吗
    //这是向上转型的另一种写法,应为前面已经实例化了子类对象  Cycle cycle = new Cycle();   
     shapes1[0] = cycle;  // 如果前面没实例化子类对象,就要写成shape1[0] = new Cycle
     shapes1[1] = flower;
     shapes1[2] = square;

    对于多态来说,他有这三个要素

    1. 继承(我们刚才的Cycle类继承Shape抽象类)
    2. 重写(我们子类对draw方法的重写)
    3. 父类指向子类对象(就是shape1[0] = cycle -->也可以称作向上转型) 

    🍑回头再看一下我们的代码,是不是就刚好符合了多态的三要素😉。

    📝当我们的父类引用指向不同的子类对象时,当我们调用同一个draw方法时却输出了不同的结果。(其实就是该方法再子类中被重写成了不同形式)这就叫做多态 。

    嘻嘻😂,其实只要只要结合着例子来看,多态也没那么难理解呀😎

      

    🍑那为啥一定要用抽象类呢😂?我一个普通类继承普通类来实现多态不可以吗🤔

    🌰当然可以,但不太安全有风险;

         

    但如果是抽象类的话,就不一样了😉 

      

    🍑从这我们也可以看出,当用抽象类的时候,编译器自动就对我们是否重写进行了校验,而充分利用编译器的校验, 在实际开发中是非常有意义的 。所以说抽象类还是有用的,嘻嘻😉

    📝好了,相信到这里你对抽象类也有了一个大概的认识😊,下面我们来简单做一下总结

    1. 使用abstract修饰的类或方法,就抽象类或者抽象方法
    2. 抽象类是不能具体的描述一个对象,不能用抽象类直接实例化对象
    3. 抽象类里面的成员变量和成员方法,都是和普通类一样的,只不过就是不能进行实例化了
    4. 当一个普通类继承这个抽象类后,那么这个普通类必须重写抽象类当中的所有的抽象方法🤔(我们之前说过抽象类是不具体的,没有包含足够的信息来描述一个对象,所以我们需要把他补充完整)
    5. 但当一个抽象类A继承了抽象类B,这是抽象类A就可以不重写抽象类B当中的抽象方法
    6. final不能修饰抽象类和抽象方法(因为抽象类存在的最大意义就是被继承,而被final修饰的不能被继承,final和抽象,他们两个是天敌😂)
    7. 抽象方法不能被private修饰(抽象方法一般都是要被重写的,你被private修饰了,还怎么重写😫)
    8. 抽象类当中不一定有抽象方法,但如果一个类中有抽象方法,那么这个类一定是抽象类

    🌰哈哈,上面的8条总结是不是臭长臭长的,大家也不用专门去记(用的多了,自然就记住了😉)

    🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟🐟


    接口是什么

    🍑抽象类是从多个类中抽象出来的模板,如果将这种抽象进行的更彻底,则可以提炼出一种更加特殊的“抽象类”——接口(Interface)🤔。

    📝接口是Java中最重要的概念之一,它可以被理解为一种特殊的类,不同的是接口的成员没有执行体,是由全局常量和公共的抽象方法所组成😎。

    如何定义一个接口呢?下面我们来看一个栗子🌰

    //接口的定义格式与定义类的格式基本相同,将class关键字换成 interface 关键字,就定义了一个接口
    
    public interface 接口名称{
    // 定义变量
    int a = 10;      // 接口当中的成员变量默认都是public static final
    
    // 抽象方法
    public abstract void method1(); // public abstract 是固定搭配,可以不写
    void method2();  //  接口当中的成员方法默认都是public abstract, 更推荐用第二种来定义方法 
    }

    可以看到接口和类其实还是有很多相似点:

    📝接口中也包含抽象方法,所以也不能直接实例化接口🤔,那么我们怎么用接口呢?

    🍑哈哈,很简单😉,我们再用一个普通类实现这个接口不就行了吗😂,不同的是抽象类是被子类来继承而实现的,而接口与类之间则是用关键字implements来实现

    📝就像普通类实现实现抽象类一样,一个类实现某个接口则必须实现该接口中的抽象方法,否则该类必须被定义为抽象类🤔。


     通过接口实现多态

    🍑铁汁们!刚才我们是用抽象类来实现多态,那么现在我们可以尝试用接口来实现多态,嘻嘻😎

    接口可以看成是一种特殊的类,只能用 interface 关键字修饰
    interface IShape {
        int a = 10;   接口当中的成员变量默认都是public static final
        int b = 23;
        void draw();  接口当中的成员方法一般只能是抽象方法,默认是public abstract(JDK1.8以前)
      
        default void show() {
            System.out.println("接口中的其他方法");//接口中的其他方法也可以实现,但要用default修饰
        }
        public static void test() {
            System.out.println("这是接口当中的一个静态的方法");
        }
    }
    
    // 一个普通的类要想实现接口,可以用implement, 
    //因为接口也是抽象方法的,所以实现接口的这个类也要重写抽象方法
    class Cycle implements IShape {
    
        @Override
        public void draw() {
            System.out.println("画一个圆圈");
        }
    }
    class Square implements IShape {
        @Override
        public void draw() {
            System.out.println("画一个正方形");
        }
    }
    class Flower implements IShape {
    
        @Override
        public void draw() {
            System.out.println("画一朵花");
        }
    }
    public class Test4 {
        public static void main(String[] args) {
            // IShape iShape = new IShape(); 接口也不能直接实例化
            Cycle cycle = new Cycle();
            Square square = new Square();
            Flower flower = new Flower();
            // 这里的IShape接口就相当与抽象类中父类,接口类型也是一种引用类型
    
            IShape[] iShapes = {cycle, square, flower}; // 这个过程其实就发生了向上转型
    
            for (IShape iShape : iShapes) { // 增强型的for—each循环,也可以写成普通的for循环形式
                iShape.draw();              // 通过重写实现了多态
            }
        }
    }
    引用变量cycle和square都赋值给了Shape类型的引用变量shape,
    但当执行shape.draw()时,java虚拟机到底要调用谁重写的的draw方法,
    就看此时接口引用的是那个对象的,是shape的、还是cycle的

     😎看一下运行结果😎

     看完代码你可能有点晕😫,但没关系。一般接口咱也不这么用,直接使用抽象类不就好了😉(我只是演示一下用接口也能实现多态😂)

    🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑🍑

    📝下面我们来总结一下Java中接口的几个主要特点

    1. 🌰接口中可以包含变量和方法,变量被隐式指定为 public static final,方法被隐式指定为 public abstract(JDK 1.8 d一个类可以同时实现多个接口,一个类实现某个接口则必须实现该接口中的抽象方法,否则该类必须被定义为抽象类
    2. 🌰接口支持多继承,即一个接口可以继承(extends)多个接口,间接解决了 Java 中类不能多继承的问题。

    🍑那么接口一般用在什么地方呢?

    • 一般情况下,实现类和它的抽象类之前具有 "is-a" 的关系,但是如果我们想达到同样的目的,但是又不存在这种关系时,使用接口。
    • 由于 Java 中单继承的特性,导致一个类只能继承一个类,但是可以实现一个或多个接口,此时可以使用接口。

    🌰下面就让我们来看看接口的正确用法:帮助java实现“ 多继承 ”😎

    由于 Java 中单继承的特性,导致一个类只能继承一个类,但是可以实现一个或多个接口,此时可以使用接口。
    class Animal {
        String name;        // 不能使用private,后面的子类也要用
    
        public Animal(String name) { // 父类的自定义的构造方法
            this.name = name;
        }
    }
    interface IFlying {   // 自定义多种接口
        void fly();
    }
    interface IRunning {
        void run();
    }
    interface ISwimming {
        void swimming();
    }
    // 小鸭子,不仅会跑,还会游泳、飞行
    一个类继承父类,并实现多个接口,间接的解决java中不能多继承的问题
    class Duck extends Animal implements IRunning, ISwimming, IFlying {
    
        public Duck(String name) {  // 子类构造方法
            super(name);            // 必须在子类构造方法的第一行
            // 在给实现子类的构造方法前,先要用super()调用实现父类的构造方法,比较先有父后有子呀!
            // 因为父类自己定义了构造方法,编译器不会自动给给子类构造方法中添加super();来实现父类的构造方法,需要我们自己实现
        }
        // 对接口中的抽象方法进行重写
        @Override
        public void fly() {
            System.out.println(this.name + "正在用翅膀飞");
        }
    
        @Override
        public void run() {
            System.out.println(this.name + "正在用两条腿跑");
        }
    
        @Override
        public void swimming() {
            System.out.println(this.name + "正在漂在水上");
        }
    
    }
    
    public class 接口的使用 {  // 不用学我用中文名作为类名,我只是为演示方便
        public static void main(String[] args) {
            Duck duck = new Duck("第一个小鸭子");  // 实例化鸭子对象
            duck.fly();  // 通过引用 变量名.方法名 输出重写后的方法
            duck.run();
            duck.swimming();
        }
    }
    有人可能会说干嘛用接口,我直接在父类Animal中实现fly、run、swimming这些属性,
    然后不同的动物子类再继承父类这些方法不行吗?
    
    但问题是,鸭子会fly、swimming,那猫会飞和游泳吗?你再写个其他动物的子类是不是就不行了
    而用接口呢?我们只是把这种飞、游泳的行为给抽象出来了,
    
    只要一个子类有这种行为,他就可以实现相对应的接口,接口是更加灵活的
    
    

     📝上面的代码展示了 Java 面向对象编程中最常见的用法: 一个类继承一个父类, 同时实现多个接口。

     📝继承表达的含义是 is - a 语义, 而接口表达的含义是 具有 xxx 特性 ,能实现接口的类和该接口并不一定有is_a的关系,只要该类有这个接口的特性就行

    猫是一种动物, 具有会跑的特性.

    青蛙也是一种动物, 既能跑, 也能游泳

    鸭子也是一种动物, 既能跑, 也能游, 还能飞

     🍑这样设计有什么好处呢? 时刻牢记多态的好处, 让程序猿忘记类型. 有了接口之后, 类的使用者就不必关注具体类型,只要这个类有有这个特性就好。

    举个栗子🌰

    class Robot implements IRunning {
        private String name;
        public Robot(String name) {
            this.name = name;
        }
        // 对run方法进行重写
        @Override
        public void run() {
            System.out.println("机器人" + this.name + "正在跑");
        }
    }
    public class Test4 {
        public static void main(String[] args) {
            Robot robot1 = new Robot("图图");
            robot1.run();
        }
    }
    // 执行结果
    机器人图图正在跑

    😎只要能跑就行,管他是机器人还是动物呢😂,接口是不是很灵活呀!

    同时在实际的开发过程中,一般来说,一个类是一个Java文件,一个接口也是一个Java文件。大家也要在平时就养成这个好习惯呀!

    哈哈,不知道现在你对抽象类和接口的认识是不是又上升了一个高度呢?嘻嘻,我们下篇博客再见了,下篇让我们瞅瞅Java中常用的接口有哪些😉

     每天进步一点点,铁汁们,一起加油😎😎😎

    展开全文
  • 抽象代数是现代代数的基础,以其晦涩和高度概括性而著称,如果介绍一些它的实际应用和核心思想,会对大家学习有所裨益.本文的特点是形散(采自网络)而神不散(主题明确). 核心思想 作者:Yuhang Liu 抽象代数...

    一些<<抽象代数>>的核心思想和实际应用(持续更新)


    在这里插入图片描述

    抽象代数是现代代数的基础,以其晦涩和高度概括性而著称,如果介绍一些它的实际应用和核心思想,会对大家学习有所裨益.本文的特点是形散(采自网络)而神不散(主题明确).


    核心思想

    作者:Yuhang Liu

    抽象代数其实起源于数论。很多重要的概念,比如环、理想,都来自于数论的研究。比如理想,一开始是数论学家研究费马大定理的时候发现有些整环不是UFD,于是开始用素理想来代替素数,这样在Dedekind domain理想的分解仍然满足唯一因子分解,但是“数”(元素)本身分解成素因子乘积的方式则不一定唯一。学抽代的时候要多积累例子,比如数论里面就有很多有趣的例子。

    抽代一开始那些抽象的语言只不过是提供一个框架,某种意义上和集合论差不多,要掌握了足够多的例子才能看到它的内容。

    作者:匿名用户

    不要想的太玄,抽象代数是一个普通的概念系统,就像学习其他的概念一样去学习即可。它的难点主要在于两点:

    • 内涵的抽象性
    • 外延的非直观性举例而言:如何认识苹果这个概念?

    通过各种感官提取出苹果的特征如圆形,甜味,脆,红色等等,再概括为“苹果”这个概念。这个过程不会让人感到困难,在于:利用感官抽象出事物的特征是我们的先天禀赋,是一个自动化的过程,意识不参与进来;

    其次,苹果作为一个独立概念,需要处理的工程量很小。而抽象代数作为一个“人工”概念系统,

    • 其一,结构复杂,由大量的独立概念复合而成,在了解所有部分之前很难对整体有直观印象,所以需要大量例子帮学习者从多个不同角度和层次去“观察”这个系统的成分和结构,这是学习任何一个学科都会遇到的;

    • 其二,抽象代数系统的刻画是由高度专业化的数学语言实现的,人类的感觉系统所起作用不大,必须要调动意识层面的处理,也就是思考,而思考是毫无水分的“体力活”,就像爬山,路径或许不同,但都是实打实的功夫,不要抱偷懒的心理。

    作者:乐文好墨

    如果说Newton时代创造的微积分是用函数的观点了解世界,那么以Galois为代表的近世代数则是以结构的观点去剖析万物。所以近世代数一定要尽早学!要说近世代数的用途,那真是多了去了。但你要问本科阶段学的代数有啥用,那么只能说,它给你另一种世界观,培养你跳出计算,分析结构的技能。

    作者: zyearn

    对于一个群 G G G,我们已经知道它的一少部分信息,就如同一个黑匣子,我们大概知道它的一些表面信息。要掌握它的内部结构,就要用群在集合上的作用这一“X光”,底片就是群所作用的集合。通过分析解读群在集合上的作用的效果,也就是透射出来的“胶片”,来获取群 G G G的内部信息。当然这个集合不能是随便哪个集合都可以的,要利用已知的信息,构造一个合适的集合,以及群在这一集合上的某个合适的作用。如果你掌握了这种思想,就可以随时推导出Sylow定理的证明来。

    作者:strongart

    有的人总是想借助直观来理解抽象,但这对抽象代数的入门却是一个妨碍。还有回忆学习普通代数的情形,如果在学习普通代数的时候固执于用数值检验未知数 x x x,并不能让你真正领会 x x x的精神,只有直接用 x x x来进行运算,才能在此基础上领会高级的直观。

    抽象代数的学习也需要领会相应的高级直观,这里的直观重在代数的结构,因此初学者就应该特别注意那些关于结构的定理。

    • 第一个结构定理大概就是同态基本定理,由此可以更加深刻的理解商群。

    • 此后,一个非常自然的结构定理就是有限Abel结构定理,如果你能够依据此定理确定任意Abel群的结构,那么可以说你基本上已经算是入门了。

    • 此后,就可以考虑对付非Abel群的武器,最初级的武器是共轭类,由此衍生出正规子群的概念。

    • 而更加深刻的武器则是Sylow定理。仅仅作为入门的话,能理解Sylow定理也应该算是足够了。

    只要能把注意把握结构,抽象代数的入门应该不是太困难,我甚至提议数学专业课是不是可以一开始就群论讲起,这可以促使学生尽早完成代数思维的转变。只要走过了这道门槛,后面还有更加丰富多彩的内容等着你们呢!

    作者:马同学

    运算不止加减乘除,数学学到后面就多了很多抽象运算。甚至从集合和运算的角度来看,学数学的过程很多时候就是在不断的扩大对集合和运算的认知。理解的集合和运算越多,相关领域的数学基本上也就理解了。其中有种特殊的集合+运算就是群。

    简单来说,群的作用是描述对称。什么叫对称?我们来看看:正方形对称吗?物理定律对称吗?多项式的根对称吗?

    上面的问题的答案都是:对称!对称就是:“某种操作下的不变性”,关键字是两个:“操作”和“不变性”,要说明这点让我们通过上面的三个问题来理解。

    作者:匡世珉

    说好的『结构』呢:
    那如果我告诉你群其实长这样呢(Cayley图):

    在这里插入图片描述

    描绘的是群同构第一基本定理:

    在这里插入图片描述


    实际应用

    作者:TomHall

    有人在用haskell写一个机器学习库的时候发现,因为朴素贝叶斯在不同样本点上训练出来的模型构成了一个,可以很容易地定义加法运算合并起来,免去了重复训练的需求。于是在做k-fold cross validation的时候只需要在每一折上单独训练,从而把复杂度从O(kn)降低为O(n)。如果能发现其他模型有类似的代数性质,也可以使用同样的方法降低cv的开销。

    作者:chris

    抽象代数教会了你从同态,同构的角度去看待问题,特别是同态的思想,你看实分析中的几乎处处收敛,微分几何中的切矢,余切,都是通过同态和同构这两个强大的工具构造出来的
    其他具体应用可能就是物理了,特别是李群在量子力学,中可谓是大范围的使用

    展开全文
  • Spring常用设计模式--抽象工厂模式

    千次阅读 2022-03-15 16:54:45
    本专栏内容参考自:咕泡学院Tom老师的《Spring5核心原理30个类手写实战》,仅作个人学习记录使用,如有侵权,联系速删。   抽象工厂模式是指提供一个创建一系列相关或相互依赖对象的接口,无需指定他们的具体类...

    本专栏内容参考自:咕泡学院Tom老师的《Spring5核心原理与30个类手写实战》,仅作个人学习记录使用,如有侵权,联系速删。

      抽象工厂模式是指提供一个创建一系列相关或相互依赖对象的接口,无需指定他们的具体类。客户端(应用层)不依赖于产品实体类如何被创建、如何被实现等细节,强调的是一系列相关的产品对象(属于同一产品族)一起使用创建对象需要大量重复的代码。需要提供一个产品类的库,所有的产品以同样的接口出现,从而使客户端不依赖于具体实现。
      看抽象工厂模式之前,我们要了解两个概念:产品等级结构和产品族。

    在这里插入图片描述

    如上图,一句话解释:一行是一个产品族,一列是一个产品等级(列表)结构,同一族的产品是出自同一个工厂的
    通过上图大概能了解一下产品等级结构和产品族,还是以代码举例吧:
    第一期简单工厂第二期工厂方法
    学校有了第三期优化:每个课程不仅要提供课程的录播视频,还要提供课堂笔记,甚至还要有源码才能构成一个完整的课程。在产品等级中新增两个产品:IVideo录播视频和INode课堂笔记接口。

    public interface IVideo {
        void record();
    }
    
    public interface INote {
        void edit();
    }
    

    然后创建一个抽象工厂类CourseFactory:

    /**
     * 抽象工厂是用户的主入口
     * 是Spring中应用最广泛的一种设计模式
     * 易于扩展
     */
    public interface CourseFactory {
        INote createNote();
        IVideo createViedo();
    }
    

    接下来,创建Java产品族的Java视频类JavaVideo:

    public class JavaVideo implements IVideo{
        @Override
        public void record() {
            System.out.println("录制Java视频");
        }
    }
    

    扩展产品等级Java课堂笔记类JavaNote:

    public class JavaNote implements INote{
        @Override
        public void edit() {
            System.out.println("编写Java笔记");
        }
    }
    

    创建Java产品族的工厂JavaCourseFactory:

    public class JavaCourseFactory implements CourseFactory{
        @Override
        public INote createNote() {
            return new JavaNote();
        }
    
        @Override
        public IVideo createViedo() {
            return new JavaVideo();
        }
    }
    

    然后创建Python产品的Python视频类PythonVideo:

    public class PythonVideo implements IVideo{
        @Override
        public void record() {
            System.out.println("录制python视频");
        }
    }
    

    扩展产品等级Python课堂笔记类PythonNote:

    public class PythonNote implements INote{
        @Override
        public void edit() {
            System.out.println("编写python笔记");
        }
    }
    

    然后创建Python产品族的具体工厂PythonCourseFactory:

    public class PythonCourseFaactory implements CourseFactory{
        @Override
        public INote createNote() {
            return new PythonNote();
        }
    
        @Override
        public IVideo createViedo() {
            return new PythonVideo();
        }
    }
    

    来看客户端调用:

    public class Main {
        public static void main(String[] args) {
            JavaCourseFactory factory = new JavaCourseFactory();
            factory.createNote().edit();
            factory.createViedo().record();
            PythonCourseFaactory factory2 = new PythonCourseFaactory();
            factory2.createNote().edit();
            factory2.createViedo().record();
        }
    }
    

    在这里插入图片描述

    是不是有那么一丝丝感觉了,上面的代码完整的描述了两个产品族Java和python课程,也描述了两个产品恩济视频和笔记。抽象工厂模式完美且清晰的描述了这样一层复杂的关系,但是如果我们再继续扩展产品等级呢,将源码也加入课程,那么我们的代码从抽象工厂到具体工厂全部都要调整,但很显然不符合开闭原则。所以抽象工厂模式也是有缺点的:
    (1)规定了所有可能被创建的产品集合,产品族中扩展新的产品困难,需要修改抽象工厂的接口。
    (2)增加了系统的抽象性和理解难度。
    但在实际应用中,我们千万不能“犯强迫症”甚至有洁癖。实际需求中,产品等级结构升级是一件非常正常的事情。只要不频繁的升级,根据实际情况可以不遵循开闭原则。代码每半年或者一年升级一次有何不可?

    在这里插入图片描述

    展开全文
  • Java观察者模式例子

    2020-09-03 01:55:34
    主要介绍了Java观察者模式例子的相关资料,需要的朋友可以参考下
  • 在今天我刚阅读了《kafka权威指南》的第一章,关于介绍kafka这个消息发布订阅系统的概念。在之前的一份实习中,我曾经接触到了kafka,但是我一知半解,也没有深入的了解为什么会有kafka的存在。恰巧前几天我在市...
  • 在面向对象编程中, 最通常的方法是一个new操作符产生一个对象实例,new操作符...比如在我的一个报表系统中,有一种报表生成事件,该事件实现run接口,实现具体的报表生成操作,但是它不能被new出来,因为它需要依赖spring的依
  • 下面会简单介绍抽象类和接口的定义,并根据它们...不允许用final修饰抽象类或抽象方法(final关键字修饰的类不能被继承,final修饰的方法不能被重写,这样的话,定义一个没有具体实现的方法和类是么有意义的)。 ...
  • Java:接口和抽象类,傻傻分不清楚?

    千次阅读 多人点赞 2019-04-26 07:28:15
    再来聊聊接口和抽象类。
  • Java的接口和抽象类 1.抽象类 1.1 语法   抽象方法必须用abstract关键字进行修饰。如果一个类含有抽象方法,则称这个类为...对于一个父类,如果它的某个方法在父类中实现出来没有任何意义,必须根据子类的实际需求...
  • 纯虚函数 、抽象类 、多重继承 、二义性问题 、菱形继承 、虚基类 、从内存布局看虚继承的底层实现原理
  • 抽象类和接口的详解(实例)

    万次阅读 多人点赞 2017-12-20 17:15:17
    抽象类和接口在我们的代码中,生活中息息相关,上图所示,操纵复杂,密切相关,那么问题来了,何谓抽象类,何谓接口?带着这层薄纱,慢慢揭开这层薄纱;也许在古代,新婚之夜,透过这层薄纱,你看到的或者是惊喜,...
  • Java 的抽象特性:抽象接口深度解析

    千次阅读 热门讨论 2016-10-27 11:56:48
    对于面向对象编程来说,抽象是它的四大特征之一。在Java中,可以通过两种形式来体现OOP的抽象:...接口和抽象类为我们提供了一种将接口实现分离的更加结构化的方法。总的来说,抽象类是一种模板,而接口是一种契约。
  • C++设计模式:抽象工厂模式

    千次阅读 多人点赞 2021-12-11 20:20:47
    抽象工厂模式是一种创建型设计模式, 它能创建一系列相关的对象, 而无需指定其具体类。
  • 重新认识java(八) ---- 抽象接口

    千次阅读 多人点赞 2017-02-10 18:40:14
    你很清楚的知道什么时候用抽象类,什么时候用接口么? p.s. 多文字预警!
  • 程序员必备的思维能力:抽象思维

    万次阅读 多人点赞 2021-02-12 18:03:28
    若想捉大鱼,就得潜入深渊。深渊里的鱼更有力,也更纯净。硕大而抽象,且非常美丽。——大卫·林奇抽象思维是我们工程师最重要的思维能力。因为软件技术 本质上就是一门抽象的艺术。我们的工作是存思维...
  • 当程序员具备了抽象思维

    万次阅读 2021-03-22 14:32:46
    硕大而抽象,且非常美丽。 作者:张建飞 若想捉大鱼,就得潜入深渊。深渊里的鱼更有力,也更纯净。硕大而抽象,且非常美丽。——大卫·林奇 前言 抽象思维是我们工程师最重要的思维能力。因为软件技术 ...
  • 抽象类和接口在项目中使用的实例

    千次阅读 2018-10-06 19:10:06
    抽象类和接口在项目中经常使用如果使用恰当,可以大大精简代码 抽象类:指的是用abstract关键字修饰或者...接口:接口只有方法体没有具体的实现,用inferce修饰 特点: 接口中没有自己的属性,只能有方法体 类在实...
  • 这两种机制之间最明显的区别在于,抽象类允许包含某些方法的实现,但是接口不允许,一个更重要的区别在于,为了实现抽象定义的类型,类必须成为抽象类的子类,任何一个类,只要它定义了所有必要的方法,并且遵守通用...
  • Java中抽象类和接口的区别

    万次阅读 多人点赞 2019-02-07 14:10:07
    对于面向对象编程来说,抽象是它的一大特征之一。在Java中,可以通过两种形式来体现OOP的抽象:接口和抽象类。...抽象方法是一种特殊的方法:它只有声明,而没有具体的实现。抽象方法的声明格式为...
  • java-面向对象编程-抽象

    千次阅读 2017-04-04 15:12:40
    实际上,在面向对象的概念中,有一个知识点是极容易被人接口混淆的,人们往往会误解为这两者是同一个概念。但不幸的是,两者虽然有相似之处,但却是完全不一样的概念。那么,如此神秘的它到底是什么呢?让我们...
  • 接口和接口实现类,接口与抽象

    千次阅读 2019-02-07 16:34:56
    Java不支持多重继承,即一个...接口体包括属性常量和抽象方法。 [public] interface 接口名 { 属性常量 ... 抽象方法 ... } interface是声明一个接口的关键字,在Java中,接口的属性只允许为静态...
  • Java---抽象接口

    千次阅读 多人点赞 2021-10-12 19:42:49
    在面向对象的概念中,所有的对象都是通过类来描绘的,但是反过来,并不是所有的类都是用来描绘对象的,如果一个类没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类。例如: 说明: 1.Animal类是动物...
  • 抽象类和接口使用场景区别

    千次阅读 2018-03-16 14:13:13
    2 如果许多类实现了某个接口,那么每个都要用代码实现那些方法3 如果某一些类的实现有共通之处,则可以抽象出来一个抽象类,让抽象类实现接口的公用的代码,而那些个性化的方法则由各个子类去实现。所以,抽象类是...
  • 传输优化抽象

    千次阅读 2022-06-29 18:23:03
    昨天跟朋友聊起传输优化的抽象(用词不当,但我及其恶心方法论这个说法),整理一些观点。端到端传输优化的上限取决于能有效利用多少信息,而下限取决于这副牌你想打多烂,注意,你有什么牌并不由你决定,你只能决定...
  • java抽象方法怎么写

    千次阅读 2021-02-13 00:44:13
    1. java中什么叫抽象方法和抽象类及他们的特点,说的具体些,写个例子7.何为抽象方法和抽象类?马 克 -to -win:方法前有个abstract修饰符,就叫抽象方法。类前有个abstract修饰符就是抽象类,完了,简单就好记。以下...
  • C++ 抽象

    千次阅读 2020-10-01 15:04:00
    抽象类(接口) 接口描述了类的行为和功能,而无需完成类的特定实现 C++接口时通过抽象类实现的,设计抽象类的目的,是为了给其他类提供一个可以继承的适当的基类。抽象类本类不能被用于实例化对象,只能作为...抽象纯虚
  • 抽象接口之间的继承和实现关系  对于面向对象编程来说,抽象是它的一大特征之一。在Java中,可以通过两种形式来体现OOP的抽象:接口和抽象类。这两者有太多相似的地方,又有太多不同的地方。很多人在初学的...
  • 在面向对象的编程中,一般通过继承和虚函数来提供抽象能力,多态让程序在执行期,调用者只需要看到父类类型,而不需要关心继承的子类类型。举个例子: 比如有个游戏,里面的游戏的活动对象为动物,比如有老虎和猫,会...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 228,386
精华内容 91,354
关键字:

抽象与具体实际例子