精华内容
下载资源
问答
  • java中抽象类和接口的异同点
    千次阅读
    2019-09-25 23:05:57

    抽象类:

    1. 关键字abstract
    2. 可以修饰类,也可以修饰方法
    3. 修饰类的话,可以创建构造方法,但是不可以被实例化,创建构造方法的目的是为了子类的调用
    4. 有抽象方法的类一定是抽象类,抽象类可以没有抽象方法,抽象类可以有非抽象方法
    5. 如果抽象类的子类重写了所有的抽象方法,子类可以是非抽想类,则可以实例化
    6. 如果抽象类的子类没有重写了所有的抽象方法,则子类是抽想类,不可以实例化

    接口:

    1. 关键字interface
    2. 接口不能实例化,不能创建构造方法
    3. 接口里的方法可以是静态方法(jdk1.8之后)、默认方法(default 返回类型 方法名(){})或者抽象方法,这里的抽象方法可以省略关键字abstract,这里的静态方法只能由接口自己调用(接口名.方法名),这里的默认方法可以使用实现类对象调用
    4. 一个类可以实现多个接口,一个接口可以继承接口
    5. 接口里的方法必须是public访问权限,可以省略public(因为不写的话默认就是public访问权限)
    6. 接口可以含有变量,但是接口中的变量会被隐式修饰为public static final,并且只能是public类型

    抽象类和接口的区别

    1. 接口被用于常用的功能,便于日后维护和添加删除,而抽象类更倾向于充当公共类的角色,不适用于日后重新对立面的代码修改。功能需要累积时用抽象类,不需要累积时用接口
    2. 接口只有定义,不能有方法的实现(jdk1.8以后可以定义default方法体),而抽象类可以有定义与实现,方法可在抽象类中实现
    3. 抽象类中的成员变量可以是各种类型的,而接口中的成员变量只能是 public static final 类型的
    4. 一个类只能继承一个抽象类,而一个类却可以实现多个接口
    5. 接口强调特定功能的实现,而抽象类强调所属关系
    更多相关内容
  • Java中抽象类和接口的区别

    万次阅读 多人点赞 2019-02-07 14:10:07
    Java中,可以通过两种形式来体现OOP的抽象:接口和抽象类。这两者有太多相似的地方,又有太多不同的地方。很多人在初学的时候会以为它们可以随意互换使用,但是实际则不然。今天我们就一起来学习一下Java中接口...

    对于面向对象编程来说,抽象是它的一大特征之一。在Java中,可以通过两种形式来体现OOP的抽象:接口和抽象类。这两者有太多相似的地方,又有太多不同的地方。很多人在初学的时候会以为它们可以随意互换使用,但是实际则不然。今天我们就一起来学习一下Java中的接口和抽象类。

    一、抽象类

    在了解抽象类之前,先来了解一下抽象方法。抽象方法是一种特殊的方法:它只有声明,而没有具体的实现。抽象方法的声明格式为:

    abstract void fun();

    抽象方法必须用abstract关键字进行修饰。如果一个类含有抽象方法,则称这个类为抽象类,抽象类必须在类前用abstract关键字修饰。因为抽象类中含有无具体实现的方法,所以不能用抽象类创建对象。

    下面要注意一个问题:在《JAVA编程思想》一书中,将抽象类定义为“包含抽象方法的类”,但是后面发现如果一个类不包含抽象方法,只是用abstract修饰的话也是抽象类。也就是说抽象类不一定必须含有抽象方法。个人觉得这个属于钻牛角尖的问题吧,因为如果一个抽象类不包含任何抽象方法,为何还要设计为抽象类?所以暂且记住这个概念吧,不必去深究为什么。

    [public] abstract class ClassName {
    
        abstract void fun();
    
    }

     从这里可以看出,抽象类就是为了继承而存在的,如果你定义了一个抽象类,却不去继承它,那么等于白白创建了这个抽象类,因为你不能用它来做任何事情。对于一个父类,如果它的某个方法在父类中实现出来没有任何意义,必须根据子类的实际需求来进行不同的实现,那么就可以将这个方法声明为abstract方法,此时这个类也就成为abstract类了。

    包含抽象方法的类称为抽象类,但并不意味着抽象类中只能有抽象方法,它和普通类一样,同样可以拥有成员变量和普通的成员方法。注意,抽象类和普通类的主要有三点区别:

    • 抽象方法必须为public或者protected(因为如果为private,则不能被子类继承,子类便无法实现该方法),缺省情况下默认为public。
    • 抽象类不能用来创建对象;
    • 如果一个类继承于一个抽象类,则子类必须实现父类的抽象方法。如果子类没有实现父类的抽象方法,则必须将子类也定义为为abstract类。

    在其他方面,抽象类和普通的类并没有区别。

    二、接口

    接口,英文称作interface,在软件工程中,接口泛指供别人调用的方法或者函数。从这里,我们可以体会到Java语言设计者的初衷,它是对行为的抽象。在Java中,定一个接口的形式如下:

    [public] interface InterfaceName {
    
     
    
    }

    接口中可以含有 变量和方法。但是要注意,接口中的变量会被隐式地指定为public static final变量(并且只能是public static final变量,用private修饰会报编译错误),而方法会被隐式地指定为public abstract方法且只能是public abstract方法(用其他关键字,比如private、protected、static、 final等修饰会报编译错误),并且接口中所有的方法不能有具体的实现,也就是说,接口中的方法必须都是抽象方法。从这里可以隐约看出接口和抽象类的区别,接口是一种极度抽象的类型,它比抽象类更加“抽象”,并且一般情况下不在接口中定义变量。

    要让一个类遵循某组特地的接口需要使用implements关键字,具体格式如下:

    class ClassName implements Interface1,Interface2,[....]{
    
    }

    可以看出,允许一个类遵循多个特定的接口。如果一个非抽象类遵循了某个接口,就必须实现该接口中的所有方法。对于遵循某个接口的抽象类,可以不实现该接口中的抽象方法。

    三、抽象类和接口的区别

    1.语法层面上的区别

    • 抽象类可以提供成员方法的实现细节,而接口中只能存在public abstract 方法;
    • 抽象类中的成员变量可以是各种类型的,而接口中的成员变量只能是public static final类型的;
    • 接口中不能含有静态代码块以及静态方法,而抽象类可以有静态代码块和静态方法;
    • 一个类只能继承一个抽象类,而一个类却可以实现多个接口。

    2.设计层面上的区别

    1)抽象类是对一种事物的抽象,即对类抽象,而接口是对行为的抽象。抽象类是对整个类整体进行抽象,包括属性、行为,但是接口却是对类局部(行为)进行抽象。举个简单的例子,飞机和鸟是不同类的事物,但是它们都有一个共性,就是都会飞。那么在设计的时候,可以将飞机设计为一个类Airplane,将鸟设计为一个类Bird,但是不能将 飞行 这个特性也设计为类,因此它只是一个行为特性,并不是对一类事物的抽象描述。此时可以将 飞行 设计为一个接口Fly,包含方法fly( ),然后Airplane和Bird分别根据自己的需要实现Fly这个接口。然后至于有不同种类的飞机,比如战斗机、民用飞机等直接继承Airplane即可,对于鸟也是类似的,不同种类的鸟直接继承Bird类即可。从这里可以看出,继承是一个 "是不是"的关系,而 接口 实现则是 "有没有"的关系。如果一个类继承了某个抽象类,则子类必定是抽象类的种类,而接口实现则是有没有、具备不具备的关系,比如鸟是否能飞(或者是否具备飞行这个特点),能飞行则可以实现这个接口,不能飞行就不实现这个接口。

    2)设计层面不同,抽象类作为很多子类的父类,它是一种模板式设计。而接口是一种行为规范,它是一种辐射式设计。什么是模板式设计?最简单例子,大家都用过ppt里面的模板,如果用模板A设计了ppt B和ppt C,ppt B和ppt C公共的部分就是模板A了,如果它们的公共部分需要改动,则只需要改动模板A就可以了,不需要重新对ppt B和ppt C进行改动。而辐射式设计,比如某个电梯都装了某种报警器,一旦要更新报警器,就必须全部更新。也就是说对于抽象类,如果需要添加新的方法,可以直接在抽象类中添加具体的实现,子类可以不进行变更;而对于接口则不行,如果接口进行了变更,则所有实现这个接口的类都必须进行相应的改动。

    下面看一个网上流传最广泛的例子:门和警报的例子:门都有open( )和close( )两个动作,此时我们可以定义通过抽象类和接口来定义这个抽象概念:

    abstract class Door {
    
        public abstract void open();
    
        public abstract void close();
    
    }

    或者:

    interface Door {
    
        public abstract void open();
    
        public abstract void close();
    
    }

    但是现在如果我们需要门具有报警alarm( )的功能,那么该如何实现?下面提供两种思路:

    1)将这三个功能都放在抽象类里面,但是这样一来所有继承于这个抽象类的子类都具备了报警功能,但是有的门并不一定具备报警功能;

    2)将这三个功能都放在接口里面,需要用到报警功能的类就需要实现这个接口中的open( )和close( ),也许这个类根本就不具备open( )和close( )这两个功能,比如火灾报警器。

    从这里可以看出, Door的open() 、close()和alarm()根本就属于两个不同范畴内的行为,open()和close()属于门本身固有的行为特性,而alarm()属于延伸的附加行为。因此最好的解决办法是单独将报警设计为一个接口,包含alarm()行为,Door设计为单独的一个抽象类,包含open和close两种行为。再设计一个报警门继承Door类和实现Alarm接口。

    interface Alram {
    
        void alarm();
    
    }
    
     
    
    abstract class Door {
    
        void open();
    
        void close();
    
    }
    
     
    
    class AlarmDoor extends Door implements Alarm {
    
        void oepn() {
    
          //....
    
        }
    
        void close() {
    
          //....
    
        }
    
        void alarm() {
    
          //....
    
        }
    
    }

    最后再用一个表格的形式来总结一下抽象类和接口的区别:

    参数抽象类接口
    默认的方法实现它可以有默认的方法实现接口完全是抽象的。它根本不存在方法的实现
    实现子类使用extends关键字来继承抽象类。如果子类不是抽象类的话,它需要提供抽象类中所有声明的方法的实现。子类使用关键字implements来实现接口。它需要提供接口中所有声明的方法的实现
    构造器抽象类可以有构造器接口不能有构造器
    与正常Java类的区别除了你不能实例化抽象类之外,它和普通Java类没有任何区别接口是完全不同的类型
    访问修饰符抽象方法可以有publicprotecteddefault这些修饰符接口方法默认修饰符是public。你不可以使用其它修饰符。
    main方法抽象方法可以有main方法并且我们可以运行它接口没有main方法,因此我们不能运行它。
    多继承抽象方法可以继承一个类和实现多个接口接口只可以继承一个或多个其它接口
    速度它比接口速度要快接口是稍微有点慢的,因为它需要时间去寻找在类中实现的方法。
    添加新方法如果你往抽象类中添加新的方法,你可以给它提供默认的实现。因此你不需要改变你现在的代码。如果你往接口中添加方法,那么你必须改变实现该接口的类。

     我有一个微信公众号,经常会分享一些Java技术相关的干货;如果你喜欢我的分享,可以用微信搜索“Java团长”或者“javatuanzhang”关注。

    展开全文
  • 抽象类: 在面向对象的概念,所有的对象都是通过类来描绘的,但是反过来,并不是所有的类都是...在Java中抽象类表示的是一种继承关系,一个类只能继承一个抽象类,而一个类却可以实现多个接口接口接口(英文:
  • 说一下Java中抽象类和接口存在的意义与价值

    千次阅读 多人点赞 2018-10-15 16:29:41
    定义是很简单的,我们这里不写官方的语言,我自己看着都烦,我们就用白话介绍,抽象类本质是一个类,没问题,那么类里面一般都是有方法的,方法包括方法名方法体,这是常识对不对,那么什么是抽象类呢?...

    首先简单的介绍一下抽象类:

    定义是很简单的,我们这里不写官方的语言,我自己看着都烦,我们就用白话介绍,抽象类本质是一个类,没问题,那么类里面一般都是有方法的,方法包括方法名和方法体,这是常识对不对,那么什么是抽象类呢?如果一个类里面有一种方法只有方法名却没有方法体,这样的类就是抽象类!

    举个例子:

    public abstract class TestAbstract {
    	//这是一个抽象方法,
    	public abstract void run(); 
    	//当然这里面也可以是普通的方法
    	public void eat() {
    		System.out.println("我是一个在抽象类里面的普通方法");
    	}
    }

    这里为了区别普通的类,我们一般加abstract这个关键字,我们就认为他是一个抽象类。既然是一个类,那么普通类的属性他都有,它也可以写普通的方法。

    这里就有人说了,那这个有什么用呢?没有实现体,就是调用也没用啊,JDK也想到这个了,所以呢他是不让你直接实例化调用的,因为没用啊,对吧,这也是为什么抽象类不可以直接实例化自己,这里说实例化自己有些人不明白,说人话就是不可以自己创建一个自己的对象出来,他只能是子类的引用来创建父类的对象。

    举个例子:

    	public static void main(String[] args) {
    		/**
    		 * 抽象类是不可以自己实例化自己的,只能实例化自己的子类,因为只有子类才有方法的实现,自己实例化自己是没有意义的。况且就是自己
    		 * 里面有普通方法的实现,他的子类都是可以使用的。
    		 */
    		TestAbstract t = new TestA01();
    		
    	}

    回到之前的话题,既然有些方法不可以实现,写了做什么呢?难道就为了那几个可以实现的方法?当然不是的,这里的抽象类是为了子类更好的实现。

    我们举个简单的例子:我们有一个动物的类,里面有一个Run的方法,这个时候我们需要继承他,一只狗说我会跑,老虎说我也会跑,孔雀说我也会跑,这个时候每一个子类都要继承他,而且由于Run方法已经被父类实现了,所以每一个都要重写方法体,是不是很麻烦,这个时候JDK就说了,既然那么多类需要继承他,我直接不实现这个方法,你们谁用谁实现算了。这个就是抽象类存在的意义!

    说的比较官方一些的话,就是抽象类可以将设计和实现分离,你写你的抽象类,我写我的实现方法。这也是为什么说抽象方法必须被继承才有意义!

    举个例子:

    class TestA01 extends TestAbstract{
    	/**
    	 * @Override 是注解,JDK5.0以后的新特性,重写的意思,也就是说,如果是注解了的话,就是重写的方法,名字是不可以改的, 如果去掉注解,说明不是重写的方法
    	 * 名字是可以改掉的。
    	 */
    	@Override
    	public void run() {
    		System.out.println("我是子类的run()");
    	}
    	
    }

    总结一下:

     有抽象方法的类必然是抽象类
     抽象类不可以被实例化,不能被new来实例化抽象类
     抽象类可以包含属性,方法,构造方法,但是构造方法不能用来new实例,只能被子类调用
     抽象类只能用来继承
     抽象类的抽象方法必须被子类继承

    下面我们说一下接口:

    接口是我觉得Java里面相当伟大的一个发明,为什么呢?听我说完,接口我们可以认为本质也是一个类,只是修饰符改为了interface,类的修饰符是Class而已,那么接口是干嘛呢?前面讲了抽象类的使用,接口就是一个比抽象类还要抽象的类,前面说抽象类里面可以写普通的方法,说明还不够抽象,抽象的不够彻底,接口说干脆一不做二不休,规定只能写抽象方法算了,所以说接口是比抽象方法更抽象的类。

    举个例子:

    public interface MyIinterface {
    	/**
    	 * 接口里面只有常量和抽象方法
    	 */
    	/*public static final   接口中常量定义时都有这个,写不写都是这样*/String MAX_GREAD = "BOSS";
    	int MAX_SPEED = 120;
    	/*public abstatic  这里一样写不写都是public,因为不用public的话没有意义*/ void test01();
    	public int test02(int a, int b);
    	
    }

    有的人说不能被继承,不是和抽象类一样吗?为什么不写abstract关键字呢?不能被普通方法调用,不是静态变量吗?是的,说的都对,所以JDK这里不管你写不写,都是默认前面有这些修饰词的,上面我写的很明白!

    上面有句话说不同public的话没有意义,其实写到这里我们可以基本认为接口和抽象类是一种规则了,它规定你这样用,你只要继承或者实现,就必须要按照他的来,所以我们对应到现实生活中的话,就是说是一种规则,既然是规则就是给别人看的,你一个公司制定出来了规章制度,不公布,别人怎么遵守?一个道理,如果不用public修饰别人引用不到,和不规定是一样的。所以JDK也明白,所以这里的方法你写不写public他都默认帮你加上!

    下面讲实现

    我们说了,抽象类也好,接口也好,不继承,不实现都是没有意义的,但是因为接口里面只有抽象方法,所以他必须被实现才有意义,不然就会被垃圾回收机制System.gc给回收掉,前面的文章说过了垃圾回收的原理,这里不做赘述,但是为什么不继承呢?有人说了?既然要被实现里面的方法,直接继承不行了吗?是的,但是类的继承只能是单继承,所以,如果一个类里面有很多的接口,怎么做?所以只能是实现!

    但是有人说了,如果很多接口,最后一个继承了上面的所有接口,那我实现的时候是不是需要实现所有接口的方法?答案是肯定的:

    举个例子:

    package com.gaojizu.TestInterface;
    /**
     * 测试接口的多继承
     * @author admin
     *
     */
    public interface InterFaceA {
    
    	void aaa();
    }
    /**
     * 接口B
     * @author admin
     *
     */
    interface InterFaceB{
    	void bbb();
    }
    /**
     * 接口C
     * @author admin
     *
     */
    interface InterFaceC extends InterFaceA,InterFaceB{
    	void ccc();
    }
    /**
     * 实现类
     * @author admin
     *
     */
    class TestClass implements InterFaceC{
    
    	@Override
    	public void aaa() {
    		System.out.println("TestClass.aaa()");
    		
    	}
    
    	@Override
    	public void bbb() {
    		System.out.println("TestClass.bbb()");
    		
    	}
    
    	@Override
    	public void ccc() {
    	   System.out.println("TestClass.ccc()");
    		
    	}
    	
    }
    

    其实这里也不难理解,继承了就是拥有了父接口的抽象方法,自然就必须实现他。

    那有人说了,我这里如果在子类里面声明了一个变量,那我直接用父接口的对象调用行不行呢?

    举个例子:

    class Plane implements FlyAble{
    
    	String name;
    	@Override
    	public void fly() {
    		System.out.println("我可以飞");
    		
    	}
    	
    }

    这里有一个name,我测试的时候是不是可以直接使用呢?当然不是,需要强制转换:

    看例子:

    	public static void main(String[] args) {
    		/**
    		 * 这里的接口是不可以自己实例化自己的,原因和抽象类是一样的,里面只有抽象方法,没有实现的,所以是实例化没有意义的
    		 * 那么直接f是不可以调出子类里面的属性的,原因很简单,他是FlyAble的对象,那么他就只能找到自己下面的属性和方法
    		 * 是没有办法知道子类的属性和方法的,想知道的话,就强制转换为子类的对象就行了。下面是例子
    		 */
    		FlyAble f = new Plane();
    		//强制转换为Plane类
    		Plane p = (Plane)f;
    		p.name = "test";
    	}

    其实这里用我们生活中的例子也是一样可以理解的,我们有一个会飞的类,他创建了一个天鹅的对象出来,天鹅说我会下蛋,那按照我们代码的逻辑来想,会飞的应该都会下蛋,显然不是,飞机也会飞,但是不会下蛋,怎么可以下蛋呢?将实例化出来的对象给一个具体使用的类,也就是天鹅!这里也是多态的一个体现,你给一个笼统的概念,然后具体的使用是什么就是什么的思想!

    最后一点:实现是可以多实现的!

    前面我们说接口的继承是可以多继承的,看明白,是接口可以多继承,类一样是单继承,实现是可以多实现的,你说我既可以飞,也可以跑,飞和跑在两个接口里面怎么办?可以同时实现:

    看例子:

    public interface FlyAble {
    
    	int MAX_SPEED = 11000;
    	int MIN_SPEED = 1;
    	void fly();
    }
    /**
     * 攻击的接口
     * @author admin
     *
     */
    interface Attack{
    	void tack();
    }
    
    class Plane implements FlyAble{
    
    	String name;
    	@Override
    	public void fly() {
    		System.out.println("我可以飞");
    		
    	}
    	
    }
    /**
     * 可以实现多个接口
     * @author admin
     *
     */
    class men implements FlyAble,Attack{
    
    	@Override
    	public void tack() {
    		System.out.println("我可以攻击");
    		
    	}
    
    	@Override
    	public void fly() {
    		System.out.println("我可以飞");
    	}
    	
    }

    那么接口存在的意义就不用说了吧,很明显了,为了更好的将设计与实现分离。

    设计师写完需要的接口,别的不用管了,怎么实现是下面的事情了,这样不仅仅可以提高开发效率,也可以更好的维护。当然如果只有一个人开发,那就没必要分接口和类了!

    觉得写的还行的,关注一下!一起交流!

    展开全文
  • 结论:abstract classInterface是JAVA语言的两种定义抽象类的方式。Interface将abstract的概念作了更进一步的发挥。你可以想像Interface是“纯粹”的 abstract class,只可以包含抽象方法,也包括一些常量的定义...
  • java中抽象类和接口的特点

    千次阅读 2016-08-02 15:19:34
    5. 抽象类中可以存在普通属性、方法、静态属性静态方法 6. 抽象类中的抽象方法需要有子类实现,如果子类不实现,则子类也需要定义为抽象的 java中接口的特点: 1. 接口中的方法,永远都被

    java中抽象类的特点:

    1. 如果一个类中有抽象方法,那么这个类一定是抽象类

    2. 抽象类中不一定有抽象方法

    3. 抽象类中可以存在抽象方法

    4. 抽象类中可以存在构造方法

    5. 抽象类中可以存在普通属性、方法、静态属性和静态方法

    6. 抽象类中的抽象方法需要有子类实现,如果子类不实现,则子类也需要定义为抽象的



    java中接口的特点:

    1. 接口中的方法,永远都被public来修饰

    2. 接口中没有构造方法,也不能实例化接口对象

    3. 接口中只有方法的声明,没有方法体

    4. 接口中只有常量,如果定义变量,在编译的时候都会默认加上“public static final”

    5. 接口中定义的方法都需要实现类来实现,如果实现类不能实现接口中的所有方法,则实现类需要定义为抽象类

    6. 静态方法不能被子类重写(覆盖),因此接口中不定声明静态方法

    7. 使用接口可以实现多继承


    接口和抽象类的区别之处:

    1. 接口中所有的方法隐含都是抽象的,而抽象类则可以同时包含抽象和非抽象的方法

    2. 类可以实现很多个接口,但是只能继承一个抽象类

    3. 类可以不实现抽象类和接口声明的所有方法,在这种情况下,类也必须得声明成是抽象的

    4. 抽象类可以在不提供接口方法实现的情况下实现接口

    5. java接口中声明的变量默认都是final的,抽象类可以包含非final变量

    6. java接口中的成员函数默认都是public的,抽象类中的成员函数可以是private,protected或者是public的

    7. 接口是绝对抽象的,不可以被实例化。抽象类也不可以被实例化,但是如果它包含main方法的话是可以被调用的


    展开全文
  • 下面小编就为大家带来一篇Java基础篇_有关接口和抽象类的几道练习题(分享)。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • Java抽象类接口实验报告
  • java中抽象类和接口有什么区别

    千次阅读 2015-04-02 14:31:00
    抽象类(abstract class):含有abstract修饰符的类。它不能创建实例对象;含有abstract方法的类必须定义为abstract class;abstract class类的方法不必是抽象的;abstract class类定义抽象方法必须在具体子类...
  • java抽象类和接口有什么意义

    千次阅读 2021-02-04 16:53:06
    为什么接口和抽象类不能实例化,为什么接口可以多个实现而抽象类只能单继承,特别是java8之后,抽象类和接口里面都可以写代码后,就更加分不清了,今天重新整理一下。 什么是抽象类(abstract class) 使用abstract...
  • Java中抽象类和接口

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

    千次阅读 2019-03-08 20:39:50
    这主要是由于定义抽象类的代价高(因为每个类只能继承一个类,在这个类,必须继承或者编写出其子类的所有共性),因此,虽然接口在功能上会弱化很多,但它只是针对一个动作的描述,而且可以在一个类同时实现多个...
  • 简述Java中抽象类和接口,及其两者区别

    万次阅读 多人点赞 2018-04-19 13:00:48
    在说区别之前,先简要说一下什么是抽象类和接口   1.抽象类    用abstract修饰的类叫做抽象类。    在讲抽象类之前有必要强调一下abstract修饰符:  1.abstract修饰的类为抽象类,此类不能有对象,...
  • Java抽象类和Java接口一样,都用来声明一个新的类型。并且作为一个类型的等级结构的起点。(2).格式:public abstract class abstractDemo{/**属性*/private String name;/**方法*/public abstract void f...
  • java中抽象类和接口的三点区别

    千次阅读 2015-11-06 16:36:02
    抽象类可以声明使用字段;接口则不能,但可以创建静态的final常量 抽象类中的方法可以是public、protected、private或者默认的package;接口的方法都是public 抽象类可以定义构造函数;接口不能
  • Java 抽象类和接口

    千次阅读 热门讨论 2021-11-14 16:09:56
    接口的特征三、抽象类和接口的区别 一、抽象类 1.抽象类 1.1抽象类的定义 在Java面向对象当中,所有的对象都是用过类进行描绘的,但是并不是所有的类都是用来描绘对象的,如果一个类没有包含足够多的信息来描述一个...
  • Java抽象类和接口中有构造方法吗?

    千次阅读 2019-04-18 20:22:00
    (1) Java抽象类和接口中有构造方法吗? ①在接口中 不可以有构造方法 在接口里写入构造方法时,编译器提示:Interfaces cannot have constructors。 A. 构造方法用于初始化成员变量,但是接口成员变量是常量,无需...
  • Java抽象类和接口的区别

    千次阅读 2020-02-09 16:56:31
    抽象类:如果一个类含有抽象方法(抽象方法是一种特殊的方法,它只有声明,而没有具体的实现),则称这个类为抽象类,...包含抽象方法的类称为抽象类,但并不意味着抽象类中只能有抽象方法,它普通类一样,同样...
  • 举例说明java中抽象类和接口的区别

    千次阅读 2018-04-13 11:42:32
    最近才了解到:如果一个类继承了某个抽象类或者实现了某个接口都需要对其中的抽象方法进行实现,否则该类需要被声明为抽象类。而在接口中有几点需要注意:1.接口中的所有方法都是抽象方法(修饰词abstract没有一点...
  • 展开全部答案:ABCFJava 抽象类在面向对象的概念,所有的对象都是通过类来32313133353236313431303231363533e58685e5aeb931333431343036描绘的,但是反过来,并不是所有的类都是用来描绘对象的,如果一个类没有...
  • java中接口和抽象类的区别(保证你一看就懂)

    千次阅读 多人点赞 2021-02-25 10:48:39
    3、接口中的变量必须给出初始值,抽象类可以不给; 4、一个类只能继承一个抽象类,但可以实现多个接口; 5、抽象类中可以写非抽象的方法,从而避免在子类中重复书写它们,这样可以提高代码的复用性,这是抽象类的...
  • Java抽象类和接口中有构造方法吗?

    万次阅读 多人点赞 2018-04-11 00:40:58
    以举例的方式说到如何区分抽象类和接口,这里我们从Java语法谈起,使我们更加了解这两者的内在区别。它们的语法区别: 1)接口不能有构造方法,抽象类可以有。 2)接口不能有方法体,抽象类可以有。 3)接口不能有...
  • [Java基础]Java抽象类和接口中有构造方法吗?

    万次阅读 多人点赞 2017-07-05 10:56:13
    2.问题描述:Java抽象类和接口中有构造方法吗? 3.问题解答: (1)Java抽象类和接口中有构造方法吗? ①在接口中 不可以有构造方法 在接口里写入构造方法时,编译器提示:Interfaces ...
  • 转自:https://www.cnblogs.com/zksh2016/p/5813857.html1、Java抽象类中不能有静态的抽象方法。 抽象类是不能实例化的,即不能被分配内存;而static修饰的方法在类实例化之前就已经别分配了内存,这样一来矛盾就...
  • java中抽象类和接口的区别

    千次阅读 2016-10-06 18:06:56
    java中抽象类和接口的区别抽象类和接口都体现了oop的抽象,两者之间有很多相似之处,但同时又有许多的不同之处。容易弄混淆,今天就简单的说一下两者之间的区别于相似之处吧! 一.抽象类与基本类抽象方法: 抽象方法...
  • JAVA抽象类和接口的联系与区别

    万次阅读 2018-08-15 20:35:32
    抽象类接口一直是面试问到的一道比较基础的问题,弄懂它们之间的联系与区别,将会提升我们面向对象编程的功底。 联系 (1)抽象类和接口都不能被实例化。如果要实例化,则抽象类变量必须指向某一个实现其...
  • 抽象类:使用abstract修饰,使用时,子类用extends继承! 接口:使用interface修饰,使用时,具体实现类用implements实现! 按照类所有元素,层次的区分两者: ...(1)抽象类可以有普通成员变量,接口不...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 577,062
精华内容 230,824
关键字:

java中的抽象类和接口

java 订阅