抽象类、接口和内部类_JavaCore

抽象类和接口的区别抽象类和接口的区别和联系在Java语言中,抽象类(abstract class)和接口(interface)是支持抽象类定义的两种机制。

正是由于这两种机制的存在,才赋予了Java强大的面向对对象的功能。

抽象类和接口之间存在着很多相似性,但是又有本质的区别。

对于初学者而言,在使用时很难界定到底采用者两种机制的哪一种。

本文具体分析了这两个概念的相同点和相异处。

二、正文：接口简述：在Java语言规范中，一个方法的特征仅包括方法的名字，参数的数目和种类，而不包括方法的返回类型，参数的名字以及所抛出来的异常。

在Java编译器检查方法的重载时，会根据这些条件判断两个方法是否是重载方法。

但在Java编译器检查方法的置换时，则会进一步检查两个方法(分处超类型和子类型)的返还类型和抛出的异常是否相同。

接口继承和实现继承的规则不同，一个类只有一个直接父类，但可以实现多个接口。

Java接口本身没有任何实现，因为Java接口不涉及表象，而只描述public行为，所以Java接口比Java抽象类更抽象化。

Java接口的方法只能是抽象的和公开的，Java接口不能有构造器，Java接口可以有public，静态的和final属性。

接口把方法的特征和方法的实现分割开来。

这种分割体现在接口常常代表一个角色，它包装与该角色相关的操作和属性，而实现这个接口的类便是扮演这个角色的演员。

一个角色由不同的演员来演，而不同的演员之间除了扮演一个共同的角色之外，并不要求其它的共同之处。

抽象类描述：abstract class和interface在Java语言中都是用来进行抽象类定义的，那么什么是抽象类，使用抽象类能为我们带来什么好处呢？在面向对象的概念中，我们知道所有的对象都是通过类来描绘的，但是反过来却不是这样。

并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

抽象类往往用来表征我们在对问题领域进行分析、设计中得出的抽象概念，是对一系列看上去不同，但是本质上相同的具体概念的抽象。

JA V A包、接口与抽象类【概述】包（Package）定义了软件单元，它能够独立发布，并能够与其它包组成应用程序，包的成员是一些相关联的类、接口，也可包含包中的类所使用的附加资源文件。

在Java程序的第一行代码，可以通过以下代码来申明源程序中所创建类型的包。

package 包名；如果某个Java程序源代码中没有上面的package 包名；那么这个源代码中定义的所有类型都属于一个默认包（default package）。

【包的主要作用】1.包将相互关联的接口和类结合成组。

2.包创建了命名空间来避免类型之间的命名冲突。

在一个包中的接口和类可以使用流行的公共名字来命名，而这些命名只在一个包内才有意义，在不同的包之间则可以有相同的命名。

3.包机制为开发应用提供了保护域。

包内的代码通过访问标志可以相互协作，而这些标志对外部代码是不可用的【包的命名约定】♦如果包名为c，那么相应的编译出的.class文件必须位于某个工作目录下的aaa\bbb\ccc目录里面或者某个Jar文件的aaa\bbb\ccc目录里面。

♦可以采用Internet域名反序，比如，可以将包命名为.zucc; 虽然这种命名模式使得包名变得很长，但却不容易重名。

【执行包中的类文件】对于包c中定义的某个类A，那么类文件A.class必定位于（1）工作目录下的aaa\bbb\ccc目录里面，或者（2）某个Jar文件中的aaa\bbb\ccc目录里面。

对于前一种情况，可以在命令提示符下，敲入java –cp 工作目录c.A 执行类A。

比如，如果工作目录是d:\test，那么可以键入java –cp d:\test c.A执行类A；如果命令提示符当前目录就是工作目录d:\test, 那么可以省去-cp d:\test, 而仅仅需要键入java c.A对于后一种情况，可以在命令提示符下，敲入下面命令可以执行类A；java –cp jar文件的路径文件名c.A比如，类文件A.class位于已经打包的jar文件abc.jar中，而abc.jar位于目录d:\test, 那么就可以键入如下命令来执行A.classjava –cp d:\test\abc.jar c.A【使用包成员（导入类型方式）】对于其它包中定义的类型，可以程序中使用类型的完全限定名（Fully qualified name, 即包名.类型名）来申明和使用类型；如果不想在程序中使用完全限定名（因为完全限定名比较长），而是希望通过简单的类型名来申明和使用其它包中的类型，那么可以通过import 语句将程序中使用到的类型（一般位于其它包）导入到当前程序中。

JA V A继承、抽象类、接口编辑人：星辰·樱联系QQ：838826112一．类的继承通过继承可以实现代码的复用，被继承的类称为父类或超类（superclass），由继承而得到的类称为子类（subclass）。

一个父类可以拥有多个子类，但一个类只能有一个直接父类，这是因为JA V A语言中不支多重继承。

子类继承父类的成员变量和成员方法，同时可以修改父类的成员变量或重写父类的方法，还可以添加新的成员变量或成员方法。

JA V A语言中有一个名为ng.Object的特殊类，所有的类都是直接或间接地继承该类而得到的。

1.子类的创建类的继承是通过extends关键字来实现的，在定义类时若使用ectends关键字指出新定义类的父类，就是在两个类之间建立了继承关系。

新定义的类称为子类，它可以从父类那里继承所有非private的成员作为自己的成员。

子类的创建：* 格式：class SubClass extends SuperClass* {* .* .* .* }2.调用父类中特定的构造方法在没有明确地指定构造方法时，子类还是会先调用父类中没有参数的构造方法，以便进行初始化的操作。

在子类的构造方法中可以通过super()来调用父类特定的构造方法。

例：//以Person作为父类，创建学生子类Student，并在子类中调用父类里某指定的构造方法。

class Person2{private String name;private int age;public Person2()//定义Person2类的无参构造方法{System.out.println("调用了Person2类的无参构造方法");}public Person2(String name,int age)//定义Person2类的有参构造方法{System.out.println("调用了Person2类的有参构造方法");=name;this.age=age;}public void show(){System.out.println("姓名："+name+" 年龄："+age);}}class Student2extends Person2//定义继承自Person2类的子类Student2{private String department;public Student2()//定义Student2类的无参构造方法{System.out.println("调用了学生类的无参构造方法Student2()");}public Student2(String name,int age,String dep)//定义Student2类的有参构造方法{super(name,age);//调用父类的胡参构造方法department=dep;System.out.println("我是"+department+"学生");System.out.println("调用了学生类的有参构造方法Student2(String name,int age,String dep)");}}public class App8_2 {public static void main(String[] args){Student2 stu1=new Student2();//创建对象，并调用无参构造方法Student2 stu2=new Student2("李小四",23,"信息系");//创建对象并调用有参构造方法stu1.show();stu2.show();}}/*在子类中访问你类的构造方法，其格式为super(参数列表)。

类、抽象类、接口、继承和对象(java)来源：JA V A中文站(www_java-cn_com)这不是什么教材，笔者有时会在论坛上瞧瞧，看到不少初学者问到很多问题，这些问题是java程序员应该懂得的，而一般书上不会讲到或者一笔带过的知识。

因此斗胆涂鸦一篇文章，把想说的在这里一口气说完。

这也是本人第一次写技术性的文章，文笔不畅之外，还请各位见谅。

首先讲清楚类和对象的区别。

类是广泛的概念，表示一个有共同性质的群体，而对象指的是具体的一个实实在在的东西。

例如，“人”是一个类，它可以表示地球上所有的人；而“张三”、“李四”、“爱因斯坦”等则是一个个的对象，或者说它们是“人”这个类的一个个实例。

在Java 中，我们可以定义类，然后创建类的对象。

例如：// 声明一个类“Human”class Human{private String name;public String getName(){实用文档return name;}public void setName(String value){ = value;}//......}创建一个类：Human human = new Human();其次，很多人对对象和对象的引用认识模糊引用是程序操作对象的句柄，相当于C和C++中的指针。

前面说了，对象是一个实实在在的东西，比如前面的代码：Human human = new Human();实用文档程序执行到这里之后，java虚拟机将会在内存中创建一个Human 对象，并将这个对象的引用赋给human 变量。

这里有两步，首先是创建Human 对象，然后把创建的对象的引用赋给human 变量。

如果声明了一个对象的引用，但没有将对象赋值给它，则这个引用指向了空的对象，或者说引用了不存在的对象。

这时如果想通过这个引用访问对象，则会抛出空指针异常，例如：Human human;//......human.setName("张三");下面重点谈一谈类、抽象类、接口和继承之间的关系不少细心的初学者在论坛上问类似这样的问题：1、接口不实现方法，但我却在程序中可以调用接口的方法，这是为什么？比如java.sql 包中的Connection、Statement、ResultSet 等都是接口，怎么可以调用它们的方法呢？实用文档2、抽象类不能实例化，但是jdk中却有很多抽象类的对象，这是为什么？比如System.in 是一个InputStream 类型对象，但InputStream 是抽象类，怎么可以得到它的对象呢？不管怎么样，大家应该明白一点：不管是抽象类中的抽象方法，还是接口中定义的方法，都是需要被调用的，否则这些方法定义出来就没有意义了。

Java中抽象类和接口的区别与联系0 引言抽象类是我们在对某一问题领域进行设计和分析时所得出的抽象概念，是一系列本质上相同，而外在形象各异的具体概念的抽象反映。

在面向对象领域中，抽象类的主要作用就是进行类型隐藏，是实现向对象设计的核心原则OCP（Open-Closed Principle）的关键。

1 抽象类的有关概念1）抽象类不能创建对象。

2）抽象类可以调用静态方法，同时不能对非静态方法进行调用。

3）抽象类可以对一个引用进行声明。

4）一个抽象类可以被子类继承，继承它的子类也可以是抽象类。

5）抽象类与多态性是密不可分的。

6）如果一个类用到了抽象方法，那么这个类必须是抽象类。

但是一个抽象类中却不一定要有抽象方法。

抽象类是Java中最为常用的语法之一，在开发过程中，它的主要作用就是抽象出某些子类的共性，由于在抽象类中仅对方法的作用进行说明，因此在使用不同的子类时，实现的方法是不一样的，这就是方法实现的个性。

抽象类中不一定要有抽象方法，但是大多数抽象类都含有可以让子类集成的抽象方法，如果在继承过程中，子类没有将抽象类中全部的抽象方法重写，那么这个子类就会变为抽象类；如果子类完成了全部抽象方法的重写，那么就可以完成自身的实例化。

在日常生活中，事物的功能都是确定的，因此现实中的类大多属于抽象类，只不过它的实现是基本都是通过子类来完成。

因此，抽象类不能独立存在，但如果在创建子类时，先完成父类的构建也是可行的。

可以说，抽象类就是一个标准，其作用在于对某类事物的方法进行定义，使其可以被不同的子类继承和实现。

所以，对于调用者来说，只需要了解抽象类的方法定义就可以实现对不同子类的调用。

2 接口的有关概念接口（inter faces）指的是Java中的一系列方法的声明，它包含了方法的特征，但是不包括对这种方法的实现，其原因就在于这些方法可以在不同的地方由不同的类实现，从而具备不同的功能。

通过接口，我们可以实现多继承，但这也只是接口众多功能中的一个。

详细解析Java中抽象类和接口的区别【达内科技java培训】在Java语言中，abstract class 和interface 是支持抽象类定义的两种机制。

正是由于这两种机制的存在，才赋予了Java强大的面向对象能力。

abstract class和interface之间在对于抽象类定义的支持方面具有很大的相似性，甚至可以相互替换，因此很多开发者在进行抽象类定义时对于abstract class和interface的选择显得比较随意。

其实，两者之间还是有很大的区别的，对于它们的选择甚至反映出对于问题领域本质的理解、对于设计意图的理解是否正确、合理。

本文将对它们之间的区别进行一番剖析，试图给开发者提供一个在二者之间进行选择的依据。

理解抽象类abstract class和interface在Java语言中都是用来进行抽象类(本文中的抽象类并非从abstract class翻译而来，它表示的是一个抽象体，而abstract class为Java语言中用于定义抽象类的一种方法，请读者注意区分)定义的，那么什么是抽象类，使用抽象类能为我们带来什么好处呢?在面向对象的概念中，我们知道所有的对象都是通过类来描绘的，但是反过来却不是这样。

并不是所有的类都是用来描绘对象的，如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

抽象类往往用来表征我们在对问题领域进行分析、设计中得出的抽象概念，是对一系列看上去不同，但是本质上相同的具体概念的抽象。

比如：如果我们进行一个图形编辑软件的开发，就会发现问题领域存在着圆、三角形这样一些具体概念，它们是不同的，但是它们又都属于形状这样一个概念，形状这个概念在问题领域是不存在的，它就是一个抽象概念。

正是因为抽象的概念在问题领域没有对应的具体概念，所以用以表征抽象概念的抽象类是不能够实例化的。

在面向对象领域，抽象类主要用来进行类型隐藏。

我们可以构造出一个固定的一组行为的抽象描述，但是这组行为却能够有任意个可能的具体实现方式。

什么是抽象类什么是接⼝两者有什么区别？如何使⽤它⼀、抽象类：抽象类是特殊的类，只是不能被实例化；除此以外，具有类的其他特性；重要的是抽象类可以包括抽象⽅法，这是普通类所不能的。

抽象⽅法只能声明于抽象类中，且不包含任何实现，派⽣类必须覆盖它们。

另外，抽象类可以派⽣⾃⼀个抽象类，可以覆盖基类的抽象⽅法也可以不覆盖，如果不覆盖，则其派⽣类必须覆盖它们。

⼆、接⼝：接⼝是引⽤类型的，类似于类,和抽象类的相似之处有三点：1、不能实例化；2、包含未实现的⽅法声明；3、派⽣类必须实现未实现的⽅法，抽象类是抽象⽅法，接⼝则是所有成员（不仅是⽅法包括其他成员）；另外，接⼝有如下特性：接⼝除了可以包含⽅法之外，还可以包含属性、索引器、事件，⽽且这些成员都被定义为公有的。

除此之外，不能包含任何其他的成员，例如：常量、域、构造函数、析构函数、静态成员。

⼀个类可以直接继承多个接⼝，但只能直接继承⼀个类（包括抽象类）。

三、抽象类和接⼝的区别：1.类是对对象的抽象，可以把抽象类理解为把类当作对象，抽象成的类叫做抽象类.⽽接⼝只是⼀个⾏为的规范或规定，微软的⾃定义接⼝总是后带able字段，证明其是表述⼀类类“我能做。

”.抽象类更多的是定义在⼀系列紧密相关的类间，⽽接⼝⼤多数是关系疏松但都实现某⼀功能的类中.2.接⼝基本上不具备继承的任何具体特点,它仅仅承诺了能够调⽤的⽅法;3.⼀个类⼀次可以实现若⼲个接⼝,但是只能扩展⼀个⽗类4.接⼝可以⽤于⽀持回调,⽽继承并不具备这个特点.5.抽象类不能被密封。

6.抽象类实现的具体⽅法默认为虚的，但实现接⼝的类中的接⼝⽅法却默认为⾮虚的，当然您也可以声明为虚的.7.（接⼝）与⾮抽象类类似，抽象类也必须为在该类的基类列表中列出的接⼝的所有成员提供它⾃⼰的实现。

但是，允许抽象类将接⼝⽅法映射到抽象⽅法上。

8.抽象类实现了oop中的⼀个原则，把可变的与不可变的分离。

抽象类和接⼝就是定义为不可变的，⽽把可变的座位⼦类去实现。

1.抽象类和接口的区别，什么时候用？简单来说，接口是公开的，里面不能有私有的方法或变量，是用于让别人使用的，而抽象类是可以有私有方法或私有变量的，另外，实现接口的一定要实现接口里定义的所有方法，而实现抽象类可以有选择地重写需要用到的方法，一般的应用里，最顶级的是接口，然后是抽象类实现接口，最后才到具体类实现。

还有，接口可以实现多重继承，而一个类只能继承一个超类，但可以通过继承多个接口实现多重继承，接口还有标识（里面没有任何方法，如Remote接口）和数据共享（里面的变量全是常量）的作用.抽象方法是必须实现的方法。

(加了abstract的方法)2.抽象方法的声明abstract class Name {private String name;public abstract boolean isStupidName(String name) {}}这有何错误?错。

abstract method必须以分号结尾，且不带花括号abstract class Something {private abstract String doSomething ();}这好像没什么错吧?错。

abstract的methods不能以private修饰。

abstract的methods就是让子类implement(实现)具体细节的，怎么可以用private把abstractmethod封锁起来呢? (同理，abstract method前不能加final)。

3.interface A{int x = 0;}class B{int x =1;}class C extends B implements A {public void pX(){System.out.println(x);}public static void main(String[] args) {new C().pX();}}错误。

在编译时会发生错误(错误描述不同的JVM有不同的信息，意思就是未明确的x调用，两个x都匹配（就象在同时import java.util和java.sql两个包时直接声明Date一样）。

JAVA的基本结构Java是一种面向对象的编程语言，具有丰富的基本结构。

以下是Java的基本结构的详细介绍，共有1200字以上。

1. 类(Class)：Java程序主要是由类组成的。

类是描述对象的状态和行为的模板。

每个Java程序都包含一个主类(Main Class)，并且可以包含多个其他类。

一个类由类声明(类的名称、方法等)和类体(类的成员变量、成员方法等)组成。

2. 方法(Method)：方法是类中的一段可执行代码，用于完成特定的功能。

方法包括方法名、返回类型、参数和方法体。

方法可以被其他方法调用或者在类的外部通过对象进行调用。

3. 对象(Object)：对象是类的实例化结果，它具有属性和行为。

Java中的每个对象都有一个与之相关联的类。

对象可以通过创建类的实例来创建。

例如，可以通过实例化一个类来创建一个具体的人物对象。

4. 成员变量(Member Variables)：成员变量是类的属性，用于描述对象的状态。

成员变量包括变量类型、变量名和初始值。

成员变量可以是实例变量(对象的每个实例都有一份)或者是静态变量(所有对象共享一份)。

5. 局部变量(Local Variables)：局部变量是在代码块中定义的变量，只在定义它的代码块中可见。

局部变量包括变量类型、变量名和初始值。

局部变量必须在使用之前进行初始化。

6. 构造方法(Constructor)：构造方法是特殊的方法，用于创建对象时初始化对象的成员变量。

构造方法的名称必须与类名相同，但没有返回类型。

当创建一个类的对象时，会自动调用与之相关联的构造方法。

7. 异常处理(Exception Handling)：Java提供了异常处理机制，用于处理程序中出现的错误。

异常是程序运行过程中的错误情况，包括运行时异常和检查异常。

通过使用try-catch块来捕获和处理异常。

8. 继承(Inheritance)：继承是一种实现代码重用的机制。

一个类可以从另一个类继承，从而获得父类中的属性和方法。

Java中类、抽象类、接口之间的区别和联系。

类——客观世界，是由许多事物构成的，这些事物既可以是有形的(比如一辆汽车)，也可以是无形的(比如一次会议)。

把客观世界中的事物映射到面向对象的程序设计中就是对象。

将同一类别的对象归纳总结，就构成类。

包括属性和方法、构造属性：记录事物的特征（状态）方法：记录了事物的行为；例如：学生特征：学号、性别、姓名、年龄行为：学习、吃饭package ;public class Student {int id;String name;int age=20;String sex;public void study(String st){System.out.println(name+"学习了"+st);}public String eat(){return "ok";}public Student(){}public Student(int id,String name,int age,String sex){this.id=id;=name;This.age=age;this.sex=sex;}抽象方法：仅有定义，没有具体实现的方法体抽象类：含有抽象方法的类，抽象类有构造，但是无法调用构造，抽象类中没有对象，抽象方法不能执行，抽象类的引用，指向非抽象的子类对象（多态），抽象方法的调用其实是调用重写以后的非抽象方法，含有抽象方法的类一定是抽象类，当时抽象类中不一定有抽象方法。

抽象类不能被实例化，也就是说，不能有自己的对象例如：一个银行系统中的账户，包括定期账户和活期账户，定期账户和活期账户都是基本的账户，但是它们计算利息的方法不同，需要不同的实现方法，可以将基本账户定义为抽象类package day8;public abstract class Acount { //基本账户private double total=2000;public Acount(){}//抽象方法具有强制性、规范性public abstract double get(); //抽象方法public void setTotal(double total) {this.total = total;}public double getTotal() {return total;}}package day8;public class HAcount extends Acount { //活期账户public double get() {return this.getTotal()*0.02;}public static void main(String[] args){Acount a=new HAcount();System.out.println(a.get());}}package day8;public class StaticAcount extends Acount{ //定期账户public double get(){return this.getTotal()*0.03;}public static void main(String[] args){Acount a=new StaticAcount(); //抽象类的引用指向非抽象子类对象System.out.println(a.get()); //抽象方法的调用其实是调用子类重写以后的非抽象方法}}声明接口使用关键字“interface”接口中一般只包含一组public抽象方法（且必须是公有抽象方法，但方法定义中public abstract可省略），因此可以将接口看成特殊的抽象类，接口也可以包含public static final数据（一般不写）Java一个类只能直接继承（extends）另一个类，不允许一个子类继承多个超类，却允许一个子类继承一个超类并实现(implements)多个接口.强制类型转换成接口时，不检测继承关系，但是如果类型不匹配，会在运行时引发类型转换例如：黄金：黄金是一种货币黄金也是一种金属package day8;public interface Jinshu { //定义黄金是金属的接口/* private */int i=8; //public static final 常量void shine();}package day8;public interface Huobi { //定义黄金是货币的接口void change();}package day8;public class Gold implements Huobi,Jinshu{public void shine(){System.out.println("黄金闪闪发光！");}public void change(){System.out.println("黄金可以交换！");}public static void main(String[] args){Jinshu js=new Gold();js.shine();Huobi hb=new Gold();hb.change();System.out.println(js.i);}}类、抽象类、接口之间的联系，可以举例如下：一个公司，有老板，老板聘的经理，还有员工，类就是员工，抽象类就是经理，接口就是老板。