Java面向对象基础（封装继承多态）【1】

徐建国

发布于 2021-08-03 15:47:46

6800

发布于 2021-08-03 15:47:46

文章被收录于专栏：个人路线

概述

面向对象的三大特征：继承、封装、多态进行详细的讲解。另外还包括抽象类、接口、内部类等概念。很多概念对于初学者来说，更多的是先进行语法性质的了解，然后进行大量的练习，编程才算是刚刚开始。

继承的实现

继承让我们更加容易实现类的扩展。比如，我们定义了人类，再定义Boy类就只需要扩展人类即可。实现了代码的重用，不用再重新发明轮子(don’t reinvent wheels)。

从英文字面意思理解，extends的意思是“扩展”。子类是父类的扩展。现实世界中的继承无处不在。比如：

上图中，哺乳动物继承了动物。意味着，动物的特性，哺乳动物都有；在我们编程中，如果新定义一个Student类，发现已经有Person类包含了我们需要的属性和方法，那么Student类只需要继承Person类即可拥有Person类的属性和方法。继承使用要点

1.父类也称作超类、基类、派生类等。

2.Java中只有单继承（当然Java的接口可以多继承，类只有单继承），没有像C++那样的多继承。多继承会引起混乱，使得继承链过于复杂，系统难于维护。

3.Java中类没有多继承，接口有多继承。

4.子类继承父类，可以得到父类的全部属性和方法 (除了父类的构造方法)，但不见得可以直接访问(比如，父类私有的属性和方法)。

5.如果定义一个类时，没有调用extends，则它的父类是：java.lang.Object。

选中类之后ctrl+t便可看到类层次。

package javastart02;
/**
 * 测试继承
 * @author 玖点夜谈
 *
 */
public class TestExtends {
  public static void main(String[] args) {
    Student stu=new Student();
    stu.name="萌小肆";
    stu.height=178;
    stu.Rest();
    Student stu1=new Student("你好",178,"软件工程");
    System.out.println(stu1 instanceof  Student);
    System.out.println(stu1 instanceof  Student);
    System.out.println(stu1 instanceof  Person);
  }

}
class Person {
  String name;
  int height;
  public void Rest(){
    System.out.println("休息一会 ");
  }
}
class Student extends Person{
//  String name;
//  int height;
  String major;
  public void Study() {
    System.out.println("好好学习，天天向上");
  }
  public Student(String name,int height,String  major){
    this.name=name;
    this.height =height;
    this.major=major;
  }
  public Student(){
    
  }
//  public void Rest(){
//    System.out.println("休息一会 ");
//  }
}

方法的重写override

子类通过重写父类的方法，可以用自身的行为替换父类的行为。方法的重写是实现多态的必要条件。

方法的重写需要符合下面的三个要点：

1.“==”：方法名、形参列表相同。

2.“≤”：返回值类型和声明异常类型，子类小于等于父类。

3.“≥”：访问权限，子类大于等于父类。

package javastart02;
/**
 * 测试 方法的重写（覆盖）
 * @author 玖点夜谈
 *
 */

public class TestOverride {
  public static void main(String[] args) {
    
  
    House house=new House();
    house.run();
  }
  

}
  class Verchine{
    public void run() {
      System.out.println("跑 ");
    }
    public void stop() {
      System.out.println("停车");
    }
    public  Person whois() {
      return new Person();  
    }
  }
  class House extends Verchine{
    public void run() {
      System.out.println("四蹄分会，得得得");
    }
    public  Person whois() {
      return new Person();  
    }
  }

Object类基本特性

Object类是所有Java类的根基类，也就意味着所有的Java对象都拥有Object类的属性和方法。如果在类的声明中未使用extends关键字指明其父类，则默认继承Object类。

toString方法

Object类中定义有public String toString()方法，其返回值是 String 类型。Object类中toString方法的源码为：

public String toString() {
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

据如上源码得知，默认会返回“类名+@+16进制的hashcode”。在打印输出或者用字符串连接对象时，会自动调用该对象的toString()方法。

package javastart02;
/**
 * object方法重写
 * @author 玖点夜谈
 *
 */
public class TestObject {
  public static void main(String[] args) {
//    Object obj;
    TestObject to=new TestObject();
    System.out.println(to);
    System.out.println(to.toString());
    
    
  }
  //重写tostring 
  public String toString() {
    return "测试Object对象";
    
  }
  class Person {
      String name;
      int age;
      @Override
      public String toString() {
          return name+",年龄："+age;
      }
      public Person(String name,int age) {
        this.name=name;
        this.age=age;
        
        
      }
  }
}

==和equals方法

“==”代表比较双方是否相同。如果是基本类型则表示值相等，如果是引用类型则表示地址相等即是同一个对象。

Object类中定义有：public boolean equals(Object obj)方法，提供定义“对象内容相等”的逻辑。比如，我们在公安系统中认为id相同的人就是同一个人、学籍系统中认为学号相同的人就是同一个人。

Object 的 equals 方法默认就是比较两个对象的hashcode，是同一个对象的引用时返回 true 否则返回 false。但是，我们可以根据我们自己的要求重写equals方法。

package javastart02;
/**
 * equals方法重写
 * @author 玖点夜谈
 *
 */

public class Testequals {
  public static void main(String[] args) {
    Object obj;
    String string;
    User user11=new User(110, "玖点夜谈", "110");
    User user12=new User(110, "玖点夜谈", "110");
  
  
  System.out.println(user11==user12);
  System.out.println(user11.equals(user12));
  }
  static class User{
    int id;
    String name;
    String pwd;
    //alt +shift +s弹出菜单 
    public User(int id, String name, String pwd) {
      super();
      this.id = id;
      this.name = name;
      this.pwd = pwd;
    }
    @Override
    public int hashCode() {
      final int prime = 31;
      int result = 1;
      result = prime * result + id;
      return result;
    }
    @Override
    public boolean equals(Object obj) {
      if (this == obj)
        return true;
      if (obj == null)
        return false;
      if (getClass() != obj.getClass())
        return false;
      User other = (User) obj;
      if (id != other.id)
        return false;
      return true;
    }
    
    
    
    
    
  }

}

JDK提供的一些类，如String、Date、包装类等，重写了Object的equals方法，调用这些类的equals方法， x.equals (y) ，当x和y所引用的对象是同一类对象且属性内容相等时（并不一定是相同对象），返回 true 否则返回 false。

super关键字

super是直接父类对象的引用。可以通过super来访问父类中被子类覆盖的方法或属性。

使用super调用普通方法，语句没有位置限制，可以在子类中随便调用。

若是构造方法的第一行代码没有显式的调用super(...)或者this(...);那么Java默认都会调用super(),含义是调用父类的无参数构造方法。这里的super()可以省略。

继承树追溯

·属性/方法查找顺序：(比如：查找变量h)

1. 查找当前类中有没有属性h

2. 依次上溯每个父类，查看每个父类中是否有h，直到Object

3. 如果没找到，则出现编译错误。

4. 上面步骤，只要找到h变量，则这个过程终止。

·构造方法调用顺序：