JAVA继承、抽象类、接口

合集下载

java面向对象的四个特性

java面向对象的四个特性

java⾯向对象的四个特性java⾯向对象编程是指:Java语⾔提供类、接⼝和继承等⾯向对象的特性,为了简单起见,只⽀持类之间的单继承,但⽀持接⼝之间的多继承,并⽀持类与接⼝之间的实现机制(关键字为implements)。

另外,java是⾯向对象,但不是所有的都是对象,基本数据类型就不是对象,所以才会有封装类。

⾯向对象的特性有1)抽象,2)封装,3)继承,4)多态。

1)抽象 抽象类:包含抽象⽅法的类称之为抽象类,但不意味着抽象类中只能有抽象⽅法,它和普通类⼀样,可以拥有普通的成员变量、⽅法。

1、抽象类不能被实例化。

抽象类的⼦类必须给出抽象类中的抽象⽅法的具体实现,除⾮该⼦类也是抽象类。

2、抽象类中不⼀定包含抽象⽅法,但是有抽象⽅法的类必定是抽象类。

3、抽象类中的抽象⽅法只是声明,不包含⽅法体,就是不给出⽅法的具体实现也就是⽅法的具体功能。

4、构造⽅法,类⽅法(⽤ static 修饰的⽅法)不能声明为抽象⽅法。

5、被定义为abstract的类需要被⼦类继承,但是被修饰为final的类是不能被继承和改写的,这两者是不能⼀起⽤来做修饰的。

接⼝:接⼝是⼀种特殊的抽象类。

当使⽤类的时候,仅关注其⾏为,不关⼼继承时可以使⽤接⼝来代替类。

接⼝中的⽅法都是抽象⽅法,abstract默认不写,所以抽象类中的抽象⽅法不能⽤访问修饰符。

接⼝中声明的成员默认为static final成员(不管是基础数据类型还是引⽤类型),且必须初始化。

接⼝的特性: 1、接⼝中每⼀个⽅法也是隐式抽象的,接⼝中的⽅法会被隐式的指定为 public abstract(只能是 public abstract,其他修饰符都会报错)。

2、接⼝中可以含有变量,但是接⼝中的变量会被隐式的指定为 public static final 变量(并且只能是 public,⽤ private 修饰会报编译错误)。

3、接⼝中的⽅法是不能在接⼝中实现的,只能由实现接⼝的类来实现接⼝中的⽅法。

Java抽象类和接口的定义与实现

Java抽象类和接口的定义与实现

Java抽象类和接⼝的定义与实现Java 抽象类1.什么时抽象类:在⾯向对象的概念中,所有的对象都是通过类来描绘的,但是反过来,并不是所有的类都是⽤来描绘对象的,如果⼀个类中没有包含⾜够的信息来描绘⼀个具体的对象,这样的类就是抽象类。

抽象类除了不能实例化对象之外,类的其它功能依然存在,成员变量、成员⽅法和构造⽅法的访问⽅式和普通类⼀样。

由于抽象类不能实例化对象,所以抽象类必须被继承,才能被使⽤。

也是因为这个原因,通常在设计阶段决定要不要设计抽象类。

⽗类包含了⼦类集合的常见的⽅法,但是由于⽗类本⾝是抽象的,所以不能使⽤这些⽅法。

在Java中抽象类表⽰的是⼀种继承关系,⼀个类只能继承⼀个抽象类,⽽⼀个类却可以实现多个接⼝。

2.抽象类和抽象⽅法的定义:在Java语⾔中使⽤abstract class来定义抽象类。

//abstract修饰的就是抽象类public abstract class Action {//abstract修饰的⽅法就是抽象⽅法,它只有⽅法的名字没有⽅法的实现public abstract void Text();public static void main(String[] args) {//new Action() 抽象不能new出来只能靠⼦类去实现它//本质上抽象类就是⼀个约束}}抽象类的规范:1. 抽象类不能被实例化(初学者很容易犯的错),如果被实例化,就会报错,编译⽆法通过。

只有抽象类的⾮抽象⼦类可以创建对象。

2. 抽象类中不⼀定包含抽象⽅法,但是有抽象⽅法的类必定是抽象类。

3. 抽象类中的抽象⽅法只是声明,不包含⽅法体,就是不给出⽅法的具体实现也就是⽅法的具体功能。

4. 构造⽅法,类⽅法(⽤ static 修饰的⽅法)不能声明为抽象⽅法。

5. 抽象类的⼦类必须给出抽象类中的抽象⽅法的具体实现,除⾮该⼦类也是抽象类。

3.接⼝的定义:接⼝(interface)是抽象⽅法和常量值的定义的集合。

java abstract方法继承

java abstract方法继承

Java Abstract方法继承一、什么是Abstract方法Abstract方法是Java中一种特殊的方法,它只有声明而没有具体的实现。

在定义一个Abstract方法时,需要使用abstract关键字修饰方法,并且该方法所在的类必须是抽象类或者接口。

Abstract方法的定义如下:public abstract void methodName();二、抽象类与接口抽象类(Abstract Class)是一个不能被实例化的类,它可以包含Abstract方法和具体的方法实现。

抽象类通过使用abstract关键字进行修饰。

接口(Interface)是一种纯抽象的类,它只包含Abstract方法和常量。

接口定义方法时,默认使用public abstract修饰。

抽象类和接口的区别如下: - 抽象类可以有构造方法,而接口不能有构造方法。

- 类只能继承一个抽象类,但可以实现多个接口。

- 抽象类可以有成员变量,而接口只能有常量。

- 接口中的方法默认是public的,而抽象类中的方法可以有不同的访问修饰符。

三、Abstract方法的继承方式Abstract方法在继承关系中有以下几种继承方式:子类覆盖方法、子类重载方法、子类继续声明抽象方法。

1. 子类覆盖方法当一个子类继承自一个抽象类或者实现一个接口时,它必须实现抽象类或接口中的所有Abstract方法。

子类通过覆盖Abstract方法来提供具体的实现。

例如,有一个抽象类Animal,其中定义了一个Abstract方法eat(),如下所示:public abstract void eat();}如果一个子类Dog继承自Animal,则必须实现eat()方法:public class Dog extends Animal {@Overridepublic void eat() {System.out.println("狗吃骨头");}}2. 子类重载方法除了覆盖Abstract方法,子类还可以重载Abstract方法。

Java里如何实现多继承

Java里如何实现多继承

Java里如何实现多继承1.接口(interface),接口被用来建立类与类之间关联的标准。

Java codepublic interface ITest{public void test();}public class TestImpl implements ITest{public void test(){System.out.println("test");}}2.抽象类(abstract class),只要类中有一个抽象方法,此类就被标记为抽象类。

实际上抽象类除了被继承之外没有任何意义。

区别1.接口是公开(public)的,里面不能有私有的方法或变量,是用于让别人使用的,实现接口的一定要实现接口里定义的所有方法。

而抽象类是可以有私有方法或私有变量的,实现抽象类可以有选择地重写需要用到的方法,但是必须实现里面所有的抽象方法。

2.抽象类在Java语言中表示的是一种继承关系,一个类只能使用一次继承关系。

但是,一个类却可以实现多个interface(java中实现多重继承的方法之一)。

3.抽象类中可以有自己的数据成员,也可以有非abstarct的成员方法。

而在接口中,只能够有静态的不能被修改的数据成员(也就是必须是 static final的,不过在 interface中一般不定义数据成员),而且所有的成员方法都是抽象的。

4.抽象类和接口所反映出的设计理念不同。

其实abstract class表示的是"is-a"关系,interface表示的是"like-a"关系。

(组合是"has a"关系)5.接口中定义的变量默认是public static final 型,且必须给其初值,所以实现类中不能重新定义,也不能改变其值。

抽象类中的变量默认是 friendly 型,其值可以在子类中重新定义,也可以重新赋值。

一般的应用里,最顶级的是接口,然后是抽象类实现接口,最后才到具体类实现。

继承和实现接口的区别

继承和实现接口的区别

继承和实现接⼝的区别
继承和实现接⼝的区别
1,java类可以⼀次继承多个接⼝,⽤implements 接⼝1,接⼝2
2,如果是接⼝继承接⼝的话也可以⽤extends,接⼝是多继承的,java类才是单继承
3,接⼝继承接⼝可以不实现⽗接⼝中的⽅法,可以声明⾃⼰的新⽅法,
4,类实现接⼝时,⼀定要实现接⼝中声明的⽅法,如果接⼝中没有定义抽象⽅法则不需要,但是要注意,类实现了⼀个接⼝A,如果B是A的⽗接⼝,且B中有抽象⽅法,则该类必须实现A和B中的所有抽象⽅法
5,抽象⽅法只能定义在抽象类中,抽象类实现接⼝,可以不实现接⼝中的抽象⽅法
继承接⼝是说的接⼝来继承接⼝,是接⼝与接⼝间的
接⼝可以继承接⼝?
1、接⼝可以继承接⼝,抽象类不可以继承接⼝,但可以实现接⼝。

2、抽象类可以继承实体类。

抽象类可以实现(implements)接⼝,抽象类是否可继承实体类,但前提是实体类必须有明确的构造函数。

3.抽象类可以继承实体类,就是因为抽象类的可以继承性和有⽅法。

4、⼀个接⼝可以继承多个接⼝. interface C extends A, B {}是可以的. ⼀个类可以实现多个接⼝: class D implements A,B,C{} 但是⼀个类只能继承⼀个类,不能继承多个类 class B extends A{} 在继承类的同时,也可以继承接⼝: class E extends D implements A,B,C{} 这也正是选择⽤接⼝⽽不是抽象类的原因。

java集合继承关系

java集合继承关系

java集合继承关系
Java集合框架中的继承关系如下所示:
1. Collection接口是所有集合接口的根接口,它继承了Iterable
接口。

2. List接口和Set接口都继承自Collection接口。

3. Queue接口继承自Collection接口,它定义了队列的行为。

4. Deque接口继承自Queue接口,但它还定义了双端队列的操作。

5. Map接口是所有映射接口的根接口。

6. SortedSet接口和SortedMap接口都继承自Set接口和Map接口,分别定义了排序集合和排序映射的操作。

7. NavigableSet接口和NavigableMap接口都继承自SortedSet接
口和SortedMap接口,分别定义了带导航功能的排序集合和排序映射的操作。

8. AbstractCollection、AbstractSet、AbstractList、AbstractSequentialList、AbstractQueue和AbstractMap是实现集合和
映射的抽象类,它们提供了一些基本的实现。

9. ArrayList和LinkedList都实现了List接口,它们提供了不同
的列表实现方式。

10. HashSet、LinkedHashSet和TreeSet都实现了Set接口,它们
提供了不同的集合实现方式。

11. HashMap、LinkedHashMap和TreeMap都实现了Map接口,它们提供了不同的映射实现方式。

JAVA继承,接口,抽象类等练习

JAVA继承,接口,抽象类等练习

一、选择题1、为了区分重载多态中同名的不同方法,要求(A )。

A) 采用不同的参数列表B) 返回值类型不同C) 调用时用类名或对象名做前缀D) 参数名不同2、定义主类的类头时可以使用的访问控制符是( C)。

A) private B) protected C) public D) private protected3、下列整型的常量属性i 的定义中,正确的是( A)。

A) static final int i=100; B) final int i;C) static int i; D) final float i=1.2f;4、设x,y 均为已定义的类名,下列声明对象x1的语句中正确的是( C)。

A) public x x1= new y( ); B) x x1=x( );C) x x1=new x( ); D) int x x1;5、下列方法定义中,正确的是( D)。

A) int x( int a,b ) B) double x( int a,int b){ return (a-b); } { int w; w=a-b; }C) double x( a,b ) D) int x( int a,int b){ return b; } { return a-b; }6、为了使包sos在当前程序中可见,可以使用的语句是( A)。

A)import sos.*; B)package sos.*;C)sos import; D)sos package;7、设i、j、k 为类x 中定义的int 型变量名,下列类x 的构造函数中正确的是( )。

A) x( int m){ ... } B) void x( int m){ ... }C) x( int m, int n){ ... } D) x( int h,int m,int n){ ... }8、下列类头定义中,正确的是( )。

CA) class x B) public x extends y{ .... } { .... }C) public class x extends y D) class x extends y implements y1{ .... } { .... }9、下面是有关子类继承父类构造函数的描述,其中正确的是(C )。

接口可以继承多个接口总结

接口可以继承多个接口总结

接⼝可以继承多个接⼝总结接⼝是常量值和⽅法定义的集合。

接⼝是⼀种特殊的抽象类。

ava类是单继承的。

java接⼝可以继承多个接⼝。

不允许类多重继承的主要原因是,如果A同时继承B和C,⽽b和c同时有⼀个D⽅法,A如何决定该继承那⼀个呢?但接⼝不存在这样的问题,接⼝全都是抽象⽅法继承谁都⽆所谓,所以接⼝可以继承多个接⼝。

接⼝继承接⼝本质就是⼀个抽象类继承另⼀个抽象类(它们都没写⽅法的实例)。

当⼀个类继承了⼀个抽象类,它必须要重写⽗类抽象类中的抽象⽅法,如果不去重写⽗类抽象⽅法的实例,那么这个类也是抽象类(这个抽象⼦类,直到重写这个抽象⽅法的实例为⽌,才能摆脱抽象的命运)。

接⼝继承多个接⼝,就算多个接⼝有相同的⽅法,但是最终实现接⼝的类只能实现⼀个⽅法且@Override⼀个⽅法,所以调⽤时就不会有问题了在java中⼀个类中不能继承多个接⼝,但是可以通过⼀个接⼝继承多个接⼝来实现。

具体代码如下:1public interface LanguageBeharvior {2public void language();3 }LanguageBeharvior1public interface SpeakBeharvior {2public void speak();3 }SpeakBeharvior1public interface PersonBeharvior extends LanguageBeharvior,SpeakBeharvior{23 }PersonBeharvior1public class Person implements PersonBeharvior{23 @Override4public void language() {56 System.out.println("汉语");7 }89 @Override10public void speak() {1112 System.out.println("⼈会说话");13 }1415 }Person1public class Main {2public static void main(String[] args) {3 Person person = new Person();4 nguage();5 person.speak();6 }7 }Main。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

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(参数列表)。

* super()可以重载,也就是说,super()会根据参数的个数与类型,执行父类相应的构造方法。

* 调用父类构造方法的super()语句必须写在子类构造方法的第一行。

* super()与this()的功能相似,但super()是从子类的构造方法调用父类的构造方法,而this()则是在同一个类内调用其他的构造方法。

* super()与this()均必须放在构造方法内的第一行,也就是这个原因,super()与this()无法同时存在同一个构造方法内。

* 与this关键字一样,super指的也是对象,所以super同样不能在static环境中使用,包括静态方法和静态初始化器(static语句块)。

3.在子类中访问父类的成员例://在学生子类Student中访问父类Person的成员。

用protected修饰符和super关键字访问父类的成员class Person3{protected String name;//用protected(保护成员)修饰符修饰protected int age;public Person3()//定义Person3类的“不做事”的无参构造方法{}public Person3(String name,int age)//定义Person3类的有参构造方法{=name;this.age=age;}protected void show(){System.out.println("姓名:"+name+" 年龄:"+age);}}class Student3 extends Person3//定义子类Student3,其父类为Person3{private String department;int age=20;//新添加了一个与父类的成员变量age同名的成员变量public Student3(String xm,String dep)//定义Student3类的有参构造方法{name=xm;//在子类里直接访问父类的protected成员namedepartment=dep;super.age=25;//利用super关键字将父类的成员变量age赋值为25System.out.println("子类Student3中的成员变量age="+age);super.show();//去掉super而只写sho()亦可System.out.println("系别:"+department);}}public class App8_3 {public static void main(String[] args){@SuppressWarnings("unused")Student3 stu=new Student3("李小四","信息系");}}/*在子类中访问父类的成员:* 在子类中使用super不但可以访问父类的构造方法,还可以访问父类成员就是和成员方法,* 但super不能访问在子类中添加的成员。

子类中访问父类成员的格式如下:* 1. super.变量名; 2.super.方法名;* 用protected修饰的成员可以被三种类所引用:该类自身、与它在同一个包中的其他类、在其他包中该的子类。

* 将成员声明为protected的最大好处是可以同时兼顾到成员的安全性和便利性。

4.覆盖重载是指在同一个类内定义名称相同,但参数个数或类型不同的方法。

覆盖(overriding):是指在子类中,定义名称,参数个数与类型均与父类完全相同的方法,用于重写父类里同名方法的功能。

例://以个人类Person为父类,创建学生子类Student,并用子类中的方法覆盖父类的方法。

class Person4{protected String name;protected int age;public Person4(String name,int age){ = name;this.age = age;}protected void show(){System.out.println("姓名:"+name+" 年龄:"+age);}}class Student4 extends Person4{private String department;public Student4(String name,int age,String dep){super(name,age);department = dep;}protected void show()//覆盖父类Person4中的同名方法{System.out.println("系别:"+department);}}public class App8_4{public static void main(String[] args){Student4 stu = new Student4("王永涛",24,"电子");stu.show();}}*覆盖父类的方法:子类在重新定义父类已有的方法时,应保持与父类完全相同的方法声明,即应与父类有完全相同的方法名、返回值类型和参数列表,否则就不是方法的覆盖,而是子类定义自己的与父类无关的方法,父类的方法末被覆盖,所以仍然存在。

*注意:子类中不能覆盖父类中声明为final或static的方法。

在子类中覆盖父类的方法时,可以扩大父类中方法权限,但不可以缩小父类方法的权限。

5.用父类的对象访问子类的成员例://利用父类Person5的对象调用子类Student5中的成员。

与不可被继承的成员与最终类class Person5{protected String name;//如果声明为静态最终变量,则不能被覆盖。

protected int age;public Person5(String name, int age){ = name;this.age = age;}protected void show(){System.out.println("姓名:"+name+" 年龄:"+age);}}class Student5 extends Person5{private String department;public Student5(String name,int age, String dep){super(name,age);department = dep;}protected void show(){System.out.println("系别:"+department);}}public class App8_5{public static void main(String[] args){Person5 per = new Student5("王永涛",24,"电子");//声明父类变量per指向子类对象per.show(); //利用父类对象per调用show()方法}}通过父类的对象访问子类的成员,只限于“覆盖”的情况发生时。

相关文档
最新文档