精华内容
下载资源
问答
  • JAVA抽象和接口

    千次阅读 2021-06-14 21:08:49
    抽象方法,只声明而未实现的方法我们称为抽象方法,所有的抽象方法都需要用abstract关键字声明,包含抽象方法的类也需要使用abstract关键字声明,抽象普通类相比,区别在于抽象类带有抽象方法,抽象方法可以只...

    抽象类的基本概念
    抽象方法,只声明而未实现的方法我们称为抽象方法,所有的抽象方法都需要用abstract关键字声明,包含抽象方法的类也需要使用abstract关键字声明,抽象类和普通类相比,区别在于抽象类带有抽象方法,抽象方法可以只声明,而不需要方法体。

    
    
    public abstract class Shape {
        abstract public String area();
    }
    

    抽象类是可以没有抽象方法的但是一个类里面有抽象方法的话那么这个类就是抽象类,抽象类不能有方法体,如果一个类继承与一个抽象类,但是这个类不实现这个类的抽象方法,那么这个类还是抽象类。

    抽象类针对于类,接口针对于行为和方法。

    抽象类不能被实例化。

     

    接口:在JAVA编程语言中是一个抽象类型,是抽象方法的集合,接口通常以interface来声明。一个类通过继承接口的方式,从而来继承接口的抽象方法。

    public interface IMath {
        public int sum();
        public int muxNum(int a,int b);
    }
    

    接口是标准和规范,接口里必须使用public修饰符

    展开全文
  • Java 抽象和接口

    千次阅读 2018-12-04 21:45:27
    抽象类除了不能实例化对象之外,类的其它功能依然存在,成员变量、成员方法构造方法的访问方式普通类一样。 由于抽象类不能实例化对象,但可以定义一个引用。抽象类必须被继承,才能被使用。 父类包含了子类...

    在Java语言中使用abstract class来定义抽象类
    抽象类除了不能实例化对象之外,类的其它功能依然存在,成员变量、成员方法和构造方法的访问方式和普通类一样。

    由于抽象类不能实例化对象,但可以定义一个引用。抽象类必须被继承,才能被使用。

    父类包含了子类集合的常见的方法,但是由于父类本身是抽象的,所以不能使用这些方法。

    在Java中抽象类表示的是一种继承关系,一个类只能继承一个抽象类,而一个类却可以实现多个接口。
    抽象类可包含抽象方法,但抽象类不是必须包含抽象方法。抽象类相当于一个半成品,需要子类继承并覆盖其中的抽象方法,子类才可以实例化,如果子类没有实现父类的抽象方法,那么子类必须定义为抽象类。

    抽象方法只有声明没有实现,即只有方法声明没有方法体。有抽象方法就一定有抽象类,有抽象类不一定有抽象方法。
    abstract和final不能同时使用,abstract修饰类和方法就是为了继承和重写的,final则是阻止继承和重写。
    abstract和private也不能同时修饰方法,因为private阻止方法的重写,而abstract修饰的方法必须重写。
    abstract和static也不能同时修饰方法,因为static修饰的方法可以通过类名来调用,抽象方法没有方法体,调用一个没有方法体的方法肯定回出错。
    构造方法,类方法(用static修饰的方法)不能声明为抽象方法。
    对于抽象方法,不能使用private修饰符(编译出错),不能使用package修饰符(编译正常,但是不合理,后患无穷),可以使用public和protected,大多数情况下都是使用public。
    抽象类:

    package classTest;
    
    abstract class Parent{
    	public abstract void say();
    
    }
    class Child extends Parent{
    	public void say() {
    		System.out.println("子类的say方法");
    	}
    }
    
    public class TestAbstractClass {
    	public static void main(String[] args) {
    		Child child = new Child();
    		child.say();
    	}
    
    }
    
    

    结果:

    子类的say方法
    

    抽象类可以定义构造方法,抽象类仍然使用的是类继承关系。因此,子类在实例化时必须先对抽象类进行实例化(这里抽象类的实例化即子类实例化时仍然会调用抽象类的构造方法)。

    package classTest;
    
    abstract class parent1{
    	private String name;
    	public parent1() {
    		System.out.println("抽象类无参构造函数");
    	}
    	public parent1(String name) {
    		this.name = name;
    		System.out.println("抽象类有参构造函数" + name);
    	}
    	public abstract void say();
    }
    
    class Child1 extends parent1{
    	public Child1() {
    		System.out.println("子类无参构造函数");
    	}
    	public Child1(String name) {
    		super(name);
    		System.out.println("子类的有参构造函数" + name);
    	}
    	public void say() {
    		System.out.println("say");
    	}
    }
    public class TestAbstractConstructor {
              public static void main(String[] args) {
    			new Child1();
    			new Child1("hi");
    					}
    }
    
    

    结果:

    抽象类无参构造函数
    子类无参构造函数
    抽象类有参构造函数hi
    子类的有参构造函数hi
    

    接口
    接口(英文:Interface),在JAVA编程语言中是一个抽象类型,是抽象方法的集合,接口通常以interface来声明。一个类通过实现接口的方式,从而来继承接口的抽象方法。

    接口并不是类,编写接口的方式和类很相似,但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。

    接口无法被实例化,但是可以被实现。一个实现接口的类,必须实现接口内所描述的所有方法,否则就必须声明为抽象类(因为接口中所有的方法都是抽象方法,接口中的方法默认的修饰符为public abstract void;同时接口中的属性默认为静态常量,默认修饰符为public static final)。另外,在 Java 中,接口类型可用来声明一个变量,他们可以成为一个空指针,或是被绑定在一个以此接口实现的对象。

    package classTest;
     
    interface Parent2{
    	String name = "a";   // 等价于public static final String name;接口是无法被实例化的,所以接口里边的属性与对象无关,因此属性是静态的;
    	void say();        // 等价于public abstract void say();
    }
    interface Person{
    	void work();
    }
    class Child2 implements Parent2, Person{
    	public void say() {
    		System.out.println("say");
    	}
    	public void work() {
    		System.out.println("work");
    	}
    }
    public class TestImplements {
             public static void main(String[] args) {
    			Child2 c = new Child2();
    			c.say();
    			c.work();
    		}
    }
    
    

    结果:

    say
    work
    

    接口也是可以继承的,使用extends关键字,接口的继承和类的继承相似的是子接口会获得父接口中的所有抽象方法和全局常量。不同的类只能单继承,接口可以多重继承。
    示例:

    package classTest;
    
    interface Person2{
    	void say();
    }
    interface Person3{
    	void sleep();
    }
    interface Parent3 extends Person2,Person3{
    	void work();
    } 
    class Child3 implements Parent3{
    	public void say() {
    		System.out.println("say");
    	}
    	public void sleep() {
    		System.out.println("sleep");
    	}
    	public void work() {
    		System.out.println("work");
    	}
    }
    public class TestInterfaceExtend {
         public static void main(String[] args) {
    		Child3 a = new Child3();
    		a.say();
    		a.sleep();
    		a.work();
    	}
    }
    
    

    结果:

    say
    sleep
    work
    

    总结:
    对比抽象类和接口的组成:
    抽象类可以包含的成员:
    1、成员变量,和普通类相同,可以有静态变量,直接使用类名调用;
    2、成员方法,和普通类相同,可以有静态方法,直接使用类名调用;
    3、构造方法,不能用abstract修饰;
    4、抽象方法(必须含有),不能被static、private、final修饰;
    接口可以包含的成员:
    1、全局常量(静态常量),默认使用public static final修饰,必须;
    2、抽象方法,默认使用public abstract修饰;

    展开全文
  • Java 抽象类,抽象方法和接口

    千次阅读 2015-03-26 20:50:40
    讲述Java抽象类,抽象方法和接口的各种用法。

    抽象类和抽象方法

    在Java中用abstract修饰的类是抽象类,用abstract修饰的类的方法是抽象方法,抽象类和抽象方法用法总结如下。

    1. abstract可以修饰class表示抽象类,可以修饰方法表示抽象方法,但是不能修饰成员变量,也就是没有抽象的成员变量。
    2. 用abstract修饰的类中可以有abstract方法,也可以没有abstract方法;可以有非abstract方法,也可以没有非abstract方法。
    3. 只有abstract类中才能声明abstract方法,abstract方法不能声明在非abstract类中。
    4. abstract类可以是外部类,也可以是内部类。abstract类如果是外部类,不能用private修饰;abstract类如果是内部类,可以用private修饰。
    5. abstract方法不能有方法体,abstract方法必须对其子类可见,即不能用private修饰。

      // abstract类中可以没有abstract方法,但有abstract方法的类必须定义为abstract类
      abstract class C3 {
          // abstract类中可以有成员变量,但成员变量不能用abstract修饰
          private int mPara;
          // abstract方法不能有方法体,abstract方法不能是private
          public abstract void setPara(int para);
          // 抽象类中可以有非抽象方法
          public int getPara(){
              return mPara;
          }
      }
    6. abstract类可以继承自其他类,这个父类可以是abstract类,也可以是非abstract类。如果它继承自abstract类,它可以选择实现其父类中的abstract方法,也可以不实现。

    7. abstract类可以实现一个接口。它可以选择实现接口中的接口方法,也可以不实现。
    8. abstract类只有被继承时才有用,它的子类可以是abstract类,也可以是非abstract类。如果它的子类是abstract类,则会自动继承所有其所有的abstract方法,abstract子类中也可以定义新的abstract方法,如果它的子类是非abstract类,则子类必须实现其所有的abstract方法。
    9. abstract类可以用来定义变量,但不能实例化,也就是不能通过new来构造一个abstract类的对象。abstract类定义的变量可以被赋值为其非abstract子类的对象。
    10. abstract类中可以有构造方法,抽象类的构造方法不能是抽象方法。
    11. abstract类和abstract方法都不能用final修饰。

    接口

    在Java中用interface来定义一个接口,接口用法总结如下。

    1. interface只能用来定义接口,不能用来修饰类,成员变量或成员方法。
    2. interface中可以有成员变量,成员变量一定是public static final的,但允许在声明变量时仅指定部分修饰符。但即使没有添加public,static,final中任何一个修饰符,该变量仍然是public static final的。此外,由于final成员变量必须在定义时初始化,因此,接口类中定义的成员变量必须在定义时赋值。赋值可以用常量表达式,也可以用任意在该接口中能够访问的对象组成的表达式。例如:

      private interface I1 {
          //len是public static final的,len必须被初始化
          int len = String.valueOf(new GregorianCalendar().getTimeInMillis()).length();
      }
    3. interface中的成员变量在实现该接口的类中可以直接使用,在没有实现该接口,但是可见该接口的类中可以通过“接口名.成员变量名”来访问。例如:用I1.len来访问上述例子中的接口中定义的len成员变量。

    4. interface中可以有成员方法,成员方法都是public abstract的抽象方法,不能有方法体。允许声明成员方法时指定部分或不指定修饰符,但即使没有添加public abstract中任何一个修饰符,该成员方法仍然是public abstract的。
    5. 一个接口可以继承自其他接口。接口之间的继承用extends关键字,不能用implements。一个接口可以继承多个其他接口。多个接口之间用逗号分隔。例如:private interface I1 extends I2, I3{}
    6. 一个接口不能继承自任何类,包括抽象类。
    7. 一个非抽象类如果实现了某个接口,它必须要实现该接口中声明的所有的抽象方法。一个抽象类如果实现了某个接口,它可以实现该接口中声明的抽象方法,也可以不实现。
    8. 接口可以用来定义变量,但不能实例化,也就是不能通过new来构造一个接口的对象。接口定义的变量可以被赋值为实现该接口的类的对象。
    9. 接口中没有构造方法。接口不能用final修饰。
    10. 接口中可以定义内部类和内部接口
    展开全文
  • java抽象和接口有什么意义

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

    用了java这么久,对接口和抽象类使用一直很模糊。为什么接口和抽象类不能实例化,为什么接口可以多个实现而抽象类只能单继承,特别是java8之后,抽象类和接口里面都可以写代码后,就更加分不清了,今天重新整理一下。

    什么是抽象类(abstract class)

    使用abstract修饰符修饰的类。官方点的定义就是:如果一个类没有包含足够多的信息来描述一个具体的对象,这样的类就是抽象类。

    实际点来说,一个抽象类不能实例化,因为“没有包含足够多的信息来描述一个具体的对象”。但终归属于类,所以仍然拥有普通类一样的定义。依然可以在类的实体(直白点就是能在{}里面)定义成员变量,成员方法,构造方法等。

    那么可能初学者会问:既然不能实例化,那么在类里面定义成员方法,成员变量有什么用。

    抽象类在实际应用中,更多的是因为类中有抽象方法。抽象方法:只声明,不实现。具体的实现由继承它的子类来实现。实际点就是:被abstract修饰的方法,只有方法名没有方法实现,具体的实现要由子类实现。方法名后面直接跟一个分号,而不是花括号。例如:

    abstract class Animal{
        public abstract void run();
    }
    
    class Person extends Animal{
        @Override
        public void run() {
            System.out.println("Person.run");
        }
    }
    

    一个类中含有抽象方法(被abstract修饰),那么这个类必须被声明为抽象类(被abstract修饰)。

    什么是接口(interface)

    官方定义:接口在java中是一个抽象类型,是抽象方法的集合。一个类通过继承接口的方式,从而继承接口的抽象方法。

    从定义上看,接口是个集合,并不是类。类描述了属性和方法,而接口只包含方法(未实现的方法)。接口和抽象类一样不能被实例化,因为不是类。但是接口可以被实现(使用 implements 关键字)。实现某个接口的类必须在类中实现该接口的全部方法。虽然接口内的方法都是抽象的(和抽象方法很像,没有实现)但是不需要abstract关键字。

    接口中没有构造方式(因为接口不是类)

    接口中的方法必须是抽象的(不能实现)

    接口中除了static、final变量,不能有其他变量

    接口支持多继承(一个类可以实现多个接口)

    例如:

    声明两个职业 接口:

    public interface ItWorker {
        String name = "worker";
        public void coding();
    }
    public interface Teacher {
        String name = "teacher";
        public void teaching();
    }
    

    Person实现两种职业接口:

    public class Person implements ItWorker,Teacher{
        @Override
        public void coding() {
            System.out.println("I'm a"+ItWorker.name);
        }
    
    	@Override
    	public void teaching() {
    	   System.out.println("I'm a"+Teacher.name);
    	}
    
    }
    

    抽象类和接口有什么意义

    对于接口

    接口的最主要的作用是达到统一访问,就是在创建对象的时候用接口创建,【接口名】 【对象名】=new 【实现接口的类】,这样你像用哪个类的对象就可以new哪个对象了,不需要改原来的代码,就和你的USB接口一样,插什么读什么,就是这个原理。

    对于接口的作用,在一些小的项目上,很难看出其发挥的优势。这就使一些经常的做小项目的开发人员,做时间久了就感觉不到它有什么好的,有时候写起来还麻烦,干脆不用了。其实,在一些大项目上,接口的作用是发挥地相当的明显的。

    比如:如果你开发业务逻辑代码,当你好不容易的实现了它全部的功能,突然用户需求要改,你在修改你代码的同时,调用你代码的其它人也会改,如果代码关联性强的话,会有很多人都要改动代码,这样一来二去,程序会变得相当的不稳定,而且可能还会出现更多的新Bug,所有人都可能会陷入混乱。

    但如果使用接口的话,在你使用它之前,就要想好它要实现的全部功能(接口实际上就是将功能的封装)。确定下这个接口后,如果用户需求变了,你只要重新写它的实现类,而其它人只会调用你的接口,他不管你是怎么实现的,它只需要接口提供的功能。这样,很可能只需要把你的代码修改就可以了,其他人什么都不用做。

    同时:这样做的话,使得开发人员能够分工明确,只要确定下来接口了,就可以同时进行开发,提高开发效率。另外,使用接口还有使用方便,可读性强,结构清晰
    等优点。

    对于抽象类

    一般来说我们使用普通类来实现接口,这个普通类就必须实现接口中所有的方法,这样的结果就是普通类中就需要实现多余的方法,造成代码冗余。但是如果我们使用的是抽象类来实现接口,那么就可以只实现接口中的部分方法,并且当其他类继承这个抽象类时,仍然可以实现接口中有但抽象类并未实现的方法。

    总结

    我们可以把接口看成一个工具,当我们实现一个接口时,就意味着能使用这一工具,当我们实现多个接口时,就能使用多种工具,就像上面Person可以是多种职业,所以它可以同时实现Teacher和ItWorker接口。

    而抽象类则可以看成是一个祖先,所以一个类只能继承一个祖先,如上Animal是Person的祖先,所以Person具有Animal的一切属性。

    展开全文
  • 今天来讲一讲Java抽象和接口的区别。类是对象的模板,抽象和接口都可以看作是实现类的模板。由于从某种角度来看,接口是特殊的抽象类。它们的渊源颇深,有很大的相识之处,所以在选择使用谁的问题上很容易迷糊...
  • 1.抽象类(abstract class):在Java中被abstract关键字修饰的类称为抽象类,被abstract关键字修饰的方法称为抽象方法,抽象方法只有方法的声明,没有方法体。 特点: ①抽象类不能被实例化(初学者很容易犯的错),如果...
  • Java抽象和接口

    千次阅读 2016-09-20 13:58:18
    抽象方法必须存在与抽象类当中,只要一个类里定义了抽象方法,那么这个类必须得变成抽象类 子类必须实现继承自父类的所有抽象方法,如果子类不想实现,那么它得继续将自己变成抽象类,让抽象方法继续往下传,等待...
  • Java 抽象接口 继承 实现

    千次阅读 2016-07-23 17:21:14
    接口和抽象类的概念不一样。接口是对动作的抽象抽象类是对根源的抽象抽象类表示的是,这个对象是什么。接口表示的是,这个对象能做什么。比如,男人,女人,这两个类(如果是类的话……),他们的抽象类是人。...
  • 一起来搞明白JAVA抽象和接口

    千次阅读 多人点赞 2018-01-04 14:40:33
    今天我来说说自己关于JAVA抽象和接口。 抽象类: 定义:有abstract修饰的类,我们称之为抽象类 如: abstract class Test{}; 。  方法:抽象类可以有具体方法抽象方法 。 抽象方法如: abstract void ...
  • java抽象和接口

    千次阅读 2019-05-14 17:34:15
    java抽象和接口 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 开发工具与关键技术:MyEclipse10 作者:朱海恩 撰写时间: 2019.04.30 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~...
  • Java抽象和接口实验报告

    千次阅读 2016-09-09 18:43:10
    实验报告 ...Java抽象和接口 实验地点 1#608 实验类型 □验证型 √设计型 □综合型  学 时 2 一、实验目的及要求(本实验所涉及并要求掌
  • Java接口和Java抽象

    2013-04-23 08:36:36
    Java接口和Java抽象类有太多相似的地方,又有太多特别的地方,究竟在什么地方,才是它们的最佳位置呢?把它们比较一下,你就可以发现了。 1、Java接口和Java抽象类最大的一个区别,就在于Java抽象类可以提供某些...
  • 首先看看他们的区别:接口和内部类为我们提供了一种将接口与实现分离的更加结构化的方法。 抽象类与接口是Java语言中对抽象概念进行定义的两种机制,正是由于他们的存在才赋予java强大的面向对象的能力。他们两者...
  • Java抽象类与接口

    千次阅读 2016-06-07 11:20:39
    接口和内部类为我们提供了一种将接口与实现分离的更加结构化的方法。 抽象类与接口是java语言中对抽象概念进行定义的两种机制,正是由于他们的存在才赋予java强大的面向对象的能力。他们两者之间对抽象概念的...
  • 抽象和接口的区别有哪些? 答: 1.抽象类中可以没有抽象方法;接口中的方法必须是抽象方法。 2.抽象类中可以有普通的成员变量;接口中的变量必须是static final类型的,必须被初始化,接口中只有常量,没有变量。 ...
  • 浅析JAVA抽象和接口的比较

    千次阅读 2018-08-02 00:02:32
    抽象类(abstract class)和接口(interface)是Java语言中对于抽象类定义进行支持的两种机制,正是由于这两种机制的存在,才赋予了Java强大的面向对象能力。抽象和接口之间在对于抽象类定义的支持方面具有很大的...
  • Java抽象和接口的区别

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

    千次阅读 2018-12-21 08:32:57
    尽管接口使得抽象更进一步,但任何抽象性都应该根据真正的需求而产生,因此恰当的原则是优先选择类而不是接口,只有在真正需要接口的时候再重构代码。
  • Java接口和Java抽象

    千次阅读 2010-08-23 00:13:00
    在没有好好地研习面向对象设计的设计模式之前,我对Java接口和Java抽象类的认识还是很模糊,很不可理解。刚学Java语言时,就很难理解为什么要有接口这个概念,虽说是可以实现所谓的多继承,可一个只有方法名,没有...
  • java 抽象和接口的区别

    千次阅读 2018-01-23 16:29:59
    很多常见的面试题都会出诸如抽象和接口有什么区别,什么情况下会使用抽象什么情况你会使用接口这样的问题。本文我们将仔细讨论这些话题。 在讨论它们之间的不同点之前,我们先看看抽象类、接口各自的特性。...
  • java程序设计语言提供了两种机制,可以用来定义允许多个实现的类型:接口和抽象类。这两种机制之间最明显的区别在于,抽象类允许包含某些方法的实现,但是接口不允许,一个更重要的区别在于,为了实现抽象定义的类型...
  • JAVA中的接口和抽象

    万次阅读 2016-12-12 23:24:40
    抽象是面向对象设计的几大特点之一,在JAVA中的体现则是抽象和接口。这两者十分的相似,想很多初学者甚至接触java几年的人也很难分清他们。今天笔者在查看集合类相关的代码的时候,发现了有部分是接口如List、Map...
  • [Java基础]Java抽象和接口中有构造方法吗?

    万次阅读 多人点赞 2017-07-05 10:56:13
    2.问题描述:Java抽象和接口中有构造方法吗? 3.问题解答: (1)Java抽象和接口中有构造方法吗? ①在接口中 不可以有构造方法 在接口里写入构造方法时,编译器提示:Interfaces ...
  • java抽象类 与 接口

    千次阅读 2015-01-12 16:13:39
    Java接口和Java抽象类的认识 很难理解为什么要有接口这个概念,虽说是可以实现所谓的多继承,可一个只有方法名,没有方法体的东西,我实现它又有什么用呢?我从它那什么也得不到,除了一些方法名,我直接在具体类...
  • Java 抽象类与接口 编程练习

    千次阅读 2020-04-16 12:47:19
    (1)使用接口或者抽象类实现基类Employer(体会接口和抽象类的不同),包含姓名、部门和工资三个属性,显示工资的方法showSalary()和显示奖金的抽象方法showBonus();提示:因每位职工奖金不同,showBonus()...
  • Java 抽象和接口的相同点不同点

    千次阅读 2017-09-01 10:15:15
    抽象和接口都不能直接实例化,如果要实例化,抽象类变量必须指向实现所有抽象方法的子类对象,接口变量必须指向实现所有接口方法的类对象。 抽象类里的抽象方法必须全部被子类所实现,如果子类不能全部实现父类抽

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 530,385
精华内容 212,154
关键字:

java抽象和接口

java 订阅