导学

在本章节内容中，我们将继续来学习面向对象三大特性之一的继承。之前的封装，实际上是针对一个类进行隐藏和访问控制操作，而即将要学习的继承，其实是在描述两个类之间的关系。

继承是软件实现复用的重要手段之一

首先，我们来想一想生活中的继承，比如儿子继承父亲的外貌与性格，徒弟继承师傅的手艺等等。这些都是继承，在两个主体之间有着传承的关系。
对于面向对象程序而言，它的编程思想同样来自于生活。我们在程序的开发中同样也会有和生活中一样的感受。比如，我们使用两个类来描述猫和狗：
4. Java继承 - 图1
我们发现在描述过程中，它们有一些相同的属性和方法，也有一些不同的属性和方法。那么，如果我们接着描述其他的动物，是不是也会产生大量的重复的代码呢？
最好能有一种方法能把这些重复代码收集起来，然后我每次要使用的时候，就直接调用这个方法，进行重复利用就可以了。而，这种方法就是我们今天要学习的继承了。
比如我们可以将猫类和狗类中的共同属性和方法抽取出来，组成一个动物类：
4. Java继承 - 图2
当猫狗类和动物类实现继承关系时，猫狗类就可以直接使用动物类中属性和方法了，而不必在写那些重复的代码了。即使我们再写如企鹅类，狮子类，乌龟类等，也可以去继承动物类，不必再写那些重复的代码。

将一些具有相似逻辑的类中的公共的属性和方法抽取出来，组成一个类，这个类我们称之为父类。父类和子类是一种一般和特殊的关系。例如水果和苹果，苹果是一种特殊的水果

所以，我们发现继承其实有着如下的特点：

  • 利于代码复用
  • 缩短开发周期

那么，说了这么多，我们再来对继承做个总结吧：

  • 一种类与类之间的关系
  • 使用已存在的类的定义作为基础建立新类
  • 新类的定义可以增加新的数据或新的功能，也可以用父类的功能，但不能选择性地继承父类的功能！

    继承的实现

    在Java中使用extends关键字实现类与类之间的继承关系
    4. Java继承 - 图3
    在Java中，继承只能是单继承，即子类只能有一个父类，而父类可以被多个子类继承。就像现实生活中孩子只能有一个亲爹，而父亲可能有多个子女一样。
    但是Java中存在多层继承，常用的比如每个子类只有一个直接父类，但是该父类依然存在其自身的父类。注意：虽然类继承可以实现代码的复用，但是如果继承的结构过多，也会造成代码段的阅读困难，一般不建议继承的结构超过3层。

    利用extends关键字表明子类继承父类 当实现继承时，子类可以直接使用父类非私有属性和方法 在继承时，非私有属性就已经是子类的属性了 使用父类的getName()方法。可以暗中继承父类的私有name属性

接下来就结合就结合具体的案例来看看吧
父类：

  1. public class Animal {
  2.     private String name;//名称
  4.     private int month;//月份
  6.     private String species;//品种
  8.     //动物共有方法吃东西
  9.     public void eat() {
  10.         System.out.println(this.getName() + "在吃东西");
  11.     }
  12.     public String getName() {
  13.         return name;
  14.     }
  15.     public void setName(String name) {
  16.         this.name = name;
  17.     }
  18.     public int getMonth() {
  19.         return month;
  20.     }
  21.     public void setMonth(int month) {
  22.         this.month = month;
  23.     }
  24.     public String getSpecies() {
  25.         return species;
  26.     }
  27.     public void setSpecies(String species) {
  28.         this.species = species;
  29.     }
  30.     public Animal() {
  32.     }
  33.     public Animal(String name, int Month, String species) {
  34.         super();
  35.         this.setName(name);
  36.         this.setMonth(Month);
  37.         this.setSpecies(species);
  38.     }
  39. }

子类-猫：

  1. public class Cat extends Animal{
  2.     //猫自己的属性-体重
  3.     private double weight;
  5.     //猫自己的方法-跑动
  6.     public void run() {
  7.         //子类可以使用父类的非私有成员，这里可以使用父类的getName()方法，不能使用父类的name属性
  8.         System.out.println(this.getName()+ "是一只" + this.getSpecies() +"，它正在快乐地奔跑");
  9.     }
  10.     public double getWeight() {
  11.         return weight;
  12.     }
  13.     public void setWeight(double weight) {
  14.         this.weight = weight;
  15.     }
  17.     public Cat() {
  19.     }
  21.     public Cat(double weight) {
  22.         this.setWeight(weight);
  23.     }
  24. }

子类-狗：

  1. public class Dog extends Animal {
  2.     //自有的属性
  3.     private String sex;
  5.     //自有的睡觉方法
  6.     public void sleep() {
  7.         System.out.println(this.getName() + "现在" + this.getMonth() + "个月大，它在睡觉~");
  8.     }
  10.     public String getSex() {
  11.         return sex;
  12.     }
  13.     public void setSex(String sex) {
  14.         this.sex = sex;
  15.     }
  17.     public Dog() {
  19.     }
  20. }

测试：

  1. public class Test {
  2.     public static void main(String[] args) {
  3.         Cat one = new Cat();
  4.         one.setName("花花");
  5.         one.setSpecies("中华田园猫");
  6.         one.eat();
  7.         one.run();
  8.         //sleep()方法不属于父类Animal，也不属于子类Cat中定义的方法
  9.         //one.sleep();
  10.         System.out.println("=====================");
  11.         Dog two = new Dog();
  12.         two.setName("田田");
  13.         two.setMonth(1);
  14.         two.eat();
  15.         two.sleep();
  16.         System.out.println("=====================");
  17.         Animal three = new Animal();
  18.         //three.run();无法访问
  19.         //three.sleep();
  20.     }
  21. }

总结：

  • 一个子类只能有一个父类
  • 子类可以访问父类非私有成员
  • 子类自己自有成员其他兄弟类无法访问
  • 父类不可以访问子类自有成员

    方法的重写

    在上述案例中，子类都调用了父类的eat()方法。但是对于这样的方法，猫与狗都需要吃东西，但可能各自都有自己不同的想法。比如猫吃鱼，狗吃肉，具体的表现形式不同，那么各自类中的方法体描述也不应该相同。
    对于这样的问题，我们可以使用方法的重写来完成这样的操作。对于方法的重写，指的是在子类中重新描述父类中的方法。

    方法的重写，要求 返回值类型、方法名、参数类型、顺序、个数 都要与父类继承的方法完全一致。 @Override - 该注解用于去验证注解下的方法是否属于重写方法

  1. public class Cat extends Animal{
  2.     //猫自己的属性-体重
  3.     private double weight;
  5.     //猫自己的方法-跑动
  6.     public void run() {
  7.         //子类可以使用父类的非私有成员，这里可以使用父类的getName()方法，不能使用父类的name属性
  8.         System.out.println(this.getName()+ "是一只" + this.getSpecies() +"，它正在快乐地奔跑");
  9.     }
  10.     public double getWeight() {
  11.         return weight;
  12.     }
  13.     public void setWeight(double weight) {
  14.         this.weight = weight;
  15.     }
  17.     public Cat() {
  19.     }
  21.     public Cat(double weight) {
  22.         this.setWeight(weight);
  23.     }
  25.     @Override//注解，表示方法的重写，方法前面加上@Override 系统可以帮你检查方法的正确性
  26.     public void eat() {
  27.         System.out.println(this.getName() + "爱吃鱼");
  28.     }
  29. }
  1. public class Dog extends Animal {
  2.     //自有的属性
  3.     private String sex;
  5.     //自有的睡觉方法
  6.     public void sleep() {
  7.         System.out.println(this.getName() + "现在" + this.getMonth() + "个月大，它在睡觉~");
  8.     }
  10.     public String getSex() {
  11.         return sex;
  12.     }
  13.     public void setSex(String sex) {
  14.         this.sex = sex;
  15.     }
  17.     public Dog() {
  19.     }
  21.     @Override
  22.     public void eat() {
  23.         System.out.println(this.getName() + "爱吃肉");
  24.     }
  25. }
  1. public class Test {
  2.     public static void main(String[] args) {
  3.         Cat one = new Cat();
  4.         one.setName("花花");
  5.         one.setSpecies("中华田园猫");
  6.         one.eat();
  7.         System.out.println("=====================");
  8.         Dog two = new Dog();
  9.         two.setName("田田");
  10.         two.setMonth(1);
  11.         two.eat();
  12.     }
  13. }

输出结果：

  1. 花花爱吃鱼
  2. =====================
  3. 田田爱吃肉

当子类重写父类方法之后，子类对象调用的是重写之后的方法。

方法重载与方法重写

在学习中，我们有可能会把方法重载和方法重写混淆。所以我们来通过一个表格认识一下方法重载与方法重写的区别

方法的签名是由方法的方法名和形参列表（注意：包含方法的参数和类型）组成

方法重载 方法重写
类关系 发生在同一个类中 发生在有继承关系的子类与父类中
方法签名 方法名相同，参数列表不同（参数顺序、个数、类型） 方法名相同，参数列表相同（参数顺序、个数、类型）
返回值 返回值任意 返回值相同或返回值呈现父子关系
访问修饰符 访问修饰符任意 访问修饰符的访问范围需要大于等于父类的访问范围
参数名 与方法的参数名无关 与方法的参数名无关

关于属性

对于重写，在Java中只有针对方法的重写，没有针对属性的重写。但是，我们在子类中可以定义与父类同名的属性，子类对象调用的是子类的属性。

  1. public class Animal {
  2.     public int temp = 15;
  3. }
  4. public class Cat extends Animal {
  5.     public int temp = 30;
  6. }
  7. public class Test {
  8.     public static void main(String[] args) {
  9.         Cat one = new Cat();
  10.         System.out.println(one.temp);//30
  11.     }
  12. }

访问修饰符

访问控制修饰符能修饰的对象包括：属性、方法、构造器
访问修饰符可以用来限制成员被访问的范围，即用来控制被修饰的成员可以在哪里（包）被使用。

private default protected public
同一个类 √ √ √ √
同一个包 √ √ √
不同包子类 √ √
全局范围 √
  • private: 只允许在本类中进行访问(访问权限最小的)
  • default: 允许在当前类、同包子类/非子类调用；跨包子类/非子类不允许调用
    • 类的成员不写访问修饰时默认为default
  • protected: 允许在当前类、同包子类/非子类、跨包子类调用；跨包非子类不允许
    • 在不同包中的子类中使用父类protected修饰的内容，只能由子类对象去调用
    • 常用于父类为子类准备的属性和方法
  • public: 允许在任意位置访问(访问权限最大的)

    在实际的开发中，大部分的场景使用 private 定义属性，public 定义方法。

访问修饰符对方法重写的影响

子类中重写父类方法时，子类方法的访问修饰符的访问范围需要大于等于父类方法的访问范围

  1. public class Animal {
  2.     protected void eat() {
  3.     }
  4. }
  5. public class Cat extends Animal {
  6.     public void eat() {
  7.     }
  8.     /*void eat() {
  9.         有问题
  10.     }*/
  11. }

super关键字

在上节内容的学习中，我们知道子类可以继承父类的方法，也可以使用自己重写的方法。那么该如何判定子类调用的方法是继承自父类，还是自己重写的呢。

  1. public class Animal {
  2.     public String name;
  3.     //动物共有方法吃东西
  4.     public void eat() {
  5.         System.out.println(this.getName() + "在吃东西");
  6.     }
  7. }
  8. public class Cat extends Animal{
  9.     //猫自己的方法-跑动
  10.     public void run() {
  11.         eat();//调用的是子类重写的方法
  12.         System.out.println(this.getName()+ "是一只" + this.getSpecies() +"，它正在快乐地奔跑");
  13.     }
  15.     @Override
  16.     public void eat() {
  17.         System.out.println(this.getName() + "爱吃鱼");
  18.     }
  20. }

如果我想要使用父类的方法，则需要使用super关键字。super关键字代表着对父类对象的引用。

  1. public void run() {
  2.         super.eat();//调用的是父类的方法
  3.         System.out.println(this.getName()+ "是一只" + this.getSpecies() +"，它正在快乐地奔跑");
  4.     }

当然也可以使用super访问父类中允许被子类访问到的任意成员。

  1. public void run() {
  2.         super.eat();
  3.         super.name = "猫猫";
  4.         System.out.println(this.getName()+ "是一只" + this.getSpecies() +"，它正在快乐地奔跑");
  5.     }
  1. 子类重写父类的方法，则父类的方法会被隐藏，隐藏的方法或者成员变量可以通过super关键字访问
  2. 引入super关键字的原因是可以使用被隐藏的成员变量和方法，而且super只能在子类的方法中定义使用

  3. super不能在main方法 中直接使用

    继承的初始化顺序

    父类的构造方法不允许被继承，不允许被重写**。** 那么父类的构造器除了构建父类对象是否有其他作用呢？

    1. public class Animal {
    2.  private String name = "妮妮";//名称
    4.  protected int month = 2;//月份
    6.  String species = "英短";//品种
    8.  public int temp = 15;
    10.  private static int st1 = 22;
    11.  private static int st2 = 23;
    13.  static {
    14.      System.out.println("我是父类的静态代码块");
    15.  }
    17.  {
    18.      System.out.println("我是父类的构造代码块");
    19.  }
    21.  //动物共有方法吃东西
    22.  public void eat() {
    23.      System.out.println(this.getName() + "在吃东西");
    24.  }
    26.  public String getName() {
    27.      return name;
    28.  }
    29.  public void setName(String name) {
    30.      this.name = name;
    31.  }
    32.  public int getMonth() {
    33.      return month;
    34.  }
    35.  public void setMonth(int month) {
    36.      this.month = month;
    37.  }
    38.  public String getSpecies() {
    39.      return species;
    40.  }
    41.  public void setSpecies(String species) {
    42.      this.species = species;
    43.  }
    44.  public Animal() {
    45.      System.out.println("我是父类的无参构造方法");
    46.  }
    47.  public Animal(String name, int Month, String species) {
    48.      super();
    49.      this.setName(name);
    50.      this.setMonth(Month);
    51.      this.setSpecies(species);
    52.  }
    53. }

    ```java public class Cat extends Animal{ //猫自己的属性-体重 private double weight;

    private static int st3 = 44;

    static {

    1.  System.out.println("我是子类的静态代码块");

    }

    {

    1.  System.out.println("我是子类的构造代码块");

    }

    //猫自己的方法-跑动 public void run() {

    1.  System.out.println(this.getName()+ "是一只" + this.getSpecies() +"，它正在快乐地奔跑");

    } public double getWeight() {

    1.  return weight;

    } public void setWeight(double weight) {

    1.  this.weight = weight;

    }

    public Cat() {

    1.  System.out.println("我是子类的无参构造方法");

    }

    public Cat(double weight) {

    1.  this.setWeight(weight);

    }

    @Override public void eat() {

    1.  System.out.println(this.getName() + "爱吃鱼");

    }

}

  1. ```java
  2. public class Test {
  3.     public static void main(String[] args) {
  4.         Cat one = new Cat();
  5.         System.out.println(one.temp);
  6.     }
  7. }

继承后的初始化顺序（实例化子类对象的时候）：先加载父类静态成员，然后加载子类静态成员，然后父类对象构造（构造代码块—>属性—>方法），最后子类对象构造。
构建子类对象步骤

加载父类静态属性 只在第一次实例化子类对象时加载
⬇
加载父类静态代码块
⬇
加载子类静态属性
⬇
加载子类静态代码块
⬇

进入子类的构造器
⬇
由子类的构造器进入父类的构造器
⬇
加载父类的成员属性
⬇
加载父类构造代码块
⬇
加载父类构造器
⬇
加载子类构造代码块
⬇
加载子类构造器
⬇
生成子类对象

super()

在上节内容中，我们提到子类对象在实例化的时候会先去调用父类对象的构造器。那么子类构造器是否有权利去选择具体使用父类的哪个构造器呢？
在父类中添加一个有参构造器

  1. public Animal(String name, int month, String species) {
  2.     System.out.println("我是父类的有参构造器");
  3. }

在子类中也使用三参构造器

  1. public Cat(String name, int Month, String species) {
  2.     System.out.println("我是子类的有参构造器");
  3. }

测试：

  1. public class Test {
  2.     public static void main(String[] args) {
  3.         Cat one = new Cat("花花",3,"英短");
  4.         System.out.println(one.temp);
  5.     }
  6. }

最终的运行结果表明，子类应用带参构造器实例化对象的时候，同样调用的是父类无参的构造器。
这也就是在实际的开发过程中，我们都会保证一个类中有一个无参的构造器存在的原因。
这也是Java继承的一个特点，如果在子类的构造器中，没有显式的调用父类的构造器，会默认的调用父类的无参构造器。
那么，问题又来啦，如何在子类的构造器中调用父类的构造器呢?

  1. public Cat(String name, int month, String species) {
  2.     //super();调用的是父类的无参构造方法
  3.     super(name, month,species);//调用的是父类对应参数的构造方法
  4.     System.out.println("我是子类的有参构造器");
  5. }

使用super()关键字，可以完成对父类构造器的调用。

总结：

  1. 子类默认调用父类无参构造方法；
  2. 可以通过super()调用父类允许访问的其他构造方法；
  3. super()必须放在子类构造方法的有效方法的第一行，而且只能出现一次。
  4. this()和super()在同一构造器中只可能出现一个。

    super，this，super()和this()

    | | super | this | super() | this() | | :—- | :—- | :—- | :—- | :—- | | 用处 | super可以用在子类的成员方法中 | this可以用在本类中的成员方法中 | super()可以用在子类的构造器中 | this()可以用在本类的构造器中 | | 目的 | 调用父类非私有（no private）的成员变量或方法 | 调用本类的成员变量或方法 | 调用父类的构造器 | 调用本类的构造器 |

super和this可以同时出现的，而super()和this()不能同时出现在一个构造器中

子类调用父类的构造器情况

子类构造器调用父类的构造器可能出现的情况有

  1. 子类构造器执行体的第一行显式的使用super调用父类的构造器，此时系统将根据super（params）去调用对应的构造器。
  2. 子类构造器在执行体的第一行显式的使用this调用重载的构造器，系统将会根据this(params) 调用对应 的重载构造器，本类中的对应的构造器再去调用父类的构造器
  3. 子类构造器中既没有super有没有this，那么子类在执行构造器语句的时候会去执行父类的无参构造器。
  4. 无论如何子类都会调用一次父类的构造器
  • 子类构造器中既没有super有没有this，无论是通过子类的有参或无参构造器构建子类对象，都会去调用一次父类的无参构造器！

  • Object类

    Object类是所有类的老祖宗，如果有一个类没有显式的说明继承自哪个类，那么该类就默认的继承Object类。
    对于Object类，它有着如下的特点
  1. Obejct类是所有类的父类
  2. 一个类没有使用extends关键字明确标识继承关系，则默认继承Object类（包括数组）
  3. Java中每个类都可以使用Ojbect类中定义的方法
    接下来，我们就来结合Java API（JDK文档）来看看Java中对于Object类的介绍
    文档地址：http://www.matools.com/api/java8

    equals()方法

    在Object类中，我们首先要学习的就是equals()方法。

    当直接继承Object类中的equals()方法时，它的作用是判断调用equals()方法的对象的内存空间引用与传入参数对象的内存空间引用是否一致（是否指向的是同一块内存地址）。

在Java中，==不但可以判断两个基本数据类型的数据是否相等，也可以用来判断两个对象的内存地址是否一致。本章节中所讲的，equals()方法如果不对其进行重写，则作用和==没有什么太大的差异。

  1. public class Test {
  2.     public static void main(String[] args) {
  3.         Animal one = new Animal("花花",2,"英短");
  4.         Animal two = new Animal("花花",2,"英短");
  5.         System.out.println(one == two);
  6.         System.out.println(one.equals(two));
  7.     }
  8. }

上述代码的运行结果都为false。这是因为one对象通过new关键字开辟了一块堆内存空间，two对象通过new关键字开辟了另一块内存空间。one对象和two对象各自指向的内存地址不一样，即使对象中的属性值一致，也被判定为false。
在String类中，Java开发人员重写了equals()方法。那我们来看看在String类中重写后的equals()方法的作用。

  1. public static void main(String[] args) {
  2.     String str = "abc";
  3.     //String作为一个类，同样有其构造方法
  4.     String str1 = new String("abc");
  5.     String str2 = new String("abc");
  6.     System.out.println(str == str1);
  7.     System.out.println(str == str2);
  8.     System.out.println(str1 == str2);
  9.     System.out.println("================");
  10.     System.out.println(str.equals(str1));
  11.     System.out.println(str.equals(str2));
  12.     System.out.println(str1.equals(str2));
  13. }

在这次的运行中，我们可以看到分割线下equals()方法的返回值都为true，这是因为String类中重写的equals()方法，改变了判断规则，用来比较保存的字符串内容是否相等。

重写equals()方法

  1. public class Test {
  2.     public static void main(String[] args) {
  3.         Animal one = new Animal("花花",2,"英短");
  4.         Animal two = new Animal("花花",2,"英短");
  5.         System.out.println(one == two);
  6.         System.out.println(one.equals(two));
  7.     }
  8. }

回到刚刚的代码，如果只想去比较one和two这两个对象属性值是否相同怎么办呢？这时候就需要我们去Animal类中重写equals()方法了。
当参数为Object类型时，因为Object是所有类的父类，所以参数可以是任意类型
重写equals()方法用于比较调用当前equals方法的对象和参数对象是否相等

  1. public boolean equals(Object obj) {
  2.     // 1. 首先判断传入的对象是否为null
  3.     if (obj == null) {
  4.         // 如果是null则直接返回false
  5.         return false;
  6.     } else {
  7.         // 2. 接着判断两个对象中的属性值是否一致
  8.         // 此时是引用数据类型的强制类型转换，形式也是类似于之前学习过的基本数据类型强制类型转换
  9.         Animal animal = (Animal) obj;
  10.         if (this.getName().equals(animal.getName()) && this.getMonth() == animal.getMonth()
  11.                 && this.getSpecies().equals(animal.getSpecies())) {
  12.             return true;
  13.         } else {
  14.             return false;
  15.         }
  16.     }
  17. }

完成重写后，我们会发现再去运行测试类中的方法，结果已经发生了改变。
当然，上述代码还是有问题的，最大的问题在于强制类型转换的时候，如果传入的参数不能匹配Animal类，则会发生一个类型转换错误的异常。

  1. /**
  2.  * 此方法就不是对equals()方法的重载了，而是对Animal类中已经存在的equals()方法的重载
  3.  * @param ani
  4.  * @return
  5.  */
  6. public boolean equals(Animal ani) {
  7.     // 1. 首先判断传入的对象是否为null
  8.     if (ani == null) {
  9.         // 如果是null则直接返回false
  10.         return false;
  11.     } else {
  12.         // 2. 接着判断两个对象中的属性值是否一致
  13.         // 此时是引用数据类型的强制类型转换，形式也是类似于之前学习过的基本数据类型强制类型转换
  14.         if (this.getName().equals(ani.getName()) && this.getMonth() == ani.getMonth()
  15.                 && this.getSpecies().equals(ani.getSpecies())) {
  16.             return true;
  17.         } else {
  18.             return false;
  19.         }
  20.     }
  21. }

针对于，有可能发生的类型转换异常，我们可以强制限定传入的参数为Animal类型，避免异常的发生。所以，我们重载了一个参数为Animal类型的方法，在测试类中代码运行的时候，会自动根据参数类型定位到类型匹配的重载方法上。
总计：

  1. 继承Object中的equals()方法时，比较的是两个引用是否指向同一个对象
  2. 子类可以通过重写equals()方法的形式，改变比较的内容
  3. 如果一个方法的参数为引用类型，实际参数可以是该引用类型对象及其子类对象

    需要注意的是，需要针对传入的参数进行非空判断，避免空指针异常

toString()方法

toString()方法也是使用频率比较高的一个方法。

在没有重写toString()方法之前，对象调用toString()方法会返回一个类的字符串表现形式，这个表现形式就是一个类的类名 + @ + 对象在内存中位置表现的哈希值。

  1. public class Test {
  2.     public static void main(String[] args) {
  3.         Animal one = new Animal("花花",2,"英短");
  4.         Animal two = new Animal("花花",2,"英短");
  5.         System.out.println(one);
  6.         System.out.println(one.toString());
  7.         String str = new String("Hello,world!");
  8.         System.out.println(str);
  9.         System.out.println(str.toString());
  10.     }
  11. }

输出结果

  1. com.dodoke.animal.model.Animal@15db9742
  2. com.dodoke.animal.model.Animal@15db9742
  3. Hello,world!
  4. Hello,world!

由此可见，当直接打印对象的对象名时，会默认调用对象继承自Object类的toString()方法

在类中重写toString()方法

可以通过eclipse完成重写toString()方法

  1. @Override
  2. public String toString() {
  3.     return "Animal [name=" + name + ", month=" + month + ", species=" + species + "]";
  4. }

总结：

  • 直接输出对象名时，默认会直接调用类中的toString方法
  • 继承Object中的toString()方法时，输出对象的字符串表现形式：类型信息+@+地址信息
  • 子类可以通过重写toString()方法的形式，改变输出的内容及其表现形式

    final关键字

    通过继承，我们可以提高代码的复用性和灵活性。但是在有些时候，我们并不希望这个类被继承，这个方法被重写和这个变量的值被修改，那么这个时候final关键字就起了大作用了。
    在定义方法或属性时，访问修饰符的位置和控制修饰符的位置可以互换

  1. final修饰类，则该类不允许被继承

    1. public final class Animal {}
    2. final public class Animal {}
    • 我们常用的String类和System类等，都是使用final去修饰的。

  2. final修饰方法，则该方法不允许被重写，但可以正常被子类继承使用

    1. public final void eat() {}

  3. final修饰变量，赋值后不可修改

    • final修饰局部变量，初始化(赋值)后不允许被修改

      1. public void eat() {
      2. int temp = 10;
      3. final int temp1 = 12;
      4. temp1 = 14;//不可修改
      5. final int temp2;
      6. temp2 = 13;
      7. temp2 = 14;//不可修改
      8. System.out.println(this.getName() + "在吃东西");
      9. }

    • final修饰属性变量，同样赋值后不可以修改

      1. public class Animal {
      2. public final int temp = 15;
      3. public final int temp1;
      4. public final int temp2;
      5. public final int temp3;
      6. public Animal() {
      7.    super();
      8.    temp1 = 20;
      9. }
      10. {
      11.    temp2 = 20;
      12. }
      13. static {
      14.    temp3 = 20;//不可以赋值
      15. }
      16. }

    • 被final定义的成员属性，只有三种方式进行赋值：

      • 定义时直接赋值；
      • 在构造代码块中赋值；
      • 在构造方法中赋值。
      • 不可以在方法中赋值

        final其他应用

        之前我们使用final修饰变量的时候，实验的都是基本数据类型，如果使用final修饰引用数据类型会发生什么样的变化呢？
        1. public void eat() {
        2. final Animal ani = new Animal();
        3. ani = new Animal();//不允许重新赋值，也就是ani所代表的引用地址不允许被修订
        4. ani.setMonth(3);//对象中的属性值是允许被修改的
        5. ani.setMonth(2);
        6. System.out.println(this.getName() + "在吃东西");
        7. }
        总结：
        final当修饰的变量为引用类型时，对象不允许再被重新实例化（不允许再被new），但是此对象里的属性的值依然可以更改。

        在实际的开发中， final用的最多的场景是结合 static 关键字定义类变量，即静态变量。定义的这个变量我们也称之为常量。 定义为final另一个意图就是将变量的值保护起来。

  1. public class Animal {
  2.     public static final int TEMP = 200;
  3.     public final static int TEMP1 = 200;
  4. }

final修饰的这个常量需要字母全部大写

final不能修饰构造方法

静态属性，可以被继承，但是不能在子类中重新定义，否则在子类之外只能调用子类定义的静态属性
静态方法也可以被继承，但是不能被重写

注解

在之前的的学习中，我们提到可以适应@Override来添加对于重写方法的约束，同样的在eclipse中采用快捷方式完成重写方法时也会出现@Override。这样一个事物，我们称之为注解。在本章节中，我们就来简单的学习使用注解。
注解是JDK1.5版本引入的一个特性，可以声明在包、类、属性、方法、局部变量、方法参数等的前面，用来对这些元素进行说明、注释。简单来说，注解就相当于一个标记，在程序中使用了注解就相当于给这个程序打上了某种标签。被打过标签的一些程序，以后Java编辑器、开发工具、以及其他的程序就会借由这个标签来了解你所写的程序。
按照运行机制分：

  • 源码注解：注解只在源码中存在，编译成.class文件就不存在了。如@Override
  • 编译时注解：注解在源码和.class文件中都存在。
  • 运行时注解：在运行阶段还起作用，甚至会影响运行逻辑的注解。如以后要学习到的框架的注解@Autowired

按照来源分：

  • 来自JDK的注解
  • 来自第三方的注解
  • 我们自己定义的注解

    还有特殊的注解：元注解：对注解进行注释的