当前位置:   article > 正文

JAVA笔记五:继承_java extend

java extend

一、继承(inheritance)

继承:基于已有类创建新的类,复用(继承)已有类的方法,可以增加一些新的字段与方法。

已存在的类称为:超类(superclass)、基类(base class)、父类(parent class)

新类为:子类(subclass),派生类(derived class)、孩子类(child class)

1、继承(extend):

在Java中,所有继承都是公共继承。使用关键字extend继承父类的所有公共方法与公共字段。

public class Manger extends Employee

{

        add mothdos and fields

}

//子类通过extends关键字继承父类Employee的所有方法

2、覆盖(override)

子类定义的方法名与父类方法重名时,将覆盖父类方法。

覆盖只是对子类的方法进行重写。

实例:Manger.java,Manger类继承Employee类,并定义私有bonus字段以getBonus(),setBonus(),getInfo()等方法

  1. package cn.edu.abc.corejava;
  2. public class Manger extends Employee
  3. {
  4. private double bonus;
  5. public Manger(String N, double S, int Year, int month, int day)
  6. {
  7. super(N, S, Year, month, day);
  8. }
  9. public double getBonus()
  10. {
  11. return this.bonus;
  12. }
  13. public void setBonus(double bonus)
  14. {
  15. this.bonus = bonus;
  16. }
  17. public static String getInfo(Manger A[])
  18. {
  19. String info="";
  20. for (Manger e:A)
  21. info +=e.getName()+"\t"+e.getBonus()+"\n";
  22. return info;
  23. }
  24. public String getName()
  25. {
  26. return "管理员: "+super.getName();
  27. }
  28. public static void main(String args[])
  29. {
  30. Manger[] boss = new Manger[2];
  31. boss[0] = new Manger("张某",6000,1999,1,2);
  32. boss[1] = new Manger("李某",6000,1999,1,2);
  33. boss[0].setBonus(1000);
  34. boss[1].setBonus(2000);
  35. System.out.println(getInfo(boss));
  36. System.out.println(boss[1].getName());
  37. }
  38. }

注意:

1、继承为公共继承,可以增加字段、方法或覆盖方法,继承绝对不会删除任何字段与方法。

2、可以利用:super.父类方法,格式调用父类方法。

 public String getName()
    {
        return "管理员:  "+super.getName();
    }

//在Manger子类中定义getName方法覆盖所继承到的父类Employee的getName方法

//super.getName()这条语句调用的是父类Employee的getName方法

    public static String getInfo(Manger A[])
    {
        String info="";
        for (Manger e:A)
            info +=e.getName()+"\t"+e.getBonus()+"\n";
        return info;
    }

//e.getName()为子类的方法

        Employee A = new Employee("员工1",1211,1998,11,1);
        System.out.println(A.getName());
        Manger B = new Manger("管理员1",123,1322,89,88);
        System.out.println(B.getName());

        //覆盖只是对子类的方法进行重写。A.getName()仍旧调用父类Employee的方法

 3、子类构造器

由于Manger类的构造器不能访问Employee的私有字段,所有必须通过super语法调用构造器初始化这些私有字段。super()语句必须是子类构造器的第一条语句。

public class Manger extends Employee
{
    private double bonus;
    public Manger(String N, double S, int Year, int month, int day)
    {
        super(N, S, Year, month, day);
    }

.....

}

关键字this有两个含义:一是指示隐式参数的引用,二是调用该类的其他构造器。

类似的,关键字super有两个含义:一是调用超类的方法,二是调用超类的构造器。

 4、Object类

Object类是所有类的父类,是java中最高层的类,每一个类都扩展了Object,如果没有明确指出父类,Object就被认为是这个类的父类。所有的类都是Object的子类,所有任何类都可以重写Object类中的方法。

<要点>:

        1、可以使用Object类型变量引用任何类型的对象

Object obj = new Employee("管理员",1234,......);

        2、Object类型的变量只能用于作为各种值的一个泛型容器,要对其进行具体的操作还需要清楚其原始的类型,并进行强制转换

Employee e = (Employee)obj;

        3、在Java中只有基本类型不是对象(数值,字符,布尔型),所有的数组类型均为对象。

<方法>:

        1、 equals方法

"=="运算符比较两个对象引用地址是否相等,equals方法比较的是两个对象的实际内容

5、强制类型转换 

向上转型、向下转型、instanceof关键字

向上转型:利用父类描述子类,将一个具体的类转换为一个抽象的类,调用所继承的公共方法,没重写调用没重写的,重写的调用重写的。

Employee Test = new Manger("abc",12,12,1,1);

格式:父类类型 父类对象 = new 子类类型 (即为构造器)

例1、Test调用getName()  ​​​​

 由此可得:调用所继承的公共方法,没重写调用没重写的,重写的调用重写的。

向下转型:父类转化为子类,将抽象的类转化为具体的类,例如:某个员工就是经理

将抽象类的对象转换为具体类的对象是通常是错误的,使用instanceof关键字判断其是否能相互转转换

向下转换:

        Employee Test = new Manger("abc",12,12,1,1);

        Manger  subTest = (Manger) Test;

        前提:父类对象要先引用这个子类对象

        语法格式:子类类型 子类对象 = (子类类型)父类对象

instanceof关键字:

        语法格式myobject instanceof ExampleClass

 例2、subTest 调用子类特有方法setBonus()、getBonus()

  1. Employee Test = new Manger("abc",12,12,1,1);//父类对象引用子类对象
  2. if (Test instanceof Manger)//判断Test是否属于Manger类对象
  3. {
  4. Manger subTest = (Manger) Test;//向下转换
  5. subTest.setBonus(1000);
  6. System.out.println(subTest.getName()+" "+subTest.getBonus());
  7. }else
  8. {
  9. System.out.println("转换失败");
  10. }

                                                                                                            

6、阻止继承:final关键字

凡是被final关键字修饰过的内容都是不可被改变的。简称为无法修改,无法重写,无法继承

final字段:在定义时必须赋初值,且使用后无法被修改

final方法:将方法定义为final类型,可以防止子类修改父类的定义与实现方式,其中private修饰符将其方法隐式的指定为final,自然无法覆盖其父类方法

final类:不允许扩展的类被称为final类。定义final的类不能被继承,且不允许对这个类进行任何改动。如果这个类为final,则这个类中的方法均被隐式的设置为final,但其中的字段可以被设置为final或非final。

语法格式:public final class......

7、多态

一个对象变量可以指示多种实际类型的现象称为多态。多态就是同一个接口,使用不同的实例而执行不同操作。也可以理解为同一个事件发生在不同的对象上会产生不同的结果。

例如:如Student类继承了Person类,若定义Student类的对象为Tom则Tom既是Person类又是Student类。

任何父类出现的地方,我们都可以用子类来替代。

多态存在的三个必要条件:

        1、继承

        2、重写

        3、超类引用子类的对象

当使用多态方式调用方法时,首先检查父类中是否有该方法,如果没有,则编译错误;如果有,再去调用子类的同名方法。

例1、多态性的体现  Polymorphism.java

  1. package cn.edu.abc.corejava;
  2. public class Polymorphism {
  3. public static void main(String args[]) {
  4. get_class(new Student());
  5. get_class(new Teacher());
  6. }
  7. public static void get_class(Person X)
  8. {
  9. X.work();
  10. }
  11. }
  12. class Person
  13. {
  14. public void work(){}
  15. }
  16. class Student extends Person
  17. {
  18. public void eat()
  19. {
  20. System.out.println("吃饭");
  21. }
  22. public void work()
  23. {
  24. System.out.println("Student work :学习");
  25. }
  26. }
  27. class Teacher extends Person
  28. {
  29. public void work()
  30. {
  31. System.out.println("Teacher work :上课");
  32. }
  33. }

  

Person类有两个子类:Student,Teacher,均重写了父类的work方法,work()为同一事物,而同一个work方法在Student类下表现为“学习”,而在Teacher类下表现为“上课”,这就体现了同一个事件发生在不同的对象上会产生不同的结果,这就是多态。

8、抽象类

使用abstract关键字定义的类为抽象类,使用这个关键字定义的方法称为抽象方法。抽象类没有具体方法体这个方法本身也没有任何意义,除非它被重写。实际上抽象类除了被继承无任何意义。

只要类中有一个抽象方法,此类就应该被标记为抽象类。

为什么要设置抽象类,一般类不是已经够用了吗?。一般类里定义的方法,子类也可以覆盖,没必要定义成抽象的啊。

        其实不是说抽象类有什么用,一般类确实也能满足应用,但是现实中确实有些父类中的  方法确实没有必要写,因为各个子类中的这个方法肯定会有不同,所以没有必要再父类里写。当然你也可以把抽象类都写成非抽象类,但是这样没有必要。

 其抽象类只能被继承,无法被实例化,即无法创建对应的实例。在抽象类中可以有非抽象方法与抽象方法,但如果有抽象方法该类只能设定为抽象类。

 写成抽象类,这样别人看到你的代码,或你看到别人的代码,你就会注意抽象方法,而知道这个方法是在子类中实现的,所以,有个提示作用。

9、接口

接口是抽象方法的集合。接口中的所有方法都没有方法体,接口只是一种形式,接口自身不能做任何事情。接口修饰符为public,不能使用其他的修饰符,在接口定义的任何字段都是static和final

语法格式:

        public interface Paintable{      //定义接口方法可省略public abstract关键字

                void age();

                }

一个类继承父类的同时再实现一个接口:

语法格式:

        public class parallelogram(子类) extends Quadrangle(超类) implements Paintale {

        .........

        }

1、一个类可以继承多个接口  class 类名 implements 接口1、接口...

2、一个接口可以继承另一个接口 interface intf1 extends intf2

应该注意的是继承接口的子类必须在类中实现接口中的方法接口无法被实例化,但是可以被实现。一个实现接口的类,必须实现接口内所描述的所有方法,否则就必须宣告为抽象类(Abstract Class)。如下例 

 定义接口中的方法可以省略public abstract关键字

/*解释*/

我们定义一个Age接口,并且定义一个接口方法age()。

(实现接口的类)子类Student、Teacher继承超类Person与接口Age,此时子类中必须实现接口中的方法或将子类其方法设置为抽象类

/*对接口的理解*/

接口类似于招牌,如“做面的流程”(接口A),接口A中定义了“切面”这个方法。一个子类继承了接口A,就必须实现这个接口中的方法,即也要实现“切面”这个方法(可以理解为要想继承“做面的流程”就也必须学会“切面”)。虽然这个子类可以不继承该接口也能实现“切面”方法,如餐厅类也可以自己定义“切面”方法,但显然是不明显的,没有接口那么明确,也增加了代码量。

抽象类和接口的对比

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/菜鸟追梦旅行/article/detail/78758
推荐阅读
相关标签
  

闽ICP备14008679号