精华内容
下载资源
问答
  • 抽象方法是一种特殊的方法:它只有声明,而没有具体的实现。抽象方法的声明格式为:  abstract void fun();  抽象方法必须用abstract关键字进行修饰。如果一个类含有抽象方法,则称这个类为抽象类,抽象类必须在...
  • 如果我们的应用代码被设计成与根类一起工作,那么它也可以任何一个从根类继承出来的子类合作. 抽象方法是就像子类中一般的方法的占位符(占个地方但不起作用),它与一般方法不同—没有任何代码. 如果类中存在一个或...
  • 在面试中我们经常被问到:Java中抽象...  类是具体实例的抽象,比如一个json字符串的抽象;而抽象类是类的抽象;接口是抽象类的抽象,接口更像是一种协议  听我慢慢道来~  吐槽  首先,我必须吐槽一下这种面试,
  • 抽象类与具体类区别

    千次阅读 2018-07-07 12:28:00
    abstract 抽象是不能被直接实例化的类、用例、信号、其他类元或其他泛化元素,它也可以用来描述没有实现的操作。反义词:具体(concrete)。 见抽象操作(abstract opera
    原文地址为:
    抽象类与具体类区别
    

    abstract

    抽象是不能被直接实例化的类、用例、信号、其他类元或其他泛化元素,它也可以用来描述没有实现的操作。反义词:具体(concrete)

    抽象操作(abstract operation)可泛化元素(generalizable element)

    语义

    抽象类是不可被实例化的类,即它可以没有直接实例,这既可能是因为它的描述是不完整的(如缺少一个或多个操作的方法),也可能是因为即使它的描述是完整的它也不想被实例化。抽象类是为了以后说明。抽象类必须有可能含有实例的后代才能使用,一个抽象的叶类是没用的(它可以作为叶在框架中出现,但是最终它必须被说明)。

    具体类可以没有任何抽象操作(否则,它必为抽象的),但是抽象类可以有具体操作。具体操作是可以被实现一次并在所有子类中不变地使用的操作。在它们的实现中,具体操作可以只使用声明它们的类所知道的特征(属性和操作)。继承的目的之一即将这些操作在抽象的超类中分解以使得它们可以被所有的子类分享。一个具体操作可以是多态的,即后代类中的方法优先于它,但是它也可以不必是多态的,它可以是一个叶操作。一个所有操作都被实现的类可以是抽象的,但是这一点必须被明确声明。一个有着一个或多个未实现操作的类自然是抽象的。

    同样的语义也适用于用例。抽象的用例定义了行为的片断,这个行为自己不能出现,但是它可以通过泛化、包括或扩展关系在具体用例的定义中出现。通过在抽象的用例中分解公用的行为,模型变得更小和易于理解。

    类似的关系也存在于其他的类元和泛化元素中。


    转载请注明本文地址: 抽象类与具体类区别
    展开全文
  • java抽象和抽象方法

    千次阅读 2021-02-27 12:26:26
    一、什么是抽象和抽象方法没有具体功能的实现,通过子类继承后重写方法来实现一定约束的类称之为抽象类,抽象类必须被abstract修饰。抽象方法就是只有方法声明,没有方法体的方法。抽象类的使用一般通过继承来实现...

    一、什么是抽象类和抽象方法

    没有具体功能的实现,通过子类继承后重写方法来实现一定约束的类称之为抽象类,抽象类必须被abstract修饰。抽象方法就是只有方法声明,没有方法体的方法。抽象类的使用一般通过继承来实现

    二、为什么需要抽象类和抽象方法

    引用抽象方法和抽象类,是java提供的一种语法工具,引导使用者正确的使用它们,减少误用。相当于对子类进行一定限制。

    三、抽象类和抽象方法的语法规则及其注意事项

    抽象类抽象方法必须被abstract修饰。

    抽象类中可以有普通方法,但是有抽象方法的类必须是抽象类。抽象类中的普通方法因为不能被创建对象,所以不能使用这个普通方法。

    抽象类除了不能实例化对象之外,类的其它功能依然存在。

    抽象方法中可以有被static修饰main方法,并且可以执行。

    一个类在继承抽象类后,必须实现抽象类中定义的所有抽象方法。除非它自己也声明为抽象类。

    抽象方法名后面直接跟一个分号,而不是花括号。

    四、抽象类和抽象方法的实现案例

    1、抽象类中可以有普通方法,但是有抽象方法的类必须是抽象类。

    public abstract class Demo01 {

    public abstract void run();

    public void test(){}

    }

    //编译通过,不报错

    public class Demo01 {

    public abstract void run();

    public void test(){}

    }

    //报错:

    Class 'Demo01' must either be declared abstract or implement abstract method 'run()' in 'Demo01'

    Abstract method in non-abstract class

    2a03c1ce46b001404d74cb483c53dfed.png

    2、抽象类除了不能实例化对象

    public abstract class Demo01 {

    public abstract void run();

    public static void main(String[] args) {

    Demo01 demo01=new Demo01();

    }

    }

    e391d9aa2a3f1229ee45ef3aa8a40ae4.png

    3、抽象方法中可以有被static修饰main方法,并且可以执行。

    public abstract class Demo01 {

    public abstract void run();

    public static void main(String[] args) {

    System.out.println("抽象类中的main方法");

    }

    }

    //输出结果:抽象类中的main方法

    4、抽象类的使用一般通继承来实现,且子类中要么对抽象类的方法进行重写,要么声明子类也为抽象类

    public class Demo02 extends Demo01{

    @Override

    public void run() {

    }

    }

    abstract class Demo03 extends Demo01{

    }

    //Demo02和Demo3均能编译通过。

    5、抽象类中的静态方法可以用类名.方法名的方式调用

    e48ac6d43d5525c72074397ed91e40cc.png

    6、抽象的实例:

    有抽象类Father,和抽象方法run()。

    public abstract class Father {

    private String name;

    private int age;

    private char sex='男';

    public int money=100_000;

    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;

    }

    public char getSex() {

    return sex;

    }

    public void setSex(char sex) {

    this.sex = sex;

    }

    abstract void run();

    public void say(){

    System.out.println("这是父类普通方法");

    }

    public static void go(){

    System.out.println("这是父类静态方法");

    }

    }

    有子类Son继承了抽象类,重写了父类的抽象方法run

    public class Son extends Father{

    private double salary;

    @Override

    void run() {

    System.out.println("子类重写了父类的方法run");

    System.out.println(super.getSex());

    super.say();

    }

    public static void main(String[] args) {

    Son son=new Son();

    son.run();

    System.out.println(son.getSex());

    //System.out.println(super.getSex()); //错误

    son.setAge(47);

    System.out.println(son.getAge());

    son.setName("ThreePure");

    System.out.println(son.getName());

    //调用父类的公有属性

    System.out.println(son.money);

    //使用继承于父类的方法

    son.say();

    }

    }

    运行结果:

    子类重写了父类的方法run

    这是父类普通方法

    47

    ThreePure

    100000

    这是父类普通方法

    尽管我们不能实例化一个 Father类的对象,但是如果我们实例化一个 Son 类对象,该对象将从 Father 类继承 成员方法,且通过该方法可以设置或获取成员变量。

    五、抽象类的其他补充吗

    抽象类是否有构造器:

    e4dc66d994535459d7bdc270574d7b1e.png

    从图中我们可以知道抽象类也是有构造器的,并别在子类创建对象时被调用。

    public abstract class Demo3 {

    public Demo3() {

    System.out.println("抽象类的构造方法");

    }

    }

    public class Demo4 extends Demo3{

    public static void main(String[] args) {

    Demo4 demo4 =new Demo4();

    }

    }

    //抽象类的构造方法

    2、final与abstract的矛盾

    final关键字可以修饰类、方法、变量。final修饰的类不能被派生;final修饰的方法,禁止子类重写。所以我们可以看出,final和abstract不能一起使用。

    3、构造方法,类方法(用 static 修饰的方法)不能声明为抽象方法。

    ef1db7eeaea5b0eb959f00a80b959e63.png

    展开全文
  • 抽象方法 即使用abstract 关键字修饰,仅有声明没有方法体的方法。 public abstract void f();//没有内容 抽象类即包含抽象方法的类。 如果一个类包含一个或者多个抽象方法,该类必须限定为抽象的。抽象类可以不...

    抽象方法 即使用abstract 关键字修饰,仅有声明没有方法体的方法。

    public abstract void f();//没有内容

    抽象类即包含抽象方法的类。

    如果一个类包含一个或者多个抽象方法,该类必须限定为抽象的。抽象类可以不包含抽象方法。

    public abstract class BaseActivity{
    	private final String TAG =this.getClass().getSimpleName();//抽象类可以有成员
    	
    	void log(String msg){
    		System.out.println(msg);//抽象类可以有具体方法
    	}
    	//abstract void initView();// 抽象类也可以没有抽象方法
    }
    

    接口是抽象类的一种特殊形式,使用interface 修饰。

    接口是抽象类的延伸,它可以定义没有方法体的方法

    public interface OnClickListener{
    	void onClick(View v);//没有方法体
    }
    

    特点与区别:

    抽象类的特点
    1. 抽象类的初衷是“抽象”,即规定这个类“是什么”,具体的实现暂不确定,是不完整的,因此不允许直接创建实例
    2. 抽象类是由子类具有相同的一类特征抽象而来,也可以说是其基类或者父类
    3. 抽象方法必须为 public 或者 protected(因为如果为 private,则不能被子类继承,子类便无法实现该方法),缺省情况下默认为 public
    4. 抽象类不能用来创建对象
    5. 抽象方法必须由子类来实现
    6. 如果一个类继承于一个抽象类,则子类必须实现父类的抽象方法,如果子类没有实现父类的抽象方法,则必须将子类也定义为抽象类
    7. 抽象类还是很有用的重构工具,因为它们使得我们可以很容易地将公共方法沿着继承层次结构向上移动

    接口的特点:

    Java 为了保证数据安全性是不能多继承的,也就是一个类只有一个父类。

    但是接口不同,一个类可以同时实现多个接口,不管这些接口之间有没有关系,所以接口弥补了抽象类不能多继承的缺陷。

    接口是抽象类的延伸,它可以定义没有方法体的方法,要求实现者去实现。

    接口的所有方法访问权限自动被声明为 public

    接口中可以定义“成员变量”,会自动变为 public static final 修饰的静态常量

    • 可以通过类命名直接访问:ImplementClass.name
    • 不推荐使用接口创建常量类

    实现接口的非抽象类必须实现接口中所有方法,抽象类可以不用全部实现

    接口不能创建对象,但可以申明一个接口变量,方便调用

    完全解耦,可以编写可复用性更好的代码

    例子:

    假设我们新开始一个项目,需要写大量的 Activity,这些 Activity 会有一些通用的属性和方法,于是我们会创建一个基类,把这些通用的方法放进去:

    public class BaseActivity extends Activity{
    	private final String Tag =this.getClass().getSimpleName();
    	
    	void toast(String msg){
    		Toast.makeText(this,msg,Toast.LENGTH_SHORT).show();
    	}
    	//其他重复的工作,比如设置标题栏、沉浸式状态栏、检测网络状态等
    }
    

    这时 BaseActivity 是一个基类,它的作用就是:封装重复的内容

    写着写着,我们发现有的同事代码写的太烂了,一个方法里几百行代码,看着太痛苦。于是我们就本着“职责分离”的原则,在 BaseActivity 里创建了一些抽象方法,要求子类必须实现:

    public abstract class BaseActivity extends Activity {
        private final String TAG = this.getClass().getSimpleName();
    
        @Override
        protected void onCreate(final Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(getContentViewLayoutId());
    
            initView(); //这里初始化布局
            loadData(); //这里加载数据
        }
    
        /**
         * 需要子类实现的方法
         * @return
         */
        protected abstract int getContentViewLayoutId();
        protected abstract void initView();
        protected abstract void loadData();
    
        void toast(String msg) {
            Toast.makeText(this, msg, Toast.LENGTH_SHORT).show();
        }
    }
    

    定义的抽象方法访问权限修饰符可以是 public protecteddefault,但不能是 private,因为这样子类就无法实现了。

    这时 BaseActivity 因为有了抽象方法,变成了一个抽象类。它的作用就是:定义规范,强制子类符合标准;如果有调用抽象方法,也会制定执行顺序的规则。

    继承 BaseActivity 的类只要实现这些方法,同时为父类提供需要的内容,就可以和父类一样保证代码的整洁性。

    public class MainActivity extends BaseActivity{
    
        private TextView mTitleTv;
    
        @Override
        protected int getContentViewLayoutId() {
            return R.layout.activity_main;
        }
    
        @Override
        void initView() {
            mTitleTv = (TextView) findViewById(R.id.main_title_tv);
            mTitleTv.setOnClickListener(this);
        }
    
        @Override
        protected void loadData() {
            //这里加载数据
        }
    }
    

    以后如果发现有某些功能在不同 Activity 中重复出现的次数比较多,就可以把这个功能的实现提到 BaseActivity 中。但是注意不要轻易添加抽象方法,因为这会影响到之前的子类。

    项目写着写着,发现很多页面都有根据定位信息改变而重新请求数据的情况,为了方便管理,再把这样的代码放到 BaseActivity? 也可以,但是这样一来,那些不需要定位相关的代码不也被“污染”了么,而且冗余逻辑太多 BaseActivity 不也成了大杂烩了么。

    我们想要把位置相关的放到另一个类,但是 Java 只有单继承,这时就可以使用接口了。

    我们创建一个接口表示对地理位置的监听:

    interface OnLocationChangeListener {
        void onLocationUpdate(String locationInfo);
    }
    

    接口默认是 public,不能使用其他修饰符。

    然后在一个位置观察者里持有这个接口引用

    public class LocationObserver {
    
        List<OnLocationChangeListener> mListeners;
    
        public LocationObserver setListeners(final List<OnLocationChangeListener> listeners) {
            mListeners = listeners;
            return this;
        }
    
        public List<OnLocationChangeListener> getListeners() {
            return mListeners;
        }
    
        public void notify(String locationInfo) {
            if (mListeners != null) {
                for (OnLocationChangeListener listener : mListeners) {
                    listener.onLocationUpdate(locationInfo);
                }
            }
        }
    
        interface OnLocationChangeListener {
            void onLocationUpdate(String locationInfo);
        }
    }
    

    这样我们在需要定位的页面里实现这个接口:

    public class MainActivity extends BaseActivity implements View.OnClickListener,
            LocationObserver.OnLocationChangeListener {
    
        private TextView mTitleTv;
    
        @Override
        protected int getContentViewLayoutId() {
            return R.layout.activity_main;
        }
    
        @Override
        public void onClick(final View v) {
            int id = v.getId();
            if (id == R.id.main_title_tv) {
                toast("你点击了 title");
            }
        }
    
        @Override
        void initView() {
            mTitleTv = (TextView) findViewById(R.id.main_title_tv);
            mTitleTv.setOnClickListener(this);
        }
    
        @Override
        protected void loadData() {
            //这里加载数据
        }
    
        @Override
        public void onLocationUpdate(final String locationInfo) {
            mTitleTv.setText("现在位置是:" + locationInfo);
        }
    }
    

    这样 MainActivity 就具有了监听位置改变的能力。

    如果 MainActivity 中需要添加其他功能,可以再创建对应的接口,然后予以实现。

    小结

    通过上面的代码例子,我们可以很清晰地了解下面这张图总结的内容。

    这里写图片描述

    图片来自:www.jianshu.com/p/8f0a7e22b…

    我们可以了解到抽象类和接口的这些不同:

    • 抽象层次不同
      • 抽象类是对类抽象,而接口是对行为的抽象
      • 抽象类是对整个类整体进行抽象,包括属性、行为,但是接口却是对类局部行为进行抽象
    • 跨域不同
      • 抽象类所跨域的是具有相似特点的类,而接口却可以跨域不同的类
      • 抽象类所体现的是一种继承关系,考虑的是子类与父类本质**“是不是”**同一类的关系
      • 而接口并不要求实现的类与接口是同一本质,它们之间只存在**“有没有这个能力”**的关系
    • 设计层次不同
      • 抽象类是自下而上的设计,在子类中重复出现的工作,抽象到抽象类
      • 接口是自上而下,定义行为和规范

    如何选择

    现在我们知道了,抽象类定义了“是什么”,可以有非抽象的属性和方法;接口是更纯的抽象类,在 Java 中可以实现多个接口,因此接口表示“具有什么能力”。

    在进行选择时,可以参考以下几点:

    • 若使用接口,我们可以同时获得抽象类以及接口的好处
    • 所以假如想创建的基类没有任何方法定义或者成员变量,那么无论如何都愿意使用接口,而不要选择抽象类
    • 如果事先知道某种东西会成为基础类,那么第一个选择就是把它变成一个接口
    • 只有在必须使用方法定义或者成员变量的时候,才应考虑采用抽象类

    抽象与多态

    俗话说:“做事留一线,日后好相见”。

    程序开发也一样,它是一个不断递增或者累积的过程,不可能一次做到完美,所以我们要尽可能地给后面修改留有余地,而这就需要我们使用传说中“面向对象的三个特征” — 继承、封装、多态。

    不管使用抽象类还是接口,归根到底还是尽可能地职责分离,把业务抽象,也就是“面向接口编程”。

    面向接口编程

    日常生活里与人约定时,一般不要说得太具体。就好比别人问我们什么时候有空,回一句“大约在冬季” 一定比 “这周六中午” 灵活一点,谁知道这周六会不会突然有什么变故。

    我们在写代码时追求的是“以不变应万变”,在需求变更时,尽可能少地修改代码就可以实现。

    而这,就需要模块之间依赖时,最好都只依赖对方给的抽象接口,而不是具体实现。

    在设计模式里这就是“依赖倒置原则”,依赖倒置有三种方式来实现:

    1. 通过构造函数传递依赖对象
      • 比如在构造函数中的需要传递的参数是抽象类或接口的方式实现
    2. 通过 setter 方法传递依赖对象
      • 即在我们设置的 setXXX 方法中的参数为抽象类或接口,来实现传递依赖对象
    3. 接口声明实现依赖对象,也叫接口注入
      • 即在函数声明中参数为抽象类或接口,来实现传递依赖对象,从而达到直接使用依赖对象的目的。

    可以看到,“面向接口编程”说的“接口”也包括抽象类,其实说的是基类,越简单越好。

    多态

    多态指的是编译期只知道是个人,具体是什么样的人需要在运行时能确定,同样的参数有可能会有不同的实现。

    通过抽象建立规范,在运行时替换成具体的对象,保证系统的扩展性、灵活性。

    实现多态主要有以下三种方式:

    1. 接口实现
    2. 继承父类重写方法
    3. 同一类中进行方法重载

    不论哪种实现方式,调用者持有的都是基类,不同的实现在他看来都是基类,使用时也当基类用。

    这就是“向上转型”,即:子类在被调用过程中由继承关系的下方转变成上面的角色。

    向上转型是能力减少的过程,编译器可以帮我们实现;但 “向下转型”是能力变强的过程,需要进行强转。

    以上面的代码为例:

    public class LocationObserver {
    
        List<OnLocationChangeListener> mListeners;
    
        public LocationObserver setListeners(final List<OnLocationChangeListener> listeners) {
            mListeners = listeners;
            return this;
        }
    
        public List<OnLocationChangeListener> getListeners() {
            return mListeners;
        }
    
        public void notify(String locationInfo) {
            if (mListeners != null) {
                for (OnLocationChangeListener listener : mListeners) {
                    listener.onLocationUpdate(locationInfo);
                }
            }
        }
    }
    

    LocationObserver 持有的是 OnLocationChangeListener 的引用,不管运行时传入的是 MainActivity 还是其他 Activity,只要实现了这个接口,就可以被调用实现的方法。

    在编译期就知道要调用的是哪个方法,称为“前期绑定”(又称“静态绑定”),由编译器和连接程序实现。

    在运行期调用正确的方法,这个过程称为“动态绑定”,要实现动态绑定,就要有一种机制在运行期时可以根据对象的类型调用恰当的方法。这种机制是由虚拟机实现的, invokevirtual 指令会把常量池中的类方法符号引用解析到不同的引用上,这个过程叫做“动态分派”,具体的实现过程我们暂不讨论。

    继承和组合

    尽管继承在学习 OOP 的过程中得到了大量的强调,但并不意味着应该尽可能地到处使用它。

    相反,使用它时要特别慎重,因为继承一个类,意味着你需要接受他的一切,不管贫穷富贵生老病死,你都得接受他,你能做到吗?

    一般人都无法做到白头偕老,所以只有在清楚知道需要继承所有方法的前提下,才可考虑它。

    有一种取代继承的方式是 “组合”。

    组合就是通过持有一个类的引用来拥有他的一切,而不是继承,在需要调用他的方法时传入引用,然后调用,否则就清除引用。

    组合比继承灵活在于关系更松一些,继承表示的是“is-a” 关系,比较强;而组合则是 “has-a” 关系

    为判断自己到底应该选用合成还是继承,一个最简单的办法就是考虑是否需要从新类向上转型回基础类。

    假如的确需要向上转,就使用继承;但如果不需要上溯造型,就应提醒自己防止继承的滥用。

    转自:https://juejin.im/entry/59fa7b07518825076a0c4a0c

    展开全文
  • 面向对象和抽象接口的理解 面向对象和抽象接口的理解 面向对象和抽象接口的理解
  • 2.可以有抽象方法和具体方法 3.接口中的成员全都是 public 的 4.抽象类中可以定义成员变量 5.有抽象方法的类必须被声明为抽象类,而抽象类未必要有抽象方法 6.抽象类中可以包含静态方法 7.一个类只能继承一...

    二者不同:

    抽象类:

    1.抽象类中可以定义构造器

    2.可以有抽象方法和具体方法

    3.接口中的成员全都是 public 的

    4.抽象类中可以定义成员变量

    5.有抽象方法的类必须被声明为抽象类,而抽象类未必要有抽象方法

    6.抽象类中可以包含静态方法

    7.一个类只能继承一个抽象类

    接口:

    1.接口中不能定义构造器

    2.方法全部都是抽象方法

    3.抽象类中的成员可以是 private、默认、protected、public

    4.接口中定义的成员变量实际上都是常量

    5.接口中不能有静态方法

    6.一个类可以实现多个接口

    相同:

    1.不能够实例化

    2.可以将抽象类和接口类型作为引用类型

    3.一个类如果继承了某个抽象类或者实现了某个接口都需要对其中的抽象方法全部进行实现,否则该类仍然需要

    被声明为抽象类

    展开全文
  • unity理解抽象方法虚方法

    千次阅读 2021-11-16 14:05:27
    Abstract抽象方法Virtual虚方法的区别 一、抽象方法:只在抽象类中定义,方法修饰符不能使用private,virtual,static. 总结:(1)抽象方法只能声明在抽象类中,使用关键字abstract    (2)抽象类中的...
  • 什么是抽象类? 什么是抽象方法? 抽象和抽象方法有什么特性? 抽象类的使用场景? 抽象类的作用? 抽象接口的区别? 抽象和抽象方法怎么声明? 抽象和抽象方法如何使用?
  • 抽象和接口的区别

    万次阅读 2019-05-11 11:28:06
    抽象类中必须包含至少一个抽象方法,并且所有抽象方法不能有具体的实现,而应在它们的子类中实现所有的抽象方法(要有方法体)。 接口类似于类,但接口的成员没有执行体,它只是方法、属性、事件索引符的组合...
  • Java抽象Java接口一样,都用来声明一个新的类型。并且作为一个类型的等级结构的起点。(2).格式:public abstract class abstractDemo{/**属性*/private String name;/**方法*/public abstract void f...
  • 反向传播理解--从抽象具体

    千次阅读 2018-09-12 10:18:46
    反向传播理解–从抽象具体 反向传播是深度学习的基础理论知识,在去年很早的时候,就把研究生期间学习推导BP的过程总结了一下,写了一篇文章,但是给同事分享的时候还是发现不能非常清晰的让大家理解什么是反向...
  • 深入理解Solidity——抽象合约接口

    千次阅读 2018-05-21 22:32:19
    抽象合约(Abstract Contracts) 合约函数可以缺少实现(请注意,函数声明头被;终止),见下面的例子: ...这样的合约不能被编译(即使它们同时包含具体函数和抽象函数),但它们可以用作父合约...
  • 要依赖于抽象,不要依赖于具体

    千次阅读 2020-12-24 20:13:44
    在面向对象设计原则中,要求"要依赖于抽象,不要依赖于具体", 这句话有很多人搞不懂。在这里谈谈我自己的理解。首先看看以下代码 class A{ public void swim(){ Dog dog = new Dog(); dog.move(); } } Swim方法...
  • 对软件开发中的"抽象"的理解

    千次阅读 2019-03-09 23:15:54
    这一概念,无论是应用层、操作系统层,还是驱动层,都会涉及到抽象编程,那到底什么是抽象呢? 1 何为抽象? 1.1从哲学的角度看: 抽象是从众多的事物中抽取出共同的、本质性的特征,而舍弃其非本质的特征。 例如...
  • Java中封装与抽象类的理解

    千次阅读 2020-06-11 10:36:02
    封装,提供的对象隐藏内部特性行为的一种能力,每个对象提供了一些方法,其他的对象可以访问并改变其内部数据。在Java中,提供了三种访问... 抽象是从具体的实例中分离想法的过程,根据他们各自的功能而非具体的实现
  • 主要介绍了java 抽象类的实例详解的相关资料,希望通过本大家能理解掌握这部分内容,需要的朋友可以参考下
  • 接口和抽象类应用场景及比较

    千次阅读 多人点赞 2019-04-12 17:45:31
    2. 抽象接口的区别以及使用场景 3. 为什么要使用接口 - 接口的特性: 接口不是类,不能使用new运算符实例化一个接口,但是可以声明接口的变量,这个接口变量必须引用实现了接口的类对象 使用instanceof可以...
  • 对面向抽象编程的理解

    千次阅读 2018-10-01 11:11:53
    面向抽象编程是什么,第一遍...也就是说 当设计某种重要的类时,不让该类面向具体的类,而是面向抽象类,即 设计类中的重要数据 是 抽象类的对象 ,不是具体类声明的对象。 简单一点理解,就是定义了一个abstrac...
  • 抽象接口有什么区别

    万次阅读 多人点赞 2018-08-25 20:36:35
    原文链接:  javacodegeeks  翻译:  ...上面的说法只是提供一个角度来理解抽象接口的关系,每个人都会有自己的理解,有人认为两者一点关系都没有,这也有道理。总之,模式语法是死的,人是活的。
  • 在学习数据结构类型时,首先遇到的一个难点即是如何理解抽象数据结构类型。通过阅读多个博客,将个人理解总结如下: 如已看过抽象数据类型定义,可直接跳过定义。 抽象数据类似的定义 抽象数据类型(Abstract Data ...
  • 多态 抽象类的理解

    2018-07-28 09:59:31
    多态:一个类在不同时刻表现出的具体对象 ...这一句则是明确告诉编译器,现在这个类的具体对象是B,根据B的实际变量方法,来进行相应操作   成员访问特点: 成员变量:编译看左边,运行看左边。 构造方...
  • 在Python中定义使用抽象类及抽象方法
  • 2、抽象类可以包含具体的方法,接口的所有方法都是抽象的; 3、抽象类可以声明使用字段;接口则不能,但接口可以创静态的final常量; 4、接口的方法都是public的,抽象类的方法可以使public,private,protecte...
  • 工厂方法和抽象工厂的区别

    千次阅读 2019-07-04 22:50:42
    定义 :抽象工厂模式提供了一个创建一系列相关或者相互依赖对象的接口,无需指定它们具体的类 创建型 :创建型 适用场景: 客户端(应用层)不依赖于产品类实例如何被创建、实现等细节 强调一系列相关的产品对象...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 411,627
精华内容 164,650
关键字:

具体和抽象怎么理解