• 第9章 Java类的三大特性之一:继承


     

    1.什么是继承

    子类继承父类就是对父类的扩展,继承时会自动拥有父类所拥有的处private之外的所有成员
    作用:增加代码复用
    语法格式:

    class 子类名 extends 父类名{
    …………
    }第9章 Java类的三大特性之一:继承
    例子:

     1 //测试类,创建子类对象,可以直接调用属性和方法
     2 public class testDog {
     3     public static void main(String[] args) {
     4         Dog dog = new Dog();
     5         dog.age=10;
     6         dog.name="旺财";
     7         dog.eat();
     8     }
     9 }
    10 
    11 //子类,没有写任何方法
    12 public class Dog extends Animal {
    13 
    14 }
    15 
    16 //测试类,创建子类对象,可以直接调用属性和方法
    17 public class testDog {
    18     public static void main(String[] args) {
    19         Dog dog = new Dog();
    20         dog.age=10;
    21         dog.name="旺财";
    22         dog.eat();
    23     }
    24 }
    25 
    26 
    27 …………………………
    28 动物具有吃东西的能力

    2.继承中的方法的重写

    子类在继承父类之后,可以把这个方法重写,并优先调用子类的方法,就近原则。
    方法重写是在继承时候对父类中存在的方法重新定义,重载是指一个类中有几个方法的名字是不一样的,只有在接收不同的参数时,才会调用对应的那个方法
    继承时方法的重写有一些限制:
    1.返回值类型
    2.方法名
    3.参数类型及个数
    上面三个都要与父类继承的方法相同,如此才叫方法的重写
    例子:

     1 //父类
     2 public class Animal {
     3     public String name;
     4     public void eat(){
     5         System.out.println("动物"+name+"是可以吃东西的");
     6     }
     7 }
     8 
     9 //子类,重写了eat()方法
    10 public class Dog extends Animal {
    11 
    12     public void eat() {
    13         System.out.println("这里是在子类中重写的方法");
    14     }
    15 }
    16 
    17 
    18 //测试类,创建子类对象,可以直接调用属性和方法
    19 public class testDog {
    20     public static void main(String[] args) {
    21         Dog dog = new Dog();
    22         dog.name="旺财";
    23         dog.eat();
    24     }
    25 }
    26 
    27 ………………
    28 这里是在子类中重写的方法

    3.继承初始化顺序

    继承的初始化顺序:
    1.使用类的时候都是在创建对象的时候,在创建子类对象时,是先初始化子类还是先初始化父类呢?

    答案是先初始化父类再初始化子类

    这个可以通过分别在父类和子类构造函数中打印语句,肯定是父类先打印出来
    2.既然是先初始化父类再初始化子类,那么是先初始化属性还是先初始化构造方法呢?

    答案是先初始化属性,再初始化构造方法

    总结:创建一个子类对象时,先初始化父类的属性,然后初始化父类构造方法;再初始化子类属性,然后子类构造方法

    4.父类中final的使用

    final关键字:
    使用final关键字做标识有“最终的”含义
    final可以修饰类,方法,属性,变量
    若修饰类:则该类不允许被继承
    若修饰方法:则该方法不允许被重写(覆盖)
    若修饰属性:则该类的属性不会进行隐式的初始化(类的初始化属性必须有值),或在构造方法中赋值(但只能选其一)
    若修饰变量:则该变量的值只能在定义的时候赋值,即变为常量

    5.子类中super的使用

    super关键字:

    在对象的内部使用,可以代表父类对象

    1.访问父类的属性

    super.age

    2.访问父类的方法

    super.eat()

    注意:
    父类对象的属性和子类对象的属性并无关系,是两个属性

    super与构造方法之间的关系:
    1.子类的构造过程当中必须调用父类的构造方法
    举个例子:创建子类对象的时候,父类的构造方法也会执行,相当与在子类的构造方法中隐式的写了一个super

     1 //父类
     2 public class Animal {
     3     public Animal(){
     4         System.out.println("父类执行了");
     5     }
     6 
     7 }
     8 
     9 //子类
    10 public class Dog extends Animal {
    11     public Dog(){
    12         //子类构造方法,此处隐式写了一个super
    13         System.out.println("子类执行了");
    14     }
    15 
    16 }
    17 
    18 //测试类,创建子类对象
    19 public class testDog {
    20     public static void main(String[] args) {
    21         Dog dog = new Dog();//创建子类对象
    22 
    23     }
    24 }
    25 
    26 ………………
    27 父类执行了
    28 子类执行了

    2.如果子类的构造方法中没有显示调用父类的构造方法,则系统默认调用父类无参的构造方法。

    3.如果显示的调用构造方法,必须在子类的构造方法的第一行,显示调用用super();

    4.如果子类构造方法中记没有显示调用父类的构造方法,而父类又没有无参的构造方法,则编译出错。

    解释:父类默认是有无参构造方法的,如果自己定义了一个有参的构造方法,则不会再自动添加无参构造方法。而子类构造方法中,如果没有super(),则默认只会调用父类的无参构造方法,如果要调用父类的有参构造方法,则只需要在super(参数);

    例子:

     1 //父类
     2 public class Animal {
     3     public int age;
     4     public Animal(int age){
     5         this.age=age;
     6         System.out.println("父类执行了"+this.age);
     7     }
     8 
     9 }
    10 
    11 //子类
    12 public class Dog extends Animal {
    13     public Dog(){
    14         super(10);
    15         System.out.println("子类执行了");
    16     }
    17 
    18 }
    19 
    20 //测试类,创建子类对象
    21 public class testDog {
    22     public static void main(String[] args) {
    23         Dog dog = new Dog();
    24 
    25     }
    26 }

    总结一下,其实上面说了这么多就一个意思:

    如果父类有无参构造方法,super()写不写没关系,如果没有无参构造方法,则需要写super(),并用super()传递参数

    6.Java的Object类

    1.Object类是所有类的父类,如果一个类没有使用extends,关键字明确标识继承另外一个类,那么这个类默认继承Object
    2.Object类中的方法,适合所有子类
    3.Object类中的几种方法:
    toString()方法:
    Object类里面定义的toString方法是返回对象的哈希码(对象地址字符串)
    如果直接输出对象名,就会执行toStirng()方法,例如:

    System.out.println(实例化对象名)

    可以通过在子类中重写toString()方法输出对象的属性

    public String toString(){
        return "Dog[age"+age+"]";
    }

    equals()方法
    源码中比较的是对象的引用是否指向统一块内存地址,
    子类中可以修改为比较两个对象的值是否相等。可以这样修改:

     1 //父类
     2 public class Animal {
     3     public int age;
     4 
     5 
     6 }
     7 
     8 //子类
     9 public class Dog extends Animal {
    10     @Override
    11     public boolean equals(Object obj) {
    12         if (this==obj) //判断引用的地址是否相同
    13             return true;
    14         if (obj==null) //判断比较的值是不是空值
    15             return false;
    16         if (getClass()!=obj.getClass()) //比较两个对象类的的代码信息
    17             return false;
    18         Dog other = (Dog) obj;
    19         if (age != other.age) //判断两个对象的属性值是否相等
    20             return false;
    21         return true;
    22     }
    23 }
    24 
    25 
    26 //测试类,创建子类对象
    27 public class testDog {
    28     public static void main(String[] args) {
    29         Dog dog = new Dog();
    30         Dog dog2 = new Dog();
    31         if(dog.equals(dog2)){
    32             System.out.println("两个对象是相同的");
    33         }else{
    34             System.out.println("两个对象是不相同的");
    35         }
    36 
    37     }
    38 }
  • 相关阅读:
    DDD~大话目录
    基于DDD的.NET开发框架-DDD经典分层
    补习知识:Entity Framework Code First属性映射约定
    一个官翻教程集合:ASP.NET Core 和 EF Core 系列教程
    补知识:EntityFramework Core映射关系详解
    关于this的问题
    promise
    js的类型转换
    不要在块内声明一个函数
    let和var
  • 原文地址:https://www.cnblogs.com/cenyu/p/6068857.html
Copyright © 2020-2023  润新知